FasterRCNN GeneralizedRCNNTransform部分

我们上一次已经创建了自己的数据集，接下来就到了GeneralizedRCNNTransform部分，这部分包括了normalize和resize的操作。

首先说normalize部分，因为图像是三维，所以标准差和均值都要扩充到三维

    def normalize(self,image):

        #获取图片数据类型及设备信息，是在cpu还是在GPU上
        dtype,device=image.dtype,image.device
        #把均值和方差变为tensor格式【0,1】
        mean=torch.as_tensor(self.image_mean,dtype=dtype,device=device)
        std=torch.as_tensor(self.image_std,dtype=dtype,device=device)
        #图像-均值除标准差
        return (image-mean[:,None,None])/std[:,None,None]

然后是resize部分，这一部分就是把图片缩放成你指定的最小边长到最大边长范围内，同时把图片对应的bbox信息也按照比列缩放

    def resize(self,image,target):
        # type: (Tensor, Optional[Dict[str, Tensor]]) -> Tuple[Tensor, Optional[Dict[str, Tensor]]]

        #resize是指定一个长宽，在这个范围内，小的图片放大到指定的最小边长，大的图片缩小到指定的最大边长，然后bbox也要对应改变
        h,w=image.shape[-2:]
        # print("original",h,w)
        if self.training:
            #指定输入图片的最小边长
            size=float(self.torch_choice(self.min_size))
            # print("指定最小边长",size)
        else:
            #指定输入图片的最小边长
            size=float(self.min_size[-1])
        #if torchvision._is_tracing():不会进入这个函数，这个函数是可以不依赖pytorch框架，很多框架都能用
        # if torchvision._is_tracing():
        #     image=_resize_image_onnx(image,size,float(self.max_size))
        # else:
        image=_resize_image(image,size,float(self.max_size))
        if target is None:
            return image,target
        bbox=target["boxes"]
        # print("bbox",bbox)
        #根据图像缩放比例缩放bbox
        bbox=resize_boxes(bbox,original_size=[h,w],new_size=image.shape[-2:])
        target["boxes"]=bbox
        return image,target

测试代码，因为是从自己定义的数据集传入过来的，要用到images和targets信息

from torch.utils.data import DataLoader
data_transforms={
    "train": transforms.Compose([transforms.ToTensor(),
                                transforms.RandomHorizontalFlip(0.5)]),
    "val": transforms.Compose([transforms.ToTensor()])
}
train_data_set=VOCDataSet("../VOC",transforms=data_transforms["train"],train_set=True)
images=[images for images,targets in train_data_set]
targets=[targets for images,targets in train_data_set]
# train_data_loader = DataLoader(train_data_set,
#                                 batch_size=8,
#                                 shuffle=True,
#                                 num_workers=0,
#                                 collate_fn=train_data_set.collate_fn)
transform = GeneralizedRCNNTransform(min_size=800, max_size=1333, image_mean=[0.485, 0.456, 0.406],
                                     image_std=[0.229, 0.224, 0.225])
tran=transform(images,targets)

以下附上所有代码

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2022/5/19 22:09
# @Author  : 半岛铁盒
# @File    : transform.py
# @Software: win10  python3.6
import math

import torch.nn as nn
import torch
import torchvision
from PIL import Image
import numpy as np
from typing import List, Tuple, Dict, Optional
import torch.nn.functional as F
from mydataset import VOCDataSet
import transforms
from image_list import ImageList

def _resize_image_onnx(image,self_min_size,self_max_size):
    # type: (Tensor, float, float) -> Tensor
    from torch.onnx import operators
    #获取图像宽高
    im_shape=operators.shape_as_tensor(image)[-2:]
    # print("123",im_shape)
    #图像最小边，最大边
    min_size=torch.min(im_shape).to(dtype=torch.float32)
    max_size=torch.max(im_shape).to(dtype=torch.float32)
    #定义一个比列因子,是最小值范围除以最小值和最大值范围除以最大值中的最小的那个,保证图片在最小或最大边长范围内
    scale_factor=torch.min(self_min_size/min_size,self_max_size/max_size)
    # 这个函数是用来上采样或下采样，可以给定size或者scale_factor来进行上下采样。采样完后再把图片变回3d
    image=F.interpolate(image[None],scale_factor=scale_factor,mode="bilinear",recompute_scale_factor=True,
                        align_corners=False)[0]
    return image
def _resize_image(image,self_min_size,self_max_size):
    # type: (Tensor, float, float) -> Tensor
    im_shape=torch.tensor(image.shape[-2:])
    # print("im_shape",im_shape)
    # 获取高宽中的最小值
    min_size=float(torch.min(im_shape))
    # 获取高宽中的最大值
    max_size=float(torch.max(im_shape))
    # 根据指定最小边长和图片最小边长计算缩放比例
    scale_factor=self_min_size/min_size
    # print("scale_factor",scale_factor)
    # 如果使用该缩放比例计算的图片最大边长大于指定的最大边长
    if max_size*scale_factor>self_max_size:
        # 将缩放比例设为指定最大边长和图片最大边长之比
        scale_factor=self_max_size/max_size
    # interpolate利用插值的方法缩放图片
    # image[None]操作是在最前面添加batch维度[C, H, W] -> [1, C, H, W]
    # bilinear只支持4D Tensor
    #把图片缩放到指定的边长范围内
    image = torch.nn.functional.interpolate(
        image[None], scale_factor=scale_factor, mode="bilinear", recompute_scale_factor=True,
        align_corners=False)[0]
    # print("image",image.shape)
    return image

class GeneralizedRCNNTransform(nn.Module):
    def __init__(self,min_size,max_size,image_mean,image_std):
        super(GeneralizedRCNNTransform, self).__init__()
        #判断min_size是不是list或tuple类
        if not isinstance(min_size,(list,tuple)):
            #不是的话转为tuple
            min_size=(min_size,)
            # print("1",min_size)
        #指定图像的最小边长范围
        self.min_size=min_size
        #图像最大边范围
        self.max_size=max_size
        #均值方差
        self.image_mean=image_mean
        self.image_std=image_std

    def torch_choice(self,k):
        # type: (List[int]) -> int
        # uniform_随机生成一个（x，y）范围内的实数
        # torch.empty()创建任意数据类型的张量，是一个随机数,empty(1)创健一个随机一维张量
        #提取出0到len(k)长度中随机一个整数,返回k的索引
        #len(k)是看k也就是self.min_size元祖中有几个元素，默认为一个，是最小边长，所以为1
        index=int(torch.empty(1).uniform_(0.,float(len(k))).item())
        return k[index]

    def normalize(self,image):

        #获取图片数据类型及设备信息，是在cpu还是在GPU上
        dtype,device=image.dtype,image.device
        #把均值和方差变为tensor格式【0,1】
        mean=torch.as_tensor(self.image_mean,dtype=dtype,device=device)
        std=torch.as_tensor(self.image_std,dtype=dtype,device=device)
        #图像-均值除标准差
        return (image-mean[:,None,None])/std[:,None,None]

    def resize(self,image,target):
        # type: (Tensor, Optional[Dict[str, Tensor]]) -> Tuple[Tensor, Optional[Dict[str, Tensor]]]

        #resize是指定一个长宽，在这个范围内，小的图片放大到指定的最小边长，大的图片缩小到指定的最大边长，然后bbox也要对应改变
        h,w=image.shape[-2:]
        # print("original",h,w)
        if self.training:
            #指定输入图片的最小边长
            size=float(self.torch_choice(self.min_size))
            # print("指定最小边长",size)
        else:
            #指定输入图片的最小边长
            size=float(self.min_size[-1])
        #if torchvision._is_tracing():不会进入这个函数，这个函数是可以不依赖pytorch框架，很多框架都能用
        # if torchvision._is_tracing():
        #     image=_resize_image_onnx(image,size,float(self.max_size))
        # else:
        image=_resize_image(image,size,float(self.max_size))
        if target is None:
            return image,target
        bbox=target["boxes"]
        # print("bbox",bbox)
        #根据图像缩放比例缩放bbox
        bbox=resize_boxes(bbox,original_size=[h,w],new_size=image.shape[-2:])
        target["boxes"]=bbox
        return image,target
    def max_by_axis(self,the_list):
         # type: (List[List[int]]) -> List[int]
         #获得第一张图片信息
        maxes=the_list[0].copy()
         #遍历从第一张图片开始一直到最后的图片
        for sublist in the_list[1:]:
            for index,item in enumerate(sublist):
                maxes[index]=max(maxes[index],item)
        return maxes



    def batch_images(self,images,size_divisible=32):
        # type: (List[Tensor], int) -> Tensor
        """
        将一批图像打包成一个batch返回（注意batch中每个tensor的shape是相同的）
        Args:
            images: 输入的一批图片
            size_divisible: 将图像高和宽调整到该数的整数倍

        Returns:
            batched_imgs: 打包成一个batch后的tensor数据
        """
        # 分别计算一个batch中所有图片中的最大channel, height, width
        max_size=self.max_by_axis([list(img.shape) for img in images])
        stride=float(size_divisible)
        #math.ceil向上取整,将height调整到stride的整数倍
        max_size[1]=int(math.ceil(float(max_size[1])/stride)*stride)
        # 将width向上调整到stride的整数倍
        max_size[2]=int(math.ceil(float(max_size[2])/stride)*stride)
        #增加图片维度，N就是图片的个数[batch, channel, height, width]
        batch_shape=[len(images)]+max_size
        #创健shape为batch_shape且填充值都为0的tensor，这里images【】取几都行，只是要在一个tensor下创健一个新的tensor
        #这里就创建了一批图片中有着最大宽高的图片，所有的图片都在这个范围内
        batch_imgs=images[0].new_full(batch_shape,0)
        for img,pad_img in zip(images,batch_imgs):
            # 将输入images中的每张图片复制到新的batched_imgs的每张图片中，对齐左上角，保证bboxes的坐标不变
            # 这样保证输入到网络中一个batch的每张图片的shape相同
            pad_img[:img.shape[0],:img.shape[1],:img.shape[2]].copy_(img)

        return batch_imgs

    def postprocess(self,
                    result,     # type: List[Dict[str, Tensor]]  #每张图片的预测结果
                    images_shapes, # type: List[Tuple[int, int]]    #每张图片resize后的H和W
                    original_image_size # type: List[Tuple[int, int]]   #每张图片的原始尺寸
                    ):
        # type: (...) -> List[Dict[str, Tensor]]
        """
        对网络的预测结果进行后处理（主要将bboxes还原到原图像尺度上）
        Args:
            result: list(dict), 网络的预测结果, len(result) == batch_size
            image_shapes: list(torch.Size), 图像预处理缩放后的尺寸, len(image_shapes) == batch_size
            original_image_sizes: list(torch.Size), 图像的原始尺寸, len(original_image_sizes) == batch_size

        Returns:

        """
        #如果训练模式，直接返回结果
        if self.training:
            return result
        #遍历每一张图片的预测信息，resize前后的长宽， 将boxes信息还原回原尺度
        for i,(pred,im_s,o_im_s) in enumerate(zip(result,images_shapes,original_image_size)):
            boxes=pred["boxes"]
            #将bboxes缩放回原图像尺度
            boxes=resize_boxes(boxes,original_size=im_s,new_size=o_im_s)
            result[i]["boxes"]=boxes
        return result




    def forward(self,
                images,   # type: List[Tensor]
                targets=None   # type: Optional[List[Dict[str, Tensor]]]
                ):
        # type: (...) -> Tuple[ImageList, Optional[List[Dict[str, Tensor]]]]
        #把turple的image转为list
        images=[img for img in images]
        for i in range(len(images)):
            image=images[i]
            target_index=targets[i] if targets is not None else None
            if image.dim()!=3:
                raise ValueError("images is expected to be a list of 3d tensors "
                                 "of shape [C, H, W], got {}".format(image.shape))
            #图像标准化处理
            image=self.normalize(image)
            #对图像和对应的bboxes缩放到指定范围
            image,target_index=self.resize(image,target_index)
            images[i]=image
            if targets is not None and target_index is not None:
                targets[i]=target_index
        #记录一下resize后的长宽
        image_sizes=[img.shape[-2:] for img in images]
        #将images打包成一个batch[N,C,W,H]torch.Size([156, 3, 800, 1088])1088是32的倍数
        images=self.batch_images(images)
        #创健一个列表
        image_sizes_list=torch.jit.annotate(List[Tuple[int,int]],[])
        for image_size in image_sizes:
            #确保是长宽长度为2
            assert len(image_size)==2
            image_sizes_list.append((image_size[0],image_size[1]))
        #记录一下resize后的images[N,C,W,H]，和image_sizes_list也就是全部图片的长宽
        #为了和原图映射
        image_list=ImageList(images,image_sizes_list)
        #image_list,targets即将输入到backbone targets就是原目标信息 image_list就是resize后的目标信息
        return image_list,targets









def resize_boxes(boxes,original_size,new_size):
    #type: (Tensor, List[int], List[int]) -> Tensor
    """
    将boxes参数根据图像的缩放情况进行相应缩放

    Arguments:
        original_size: 图像缩放前的尺寸
        new_size: 图像缩放后的尺寸
    """
    #比列因子是新图除以原图 得到的高度方向和宽度方向的缩放因子,缩放后的长除以缩放前的长，宽除以宽
    ratios=[torch.tensor(s,dtype=torch.float32,device=boxes.device)/
            torch.tensor(s_orig,dtype=torch.float32,device=boxes.device)
        for s,s_orig in zip(new_size,original_size)]
    # print("new_size,original_size",new_size,original_size)
    # print("ratios",ratios)
    ratios_height,ratios_width=ratios
    #unbind是在第一维度上展开,将所有目标的 xmin,ymin,xmax,ymax展开后x乘以宽度，y乘以高度
    xmin,ymin,xmax,ymax=boxes.unbind(1)
    # print("boxes.unbind(1)",boxes.unbind(1))
    xmin=xmin*ratios_width
    xmax=xmax*ratios_width
    ymin=ymin*ratios_height
    ymax=ymax*ratios_height
    #在沿第一维度拼接起来
    x=torch.stack((xmin,ymin,xmax,ymax),dim=1)
    # print("resize_boxes",x)
    return x


from torch.utils.data import DataLoader
data_transforms={
    "train": transforms.Compose([transforms.ToTensor(),
                                transforms.RandomHorizontalFlip(0.5)]),
    "val": transforms.Compose([transforms.ToTensor()])
}
train_data_set=VOCDataSet("../VOC",transforms=data_transforms["train"],train_set=True)
images=[images for images,targets in train_data_set]
targets=[targets for images,targets in train_data_set]
# train_data_loader = DataLoader(train_data_set,
#                                 batch_size=8,
#                                 shuffle=True,
#                                 num_workers=0,
#                                 collate_fn=train_data_set.collate_fn)
transform = GeneralizedRCNNTransform(min_size=800, max_size=1333, image_mean=[0.485, 0.456, 0.406],
                                     image_std=[0.229, 0.224, 0.225])
tran=transform(images,targets)