devbox
运维做开发
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【PyTorch】单目标检测项目部署

作者：运维做开发 | 2024-08-02 23:57:37

赞

踩

【PyTorch】单目标检测项目部署

 【PyTorch】单目标检测项目

两种部署情况：部署在 PyTorch 数据集上，以及部署在本地存储的单个映像上。

目录

定义数据集

搭建模型

部署模型

定义数据集

详细参照前文【PyTorch】单目标检测项目

  1. import torchvision
  2. import os
  3. import pandas as pd
  4. import matplotlib.pylab as plt
  5. import torch
  6. %matplotlib inline
  7.  
  8. # 定义一个函数，用于将a列表中的元素除以b列表中的对应元素，返回一个新的列表
  9. def scale_label(a,b):
  10.     # 使用zip函数将a和b列表中的元素一一对应
  11.     div = [ai/bi for ai,bi in zip(a,b)]
  12.     # 返回新的列表
  13.     return div
  14.  
  15. # 定义一个函数，用于将a列表中的元素乘以b列表中的对应元素，返回一个新的列表
  16. def rescale_label(a,b):
  17.     # 使用zip函数将a和b列表中的元素一一对应
  18.     div = [ai*bi for ai,bi in zip(a,b)]
  19.     # 返回新的列表
  20.     return div
  21.  
  22. import torchvision.transforms.functional as TF
  23.  
  24. # 定义一个函数，用于调整图像和标签的大小
  25. def resize_img_label(image,label=(0.,0.),target_size=(256,256)):
  26.     # 获取原始图像的宽度和高度
  27.     w_orig,h_orig = image.size   
  28.     # 获取目标图像的宽度和高度
  29.     w_target,h_target = target_size
  30.     # 获取标签的坐标
  31.     cx, cy= label
  32.     
  33.     # 调整图像大小
  34.     image_new = TF.resize(image,target_size)
  35.     # 调整标签大小
  36.     label_new= cx/w_orig*w_target, cy/h_orig*h_target
  37.  
  38. # 定义一个transformer函数，用于对图像和标签进行变换
  39. def transformer(image, label, params):
  40.     # 调用resize_img_label函数，对图像和标签进行尺寸调整
  41.     image,label=resize_img_label(image,label,params["target_size"])
  42.  
  43.     # 如果params中scale_label参数为True，则调用scale_label函数，对标签进行缩放
  44.     if params["scale_label"]:
  45.         label=scale_label(label,params["target_size"])
  46.         
  47.     # 将图像转换为张量
  48.     image=TF.to_tensor(image)
  49.     # 返回变换后的图像和标签
  50.     return image, label
  51.  
  52. from torch.utils.data import Dataset
  53. from PIL import Image
  54.  
  55. class AMD_dataset(Dataset):
  56.     def __init__(self, path2data, transform, trans_params):      
  57.         # 初始化函数，传入数据路径、转换函数和转换参数
  58.         pass    
  59.     def __len__(self):
  60.         # 返回数据集的大小
  61.         return len(self.labels)
  62.     def __getitem__(self, idx):
  63.         # 根据索引获取数据集中的一个样本
  64.         pass
  65.     
  66.     # 返回调整后的图像和标签
  67.     return image_new,label_new
  68.  
  69. def __init__(self, path2data, transform, trans_params):      
  70.  
  71.     # 获取标签文件路径
  72.     path2labels=os.path.join(path2data,"Training400","Fovea_location.xlsx")
  73.  
  74.     # 读取标签文件
  75.     labels_df=pd.read_excel(path2labels,engine='openpyxl',index_col="ID")
  76.  
  77.     # 获取标签数据
  78.     self.labels = labels_df[["Fovea_X","Fovea_Y"]].values
  79.  
  80.     # 获取图片名称
  81.     self.imgName=labels_df["imgName"]
  82.     # 获取图片ID
  83.     self.ids=labels_df.index
  84.  
  85.     # 获取图片全路径
  86.     self.fullPath2img=[0]*len(self.ids)
  87.     for id_ in self.ids:
  88.         # 根据图片名称判断图片类型
  89.         if self.imgName[id_][0]=="A":
  90.             prefix="AMD"
  91.         else:
  92.             prefix="Non-AMD"
  93.  
  94.         # 获取图片全路径
  95.         self.fullPath2img[id_-1]=os.path.join(path2data,"Training400",prefix,self.imgName[id_])
  96.  
  97.     # 获取数据转换函数
  98.     self.transform = transform
  99.     # 获取数据转换参数
  100.     self.trans_params=trans_params
  101.  
  102. def __getitem__(self, idx):
  103.     # 打开指定索引的图像
  104.     image = Image.open(self.fullPath2img[idx])  
  105.     # 获取指定索引的标签
  106.     label= self.labels[idx]
  107.  
  108.     # 对图像和标签进行变换
  109.     image,label = self.transform(image,label,self.trans_params)
  110.  
  111.     # 返回变换后的图像和标签
  112.     return image, label
  113.  
  114. #重写
  115. AMD_dataset.__init__=__init__
  116. AMD_dataset.__getitem__=__getitem__
  117.  
  118. path2data="./data/"
  119.  
  120. #验证参数
  121. trans_params_val={
  122.     "target_size" : (256, 256),
  123.     "p_hflip" : 0.0,
  124.     "p_vflip" : 0.0,
  125.     "p_shift" : 0.0,
  126.     "p_brightness": 0.0,
  127.     "p_contrast": 0.0,
  128.     "p_gamma": 0.0,
  129.     "gamma": 0.0,
  130.     "scale_label": True,    
  131. }
  132. amd_ds2=AMD_dataset(path2data,transformer,trans_params_val)
  133.  
  134.  
  135. from sklearn.model_selection import ShuffleSplit
  136.  
  137. sss = ShuffleSplit(n_splits=1, test_size=0.2, random_state=0)
  138.  
  139. indices=range(len(amd_ds2))
  140.  
  141. for train_index, val_index in sss.split(indices):
  142.     print(len(train_index))
  143.     print("-"*10)
  144.     print(len(val_index))
  145.  
  146. from torch.utils.data import Subset
  147.  
  148. # 创建一个Subset对象，将amd_ds2数据集按照val_index索引进行划分，得到验证集val_ds
  149. val_ds=Subset(amd_ds2,val_index)
  150.  
  151. from torch.utils.data import DataLoader
  152. # 创建一个DataLoader对象，用于加载验证集数据
  153. val_dl = DataLoader(val_ds, batch_size=16, shuffle=False)

 

搭建模型

 详细参照前文【PyTorch】单目标检测项目

  1. import torch.nn as nn
  2. import torch.nn.functional as F
  3.  
  4. class Net(nn.Module):
  5.     def __init__(self, params):
  6.         super(Net, self).__init__()
  7.     
  8.     def forward(self, x):
  9.         return x
  10.  
  11. def __init__(self, params):
  12.     super(Net, self).__init__()
  13.  
  14.     C_in,H_in,W_in=params["input_shape"]
  15.     init_f=params["initial_filters"] 
  16.     num_outputs=params["num_outputs"] 
  17.  
  18.     self.conv1 = nn.Conv2d(C_in, init_f, kernel_size=3,stride=2,padding=1)
  19.     self.conv2 = nn.Conv2d(init_f+C_in, 2*init_f, kernel_size=3,stride=1,padding=1)
  20.     self.conv3 = nn.Conv2d(3*init_f+C_in, 4*init_f, kernel_size=3,padding=1)
  21.     self.conv4 = nn.Conv2d(7*init_f+C_in, 8*init_f, kernel_size=3,padding=1)
  22.     self.conv5 = nn.Conv2d(15*init_f+C_in, 16*init_f, kernel_size=3,padding=1)
  23.     self.fc1 = nn.Linear(16*init_f, num_outputs)
  24.  
  25. def forward(self, x):
  26.     identity=F.avg_pool2d(x,4,4)
  27.     x = F.relu(self.conv1(x))
  28.     x = F.max_pool2d(x, 2, 2)
  29.     x = torch.cat((x, identity), dim=1)
  30.  
  31.     identity=F.avg_pool2d(x,2,2)
  32.     x = F.relu(self.conv2(x))
  33.     x = F.max_pool2d(x, 2, 2)
  34.     x = torch.cat((x, identity), dim=1)
  35.  
  36.     identity=F.avg_pool2d(x,2,2)
  37.     x = F.relu(self.conv3(x))
  38.     x = F.max_pool2d(x, 2, 2)
  39.     x = torch.cat((x, identity), dim=1)
  40.  
  41.     identity=F.avg_pool2d(x,2,2)
  42.     x = F.relu(self.conv4(x))
  43.     x = F.max_pool2d(x, 2, 2)
  44.     x = torch.cat((x, identity), dim=1)
  45.  
  46.     x = F.relu(self.conv5(x))
  47.  
  48.     x=F.adaptive_avg_pool2d(x,1)
  49.     x = x.reshape(x.size(0), -1)
  50.  
  51.     x = self.fc1(x)
  52.     return x
  53.  
  54. Net.__init__=__init__
  55. Net.forward=forward
  56.  
  57. params_model={
  58.         "input_shape": (3,256,256),
  59.         "initial_filters": 16, 
  60.         "num_outputs": 2,
  61.             }
  62. model = Net(params_model)
  63. model.eval()
  64.  
  65. if torch.cuda.is_available():
  66.     device = torch.device("cuda")
  67.     model=model.to(device)

部署模型

  1. path2weights="./models/weights.pt"
  2. # 加载模型权重
  3. model.load_state_dict(torch.load(path2weights))
  4.  
  5. # 定义设备为GPU
  6. device = torch.device("cuda")
  7.  
  8. # 定义一个函数，用于计算模型在数据集上的损失和指标
  9. def loss_epoch(model,loss_func,dataset_dl,sanity_check=False,opt=None):
  10.     # 初始化运行损失和运行指标
  11.     running_loss=0.0
  12.     running_metric=0.0
  13.     # 获取数据集的长度
  14.     len_data=len(dataset_dl.dataset)
  15.  
  16.     # 遍历数据集
  17.     for xb, yb in dataset_dl:
  18.         # 将标签堆叠成一维张量
  19.         yb=torch.stack(yb,1)
  20.         # 将标签转换为浮点型，并移动到GPU上
  21.         yb=yb.type(torch.float32).to(device)
  22.         
  23.         # 将输入数据移动到GPU上，并获取模型输出
  24.         output=model(xb.to(device))
  25.         
  26.         # 计算当前批次的损失和指标
  27.         loss_b,metric_b=loss_batch(loss_func, output, yb, opt)
  28.         
  29.         # 累加损失
  30.         running_loss+=loss_b
  31.         
  32.         # 如果指标不为空，则累加指标
  33.         if metric_b is not None:
  34.             running_metric+=metric_b
  35.  
  36.         # 如果是进行sanity check，则只计算一个批次
  37.         if sanity_check is True:
  38.             break
  39.     
  40.     # 计算平均损失
  41.     loss=running_loss/float(len_data)
  42.     
  43.     # 计算平均指标
  44.     metric=running_metric/float(len_data)
  45.     
  46.     # 返回平均损失和平均指标
  47.     return loss, metric
  48.  
  49. # 将中心点坐标和宽高转换为边界框坐标
  50. def cxcy2bbox(cxcy,w=50./256,h=50./256):
  51.     # 创建一个与cxcy形状相同的张量，每个元素都为w
  52.     w_tensor=torch.ones(cxcy.shape[0],1,device=cxcy.device)*w
  53.     # 创建一个与cxcy形状相同的张量，每个元素都为h
  54.     h_tensor=torch.ones(cxcy.shape[0],1,device=cxcy.device)*h
  55.  
  56.     # 将cxcy的第一列提取出来，并增加一个维度
  57.     cx=cxcy[:,0].unsqueeze(1)
  58.     # 将cxcy的第二列提取出来，并增加一个维度
  59.     cy=cxcy[:,1].unsqueeze(1)
  60.     
  61.     # 将cx、cy、w_tensor、h_tensor按列拼接起来
  62.     boxes=torch.cat((cx,cy, w_tensor, h_tensor), -1)  
  63.     
  64.     # 将boxes的第一列和第二列分别减去w_tensor和h_tensor的一半，然后将结果按行拼接起来
  65.     return torch.cat((boxes[:, :2] - boxes[:, 2:]/2,boxes[:, :2] + boxes[:, 2:]/2), 1)  
  66.  
  67. # 定义一个函数metrics_batch，用于计算输出和目标之间的交并比
  68. def metrics_batch(output, target):
  69.     # 将输出和目标转换为边界框格式
  70.     output=cxcy2bbox(output)
  71.     target=cxcy2bbox(target)
  72.     
  73.     # 计算输出和目标之间的交并比
  74.     iou=torchvision.ops.box_iou(output, target)
  75.     # 返回交并比的和
  76.     return torch.diagonal(iou, 0).sum().item()
  77.  
  78. # 定义一个函数，用于计算损失函数、输出和目标之间的损失值
  79. def loss_batch(loss_func, output, target, opt=None):
  80.     
  81.     # 计算输出和目标之间的损失值
  82.     loss = loss_func(output, target)
  83.     
  84.     # 计算输出和目标之间的度量值
  85.     metric_b = metrics_batch(output,target)
  86.     
  87.     # 如果opt不为空，则执行反向传播和优化
  88.     if opt is not None:
  89.         opt.zero_grad()
  90.         loss.backward()
  91.         opt.step()
  92.  
  93.     # 返回损失值和度量值
  94.     return loss.item(), metric_b
  95.  
  96.  
  97. # 定义损失函数，使用SmoothL1Loss，reduction参数设置为sum
  98. loss_func=nn.SmoothL1Loss(reduction="sum")
  99.  
  100. # 在不计算梯度的情况下，计算模型在验证集上的损失和指标
  101. with torch.no_grad():
  102.     loss,metric=loss_epoch(model,loss_func,val_dl)
  103.     
  104. # 打印损失和指标
  105. print(loss,metric)

 

  1. from PIL import ImageDraw
  2. import numpy as np
  3. import torchvision.transforms.functional as tv_F
  4. np.random.seed(0)
  5.  
  6. import matplotlib.pylab as plt
  7. %matplotlib inline
  8.  
  9. def show_tensor_2labels(img,label1,label2,w_h=(50,50)): 
  10.     # 将label1和label2按照img的shape进行缩放
  11.     label1=rescale_label(label1,img.shape[1:])
  12.     label2=rescale_label(label2,img.shape[1:])
  13.     # 将img转换为PIL图像
  14.     img=tv_F.to_pil_image(img) 
  15.  
  16.     # 获取w_h的宽度和高度
  17.     w,h=w_h 
  18.     # 获取label1的坐标
  19.     cx,cy=label1
  20.     # 在img上绘制一个绿色的矩形
  21.     draw = ImageDraw.Draw(img)
  22.     draw.rectangle(((cx-w/2, cy-h/2), (cx+w/2, cy+h/2)),outline="green",width=2)
  23.  
  24.     # 获取label2的坐标
  25.     cx,cy=label2
  26.     # 在img上绘制一个红色的矩形
  27.     draw.rectangle(((cx-w/2, cy-h/2), (cx+w/2, cy+h/2)),outline="red",width=2)
  28.  
  29.     # 显示img
  30.     plt.imshow(np.asarray(img))
  31.  
  32. # 生成一个长度为10的随机整数数组，数组中的元素为0到len(val_ds)之间的随机整数
  33. rndInds=np.random.randint(len(val_ds),size=10)
  34. # 打印生成的随机整数数组
  35. print(rndInds)

  1. # 设置图像大小
  2. plt.rcParams['figure.figsize'] = (15, 10)
  3. # 调整子图之间的间距
  4. plt.subplots_adjust(wspace=0.0, hspace=0.15)
  5.  
  6. # 遍历随机索引
  7. for i,rndi in enumerate(rndInds):
  8.     # 获取图像和标签
  9.     img,label=val_ds[rndi]
  10.     # 获取图像的宽度和高度
  11.     h,w=img.shape[1:]
  12.     # 不计算梯度
  13.     with torch.no_grad():
  14.         # 获取模型预测的标签
  15.         label_pred=model(img.unsqueeze(0).to(device))[0].cpu()
  16.         
  17.     # 绘制子图
  18.     plt.subplot(2,3,i+1)
  19.     # 显示图像和标签
  20.     show_tensor_2labels(img,label,label_pred)
  21.     
  22.     # 将标签转换为边界框
  23.     label_bb=cxcy2bbox(torch.tensor(label).unsqueeze(0))
  24.     # 将模型预测的标签转换为边界框
  25.     label_pred_bb=cxcy2bbox(label_pred.unsqueeze(0))
  26.     # 计算IOU
  27.     iou=torchvision.ops.box_iou(label_bb, label_pred_bb)        
  28.     # 设置标题
  29.     plt.title("%.2f" %iou.item())
  30.  
  31.     # 如果索引大于4，则跳出循环
  32.     if i>4:
  33.         break

  1. # 定义一个函数，用于加载图片和标签
  2. def load_img_label(labels_df,id_):    
  3.     # 获取图片名称
  4.     imgName=labels_df["imgName"]    
  5.     # 判断图片名称是否以"A"开头
  6.     if imgName[id_][0]=="A":
  7.         # 如果是，则前缀为"AMD"
  8.         prefix="AMD"
  9.     else:
  10.         # 否则，前缀为"Non-AMD"
  11.         prefix="Non-AMD"
  12.             
  13.     # 拼接图片路径
  14.     fullPath2img=os.path.join(path2data,"Training400",prefix,imgName[id_])
  15.     # 打开图片
  16.     img = Image.open(fullPath2img)
  17.     
  18.     # 获取图片中心点坐标
  19.     x=labels_df["Fovea_X"][id_]
  20.     y=labels_df["Fovea_Y"][id_]
  21.     
  22.     # 返回图片和中心点坐标
  23.     label=(x,y)
  24.     return img,label
  25.  
  26. # 定义标签文件路径
  27. path2labels=os.path.join(path2data,"Training400","Fovea_location.xlsx")
  28. # 读取标签文件，使用openpyxl引擎，将ID列作为索引
  29. labels_df=pd.read_excel(path2labels,engine='openpyxl',index_col="ID")
  30.  
  31. # 加载图片和标签，使用标签文件中的第一行数据
  32. img,label=load_img_label(labels_df,1)   
  33. # 打印图片和标签的大小
  34. print(img.size, label)
  35.  
  36. # 调整图片和标签的大小为256x256
  37. img,label=resize_img_label(img,label,target_size=(256,256))
  38. # 打印调整后的图片和标签的大小
  39. print(img.size, label)
  40.  
  41. # 将图片转换为张量
  42. img=TF.to_tensor(img)
  43. # 将标签缩放到256x256
  44. label=scale_label(label,(256,256))
  45. # 打印转换后的图片的形状
  46. print(img.shape)
  47.  
  48. # 在不计算梯度的情况下，使用模型对图片进行预测
  49. with torch.no_grad():
  50.     label_pred=model(img.unsqueeze(0).to(device))[0].cpu()
  51.  
  52. # 显示图片和标签以及预测结果
  53. show_tensor_2labels(img,label,label_pred)

 

  1. import time
  2. # 定义一个空列表，用于存储每次推理的时间
  3. elapsed_times=[]
  4. # 不计算梯度，进行推理
  5. with torch.no_grad():
  6.     # 循环100次
  7.     for k in range(100):
  8.         # 记录开始时间
  9.         start=time.time()
  10.         # 对输入图片进行推理，并获取预测结果
  11.         label_pred=model(img.unsqueeze(0).to(device))[0].cpu()
  12.         # 计算推理时间
  13.         elapsed=time.time()-start
  14.         # 将每次推理的时间添加到列表中
  15.         elapsed_times.append(elapsed)
  16. # 打印每次推理的平均时间
  17. print("inference time per image: %.4f s" %np.mean(elapsed_times))

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/运维做开发/article/detail/920564
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号