计算机视觉：AI人工智能时代的视觉先锋

    import numpy as np
    
    def conv2d(input, kernel):
    # 输入尺寸
    in_h, in_w = input.shape
    # 卷积核尺寸
    k_h, k_w = kernel.shape
    # 输出尺寸
    out_h = in_h - k_h + 1
    out_w = in_w - k_w + 1
    
    output = np.zeros((out_h, out_w))
    
    for y in range(out_h):
        for x in range(out_w):
            # 元素级乘法后求和
            output[y,x] = np.sum(input[y:y+k_h, x:x+k_w] * kernel)
    
    return output
    
    # 示例
    input = np.array([[1,2,3,0],
                 [4,5,6,1],
                 [7,8,9,0]])
    kernel = np.array([[1,0],
                  [0,-1]])
    
    print(conv2d(input, kernel))
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-08-16/dWGZ2kuMKxgp3B5vwTbHmr0f14OU.png)

    import torch
    import torch.nn as nn
    
    class LeNet5(nn.Module):
    def __init__(self):
        super(LeNet5, self).__init__()
        self.conv1 = nn.Conv2d(1, 6, 5, padding=2)
        self.pool1 = nn.AvgPool2d(2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.pool2 = nn.AvgPool2d(2)
        self.fc1 = nn.Linear(16*5*5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)
    
    def forward(self, x):
        x = torch.sigmoid(self.conv1(x))
        x = self.pool1(x)
        x = torch.sigmoid(self.conv2(x))
        x = self.pool2(x)
        x = x.view(-1, 16*5*5)
        x = torch.sigmoid(self.fc1(x))
        x = torch.sigmoid(self.fc2(x))
        x = self.fc3(x)
        return x
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-08-16/hJwsoYbpINRtxT6aFui54HQmzU0C.png)

    class YOLOLayer(nn.Module):
    def __init__(self, anchors, num_classes):
        super(YOLOLayer, self).__init__()
        self.anchors = anchors
        self.num_anchors = len(anchors)
        self.num_classes = num_classes
    
    def forward(self, x):
        # x shape: (batch, channels, height, width)
        batch_size = x.size(0)
        grid_size = x.size(2)
    
        # 转换预测输出
        prediction = x.view(batch_size, self.num_anchors,
                          self.num_classes + 5, grid_size, grid_size)
        prediction = prediction.permute(0,1,3,4,2).contiguous()
    
        # 获取各分量
        obj_score = torch.sigmoid(prediction[..., 4])  # 目标置信度
        cls_scores = torch.sigmoid(prediction[..., 5:]) # 类别概率
    
        # 计算边界框
        grid = torch.arange(grid_size, dtype=torch.float, device=x.device)
        grid_x = grid.view(1,1,grid_size,1).repeat(1,self.num_anchors,1,grid_size)
        grid_y = grid.view(1,1,1,grid_size).repeat(1,self.num_anchors,grid_size,1)
    
        anchor_w = torch.tensor(self.anchors, device=x.device)[:,0:1].view(1,self.num_anchors,1,1)
        anchor_h = torch.tensor(self.anchors, device=x.device)[:,1:2].view(1,self.num_anchors,1,1)
    
        pred_boxes = torch.zeros_like(prediction[...,:4])
        pred_boxes[...,0] = (torch.sigmoid(prediction[...,0]) + grid_x) / grid_size
        pred_boxes[...,1] = (torch.sigmoid(prediction[...,1]) + grid_y) / grid_size
        pred_boxes[...,2] = torch.exp(prediction[...,2]) * anchor_w
        pred_boxes[...,3] = torch.exp(prediction[...,3]) * anchor_h
    
        return pred_boxes, obj_score, cls_scores
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-08-16/rQsEFjTG9aCuzd2V43wAHIyfXv0B.png)

    def calculate_iou(box1, box2):
    # box = [x1,y1,x2,y2]
    x1 = max(box1[0], box2[0])
    y1 = max(box1[1], box2[1])
    x2 = min(box1[2], box2[2])
    y2 = min(box1[3], box2[3])
    
    inter_area = max(0, x2 - x1) * max(0, y2 - y1)
    
    box1_area = (box1[2]-box1[0])*(box1[3]-box1[1])
    box2_area = (box2[2]-box2[0])*(box2[3]-box2[1])
    
    union_area = box1_area + box2_area - inter_area
    
    return inter_area / union_area
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-08-16/0Nf9JG45i8UMCTvDK2gnquQrH7sZ.png)

    conda create -n cv python=3.8
    conda activate cv
    pip install torch torchvision opencv-python matplotlib numpy
    
    
    bash

    import torch
    import torchvision
    import torch.nn as nn
    import torch.optim as optim
    from torchvision import transforms
    
    # 数据预处理
    transform = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406],
                        std=[0.229, 0.224, 0.225])
    ])
    
    # 加载数据集
    train_set = torchvision.datasets.ImageFolder(
    root='./data/train',
    transform=transform
    )
    train_loader = torch.utils.data.DataLoader(
    train_set, batch_size=32, shuffle=True
    )
    
    # 定义模型
    model = torchvision.models.resnet18(pretrained=True)
    num_features = model.fc.in_features
    model.fc = nn.Linear(num_features, 2)  # 二分类
    
    # 训练配置
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
    
    # 训练循环
    for epoch in range(10):
    running_loss = 0.0
    for i, (inputs, labels) in enumerate(train_loader):
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
    
        running_loss += loss.item()
        if i % 100 == 99:
            print(f'Epoch {epoch+1}, Batch {i+1}, Loss: {running_loss/100:.3f}')
            running_loss = 0.0
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-08-16/Dm9LvcuhXGsyx2nkpSfEAVI74J0Q.png)

 * 图像大小统一调整为256x256
 * 中心裁剪为224x224(标准ImageNet尺寸)
 * 归一化使用ImageNet的均值和标准差

 * 使用预训练的ResNet18模型
 * 只替换最后的全连接层
 * 保留其他层的预训练权重

 * 使用带动量的SGD优化器
 * 交叉熵损失函数
 * 小批量训练(batch_size=32)

 * 每100个batch输出一次平均损失
 * 共训练10个epoch