P5 (高层语义) ↓ 上采样2xP4 = P5上采样 + C4投影 ↓ 上采样2xP3 = P4上采样 + C3投影 ↓ 上采样2xP2 = P3上采样 + C2投影

def _upsample_add(self, x, y): _,_,H,W =y.size()return F.interpolate(x, (H,W), mode='bilinear') + y # 双线性上采样

# 特征金字塔网络（FPN）class FPN(nn.Module): def __init__(self, block, num_blocks): """ 参数： block: 基础块类型（Bottleneck） num_blocks: 各层block数量（如ResNet50的[3,4,6,3]）""" super().__init__() self.in_planes =64 # 初始通道数 # 初始卷积层（模仿ResNet） self.conv1 = nn.Conv2d(3,64,7, stride=2, padding=3, bias=False) self.bn1 = nn.BatchNorm2d(64) self.maxpool = nn.MaxPool2d(3, stride=2, padding=1) # 1/4下采样 # 构建残差层（C2-C5） self.layer1 = self._make_layer(block, 64, num_blocks[0],1) # C2 self.layer2 = self._make_layer(block, 128, num_blocks[1],2) # C3 self.layer3 = self._make_layer(block, 256, num_blocks[2],2) # C4 self.layer4 = self._make_layer(block, 512, num_blocks[3],2) # C5 # 特征金字塔横向连接（1x1卷积降维） self.toplayer = nn.Conv2d(2048,256,1) # 处理C5 self.latlayer1 = nn.Conv2d(1024,256,1) # 处理C4 self.latlayer2 = nn.Conv2d(512,256,1) # 处理C3 self.latlayer3 = nn.Conv2d(256,256,1) # 处理C2 # 权重参数初始化 formin [self.toplayer, self.latlayer1, self.latlayer2, self.latlayer3]: nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu') def _make_layer(self, block, planes, num_blocks, stride): """构建残差层"""layers= [block(self.in_planes, planes, stride)] # 第一个block的stride如果大于1，可能有下采样 self.in_planes = planes * block.expansion # 更新输入通道数 for_inrange(1, num_blocks): layers.append(block(self.in_planes, planes, 1)) # 后续block无下采样 '''最终结构：假如第一个stride为2自带下采样，后面为1正常输出：Sequential(Bottleneck1(256->512, stride=2), Bottleneck2(512->512, stride=1), Bottleneck3(512->512, stride=1), Bottleneck4(512->512, stride=1) )'''returnnn.Sequential(*layers) def _upsample_add(self, x, y): """上采样并相加（特征融合）""" # 使用双线性插值上采样到y的尺寸再加上y进行特征融合 return F.interpolate(x, size=y.shape[2:], mode='bilinear') + y def forward(self, x): # 自底向上路径 c1 = F.relu(self.bn1(self.conv1(x))) # [B,64,256,256] c1 = self.maxpool(c1) # [B,64,128,128] c2 = self.layer1(c1) # [B,256,128,128] (C2) c3 = self.layer2(c2) # [B,512,64,64] (C3) c4 = self.layer3(c3) # [B,1024,32,32] (C4) c5 = self.layer4(c4) # [B,2048,16,16] (C5) # 自顶向下路径（特征金字塔构建） p5 = self.toplayer(c5) # [B,256,16,16] p4 = self._upsample_add(p5, self.latlayer1(c4)) # [B,256,32,32] self.latlayer代表连接层，将数据连接过来 p3 = self._upsample_add(p4, self.latlayer2(c3)) # [B,256,64,64] p2 = self._upsample_add(p3, self.latlayer3(c2)) # [B,256,128,128]return p2, p3, p4, p5

# 进行特征融合（FPN与自底向上路径相加）多层级融合​​：每个尺度都获得全局+局部信息 # N2-N5 路径存在的意义主要传递的是增强后的定位信息 而P2-P5才是原有的丰富语义信息 # 高层的C5特征经过多次卷积和下采样，已丢失细节但捕获了​​全局语义​​（如"这是一只狗"）。 # 通过自顶向下的上采样路径，这些语义信息被传递到所有P层。 # 虽然C2-C5本身包含多尺度信息，但低层的C2-C4主要是​​局部细节​​（边缘、纹理）。 # 横向连接到对应P层（1x1卷积）只能做通道对齐，无法直接增强语义。 # N2（P2级） → 下采样 → N3 → 下采样 → N4 → 下采样 → N5 # 低层特征（N2-N3）携带​​精确位置信息​​（如物体边缘）通过路径传递，修正高层特征的定位误差 # P5​​可能检测到"狗在图像某处" N5​​结合低层细节后，能更准确定位狗的具体位置 # P5 + N5​​：增强高层语义的定位能力 # P2 + N2​​：为细节层补充语义理解

# 自底向上增强路径（PANet核心） N2--N5class BottomUpPath(nn.Module): def __init__(self): super().__init__() # 横向连接卷积（特征融合） 创建个卷积List,存放四个卷积层 self.lat_conv = nn.ModuleList([ nn.Conv2d(256,256,1)for_inrange(4) # 每个金字塔层级一个卷积 ]) self.downsample = nn.MaxPool2d(3, stride=2, padding=1) # 2倍下采样 # 参数初始化 forconvin self.lat_conv: nn.init.kaiming_normal_(conv.weight, mode='fan_out', nonlinearity='relu') def forward(self, features): p2, p3, p4, p5 = features # 来自FPN的特征 FPN将自己每层的数据传输过来经过1*1的卷积归一化通道数目后与降采样的数据直接相加完成特征连接 # 自底向上增强路径（通过下采样和横向连接） n2 = self.lat_conv[0](p2) # [B,256,128,128] n3 = self.downsample(n2) + self.lat_conv[1](p3) # 下采样后相加 n4 = self.downsample(n3) + self.lat_conv[2](p4) n5 = self.downsample(n4) + self.lat_conv[3](p5)return [n2, n3, n4, n5]

pan_features = [ p2 + n2, # 增强后的P2特征 p3 + n3, p4 + n4, p5 + n5 ]

 # 然后进入 多层级ROI Align池化 pooled =[]for feat, name in zip(pan_features, ['p2','p3','p4','p5']): # 对每个层级的特征进行ROI Align pooled.append(self.roi_align[name](feat, proposals))

 # 特征融合（取各层级最大值） fused = torch.max(torch.stack(pooled), dim=0)[0] # [N,256,7,7]

# ROI Align配置（不同层级的空间尺度） 自适应特征池化：对每个候选区域，在每个特征层上进行ROI Align池化，然后将不同层的特征图进行最大值融合 self.roi_align ={'p2': RoIAlign(7, spatial_scale=1/4., sampling_ratio=2), # 1/4尺寸'p3': RoIAlign(7, spatial_scale=1/8., sampling_ratio=2),'p4': RoIAlign(7, spatial_scale=1/16., sampling_ratio=2),'p5': RoIAlign(7, spatial_scale=1/32., sampling_ratio=2) } ''' RoIAlign与RoIPool的区别 参考博客：https://www.cnblogs.com/xiaochouk/p/15912972.html RoIAlign与传统的RoIPool（区域兴趣池化）的主要区别在于处理边界的方式。 RoIPool在进行池化操作时会对边界进行量化处理，这会导致精度损失。 而RoIAlign则通过保持边界框内的采样点为浮点数坐标， 并进行双线性插值来计算每个采样点的值，从而减少了量化误差，提高了精度。'''

graph TDA[输入特征] -->B[全连接层1]B-->C[ReLU]C-->D[全连接层2]D--> E1[分类输出] & E2[回归输出]

# 分类头 self.cls_head = nn.Sequential( nn.Linear(256*7*7,512), # ROI特征展平后输入 nn.ReLU(), nn.Linear(512, num_classes) # 输出类别分数 ) # 回归头 self.reg_head = nn.Sequential( nn.Linear(256*7*7,512), nn.ReLU(), nn.Linear(512,4) # 输出边界框偏移量 偏移量x,y,w,h )

"""输入形状：[N,256,14,14]流程：1. 4个3x3卷积 +ReLU（保持尺寸）2. 反卷积2倍上采样 → [28,28]3. 1x1卷积生成类别相关掩膜"""

"""输入取自第3个卷积层输出：[N,256,14,14]流程：1. 2个3x3卷积降维 → [N,64,14,14]2. 展平为向量 → [N, 64*14*14]3. 单个全连接层 → [N, 28*28]4. Reshape → [N,1,28,28]5. 与主分支相加后Sigmoid"""

import torchimport torch.nn as nnimport torch.nn.functional asFclass PANetMaskHead(nn.Module): def __init__(self, in_channels=256, num_classes=80): super().__init__() # ----------------- 主分支 -----------------self.main_branch= nn.Sequential( nn.Conv2d(in_channels, 256,3, padding=1), nn.ReLU(inplace=True), nn.Conv2d(256,256,3, padding=1), nn.ReLU(inplace=True), nn.Conv2d(256,256,3, padding=1), # 从此层分叉 nn.ReLU(inplace=True), nn.Conv2d(256,256,3, padding=1), nn.ReLU(inplace=True), nn.ConvTranspose2d(256,256,2, stride=2), # 上采样2倍 nn.ReLU(inplace=True), nn.Conv2d(256, num_classes, 1) # 类别相关掩膜 ) # ----------------- 全连接融合分支 -----------------self.fc_branch= nn.Sequential( # 从第3个卷积层分叉输入（in_channels=256） nn.Conv2d(256,128,3, padding=1), nn.ReLU(inplace=True), nn.Conv2d(128,64,3, padding=1), nn.ReLU(inplace=True), nn.Flatten(), nn.Linear(64*14*14,28*28), # 仅一个全连接层 nn.Unflatten(1, (1,28,28)) # Reshape为[N,1,28,28] ) # ----------------- 融合后处理 -----------------self.sigmoid= nn.Sigmoid() def forward(self, x): # 主分支前向 main_out = self.main_branch(x) # [N,C,28,28] # 全连接分支前向 fc_out = self.fc_branch(x) # [N,1,28,28] # 特征融合与输出 fused = main_out + fc_out # 逐元素相加 return self.sigmoid(fused) # [N,C,28,28]

# 导入必要的库import torchimport torch.nn as nnimport torch.nn.functional asFfrom torchvision.ops import RoIAlign # ROI对齐操作# -------------------- 设备配置 --------------------# 检测可用设备，优先使用GPUdevice = torch.device("cuda"iftorch.cuda.is_available()else"cpu")#-------------------- 数据预处理 --------------------# 自定义数据整理函数，用于处理包含字典的批次数据def coco_collate(batch): """处理包含字典的批次数据"""images= [item[0]foritemin batch] # 提取所有图像 targets = [item[1]foritemin batch] # 提取所有标注数据 return torch.stack(images), targets # 将图像堆叠为张量，保持标注为列表# 虚拟COCO数据集生成器（带归一化）class FakeCOCODataset(torch.utils.data.Dataset): def __init__(self, num_samples=100): self.num_samples = num_samples # 样本数量 self.classes =80 # COCO数据集类别数 self.img_size =512 # 图像尺寸 def __len__(self): return self.num_samples # 返回数据集大小 def __getitem__(self, idx): # 生成虚拟图像 [3,512,512]，值范围[0,1] # 生成3通道的随机图像张量，模拟512x512大小的图片（值范围[0,1]） # 形状：(3,512,512) -> [channels, height, width] img = torch.rand(3, self.img_size, self.img_size) # 生成5个边界框的元数据 num_boxes =5 # 每张图片生成5个随机框 # 生成边界框中心坐标（归一化比例） # torch.rand生成[0,1)均匀分布，*0.8+0.1后范围[0.1,0.9) # 示例结果：tensor([[0.3,0.7], [0.5,0.5], ...])（5行2列） centers = torch.rand(num_boxes, 2) * 0.8+0.1 # 生成边界框尺寸（归一化比例） # 范围[0,0.3)，确保最大尺寸不超过图像的30% # 示例结果：tensor([[0.2,0.15], [0.25,0.1], ...]) sizes = torch.rand(num_boxes, 2) * 0.3 # 初始化边界框容器（xyxy格式） # 创建形状为[5,4]的全零张量 boxes = torch.zeros(num_boxes, 4) # 计算左上角坐标（x1,y1） # (中心x - 宽度/2) * 图像尺寸 → 实际像素坐标 # 示例：中心x=0.3，宽度=0.2 → (0.3-0.1)=0.2→0.2*512=102.4boxes[:,0:2] = (centers - sizes/2) * self.img_size # 计算右下角坐标（x2,y2） # (中心x + 宽度/2) * 图像尺寸 → 实际像素坐标 # 示例：中心x=0.3，宽度=0.2 → (0.3+0.1)=0.4→0.4*512=204.8boxes[:,2:4] = (centers + sizes/2) * self.img_size # 坐标边界约束（防止越界） # 将坐标限制在[0,511]范围内（假设img_size=512） # 示例：若计算结果为-10 → 修正为0，若520 → 修正为511 boxes = boxes.clamp(0, self.img_size-1) # 归一化处理（用于回归任务） # 将像素坐标转换为[0,1]范围内的比例 # 示例：x1=102.4→102.4/512=0.2norm_boxes= boxes / self.img_size # 生成随机类别标签（假设classes=80） # 生成1-79的整数（不包括80），形状[5,] # 示例结果：tensor([3,45,23,67,12]) labels = torch.randint(1, self.classes, (num_boxes,)) return img, { 'raw_boxes': boxes, # 原始坐标用于RoIAlign 'norm_boxes': norm_boxes, # 归一化坐标用于训练 'labels': labels }# -------------------- 模型组件 --------------------# Bottleneck模块（ResNet基础块）class Bottleneck(nn.Module): expansion =4 # 输出通道扩展倍数 def __init__(self, in_planes, planes, stride=1):""" 参数： in_planes: 输入通道数 planes: 中间层通道数 stride: 卷积步长 """ super().__init__() # 1x1卷积降维 self.conv1 = nn.Conv2d(in_planes, planes, 1, bias=False) self.bn1 = nn.BatchNorm2d(planes) # 3x3卷积 self.conv2 = nn.Conv2d(planes, planes, 3, stride, padding=1, bias=False) self.bn2 = nn.BatchNorm2d(planes) # 1x1卷积升维 self.conv3 = nn.Conv2d(planes, planes*self.expansion, 1, bias=False) self.bn3 = nn.BatchNorm2d(planes*self.expansion) # 快捷连接（当维度不匹配时） self.shortcut =nn.Sequential()if stride != 1 or in_planes != self.expansion*planes: self.shortcut = nn.Sequential( nn.Conv2d(in_planes, self.expansion*planes,1, stride, bias=False), nn.BatchNorm2d(self.expansion*planes) ) # 参数初始化（He初始化） nn.init.kaiming_normal_（）函数-- 避免引起一些梯度爆炸问题（初始参数太大或者太小之类的） # 参考博客：https://blog.csdn.net/m0_48241022/article/details/137057738 nn.init.kaiming_normal_(self.conv1.weight, mode='fan_out', nonlinearity='relu') nn.init.kaiming_normal_(self.conv2.weight, mode='fan_out', nonlinearity='relu') nn.init.kaiming_normal_(self.conv3.weight, mode='fan_out', nonlinearity='relu') def forward(self, x): out = F.relu(self.bn1(self.conv1(x))) # 卷积+BN+ReLUout = F.relu(self.bn2(self.conv2(out)))out = self.bn3(self.conv3(out)) # 最后一个BN前不加ReLU out+= self.shortcut(x) # 残差连接 returnF.relu(out) # 合并后激活# 特征金字塔网络（FPN）class FPN(nn.Module): def __init__(self, block, num_blocks): """ 参数： block: 基础块类型（Bottleneck） num_blocks: 各层block数量（如ResNet50的[3,4,6,3]）""" super().__init__() self.in_planes =64 # 初始通道数 # 初始卷积层（模仿ResNet） self.conv1 = nn.Conv2d(3,64,7, stride=2, padding=3, bias=False) self.bn1 = nn.BatchNorm2d(64) self.maxpool = nn.MaxPool2d(3, stride=2, padding=1) # 1/4下采样 # 构建残差层（C2-C5） self.layer1 = self._make_layer(block, 64, num_blocks[0],1) # C2 self.layer2 = self._make_layer(block, 128, num_blocks[1],2) # C3 self.layer3 = self._make_layer(block, 256, num_blocks[2],2) # C4 self.layer4 = self._make_layer(block, 512, num_blocks[3],2) # C5 # 特征金字塔横向连接（1x1卷积降维） self.toplayer = nn.Conv2d(2048,256,1) # 处理C5 self.latlayer1 = nn.Conv2d(1024,256,1) # 处理C4 self.latlayer2 = nn.Conv2d(512,256,1) # 处理C3 self.latlayer3 = nn.Conv2d(256,256,1) # 处理C2 # 权重参数初始化 formin [self.toplayer, self.latlayer1, self.latlayer2, self.latlayer3]: nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu') def _make_layer(self, block, planes, num_blocks, stride): """构建残差层"""layers= [block(self.in_planes, planes, stride)] # 第一个block的stride如果大于1，可能有下采样 self.in_planes = planes * block.expansion # 更新输入通道数 for_inrange(1, num_blocks): layers.append(block(self.in_planes, planes, 1)) # 后续block无下采样 '''最终结构：假如第一个stride为2自带下采样，后面为1正常输出：Sequential(Bottleneck1(256->512, stride=2), Bottleneck2(512->512, stride=1), Bottleneck3(512->512, stride=1), Bottleneck4(512->512, stride=1) )'''returnnn.Sequential(*layers) def _upsample_add(self, x, y): """上采样并相加（特征融合）""" # 使用双线性插值上采样到y的尺寸再加上y进行特征融合 return F.interpolate(x, size=y.shape[2:], mode='bilinear') + y def forward(self, x): # 自底向上路径 c1 = F.relu(self.bn1(self.conv1(x))) # [B,64,256,256] c1 = self.maxpool(c1) # [B,64,128,128] c2 = self.layer1(c1) # [B,256,128,128] (C2) c3 = self.layer2(c2) # [B,512,64,64] (C3) c4 = self.layer3(c3) # [B,1024,32,32] (C4) c5 = self.layer4(c4) # [B,2048,16,16] (C5) # 自顶向下路径（特征金字塔构建） p5 = self.toplayer(c5) # [B,256,16,16] p4 = self._upsample_add(p5, self.latlayer1(c4)) # [B,256,32,32] self.latlayer代表连接层，将数据连接过来 p3 = self._upsample_add(p4, self.latlayer2(c3)) # [B,256,64,64] p2 = self._upsample_add(p3, self.latlayer3(c2)) # [B,256,128,128]return p2, p3, p4, p5# 自底向上增强路径（PANet核心） N2--N5class BottomUpPath(nn.Module): def __init__(self): super().__init__() # 横向连接卷积（特征融合） 创建个卷积List,存放四个卷积层 self.lat_conv = nn.ModuleList([ nn.Conv2d(256,256,1)for_inrange(4) # 每个金字塔层级一个卷积 ]) self.downsample = nn.MaxPool2d(3, stride=2, padding=1) # 2倍下采样 # 参数初始化 forconvin self.lat_conv: nn.init.kaiming_normal_(conv.weight, mode='fan_out', nonlinearity='relu') def forward(self, features): p2, p3, p4, p5 = features # 来自FPN的特征 FPN将自己每层的数据传输过来经过1*1的卷积归一化通道数目后与降采样的数据直接相加完成特征连接 # 自底向上增强路径（通过下采样和横向连接） n2 = self.lat_conv[0](p2) # [B,256,128,128] n3 = self.downsample(n2) + self.lat_conv[1](p3) # 下采样后相加 n4 = self.downsample(n3) + self.lat_conv[2](p4) n5 = self.downsample(n4) + self.lat_conv[3](p5)return [n2, n3, n4, n5]# PANet完整网络class PANet(nn.Module): def __init__(self, num_classes=80): super().__init__() # 特征金字塔网络（基于ResNet50的FPN） self.fpn = FPN(Bottleneck, [3,4,6,3]) # ResNet50结构 # 自底向上增强路径 self.bottom_up = BottomUpPath() # ROI Align配置（不同层级的空间尺度） 自适应特征池化：对每个候选区域，在每个特征层上进行ROI Align池化，然后将不同层的特征图进行最大值融合 self.roi_align ={'p2': RoIAlign(7, spatial_scale=1/4., sampling_ratio=2), # 1/4尺寸'p3': RoIAlign(7, spatial_scale=1/8., sampling_ratio=2),'p4': RoIAlign(7, spatial_scale=1/16., sampling_ratio=2),'p5': RoIAlign(7, spatial_scale=1/32., sampling_ratio=2) } ''' RoIAlign与RoIPool的区别 参考博客：https://www.cnblogs.com/xiaochouk/p/15912972.html RoIAlign与传统的RoIPool（区域兴趣池化）的主要区别在于处理边界的方式。 RoIPool在进行池化操作时会对边界进行量化处理，这会导致精度损失。 而RoIAlign则通过保持边界框内的采样点为浮点数坐标， 并进行双线性插值来计算每个采样点的值，从而减少了量化误差，提高了精度。''' # 分类头 self.cls_head = nn.Sequential( nn.Linear(256*7*7,512), # ROI特征展平后输入 nn.ReLU(), nn.Linear(512, num_classes) # 输出类别分数 ) # 回归头 self.reg_head = nn.Sequential( nn.Linear(256*7*7,512), nn.ReLU(), nn.Linear(512,4) # 输出边界框偏移量 偏移量x,y,w,h ) # 参数初始化（Xavier初始化） forheadin [self.cls_head, self.reg_head]: forminhead.modules():if isinstance(m, nn.Linear): nn.init.normal_(m.weight, mean=0, std=0.01) # 小随机数初始化 nn.init.constant_(m.bias, 0) # 偏置初始化为0 def forward(self, x, proposals): # 特征提取 p2, p3, p4, p5 = self.fpn(x) # FPN输出四个阶段，也可以理解为四层的数据 # 自底向上增强路径处理 将FPN的数据经过自底向上增强路径融合连接后得到n2, n3, n4, n5 n2, n3, n4, n5 = self.bottom_up([p2, p3, p4, p5]) # 之后再进行特征融合（FPN与自底向上路径相加）多层级融合​​：每个尺度都获得全局+局部信息 # N2-N5 路径存在的意义主要传递的是增强后的定位信息 而P2-P5才是原有的丰富语义信息 # 高层的C5特征经过多次卷积和下采样，已丢失细节但捕获了​​全局语义​​（如"这是一只狗"）。 # 通过自顶向下的上采样路径，这些语义信息被传递到所有P层。 # 虽然C2-C5本身包含多尺度信息，但低层的C2-C4主要是​​局部细节​​（边缘、纹理）。 # 横向连接到对应P层（1x1卷积）只能做通道对齐，无法直接增强语义。 # N2（P2级） → 下采样 → N3 → 下采样 → N4 → 下采样 → N5 # 低层特征（N2-N3）携带​​精确位置信息​​（如物体边缘）通过路径传递，修正高层特征的定位误差 # P5​​可能检测到"狗在图像某处" N5​​结合低层细节后，能更准确定位狗的具体位置 # P5 + N5​​：增强高层语义的定位能力 # P2 + N2​​：为细节层补充语义理解 pan_features = [ p2 + n2, # 增强后的P2特征 p3 + n3, p4 + n4, p5 + n5 ] # 然后进入 多层级ROI Align池化 pooled =[]for feat, name in zip(pan_features, ['p2','p3','p4','p5']): # 对每个层级的特征进行ROI Align pooled.append(self.roi_align[name](feat, proposals)) # 特征融合（取各层级最大值） fused = torch.max(torch.stack(pooled), dim=0)[0] # [N,256,7,7] # 展平特征用于全连接层 flattened = fused.flatten(1) # [N, 256*7*7] # 预测输出 cls_logits = self.cls_head(flattened) # 分类分数 reg_preds = self.reg_head(flattened) # 回归偏移量 return cls_logits, reg_preds# -------------------- 训练验证代码 --------------------if __name__ == "__main__": # 超参数设置 batch_size =2num_epochs=5num_classes=80 # 数据加载 dataset = FakeCOCODataset() dataloader = torch.utils.data.DataLoader( dataset, batch_size=batch_size, collate_fn=coco_collate # 使用自定义整理函数 ) # 模型初始化并转移到设备 model = PANet(num_classes).to(device) # 优化器（Adam优化器） optimizer = torch.optim.Adam(model.parameters(), lr=0.001) # 损失函数 cls_criterion = nn.CrossEntropyLoss().to(device) # 分类损失 reg_criterion = nn.SmoothL1Loss().to(device) # 回归损失（对异常值更鲁棒） # 训练循环 forepochinrange(num_epochs):for batch_idx, (images, targets) in enumerate(dataloader): # 数据转移到设备 images = images.to(device) # 生成proposals（将标注框作为候选框） proposals =[]for i, t in enumerate(targets): # 构造proposal格式：[batch_index, x1, y1, x2, y2] batch_indices = torch.full((len(t['raw_boxes']),1), i, device=device) raw_boxes = t['raw_boxes'].to(device) proposal = torch.cat([batch_indices, raw_boxes], dim=1).float() proposals.append(proposal) proposals_tensor = torch.cat(proposals, dim=0) # 合并所有proposals # 前向传播 cls_out, reg_out = model(images, proposals_tensor) # 准备标签数据 gt_labels = torch.cat([t['labels']fortintargets]).long().to(device) gt_boxes = torch.cat([t['norm_boxes']fortin targets]).to(device) # 计算损失 cls_loss = cls_criterion(cls_out, gt_labels) reg_loss = reg_criterion(reg_out, gt_boxes) total_loss = cls_loss + reg_loss # 总损失为两者之和 # 反向传播与优化 optimizer.zero_grad() total_loss.backward() optimizer.step() # 每10个batch打印日志 if batch_idx % 10==0: print(f'Epoch [{epoch+1}/{num_epochs}] Batch [{batch_idx}/{len(dataloader)}]') print(f'分类损失: {cls_loss.item():.4f} 回归损失: {reg_loss.item():.4f}')