手撕yolov8代码

### 实现YOLOv5s模型训练代码 为了从零开始构建并训练YOLOv5s模型，需先安装PyTorch环境以及必要的依赖库。之后定义网络结构、损失函数，并准备数据集用于训练过程。 #### 安装依赖项 确保已安装Python 3.x版本，在命令行执行如下操作来设置开发环境： ```bash pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu113 pip install numpy opencv-python matplotlib albumentations ``` #### 导入所需模块 创建一个新的`.py`文件作为项目入口点，导入必需的Python包以支持后续工作流[^1]。 ```python import os from pathlib import Path import yaml import torch from torch.utils.data import DataLoader, Dataset import cv2 import numpy as np import random from tqdm.auto import tqdm from typing import List, Tuple import math ``` #### 数据预处理类 设计自定义的数据加载器，负责读取图像及其对应的标签信息，同时应用随机增强技术提高泛化能力。 ```python class CustomDataset(Dataset): def __init__(self, img_dir: str, label_file: str, transform=None): self.img_paths = list(Path(img_dir).glob('*.jpg')) with open(label_file, 'r') as f: lines = f.readlines() self.labels = {line.split()[0]: line.strip().split()[1:] for line in lines} self.transform = transform def __len__(self) -> int: return len(self.img_paths) def __getitem__(self, idx: int) -> Tuple[torch.Tensor, dict]: path = str(self.img_paths[idx]) image = cv2.imread(path) height, width = image.shape[:2] boxes = [] labels = [] if path.replace('.jpg', '') in self.labels.keys(): box_info = self.labels[path.replace('.jpg', '')] for info in box_info: class_id, center_x, center_y, bbox_w, bbox_h = map(float, info.split(',')) x_min = (center_x - bbox_h / 2.) * height x_max = (center_x + bbox_w / 2.) * width y_max = (center_y + bbox_h / 2.) * height boxes.append([x_min, y_min, x_max, y_max]) labels.append(int(class_id)) sample = {'image': image, 'boxes': torch.tensor(boxes), 'labels': torch.tensor(labels)} if self.transform is not None: transformed = self.transform(**sample) return transformed['image'], { "boxes": transformed["boxes"], "labels": transformed["labels"] } ``` #### 构建YOLOv5架构 基于官方论文描述搭建简化版YOLOv5小型网络[YOLOResult], 主要组件包括CSPDarknet骨干网和PANet颈部层连接FPN特征金字塔。 由于篇幅限制，这里仅给出部分核心代码片段展示如何初始化模型实例: ```python def conv_bn_relu(in_channels, out_channels, kernel_size=3, stride=1, padding=1): return nn.Sequential( nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, stride=stride, padding=padding), nn.BatchNorm2d(out_channels), nn.LeakyReLU(negative_slope=.1)) class CSPBlock(nn.Module): ... class SPPF(nn.Module): ... class YOLOv5s(nn.Module): def __init__(num_classes=80): super().__init__() # Backbone Network self.backbone = nn.Sequential(...) # Neck Layer self.neck = PANet(...) # Detection Head self.head = Detect(num_anchors_per_scale=..., num_classes=num_classes) def forward(x): backbone_out = self.backbone(x) neck_out = self.neck(backbone_out) output = self.head(neck_out) return output ``` #### 配置超参数与优化策略 设定初始学习率、权重衰减系数等关键配置选项；采用SGD或AdamW算法更新梯度；通过余弦退火调度器调整每轮迭代的学习速率大小。 ```python device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu") model = YOLOv5s(num_classes=len(CLASSES)).to(device=device) optimizer = torch.optim.Adam(model.parameters(), lr=INITIAL_LR, weight_decay=WDECAY) scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=EPOCHS) criterion = YoloLoss() train_loader = DataLoader(CustomDataset(...), batch_size=BATCH_SIZE, shuffle=True) val_loader = DataLoader(CustomDataset(...), batch_size=BATCH_SIZE*2, shuffle=False) ``` #### 开始训练循环 遍历整个数据集完成前向传播计算预测框坐标位置及类别概率分布；反向传递误差信号修正各层权值直至收敛为止。 ```python for epoch in range(EPOCHS): model.train() pbar = enumerate(train_loader) print(f'\nEpoch: [{epoch}]') loss_sum = 0. for i, data in pbar: images, targets = [_.to(device) for _ in data] optimizer.zero_grad(set_to_none=True) outputs = model(images) losses = criterion(outputs, targets) loss_value = sum(losses.values()) loss_value.backward() optimizer.step() scheduler.step() loss_sum += float(loss_value.item()) avg_loss = loss_sum/(i+1.) print(f'Average Loss:{avg_loss:.4f}') ```

### 手动实现 YOLOv1 算法 YOLO (You Only Look Once) 是一种实时目标检测算法，其核心思想是将输入图像划分为网格，并预测每个网格单元中的边界框及其类别概率。以下是关于手动实现 YOLOv1 的详细说明。 #### 1. 数据预处理 为了训练模型，需要对数据集进行标准化和标注转换。通常会使用 Pascal VOC 或 COCO 格式的标注数据[^1]。 ```python import cv2 import numpy as np def preprocess_image(image_path, input_size=448): image = cv2.imread(image_path) image_resized = cv2.resize(image, (input_size, input_size)) image_normalized = image_resized / 255.0 return image_normalized ``` #### 2. 构建网络结构 YOLOv1 使用了一个类似于 GoogLeNet 的卷积神经网络架构。可以通过 PyTorch 实现该网络结构。 ```python import torch.nn as nn class YOLOv1(nn.Module): def __init__(self, S=7, B=2, C=20): # 默认参数来自原始论文 super(YOLOv1, self).__init__() self.S = S self.B = B self.C = C self.features = nn.Sequential( nn.Conv2d(3, 64, kernel_size=7, stride=2), nn.LeakyReLU(0.1), nn.MaxPool2d(kernel_size=2, stride=2), nn.Conv2d(64, 192, kernel_size=3), nn.LeakyReLU(0.1), nn.MaxPool2d(kernel_size=2, stride=2), nn.Conv2d(192, 128, kernel_size=1), nn.Conv2d(128, 256, kernel_size=3), nn.Conv2d(256, 256, kernel_size=1), nn.Conv2d(256, 512, kernel_size=3), nn.MaxPool2d(kernel_size=2, stride=2), nn.Conv2d(512, 256, kernel_size=1), nn.Conv2d(256, 512, kernel_size=3), nn.Conv2d(512, 256, kernel_size=1), nn.Conv2d(256, 512, kernel_size=3), nn.Flatten(), nn.Linear(512 * ((448//32)**2), 4096), nn.Dropout(0.5), nn.LeakyReLU(0.1), nn.Linear(4096, S*S*(C+B*5)) # 输出层大小计算方式 ) def forward(self, x): x = self.features(x) x = x.view(-1, self.S, self.S, self.C + self.B * 5) return x ``` #### 3. 计算损失函数 YOLOv1 定义了一种多任务损失函数来联合优化分类、定位以及置信度估计的任务。 ```python class YoloLoss(nn.Module): def __init__(self, lambda_coord=5, lambda_noobj=0.5): super(YoloLoss, self).__init__() self.lambda_coord = lambda_coord self.lambda_noobj = lambda_noobj def forward(self, predictions, target): batch_size = predictions.size(0) predictions = predictions.reshape(batch_size, 7, 7, 30) iou_b1 = intersection_over_union(predictions[..., 21:25], target[..., 21:25]) iou_b2 = intersection_over_union(predictions[..., 26:30], target[..., 21:25]) ious = torch.cat([iou_b1.unsqueeze(0), iou_b2.unsqueeze(0)], dim=0) best_box = ious.argmax(dim=0).unsqueeze(-1) exists_box = target[..., 20].unsqueeze(3) box_predictions = exists_box * ( best_box * predictions[..., 26:30] + (1 - best_box) * predictions[..., 21:25] ) box_targets = exists_box * target[..., 21:25] box_predictions[..., 2:4] = torch.sign(box_predictions[..., 2:4]) * \ torch.sqrt(torch.abs(box_predictions[..., 2:4])) box_loss = self.lambda_coord * F.mse_loss(box_predictions, box_targets, reduction="sum") pred_box = best_box * predictions[..., 25:26] + (1 - best_box) * predictions[..., 20:21] object_loss = F.mse_loss(exists_box.squeeze() * pred_box.squeeze(), exists_box.squeeze() * target[..., 20].squeeze(), reduction="sum") no_object_loss = self.lambda_noobj * ( F.mse_loss((1 - exists_box) * predictions[..., 20:21], (1 - exists_box) * target[..., 20:21], reduction="sum") + F.mse_loss((1 - exists_box) * predictions[..., 25:26], (1 - exists_box) * target[..., 20:21], reduction="sum")) class_loss = F.mse_loss(exists_box.squeeze().permute(0, 2, 3, 1) @ predictions[..., :20], exists_box.squeeze().permute(0, 2, 3, 1) @ target[..., :20], reduction="sum") total_loss = box_loss + object_loss + no_object_loss + class_loss return total_loss ``` #### 4. 结果可视化与保存 可以利用 `matplotlib` 和其他工具库绘制检测结果并将其写入文件中[^2]。 ```python from matplotlib import pyplot as plt def visualize_results(image, boxes, labels=None): fig, ax = plt.subplots(1) ax.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB)) for box in boxes: rect = patches.Rectangle((box[0]-box[2]/2, box[1]-box[3]/2), box[2], box[3], linewidth=2, edgecolor='r', facecolor='none') ax.add_patch(rect) plt.show() ``` ---