🎯 计算机视觉面试题库¶

def conv_output_size(w, k, p, s):
    """计算卷积输出尺寸"""
    return (w - k + 2 * p) // s + 1

# ResNet第一层: 224 -> 112
print(conv_output_size(224, 7, 3, 2))  # 112

def compute_receptive_field(layers):
    """
    layers: list of (kernel_size, stride)
    """
    rf = 1
    stride_prod = 1
    for k, s in layers:
        rf = rf + (k - 1) * stride_prod
        stride_prod *= s
    return rf

# VGG16前3个卷积块
layers = [(3,1), (3,1), (2,2), (3,1), (3,1), (2,2), (3,1), (3,1), (3,1), (2,2)]
print(f"感受野: {compute_receptive_field(layers)}")  # 44

import torch.nn as nn

# NiN中的1x1卷积: 256通道 -> 64通道
bottleneck = nn.Sequential(
    nn.Conv2d(256, 64, kernel_size=1),   # 参数: 256*64 = 16384
    nn.BatchNorm2d(64),
    nn.ReLU(inplace=True),
    nn.Conv2d(64, 64, kernel_size=3, padding=1),  # 参数: 64*64*9 = 36864
    nn.BatchNorm2d(64),
    nn.ReLU(inplace=True),
    nn.Conv2d(64, 256, kernel_size=1),   # 参数: 64*256 = 16384
)
# 总参数: 69632 vs 直接3x3: 256*256*9 = 589824 (节省88%)

class DepthwiseSeparableConv(nn.Module):  # 继承nn.Module定义网络层
    def __init__(self, in_ch, out_ch, kernel_size=3, stride=1, padding=1):
        super().__init__()  # super()调用父类方法
        self.depthwise = nn.Conv2d(in_ch, in_ch, kernel_size, stride, padding, groups=in_ch)
        self.pointwise = nn.Conv2d(in_ch, out_ch, 1)

    def forward(self, x):
        return self.pointwise(self.depthwise(x))

class BasicBlock(nn.Module):
    def __init__(self, in_planes, planes, stride=1):
        super().__init__()
        self.conv1 = nn.Conv2d(in_planes, planes, 3, stride, 1, bias=False)
        self.bn1 = nn.BatchNorm2d(planes)
        self.conv2 = nn.Conv2d(planes, planes, 3, 1, 1, bias=False)
        self.bn2 = nn.BatchNorm2d(planes)

        self.shortcut = nn.Sequential()
        if stride != 1 or in_planes != planes:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_planes, planes, 1, stride, bias=False),
                nn.BatchNorm2d(planes)
            )

    def forward(self, x):
        out = F.relu(self.bn1(self.conv1(x)))  # F.xxx PyTorch函数式API
        out = self.bn2(self.conv2(out))
        out += self.shortcut(x)  # Skip Connection
        return F.relu(out)

class BatchNorm2d(nn.Module):
    def __init__(self, num_features, eps=1e-5, momentum=0.1):
        super().__init__()
        self.gamma = nn.Parameter(torch.ones(num_features))
        self.beta = nn.Parameter(torch.zeros(num_features))
        self.register_buffer('running_mean', torch.zeros(num_features))
        self.register_buffer('running_var', torch.ones(num_features))
        self.eps = eps
        self.momentum = momentum

    def forward(self, x):
        if self.training:
            mean = x.mean(dim=(0, 2, 3))  # 对N,H,W维度求均值
            var = x.var(dim=(0, 2, 3), unbiased=False)
            # 更新running统计量
            self.running_mean = (1 - self.momentum) * self.running_mean + self.momentum * mean
            self.running_var = (1 - self.momentum) * self.running_var + self.momentum * var
        else:
            mean = self.running_mean
            var = self.running_var

        x_norm = (x - mean[None,:,None,None]) / torch.sqrt(var[None,:,None,None] + self.eps)
        return self.gamma[None,:,None,None] * x_norm + self.beta[None,:,None,None]

# Anchor-free: 直接回归每个点到4个边界的距离
# 对于特征图上每个位置(x, y), 回归 (l, t, r, b)
def fcos_target(gt_boxes, feature_points):
    """
    gt_boxes: (N, 4) -> (x1, y1, x2, y2)
    feature_points: (H*W, 2) -> (cx, cy)
    """
    l = feature_points[:, 0:1] - gt_boxes[:, 0:1]  # 到左边界
    t = feature_points[:, 1:2] - gt_boxes[:, 1:2]  # 到上边界
    r = gt_boxes[:, 2:3] - feature_points[:, 0:1]  # 到右边界
    b = gt_boxes[:, 3:4] - feature_points[:, 1:2]  # 到下边界
    return torch.stack([l, t, r, b], dim=-1)  # torch.stack沿新维度拼接张量

def nms(boxes, scores, iou_threshold=0.5):
    """标准NMS"""
    order = scores.argsort(descending=True)
    keep = []
    while order.numel() > 0:
        i = order[0].item()  # 将单元素张量转为Python数值
        keep.append(i)
        if order.numel() == 1:
            break
        ious = compute_iou(boxes[i].unsqueeze(0), boxes[order[1:]])  # unsqueeze增加一个维度
        mask = ious.squeeze() <= iou_threshold  # squeeze压缩维度
        order = order[1:][mask]
    return keep

def soft_nms(boxes, scores, sigma=0.5, score_threshold=0.001):
    """Soft-NMS Gaussian"""
    keep = []
    while scores.max() > score_threshold:
        i = scores.argmax().item()
        keep.append(i)
        ious = compute_iou(boxes[i].unsqueeze(0), boxes)
        decay = torch.exp(-(ious ** 2) / sigma)
        scores = scores * decay.squeeze()
        scores[i] = 0
    return keep

class FPN(nn.Module):
    def __init__(self, in_channels_list, out_channels=256):
        super().__init__()
        self.lateral_convs = nn.ModuleList([
            nn.Conv2d(c, out_channels, 1) for c in in_channels_list
        ])
        self.output_convs = nn.ModuleList([
            nn.Conv2d(out_channels, out_channels, 3, padding=1)
            for _ in in_channels_list
        ])

    def forward(self, features):  # [C2, C3, C4, C5]
        laterals = [conv(f) for conv, f in zip(self.lateral_convs, features)]  # zip按位置配对
        # 自顶向下融合
        for i in range(len(laterals) - 2, -1, -1):
            laterals[i] += F.interpolate(laterals[i + 1], scale_factor=2, mode='nearest')
        return [conv(lat) for conv, lat in zip(self.output_convs, laterals)]

class ViT(nn.Module):
    def __init__(self, img_size=224, patch_size=16, dim=768, depth=12, heads=12, num_classes=1000):
        super().__init__()
        num_patches = (img_size // patch_size) ** 2  # 196
        patch_dim = 3 * patch_size ** 2              # 768

        self.patch_embed = nn.Sequential(
            nn.Conv2d(3, dim, kernel_size=patch_size, stride=patch_size),  # 等价于线性投影
        )
        self.cls_token = nn.Parameter(torch.randn(1, 1, dim))
        self.pos_embed = nn.Parameter(torch.randn(1, num_patches + 1, dim))
        self.transformer = nn.TransformerEncoder(
            nn.TransformerEncoderLayer(d_model=dim, nhead=heads, dim_feedforward=dim*4, batch_first=True),
            num_layers=depth
        )
        self.head = nn.Linear(dim, num_classes)

    def forward(self, x):
        B = x.shape[0]
        x = self.patch_embed(x).flatten(2).transpose(1, 2)  # (B, 196, 768)
        cls = self.cls_token.expand(B, -1, -1)
        x = torch.cat([cls, x], dim=1)                       # (B, 197, 768)  # torch.cat沿已有维度拼接张量
        x = x + self.pos_embed
        x = self.transformer(x)
        return self.head(x[:, 0])  # CLS token分类

def clip_loss(image_features, text_features, temperature=0.07):
    """CLIP对比学习损失"""
    # 归一化
    image_features = F.normalize(image_features, dim=-1)
    text_features = F.normalize(text_features, dim=-1)

    # 计算相似度矩阵 (B, B)
    logits = image_features @ text_features.T / temperature

    # 对称交叉熵
    labels = torch.arange(len(logits), device=logits.device)
    loss_i2t = F.cross_entropy(logits, labels)  # F.cross_entropy PyTorch函数式交叉熵损失
    loss_t2i = F.cross_entropy(logits.T, labels)
    return (loss_i2t + loss_t2i) / 2

class VisionLanguageModel(nn.Module):
    def __init__(self, vision_encoder, llm, projection_dim):
        super().__init__()
        self.vision_encoder = vision_encoder  # CLIP ViT
        self.projector = nn.Linear(vision_encoder.hidden_dim, llm.hidden_dim)
        self.llm = llm

    def forward(self, images, text_tokens):
        # 视觉特征 → 投影到LLM空间
        vis_features = self.vision_encoder(images)  # (B, N_vis, D_vis)
        vis_tokens = self.projector(vis_features)    # (B, N_vis, D_llm)

        # 拼接视觉token和文本token
        text_embeds = self.llm.embed_tokens(text_tokens)
        inputs = torch.cat([vis_tokens, text_embeds], dim=1)
        return self.llm(inputs_embeds=inputs)

import torch.quantization as quant

# 训练后静态量化 (PTQ)
model.eval()  # eval()评估模式
model.qconfig = quant.get_default_qconfig('x86')
model_prepared = quant.prepare(model)

# 用校准数据集收集统计量
with torch.no_grad():  # 禁用梯度计算，节省内存
    for data in calibration_loader:
        model_prepared(data)

model_quantized = quant.convert(model_prepared)
# 模型大小减少约4倍，推理速度提升2-4倍

import torch
import onnxruntime as ort

# 1. PyTorch → ONNX
dummy_input = torch.randn(1, 3, 224, 224)
torch.onnx.export(
    model, dummy_input, "model.onnx",
    input_names=["input"],
    output_names=["output"],
    dynamic_axes={"input": {0: "batch"}, "output": {0: "batch"}},
    opset_version=17
)

# 2. ONNX Runtime 推理
session = ort.InferenceSession("model.onnx", providers=['CUDAExecutionProvider'])
result = session.run(None, {"input": input_numpy})

# 3. TensorRT 优化（命令行）
# trtexec --onnx=model.onnx --saveEngine=model.trt --fp16 --workspace=4096

def distillation_loss(student_logits, teacher_logits, labels, T=4.0, alpha=0.5):
    """知识蒸馏损失"""
    # Hard label loss
    hard_loss = F.cross_entropy(student_logits, labels)

    # Soft label loss (KL散度)
    soft_student = F.log_softmax(student_logits / T, dim=-1)
    soft_teacher = F.softmax(teacher_logits / T, dim=-1)
    soft_loss = F.kl_div(soft_student, soft_teacher, reduction='batchmean') * (T ** 2)

    return alpha * hard_loss + (1 - alpha) * soft_loss

import torchvision.transforms as T

# MixUp
def mixup(x, y, alpha=0.2):
    lam = np.random.beta(alpha, alpha)
    idx = torch.randperm(x.size(0))
    mixed_x = lam * x + (1 - lam) * x[idx]
    y_a, y_b = y, y[idx]
    return mixed_x, y_a, y_b, lam

# CutMix
def cutmix(x, y, alpha=1.0):
    lam = np.random.beta(alpha, alpha)
    B, _, H, W = x.shape
    cut_h = int(H * np.sqrt(1 - lam))
    cut_w = int(W * np.sqrt(1 - lam))
    cx, cy = np.random.randint(W), np.random.randint(H)
    x1 = np.clip(cx - cut_w // 2, 0, W)
    y1 = np.clip(cy - cut_h // 2, 0, H)
    x2 = np.clip(cx + cut_w // 2, 0, W)
    y2 = np.clip(cy + cut_h // 2, 0, H)

    idx = torch.randperm(B)
    x[:, :, y1:y2, x1:x2] = x[idx, :, y1:y2, x1:x2]
    lam = 1 - (y2-y1)*(x2-x1) / (H*W)
    return x, y, y[idx], lam

from torch.amp import autocast, GradScaler

scaler = GradScaler()

for data, target in dataloader:
    optimizer.zero_grad()  # 清零梯度

    with autocast('cuda'):  # FP16前向传播
        output = model(data)
        loss = criterion(output, target)

    scaler.scale(loss).backward()   # 缩放梯度防止下溢
    scaler.step(optimizer)
    scaler.update()