【PyTorch】单目标检测项目

对象检测是在图像中查找特定对象位置的过程,用于处理单对象或多对象检测问题。单对象检测在给定图像中仅定位一个对象。对象的位置可以通过边界框定义。单对象检测使用四个数字预测边界框。对于正方形物体，可以固定宽度和高度，并简化问题以仅预测两个数字，例如使用两个数字来定位眼睛视网膜的中央凹。

目录

边界框定位格式

Training400数据集

探索性数据分析

用于对象检测的数据转换

创建自定义数据集

搭建残差网络模型

定义损失函数、优化器和 IOU 指标

模型训练与评估

---

边界框定位格式

以下列格式之一可以表示一个包含四个数字的边界框：

• [x0，y0，w，h]
• [x0、y0、x1、y1]
• [xc、yc、w、h]

• x0， y0： 边界框左上角的坐标
• x1， y1： 边界框右下角的坐标
• xc， yc： 边界框质心的坐标
• w， h： 边界框的宽度和高度

Training400数据集

年龄相关性黄斑变性，简称AMD，是黄斑区的一种退行性疾病。主要发生在45岁以上，发病率甚至高于老年糖尿病视网膜病变。
AMD的早期诊断对治疗和预后至关重要。眼底照相是眼底检查的基本方法之一。当前的数据集由AMD和非AMD（近视、正常对照等）照片组成。在这些照片中可以发现AMD的典型症状包括脉络膜小疣、渗出、出血等。

通过链接下载iChallenge-AMD-Training400.zip文件，将 .zip 文件移动到与代码位于同一位置的名为 data 的文件夹中。将 .zip 文件解压缩到名为 data/Training400 的文件夹中。文件夹应包含一个名为 AMD 的文件夹（89张图像），一个名为 Non-AMD 的文件夹（ 311 张图像），以及一个名为 Fovea_location.xlsx 的 Excel 文件（400张图像中中央凹的质心位置）

Home - Grand Challenge Age-related Macular Degeneration Challengehttps://amd.grand-challenge.org/也可借助以下链接下载

Baidu Research Open-Access Dataset - DownloadDownload Baidu Research Open-Access Datasethttps://ai.baidu.com/broad/download

探索性数据分析

通常进行探索性数据分析以了解数据的特征。在探索性数据分析中，检查数据集并使用箱线图、直方图和其他可视化工具可视化数据的样本或统计特征。

import os
import pandas as pd

path2data="./data/"
path2labels=os.path.join(path2data,"Training400","Fovea_location.xlsx")

# 读取Excel文件，将ID列作为索引。注意，1.2.0之后的xlrd不能直接读取xlsx文件，需指定引擎为openpyxl，
labels_df=pd.read_excel(path2labels,engine='openpyxl',index_col="ID")

# conda install seaborn
import seaborn as sns
# 设置matplotlib在jupyter中显示图像
%matplotlib inline

# 从labels_df中提取imgName列的第一个元素，并赋值给AorN
AorN=[imn[0] for imn in labels_df.imgName]
# 使用seaborn绘制散点图，x轴为labels_df中的Fovea_X列，y轴为labels_df中的Fovea_Y列，颜色映射依据为AorN
sns.scatterplot(x=labels_df['Fovea_X'], y=labels_df['Fovea_Y'],hue=AorN)

import numpy as np
from PIL import Image, ImageDraw
import matplotlib.pylab as plt

# 设置随机数生成器的种子，相同的种子将生成相同的随机数序列。有利于调试和重现结果。
np.random.seed(2019)

# 设置图形大小
plt.rcParams['figure.figsize'] = (14, 14)
# 调整子图之间的间距
plt.subplots_adjust(wspace=0, hspace=0)
# 设置子图的行数和列数
nrows,ncols=4,4

# 从labels_df中获取imgName列
imgName=labels_df["imgName"]

# 获取labels_df的索引
ids=labels_df.index

# 从ids中随机选择nrows*ncols个元素
rndIds=np.random.choice(ids,nrows*ncols)
print(rndIds)

def load_img_label(labels_df,id_):    
    # 获取图片名称
    imgName=labels_df["imgName"]    
    # 判断图片名称是否以"A"开头
    if imgName[id_][0]=="A":
        # 如果是，则前缀为"AMD"
        prefix="AMD"
    else:
        # 否则，前缀为"Non-AMD"
        prefix="Non-AMD"
            
    # 拼接图片路径
    fullPath2img=os.path.join(path2data,"Training400",prefix,imgName[id_])
    # 打开图片
    img = Image.open(fullPath2img)
    
    # 获取图片中心点坐标
    x=labels_df["Fovea_X"][id_]
    y=labels_df["Fovea_Y"][id_]
    
    # 返回图片和中心点坐标
    label=(x,y)
    return img,label

def show_img_label(img,label,w_h=(50,50),thickness=2):   
    # 定义函数show_img_label，用于在图像上绘制矩形框，并显示图像
    w,h=w_h                   
    # 获取矩形框的宽度和高度
    cx,cy=label
    
    draw = ImageDraw.Draw(img)
    # 创建一个绘图对象
    draw.rectangle(((cx-w/2, cy-h/2), (cx+w/2, cy+h/2)),outline="green",width=thickness)
    # 在图像上绘制矩形框，颜色为绿色，线宽为thickness

    plt.imshow(np.asarray(img))
    # 显示图像

# 遍历rndIds中的每个元素
for i,id_ in enumerate(rndIds):
    
    # 加载图片和标签
    img,label=load_img_label(labels_df,id_)   
    # 打印图片和标签的大小
    print(img.size,label)
    
    # 在子图中显示图片和标签
    plt.subplot(nrows, ncols, i+1) 
    show_img_label(img,label,w_h=(150,150),thickness=20)
    # 设置子图的标题为imgName中对应id_的值
    plt.title(imgName[id_])

 

# 定义两个空列表，用于存储图像的高度和宽度
h_list,w_list=[],[]
# 遍历ids列表中的每个元素
for id_ in ids:
    # 如果imgName[id_][0]等于"A"，则prefix为"AMD"，否则为"Non-AMD"
    if imgName[id_][0]=="A":
        prefix="AMD"
    else:
        prefix="Non-AMD"
        
    # 图像的完整路径
    fullPath2img=os.path.join(path2data,"Training400",prefix,imgName[id_])
        
    # 加载图像
    img = Image.open(fullPath2img)
    # 获取图像的高度和宽度
    h,w=img.size
    # 将高度和宽度添加到列表中
    h_list.append(h)
    w_list.append(w)

# 使用seaborn库中的distplot函数绘制直方图，参数a为数据列表，kde参数设置为False表示不绘制核密度估计曲线
sns.distplot(a=h_list, kde=False)

用于对象检测的数据转换

数据增强和转换是训练深度学习算法的关键步骤，尤其是对于小型数据集。这里的iChallenge-AMD数据集只有 400 张图像，可视为小数据集。由于图像的大小不同，需要将所有图像的大小调整为预先确定的大小。然后可以利用各种增强技术，例如水平翻转、垂直翻转和平移，在训练期间扩展数据集。

在对象检测任务中，当对图像进行转换时还需要更新标签。例如水平翻转图像时，图像中对象的位置会发生变化。需要构建一个用于在单对象检测中转换图像和标签的函数，包括水平翻转、垂直翻转、平移和调整大小等。

import torchvision.transforms.functional as TF

# 定义一个函数，用于调整图像和标签的大小
def resize_img_label(image,label=(0.,0.),target_size=(256,256)):
    # 获取原始图像的宽度和高度
    w_orig,h_orig = image.size   
    # 获取目标图像的宽度和高度
    w_target,h_target = target_size
    # 获取标签的坐标
    cx, cy= label
    
    # 调整图像大小
    image_new = TF.resize(image,target_size)
    # 调整标签大小
    label_new= cx/w_orig*w_target, cy/h_orig*h_target
    
    # 返回调整后的图像和标签
    return image_new,label_new

# 加载图片和标签
img, label=load_img_label(labels_df,1)   
# 打印图片和标签的大小
print(img.size,label)

# 调整图片和标签的大小
img_r,label_r=resize_img_label(img,label)
# 打印调整后图片和标签的大小
print(img_r.size,label_r)

# 在子图1中显示原始图片和标签
plt.subplot(1,2,1)
show_img_label(img,label,w_h=(150,150),thickness=20)
# 在子图2中显示调整后图片和标签
plt.subplot(1,2,2)
show_img_label(img_r,label_r)

# 定义一个函数，用于随机水平翻转图像和标签
def random_hflip(image,label):
    # 获取图像的宽度和高度
    w,h=image.size
    # 获取标签的坐标
    x,y=label        

    # 对图像进行水平翻转
    image = TF.hflip(image)
    # 更新标签的坐标
    label = w-x, y
    # 返回翻转后的图像和标签
    return image,label

# 加载图片和标签
img, label=load_img_label(labels_df,1)   

# 调整图片和标签的大小
img_r,label_r=resize_img_label(img,label)

# 随机水平翻转图片和标签
img_fh,label_fh=random_hflip(img_r,label_r)

# 显示原始图片和标签
plt.subplot(1,2,1)
show_img_label(img_r,label_r)
# 显示翻转后的图片和标签
plt.subplot(1,2,2)
show_img_label(img_fh,label_fh)

# 定义一个函数，用于随机垂直翻转图像和标签
def random_vflip(image,label):
    # 获取图像的宽度和高度
    w,h=image.size
    # 获取标签的坐标
    x,y=label

    # 对图像进行垂直翻转
    image = TF.vflip(image)
    # 翻转标签的坐标
    label = x, h-y
    # 返回翻转后的图像和标签
    return image, label

# 加载图片和标签
img, label=load_img_label(labels_df,7)   

# 调整图片和标签的大小
img_r,label_r=resize_img_label(img,label)

# 随机翻转图片和标签
img_fv,label_fv=random_vflip(img_r,label_r)

# 显示原始图片和标签
plt.subplot(1,2,1)
show_img_label(img_r,label_r)
# 显示翻转后的图片和标签
plt.subplot(1,2,2)
show_img_label(img_fv,label_fv)

import numpy as np
np.random.seed(1)

# 定义一个函数，用于对图像和标签进行随机平移
def random_shift(image,label,max_translate=(0.2,0.2)):
    # 获取图像的宽度和高度
    w,h=image.size
    # 获取最大平移量
    max_t_w, max_t_h=max_translate
    # 获取标签的坐标
    cx, cy=label

    # 生成一个随机数，范围在-1到1之间
    trans_coef=np.random.rand()*2-1
    # 计算平移量
    w_t = int(trans_coef*max_t_w*w)
    h_t = int(trans_coef*max_t_h*h)

    # 对图像进行平移
    image=TF.affine(image,translate=(w_t, h_t),shear=0,angle=0,scale=1)
    # 更新标签的坐标
    label = cx+w_t, cy+h_t
        
    # 返回平移后的图像和标签
    return image,label

# 加载图片和标签
img, label=load_img_label(labels_df,1)   

# 调整图片和标签的大小
img_r,label_r=resize_img_label(img,label)

# 随机平移图片和标签
img_t,label_t=random_shift(img_r,label_r,max_translate=(.5,.5))

# 显示原始图片和标签
plt.subplot(1,2,1)
show_img_label(img_r,label_r)
# 显示平移后的图片和标签
plt.subplot(1,2,2)
show_img_label(img_t,label_t)

# 定义一个transformer函数，用于对图像和标签进行变换
def transformer(image, label, params):
    # 调用resize_img_label函数，对图像和标签进行resize操作
    image,label=resize_img_label(image,label,params["target_size"])
    
    # 随机生成一个0-1之间的随机数，如果小于p_hflip，则对图像和标签进行水平翻转
    if random.random() < params["p_hflip"]:
        image,label=random_hflip(image,label)
        
    # 随机生成一个0-1之间的随机数，如果小于p_vflip，则对图像和标签进行垂直翻转
    if random.random() < params["p_vflip"]:            
        image,label=random_vflip(image,label)
        
    # 随机生成一个0-1之间的随机数，如果小于p_shift，则对图像和标签进行平移
    if random.random() < params["p_shift"]:                            
        image,label=random_shift(image,label, params["max_translate"])
        
    # 将图像转换为tensor类型
    image=TF.to_tensor(image)
    # 返回变换后的图像和标签
    return image, label

import random
# 设置随机数种子
np.random.seed(0)
random.seed(0)

# 从数据集中加载一张图片和对应的标签
img, label=load_img_label(labels_df,1)   

# 定义图像变换参数
params={
    "target_size" : (256, 256),  # 目标图像大小
    "p_hflip" : 1.0,  # 水平翻转概率
    "p_vflip" : 1.0,  # 垂直翻转概率
    "p_shift" : 1.0,  # 平移概率
    "max_translate": (0.2, 0.2),  # 最大平移距离
}
# 对图像进行变换
img_t,label_t=transformer(img,label,params)

# 创建一个1行2列的子图，并选择第一个子图
plt.subplot(1,2,1)
# 显示图片和标签，图片大小为150x150，线条粗细为20
show_img_label(img,label,w_h=(150,150),thickness=20)
# 创建一个1行2列的子图，并选择第二个子图
plt.subplot(1,2,2)
# 显示图片和标签，图片为img_t，标签为label_t
show_img_label(TF.to_pil_image(img_t),label_t)

调整图片亮度

# 加载图片和标签
img, label=load_img_label(labels_df,1)   

# 调整图片和标签的大小
img_r,label_r=resize_img_label(img,label)

# 调整图片的亮度
img_t=TF.adjust_brightness(img_r,brightness_factor=0.5)
label_t=label_r

# 显示原始图片和标签
plt.subplot(1,2,1)
show_img_label(img_r,label_r)
# 显示调整亮度后的图片和标签
plt.subplot(1,2,2)
show_img_label(img_t,label_t)

 

# 定义一个函数，用于将两个列表中的元素相除
def scale_label(a,b):
    # 使用zip函数将两个列表中的元素一一对应
    div = [ai/bi for ai,bi in zip(a,b)]
    # 返回相除后的结果
    return div

def transformer(image, label, params):
    # 调整图像和标签的大小
    image,label=resize_img_label(image,label,params["target_size"])

    # 随机水平翻转图像和标签
    if random.random() < params["p_hflip"]:
        image,label=random_hflip(image,label)
        
    # 随机垂直翻转图像和标签
    if random.random() < params["p_vflip"]:            
        image,label=random_vflip(image,label)
        
    # 随机平移图像和标签
    if random.random() < params["p_shift"]:                            
        image,label=random_shift(image,label, params["max_translate"])

    # 随机调整图像的亮度
    if random.random() < params["p_brightness"]:
        brightness_factor=1+(np.random.rand()*2-1)*params["brightness_factor"]
        image=TF.adjust_brightness(image,brightness_factor)

    # 随机调整图像的对比度
    if random.random() < params["p_contrast"]:
        contrast_factor=1+(np.random.rand()*2-1)*params["contrast_factor"]
        image=TF.adjust_contrast(image,contrast_factor)

    # 随机调整图像的gamma值
    if random.random() < params["p_gamma"]:
        gamma=1+(np.random.rand()*2-1)*params["gamma"]
        image=TF.adjust_gamma(image,gamma)

    # 如果需要，调整标签的大小
    if params["scale_label"]:
        label=scale_label(label,params["target_size"])
        
    # 将图像转换为张量
    image=TF.to_tensor(image)
    return image, label

# 设置随机种子，以保证结果的可重复性
np.random.seed(0)
random.seed(0)

# 从labels_df中加载第1张图片和对应的标签
img, label=load_img_label(labels_df,1)

#设定参数
params={
    "target_size" : (256, 256),
    "p_hflip" : 1.0,
    "p_vflip" : 1.0,
    "p_shift" : 1.0,
    "max_translate": (0.5, 0.5),
    "p_brightness": 1.0,
    "brightness_factor": 0.8,
    "p_contrast": 1.0,
    "contrast_factor": 0.8,
    "p_gamma": 1.0,
    "gamma": 0.4,
    "scale_label": False,
}
img_t,label_t=transformer(img,label,params)

# 创建一个1行2列的子图，并选择第一个子图
plt.subplot(1,2,1)
# 显示图片和标签，图片大小为150x150，线条粗细为20
show_img_label(img,label,w_h=(150,150),thickness=20)
# 创建一个1行2列的子图，并选择第二个子图
plt.subplot(1,2,2)
# 显示图片和标签，图片为img_t，标签为label_t
show_img_label(TF.to_pil_image(img_t),label_t)

 

创建自定义数据集

使用 torch.utils.data 中的 Dataset 类来创建用于加载和处理数据的自定义数据集，对 Dataset 类进行子类化并重写 __init__ 和 __getitem__ 函数。__len__ 函数返回数据集长度，可使用 Python len 函数调用。__getitem__ 函数返回指定索引处的图像。使用 torch.utils.data 中的 Dataloader 类来创建数据加载器。使用数据加载器自动获取小批量数据并进行处理。

from torch.utils.data import Dataset
from PIL import Image

class AMD_dataset(Dataset):
    def __init__(self, path2data, transform, trans_params):      
        # 初始化函数，传入数据路径、转换函数和转换参数
        pass    
      
    def __len__(self):
        # 返回数据集的大小
        return len(self.labels)
      
    def __getitem__(self, idx):
        # 根据索引获取数据集中的一个样本
        pass

def __init__(self, path2data, transform, trans_params):      

    # 获取标签文件的路径
    path2labels=os.path.join(path2data,"Training400","Fovea_location.xlsx")

    # 读取标签文件，并将ID列作为索引
    labels_df=pd.read_excel(path2labels,engine='openpyxl',index_col="ID")
    # 获取标签数据，包括Fovea_X和Fovea_Y两列
    self.labels = labels_df[["Fovea_X","Fovea_Y"]].values

    # 获取图片名称
    self.imgName=labels_df["imgName"]
    # 获取图片ID
    self.ids=labels_df.index

    # 获取图片的完整路径
    self.fullPath2img=[0]*len(self.ids)
    for id_ in self.ids:
        # 根据图片名称的前缀，确定图片所在的文件夹
        if self.imgName[id_][0]=="A":
            prefix="AMD"
        else:
            prefix="Non-AMD"
        # 获取图片的完整路径
        
        self.fullPath2img[id_-1]=os.path.join(path2data,"Training400",prefix,self.imgName[id_])

    # 获取数据转换函数和数据转换参数
    self.transform = transform
    self.trans_params=trans_params

def __getitem__(self, idx):
    # 打开指定索引的图像
    image = Image.open(self.fullPath2img[idx])  
    # 获取指定索引的标签
    label= self.labels[idx]

    # 对图像和标签进行变换
    image,label = self.transform(image,label,self.trans_params)

    # 返回变换后的图像和标签
    return image, label

# 重写函数
AMD_dataset.__init__=__init__
AMD_dataset.__getitem__=__getitem__

# 定义训练过程中的参数
trans_params_train={
    "target_size" : (256, 256),  # 目标图像大小
    "p_hflip" : 0.5,  # 水平翻转概率
    "p_vflip" : 0.5,  # 垂直翻转概率
    "p_shift" : 0.5,  # 平移概率
    "max_translate": (0.2, 0.2),  # 最大平移量
    "p_brightness": 0.5,  # 亮度调整概率
    "brightness_factor": 0.2,  # 亮度调整因子
    "p_contrast": 0.5,  # 对比度调整概率
    "contrast_factor": 0.2,  # 对比度调整因子
    "p_gamma": 0.5,  # 伽马调整概率
    "gamma": 0.2,  # 伽马调整因子
    "scale_label": True,  # 是否调整标签大小
}

# 定义验证过程中的参数
trans_params_val={
    "target_size" : (256, 256),
    "p_hflip" : 0.0,
    "p_vflip" : 0.0,
    "p_shift" : 0.0,
    "p_brightness": 0.0,
    "p_contrast": 0.0,
    "p_gamma": 0.0,
    "gamma": 0.0,
    "scale_label": True,    
}

# 创建AMD_dataset类的实例，用于训练集
amd_ds1=AMD_dataset(path2data,transformer,trans_params_train)
# 创建AMD_dataset类的实例，用于验证集
amd_ds2=AMD_dataset(path2data,transformer,trans_params_val)

from sklearn.model_selection import ShuffleSplit

# 创建ShuffleSplit对象，设置分割次数为1，测试集大小为0.2，随机种子为0
sss = ShuffleSplit(n_splits=1, test_size=0.2, random_state=0)

# 创建索引列表
indices=range(len(amd_ds1))

# 遍历ShuffleSplit对象，获取训练集和验证集的索引
for train_index, val_index in sss.split(indices):
    # 打印训练集的长度
    print(len(train_index))
    # 打印分隔符
    print("-"*10)
    # 打印验证集的长度
    print(len(val_index))

from torch.utils.data import Subset

# 创建训练集子集
train_ds=Subset(amd_ds1,train_index)
# 打印训练集子集的长度
print(len(train_ds))
print("-"*10)
# 创建验证集子集
val_ds=Subset(amd_ds2,val_index)
# 打印验证集子集的长度
print(len(val_ds))

import matplotlib.pyplot as plt
import numpy as np
%matplotlib inline

np.random.seed(0)

def show(img,label=None):
    # 将img转换为numpy数组，并转置维度
    npimg = img.numpy().transpose((1,2,0))
    # 显示图片
    plt.imshow(npimg)
    # 如果label不为空
    if label is not None:
        # 将label缩放到图片尺寸
        label=rescale_label(label,img.shape[1:])        
        # 获取label的x和y坐标
        x,y=label
        # 在图片上绘制label
        plt.plot(x,y,'b+',markersize=20) 

# 创建一个5x5大小的图像
plt.figure(figsize=(5,5))
# 遍历训练数据集
for img,label in train_ds:
    # 显示图像和标签
    show(img,label)
    # 只显示第一张图像和标签
    break

plt.figure(figsize=(5,5))
# 遍历验证数据集
for img,label in val_ds:
    show(img,label)
    break

from torch.utils.data import DataLoader
# 创建训练数据集的DataLoader，batch_size为8，shuffle为True，表示每次迭代时都会打乱数据集
train_dl = DataLoader(train_ds, batch_size=8, shuffle=True)
# 创建验证数据集的DataLoader，batch_size为16，shuffle为False，表示每次迭代时不会打乱数据集
val_dl = DataLoader(val_ds, batch_size=16, shuffle=False) 

# 遍历训练数据集
for img_b, label_b in train_dl:
    # 打印图像的形状和数据类型
    print(img_b.shape,img_b.dtype)
    print(label_b)
    break 

import torch

# 遍历训练数据集
for img_b, label_b in train_dl:
    # 打印图片的形状和数据类型
    print(img_b.shape,img_b.dtype)
    # 将标签堆叠成一维向量
    label_b=torch.stack(label_b,1)
    # 将标签的数据类型转换为浮点型
    label_b=label_b.type(torch.float32)
    # 打印标签的形状和数据类型
    print(label_b.shape,label_b.dtype)
    break

# 遍历验证集数据
for img_b, label_b in val_dl:
    # 打印图片的形状和数据类型
    print(img_b.shape,img_b.dtype)
    # 将标签堆叠成一维向量
    label_b=torch.stack(label_b,1)
    # 将标签的数据类型转换为浮点型
    label_b=label_b.type(torch.float32)
    # 打印标签的形状和数据类型
    print(label_b.shape,label_b.dtype)
    break

搭建残差网络模型

残差网络（Residual Network），也被称为ResNet，是一种深度神经网络架构，旨在解决梯度消失和训练困难的问题。核心思想是通过引入残差块（residual blocks）来构建网络，并通过跳跃连接将输入直接添加到层输出上。残差块就是包含了跳跃连接的块。具体而言，在每个块或子模块内部，输入被加到该块/子模块计算后得到的输出上，并且这两者尺寸必须相同。然后再将此结果送入下一个块/子模块进行处理。

将中央凹中心预测为眼睛图像中的x和y坐标，构建一个由多个卷积层和池化层组成的模型。

该模型将接收调整好的RGB图像，提供与中央凹坐标相对应的两个线性输出。模型将利用ResNet论文Deep Residual Learning for Image Recognition中介绍的skip connection跳跃连接技术。

 

跳跃连接指的是将输入数据直接添加到网络某一层输出之上。这种设计使得信息可以更自由地流动，并且保留了原始输入数据中的细节和语义信息。 使信息更容易传播到后面的层次，避免了信息丢失。跳跃连接通常会通过求和操作或拼接操作来实现。

 

import torch.nn as nn
import torch.nn.functional as F

# 定义一个Net类，继承自nn.Module类
class Net(nn.Module):
    # 初始化函数，接收一个参数params
    def __init__(self, params):
        # 调用父类的初始化函数
        super(Net, self).__init__()

    # 定义前向传播函数，接收一个参数x
    def forward(self, x):
        return x

# 定义一个初始化函数，接收参数params
def __init__(self, params):
    # 初始化父类Net
    super(Net, self).__init__()

    # 获取输入形状
    C_in,H_in,W_in=params["input_shape"]
    # 获取初始滤波器数量
    init_f=params["initial_filters"] 
    # 获取输出数量
    num_outputs=params["num_outputs"] 

    # 定义卷积层
    self.conv1 = nn.Conv2d(C_in, init_f, kernel_size=3,stride=2,padding=1)
    self.conv2 = nn.Conv2d(init_f+C_in, 2*init_f, kernel_size=3,stride=1,padding=1)
    self.conv3 = nn.Conv2d(3*init_f+C_in, 4*init_f, kernel_size=3,padding=1)
    self.conv4 = nn.Conv2d(7*init_f+C_in, 8*init_f, kernel_size=3,padding=1)
    self.conv5 = nn.Conv2d(15*init_f+C_in, 16*init_f, kernel_size=3,padding=1)
    # 定义全连接层1
    self.fc1 = nn.Linear(16*init_f, num_outputs)

# 定义前向传播函数
def forward(self, x):
    # 对输入进行平均池化，池化核大小为4，步长为4
    identity=F.avg_pool2d(x,4,4)
    # 对输入进行卷积操作，并使用ReLU激活函数
    x = F.relu(self.conv1(x))
    # 对输入进行最大池化，池化核大小为2，步长为2
    x = F.max_pool2d(x, 2, 2)
    # 将卷积后的结果与池化后的结果进行拼接
    x = torch.cat((x, identity), dim=1)

    # 对输入进行平均池化，池化核大小为2，步长为2
    identity=F.avg_pool2d(x,2,2)
    # 对输入进行卷积操作，并使用ReLU激活函数
    x = F.relu(self.conv2(x))
    # 对输入进行最大池化，池化核大小为2，步长为2
    x = F.max_pool2d(x, 2, 2)
    # 将卷积后的结果与池化后的结果进行拼接
    x = torch.cat((x, identity), dim=1)

    # 对输入进行平均池化，池化核大小为2，步长为2
    identity=F.avg_pool2d(x,2,2)
    # 对输入进行卷积操作，并使用ReLU激活函数
    x = F.relu(self.conv3(x))
    # 对输入进行最大池化，池化核大小为2，步长为2
    x = F.max_pool2d(x, 2, 2)
    # 将卷积后的结果与池化后的结果进行拼接
    x = torch.cat((x, identity), dim=1)
    
    # 对输入进行平均池化，池化核大小为2，步长为2
    identity=F.avg_pool2d(x,2,2)
    # 对输入进行卷积操作，并使用ReLU激活函数
    x = F.relu(self.conv4(x))
    # 对输入进行最大池化，池化核大小为2，步长为2
    x = F.max_pool2d(x, 2, 2)
    # 将卷积后的结果与池化后的结果进行拼接
    x = torch.cat((x, identity), dim=1)

    # 对输入进行卷积操作，并使用ReLU激活函数
    x = F.relu(self.conv5(x))

    # 对输入进行自适应平均池化，池化核大小为1
    x=F.adaptive_avg_pool2d(x,1)
    # 将输入展平成一维向量
    x = x.reshape(x.size(0), -1)

    # 对输入进行全连接操作
    x = self.fc1(x)
    return x    

# 重写
Net.__init__=__init__
Net.forward=forward

# 定义模型参数
params_model={
        "input_shape": (3,256,256), 
        "initial_filters": 16, 
        "num_outputs": 2,  
            }

# 创建模型
model = Net(params_model)

# 检查CUDA是否可用
if torch.cuda.is_available():
    # 如果可用，将设备设置为CUDA
    device = torch.device("cuda")
    # 将模型移动到CUDA设备上
    model=model.to(device) 
print(model)

定义损失函数、优化器和 IOU 指标

单对象/多对象检测问题的常见损耗函数是均方误差（MSE）和平滑L1损耗。如果绝对元素误差低于 1，则平滑 L1 损失使用平方项，否则使用 L1 项。它对异常值的敏感度低于 MSE，并且在某些情况下可以防止梯度爆炸。这里将使用平滑的 L1 损失。平滑 L1 损失可以参照：

torch.nn — PyTorch 2.3 documentationhttps://pytorch.org/docs/stable/nn.html#smoothl1loss为自动更新模型参数还需要定义优化器。最后为对象检测问题定义一个性能指标，称为 Jaccard 指数，即Intersection over Union（IOU）。

# 定义损失函数，使用SmoothL1Loss，reduction参数设置为"sum"，表示将所有样本的损失相加
loss_func = nn.SmoothL1Loss(reduction="sum")    

# 定义变量n和c
n,c=8,2
# 定义变量y，形状为(n, c)，值为0.5，requires_grad=True表示需要计算梯度
y = 0.5 * torch.ones(n, c, requires_grad=True)
# 打印y的形状
print(y.shape)

# 定义变量target，形状为(n, c)，值为0，requires_grad=False表示不需要计算梯度
target = torch.zeros(n, c, requires_grad=False)
# 打印target的形状
print(target.shape)

# 计算损失函数，loss_func为自定义的损失函数
loss = loss_func(y, target)
# 打印损失函数的值
print(loss.item())

# 重新定义变量y，形状为(n, c)，值为2，requires_grad=True表示需要计算梯度
y = 2 * torch.ones(n, c, requires_grad=True)
# 重新定义变量target，形状为(n, c)，值为0，requires_grad=False表示不需要计算梯度
target = torch.zeros(n, c, requires_grad=False)
# 重新计算损失函数
loss = loss_func(y, target)
# 打印损失函数的值
print(loss.item())

from torch import optim

# 定义优化器，使用Adam优化算法，优化模型参数，学习率为3e-4
opt = optim.Adam(model.parameters(), lr=3e-4)

# 定义一个函数，用于获取当前的学习率
def get_lr(opt):
    # 遍历opt中的param_groups
    for param_group in opt.param_groups:
        # 返回param_group中的学习率
        return param_group['lr']

# 调用get_lr函数，获取当前的学习率
current_lr=get_lr(opt)
# 打印当前的学习率
print('current lr={}'.format(current_lr))

 

from torch.optim.lr_scheduler import ReduceLROnPlateau

# 定义学习率调度器，当验证集上的损失不再下降时，将学习率降低为原来的0.5倍，等待20个epoch后再次降低学习率
lr_scheduler = ReduceLROnPlateau(opt, mode='min',factor=0.5, patience=20,verbose=1)
# 遍历100次
for i in range(100):
    # 每次循环调用lr_scheduler.step(1)方法
    lr_scheduler.step(1)

# 定义一个函数，将中心坐标和宽高转换为边界框
def cxcy2bbox(cxcy,w=50./256,h=50./256):
    # 创建一个与cxcy形状相同的张量，每个元素都为w
    w_tensor=torch.ones(cxcy.shape[0],1,device=cxcy.device)*w
    # 创建一个与cxcy形状相同的张量，每个元素都为h
    h_tensor=torch.ones(cxcy.shape[0],1,device=cxcy.device)*h

    # 将cxcy的第一列提取出来，并增加一个维度
    cx=cxcy[:,0].unsqueeze(1)
    # 将cxcy的第二列提取出来，并增加一个维度
    cy=cxcy[:,1].unsqueeze(1)
    
    # 将cx、cy、w_tensor、h_tensor按列拼接起来
    boxes=torch.cat((cx,cy, w_tensor, h_tensor), -1) 
    
    # 将boxes的第二列和第三列相减，第四列和第五列相加，并按行拼接起来
    return torch.cat((boxes[:, :2] - boxes[:, 2:]/2, boxes[:, :2] + boxes[:, 2:]/2), 1) 

# 设置随机种子
torch.manual_seed(0)

# 生成一个1行2列的随机数矩阵
cxcy=torch.rand(1,2)
# 打印中心点坐标
print("center:", cxcy*256)

# 将中心点坐标转换为边界框
bb=cxcy2bbox(cxcy)
# 打印边界框
print("bounding box", bb*256)

import torchvision
# 定义一个函数，用于计算输出和目标之间的IOU
def metrics_batch(output, target):
    # 将输出和目标转换为边界框格式
    output=cxcy2bbox(output)
    target=cxcy2bbox(target)
    
    # 计算输出和目标之间的IOU
    iou=torchvision.ops.box_iou(output, target)
    # 返回对角线上的IOU之和
    return torch.diagonal(iou, 0).sum().item()

# 定义n和c的值
n,c=8,2
# 生成一个随机张量，形状为(n, c)，并将其放在device上
target = torch.rand(n, c, device=device)
# 将cxcy格式的目标转换为bbox格式的目标
target=cxcy2bbox(target)
# 计算batch中的指标
metrics_batch(target,target)

# 定义一个函数loss_batch，用于计算损失函数
def loss_batch(loss_func, output, target, opt=None): 
    # target：真实值
    pass  
    # 计算损失函数的输出
    loss = loss_func(output, target)
    
    # 计算批量的度量
    metric_b = metrics_batch(output,target)
    
    # 如果有优化器，则进行反向传播和参数更新
    if opt is not None:
        opt.zero_grad()  # 将梯度清零
        loss.backward()  # 反向传播
        opt.step()  # 更新参数

    # 返回损失和度量
    return loss.item(), metric_b

# 遍历训练数据集
for xb,label_b in train_dl:
    # 将标签数据堆叠成一维张量
    label_b=torch.stack(label_b,1)
    # 将标签数据转换为浮点型
    label_b=label_b.type(torch.float32)
    # 将标签数据移动到指定设备上
    label_b=label_b.to(device)
 
    # 计算损失函数
    l,m=loss_batch(loss_func,label_b,label_b)
    # 打印损失函数的值
    print(l,m)
    break

模型训练与评估

为提高代码的可读性，定义一些辅助函数。

# 定义一个函数，用于计算模型在数据集上的损失和指标
def loss_epoch(model,loss_func,dataset_dl,sanity_check=False,opt=None):
    # 初始化运行损失和运行指标
    running_loss=0.0
    running_metric=0.0
    # 获取数据集的长度
    len_data=len(dataset_dl.dataset)

    # 遍历数据集
    for xb, yb in dataset_dl:
        # 将标签堆叠成一维张量
        yb=torch.stack(yb,1)
        # 将标签转换为浮点型，并移动到设备上
        yb=yb.type(torch.float32).to(device)
        
        # 将输入数据移动到设备上，并获取模型输出
        output=model(xb.to(device))
        
        # 计算当前批次的损失和指标
        loss_b,metric_b=loss_batch(loss_func, output, yb, opt)
        
        # 累加损失
        running_loss+=loss_b
        
        # 如果指标不为空，则累加指标
        if metric_b is not None:
            running_metric+=metric_b

    # 计算平均损失
    loss=running_loss/float(len_data)
    
    # 计算平均指标
    metric=running_metric/float(len_data)
    
    # 返回平均损失和平均指标
    return loss, metric

import copy
# 定义一个函数，用于训练和验证模型
def train_val(model, params):
    # 获取训练参数
    num_epochs=params["num_epochs"]
    loss_func=params["loss_func"]
    opt=params["optimizer"]
    train_dl=params["train_dl"]
    val_dl=params["val_dl"]
    sanity_check=params["sanity_check"]
    lr_scheduler=params["lr_scheduler"]
    path2weights=params["path2weights"]
    
    # 初始化损失历史和指标历史
    loss_history={ 
        "train": [],
        "val": [],
    }
    
    metric_history={ 
        "train": [],
        "val": [],
    }    
    
    # 复制当前模型参数
    best_model_wts = copy.deepcopy(model.state_dict())
    
    # 初始化最佳损失
    best_loss=float('inf')    
    
    # 开始训练
    for epoch in range(num_epochs):
        # 获取当前学习率
        current_lr=get_lr(opt)
        # 打印当前训练轮数和学习率
        print('Epoch {}/{}, current lr={}'.format(epoch, num_epochs - 1, current_lr))    
        # 设置模型为训练模式
        model.train() 
        # 计算训练损失和指标
        train_loss, train_metric=loss_epoch(model,loss_func,train_dl,sanity_check,opt) 
        # 将训练损失和训练指标添加到历史记录中        
        loss_history["train"].append(train_loss) 
        metric_history["train"].append(train_metric) 

        # 设置模型为评估模式
        model.eval() 
        with torch.no_grad(): # 不计算梯度
            # 计算验证损失和指标
            val_loss, val_metric=loss_epoch(model,loss_func,val_dl,sanity_check) 
        
        # 将验证损失和验证指标添加到历史记录中
        loss_history["val"].append(val_loss) 
        metric_history["val"].append(val_metric)  
        
        
        # 如果验证损失小于最佳损失，则更新最佳损失和最佳模型参数
        if val_loss < best_loss:
            best_loss = val_loss
            best_model_wts = copy.deepcopy(model.state_dict())
            
            torch.save(model.state_dict(), path2weights) # 保存最佳模型参数
            print("Copied best model weights!") # 打印保存成功信息
            
        lr_scheduler.step(val_loss) # 更新学习率
        # 如果学习率发生变化，则加载最佳模型参数
        if current_lr != get_lr(opt):
            print("Loading best model weights!")
            model.load_state_dict(best_model_wts) 
            


        print("train loss: %.6f, accuracy: %.2f" %(train_loss,100*train_metric)) # 打印训练损失和指标
        print("val loss: %.6f, accuracy: %.2f" %(val_loss,100*val_metric)) # 打印验证损失和指标
        print("-"*10) 
        

    model.load_state_dict(best_model_wts) # 加载最佳模型参数
    return model, loss_history, metric_history # 返回模型、损失历史和指标历史
            

# 定义损失函数为SmoothL1Loss，reduction参数为sum
loss_func=nn.SmoothL1Loss(reduction="sum")
# 定义优化器为Adam，学习率为1e-4
opt = optim.Adam(model.parameters(), lr=1e-4)
# 定义学习率调度器，当验证集上的损失不再下降时，将学习率乘以0.5，等待20个epoch，并输出信息
lr_scheduler = ReduceLROnPlateau(opt, mode='min',factor=0.5, patience=20,verbose=1)

# 定义模型保存路径
path2models= "./models/"
# 如果路径不存在，则创建路径
if not os.path.exists(path2models):
        os.mkdir(path2models)

# 定义训练参数
params_train={
    "num_epochs": 100,  # 训练的epoch数
    "optimizer": opt,  # 优化器
    "loss_func": loss_func,  # 损失函数
    "train_dl": train_dl,  # 训练数据集
    "val_dl": val_dl,  # 验证数据集
    "sanity_check": False,  # 是否进行sanity check
    "lr_scheduler": lr_scheduler,  # 学习率调度器
    "path2weights": path2models+"weights_smoothl1.pt",  # 模型保存路径
}

# 调用train_val函数进行训练和验证
model,loss_hist,metric_hist=train_val(model,params_train)

# 获取训练参数中的训练轮数
num_epochs=params_train["num_epochs"]

# 绘制训练和验证损失曲线
plt.title("Train-Val Loss")
plt.plot(range(1,num_epochs+1),loss_hist["train"],label="train")
plt.plot(range(1,num_epochs+1),loss_hist["val"],label="val")
plt.ylabel("Loss")
plt.xlabel("Training Epochs")
plt.legend()
plt.show()

 

# 绘制训练和验证精度曲线
plt.title("Train-Val Accuracy")
plt.plot(range(1,num_epochs+1),metric_hist["train"],label="train")
plt.plot(range(1,num_epochs+1),metric_hist["val"],label="val")
plt.ylabel("Accuracy")
plt.xlabel("Training Epochs")
plt.legend()
plt.show()