进过前几次的学习，我们将Faster R-CNN整个核心代码都过了一遍了，接下来我们要做的事，了解trainval_net，test_net，demo.py中各个参数是如何配置的，并且能够针对性的做出一些修改，来适应自己的数据集。

该笔记大部分参考来自：https://blog.csdn.net/weixin_43872578/article/details/86607742

1.导入相关的库

  1. # --------------------------------------------------------
  2. # Tensorflow Faster R-CNN
  3. # Licensed under The MIT License [see LICENSE for details]
  4. # Written by Jiasen Lu, Jianwei Yang, based on code from Ross Girshick
  5. # --------------------------------------------------------
  7. # Python提供了__future__模块，把下一个新版本的特性导入到当前版本
  8. from __future__ import absolute_import
  9. '''
  10. 导入python未来支持的语言特征division(精确除法)，当我们没有在程序中导入该特征时，
  11. "/"操作符执行的是截断除法(Truncating Division)
  12. 当我们导入精确除法之后，"/"执行的是精确除法
  13. '''
  14. from __future__ import division
  15. # 即使在python2.X，使用print就得像python3.X那样加括号使用
  16. from __future__ import print_function
  18. import _init_paths
  19. import os #通过os模块调用系统命令
  20. import sys #sys 模块包括了一组非常实用的服务，内含很多函数方法和变量
  22. '''numpy用来处理图片数据(多维数组), 尤其是numpy的broadcasting特性, 
  23. 使得不同维度的数组可以一起操作(加,减,乘, 除, 等).
  24. '''
  25. import numpy as np 
  26. import argparse # 为py文件封装好可以选择的参数
  27. import pprint #提供了打印出任何python数据结构类和方法。
  28. import pdb #使用 Pdb调试 Python程序
  29. import time 
  30. import cv2
  31. import torch
  32. from torch.autograd import Variable
  33. #自动微分 vairable是tensor的一个外包装
  34. import torch.nn as nn
  35. import torch.optim as optim
  37. '''
  38. 为了方便加载以上五种数据库的数据，pytorch团队帮我们写了一个torchvision包。
  39. 使用torchvision就可以轻松实现数据的加载和预处理。
  40. '''
  41. import torchvision.transforms as transforms
  42. import torchvision.datasets as dset
  44. '''
  45. scipy.misc 下的图像处理
  46. imread()：返回的是 numpy.ndarray 也即 numpy 下的多维数组对象；
  47. '''
  48. from scipy.misc import imread
  50. '''
  51. 这些封装的库都是前面的笔记中所学习的
  52. '''
  53. from roi_data_layer.roidb import combined_roidb
  54. from roi_data_layer.roibatchLoader import roibatchLoader
  56. # demo.py运行过程中的配置基本上都在config.py了. 后续的代码流程中会用到这些配置值.
  57. from model.utils.config import cfg, cfg_from_file, cfg_from_list, get_output_dir
  58. from model.rpn.bbox_transform import clip_boxes
  59. # from model.nms.nms_wrapper import nms
  60. from model.roi_layers import nms
  61. from model.rpn.bbox_transform import bbox_transform_inv
  62. from model.utils.net_utils import save_net, load_net, vis_detections
  63. from model.utils.blob import im_list_to_blob
  64. from model.faster_rcnn.vgg16 import vgg16
  65. from model.faster_rcnn.resnet import resnet
  66. import pdb
  68. try:
  69.     xrange          # Python 2
  70. except NameError:
  71.     xrange = range  # Python 3

2.解析参数 parse_args()


  1. def parse_args():
  3.   """
  4.   Parse input arguments
  5.   """
  6.   parser = argparse.ArgumentParser(description='Train a Fast R-CNN network')
  7.   parser.add_argument('--dataset', dest='dataset',
  8.                       help='training dataset',
  9.                       default='pascal_voc', type=str)
  10.                      # 指代你跑得数据集名称，例如默认为pascal-voc
  12.   parser.add_argument('--cfg', dest='cfg_file',
  13.                       help='optional config file',
  14.                       default='cfgs/vgg16.yml', type=str)
  15.                     　#配置文件　在目录faster_rcnn.pytorch-pytorch-1.0/cfgs中
  17.   parser.add_argument('--net', dest='net',
  18.                       help='vgg16, res50, res101, res152',
  19.                       default='res101', type=str)
  20.                     　#backbone网络类型
  22.   parser.add_argument('--set', dest='set_cfgs',
  23.                       help='set config keys', default=None,
  24.                       nargs=argparse.REMAINDER)
  25.                     　#设置
  26.   parser.add_argument('--load_dir', dest='load_dir',
  27.                       help='directory to load models',
  28.                       default="/srv/share/jyang375/models")
  29.                     　#模型目录
  31.   parser.add_argument('--image_dir', dest='image_dir',
  32.                       help='directory to load images for demo',
  33.                       default="images")
  34.                     　#图片目录
  36.   parser.add_argument('--cuda', dest='cuda',
  37.                       help='whether use CUDA',
  38.                       action='store_true')
  39.                     　#是否用GPU    
  41.   parser.add_argument('--mGPUs', dest='mGPUs',
  42.                       help='whether use multiple GPUs',
  43.                       action='store_true')
  44.                     　#是不是多GPU
  46.   parser.add_argument('--cag', dest='class_agnostic',
  47.                       help='whether perform class_agnostic bbox regression',
  48.                       action='store_true')
  49.                      '''
  50.                      class-agnostic 方式只回归2类bounding box，即前景和背景
  51.                      结合每个box在classification 网络中对应着所有类别的得分，
  52.                      以及检测阈值条件，就可以得到图片中所有类别的检测结果
  53.                      '''
  55.   parser.add_argument('--parallel_type', dest='parallel_type',
  56.                       help='which part of model to parallel, 0: all, 1: model before roi pooling',
  57.                       default=0, type=int)
  58.                       #模型的哪一部分并行
  60.                      '''
  61.                      以下是关于模型保存check的一些相关参数
  62.                      这里的三个check参数，是定义了训好的检测模型名称
  63.                      faster_rcnn_1_20_10021，代表了checksession = 1，
  64.                      checkepoch = 20， checkpoint = 10021，
  65.                      这样才可以读到模型“faster_rcnn_1_20_10021”。
  67.                      '''
  68.   parser.add_argument('--checksession', dest='checksession',
  69.                       help='checksession to load model',
  70.                       default=1, type=int)
  71.   parser.add_argument('--checkepoch', dest='checkepoch',
  72.                       help='checkepoch to load network',
  73.                       default=1, type=int)
  74.   parser.add_argument('--checkpoint', dest='checkpoint',
  75.                       help='checkpoint to load network',
  76.                       default=10021, type=int)
  78.   parser.add_argument('--bs', dest='batch_size',
  79.                       help='batch_size',
  80.                       default=1, type=int)
  81.                      #批大小
  83.   parser.add_argument('--vis', dest='vis',
  84.                       help='visualization mode',
  85.                       action='store_true')
  86.                       #可视化模型
  88.   parser.add_argument('--webcam_num', dest='webcam_num',
  89.                       help='webcam ID number',
  90.                       default=-1, type=int)
  91.                      # 是否调用摄像头
  93. 　　#parse_args()是将之前add_argument()定义的参数进行赋值，并返回相关的namespace。
  94.   args = parser.parse_args()
  95.   return args
  97. lr = cfg.TRAIN.LEARNING_RATE　#学习率
  98. momentum = cfg.TRAIN.MOMENTUM　#动量
  99. weight_decay = cfg.TRAIN.WEIGHT_DECAY　#权重衰减

3.函数 _get_image_blob(im)


  1. def _get_image_blob(im):
  2.     #这个函数其实就是读取图片，然后做尺寸变换，然后存储成矩阵的形式
  3.   '''
  4.   Converts an image into a network input.
  5.   Arguments:
  6.     im (ndarray): a color image in BGR order
  7.   Returns:
  8.     blob (ndarray): a data blob holding an image pyramid
  9.     im_scale_factors (list): list of image scales (relative to im) used
  10.       in the image pyramid
  11.   '''
  13.   #Numpy中 astype：转换数组的数据类型。
  14.   im_orig = im.astype(np.float32, copy=True)
  15.   #而pixel mean的话，其实是把训练集里面所有图片的所有R通道像素，求了均值，G,B通道类似
  16.   im_orig -= cfg.PIXEL_MEANS
  18.   im_shape = im_orig.shape
  19.   im_size_min = np.min(im_shape[0:2])
  20.   im_size_max = np.max(im_shape[0:2])
  22.   processed_ims = []
  23.   im_scale_factors = []
  25.   for target_size in cfg.TEST.SCALES: # target_size = 600
  26.     #遍历cfg.TEST.SCALES这个元组或列表中的值
  28.     im_scale = float(target_size) / float(im_size_min)
  29.     #测试的尺度除以图像最小长度（宽高的最小值）
  30.     # Prevent the biggest axis from being more than MAX_SIZE
  31.     #防止最大值超过MAX_SIZE,round函数四舍五入
  32.     if np.round(im_scale * im_size_max) > cfg.TEST.MAX_SIZE:
  33.       im_scale = float(cfg.TEST.MAX_SIZE) / float(im_size_max)
  35.     #调整im_orig大小
  36.     im = cv2.resize(im_orig, None, None, fx=im_scale, fy=im_scale,
  37.             interpolation=cv2.INTER_LINEAR)
  38.     #保存尺度值
  39.     im_scale_factors.append(im_scale)
  40.     #保存调整后的图像
  41.     processed_ims.append(im)
  43.   # Create a blob to hold the input images
  44.     '''
  45.     创建一个blob来保存输入图像
  46.     这个函数出自这里 from model.utils.blob import im_list_to_blob
  47.     '''
  49.   blob = im_list_to_blob(processed_ims)
  51.   return blob, np.array(im_scale_factors)

4. if name == ‘main’:


  1. if __name__ == '__main__':
  3.   #这就是上面定义的那个函数
  4.   args = parse_args()
  7.   print('Called with args:')
  8.   print(args)
  10.   if args.cfg_file is not None: #配置文件
  11.     cfg_from_file(args.cfg_file)
  12.     #model.utils.config 该文件中函数 
  13.     #Load a config file and merge it into the default options.
  15.   if args.set_cfgs is not None:
  16.     cfg_from_list(args.set_cfgs)
  17.     #model.utils.config文件中
  18.     # Set config keys via list (e.g., from command line).
  20.   '''
  21.   Use GPU implementation of non-maximum suppression
  22.   解析参数是不是用GPU
  23.   '''
  24.   cfg.USE_GPU_NMS = args.cuda
  26.   print('Using config:')
  27.   pprint.pprint(cfg)
  29.     '''
  30.     设置随机数种子
  31.     每次运行代码时设置相同的seed，则每次生成的随机数也相同，
  32.     如果不设置seed，则每次生成的随机数都会不一样
  33.     '''
  34.   np.random.seed(cfg.RNG_SEED)
  36.   # train set
  37.   # -- Note: Use validation set and disable the flipped to enable faster loading.
  39.   input_dir = args.load_dir + "/" + args.net + "/" + args.dataset
  40.   if not os.path.exists(input_dir):
  41.         #当程序出现错误，python会自动引发异常，
  42.         #也可以通过raise显示地引发异常。一旦执行了raise语句，raise后面的语句将不能执行
  43.     raise Exception('There is no input directory for loading network from ' + input_dir)
  45.   load_name = os.path.join(input_dir,
  46.     'faster_rcnn_{}_{}_{}.pth'.format(args.checksession, 
  47.                                       args.checkepoch, 
  48.                                       args.checkpoint))
  49.     #这里的三个check参数，是定义了训好的检测模型名称，例如训好的名称为faster_rcnn_1_20_10021，
  51.   '''
  52.   PASCAL类别 1类背景 + 20类Object  
  53.   array和asarray都可以将结构数据转化为ndarray，但是主要区别就是当数据源是ndarray时，
  54.   array仍然会copy出一个副本，占用新的内存，但asarray不会。
  55.   '''
  56.   pascal_classes = np.asarray(['__background__',
  57.                        'aeroplane', 'bicycle', 'bird', 'boat',
  58.                        'bottle', 'bus', 'car', 'cat', 'chair',
  59.                        'cow', 'diningtable', 'dog', 'horse',
  60.                        'motorbike', 'person', 'pottedplant',
  61.                        'sheep', 'sofa', 'train', 'tvmonitor'])
  63.   # initilize the network here.
  64.   '''
  65.   class-agnostic 方式只回归2类bounding box，即前景和背景
  66.   '''
  67.   if args.net == 'vgg16':
  68.     fasterRCNN = vgg16(pascal_classes, pretrained=False, class_agnostic=args.class_agnostic)
  69.   elif args.net == 'res101':
  70.     fasterRCNN = resnet(pascal_classes, 101, pretrained=False, class_agnostic=args.class_agnostic)
  71.   elif args.net == 'res50':
  72.     fasterRCNN = resnet(pascal_classes, 50, pretrained=False, class_agnostic=args.class_agnostic)
  73.   elif args.net == 'res152':
  74.     fasterRCNN = resnet(pascal_classes, 152, pretrained=False, class_agnostic=args.class_agnostic)
  75.   else:
  76.     print("network is not defined")
  77.     #到了pdb.set_trace()那就会定下来，就可以看到调试的提示符(Pdb)了
  78.     pdb.set_trace()
  80.   fasterRCNN.create_architecture()
  81.     #model.faster_rcnn.faster_rcnn.py 初始化模型 初始化权重
  83.   print("load checkpoint %s" % (load_name))#模型路径
  85.   if args.cuda > 0:
  86.     checkpoint = torch.load(load_name)
  87.   else:
  88.     checkpoint = torch.load(load_name, map_location=(lambda storage, loc: storage))
  89.   fasterRCNN.load_state_dict(checkpoint['model'])#恢复模型
  91.   if 'pooling_mode' in checkpoint.keys():
  92.     cfg.POOLING_MODE = checkpoint['pooling_mode'] #pooling方式
  95.   print('load model successfully!')
  97.   # pdb.set_trace()
  99.   print("load checkpoint %s" % (load_name))
  101.   # initilize the tensor holder here.
  102.   #新建一些 一维Tensor
  103.   im_data = torch.FloatTensor(1)
  104.   im_info = torch.FloatTensor(1)
  105.   num_boxes = torch.LongTensor(1)
  106.   gt_boxes = torch.FloatTensor(1)
  108.   # ship to cuda
  109.   if args.cuda > 0:#如果用GPU，张量放到GPU上
  110.     im_data = im_data.cuda()
  111.     im_info = im_info.cuda()
  112.     num_boxes = num_boxes.cuda()
  113.     gt_boxes = gt_boxes.cuda()
  115.   # make variable
  116.   #Variable的volatile属性默认为False，如果某一个variable的volatile属性被设为True，
  117.   #volatile属性为True的节点不会求导，volatile的优先级比requires_grad高。  
  118.   im_data = Variable(im_data, volatile=True)
  119.   im_info = Variable(im_info, volatile=True)
  120.   num_boxes = Variable(num_boxes, volatile=True)
  121.   gt_boxes = Variable(gt_boxes, volatile=True)
  123.   if args.cuda > 0:
  124.     cfg.CUDA = True
  126.   if args.cuda > 0:
  127.     fasterRCNN.cuda()
  129.   '''
  130.   model.eval()，让model变成测试模式，
  131.   对dropout和batch normalization的操作在训练和测试的时候是不一样的
  132.   pytorch会自动把BN和DropOut固定住，不会取平均，而是用训练好的值
  133.   '''
  134.   fasterRCNN.eval()
  136.   start = time.time() #通过time()函数可以获取当前的时间
  137.   max_per_image = 100
  138.   thresh = 0.05
  139.   vis = True
  141.   webcam_num = args.webcam_num
  142.   # Set up webcam or get image directories
  143.   if webcam_num >= 0 :#应该就是判断要不要自己用电脑录视频
  144.     '''
  145.     cap = cv2.VideoCapture(0) 打开笔记本的内置摄像头。
  146.     cap = cv2.VideoCapture('D:\output.avi') 打开视频文件
  147.     '''
  148.     cap = cv2.VideoCapture(webcam_num)
  149.     num_images = 0
  150.   else:#如果不用电脑录视频，那么就读取image路径下的图片
  151.     #os.listdir() 方法用于返回指定的文件夹包含的文件或文件夹的名字的列表
  152.     #这个列表以字母顺序
  153.     imglist = os.listdir(args.image_dir)
  154.     #有多少张图片
  155.     num_images = len(imglist)
  157.   print('Loaded Photo: {} images.'.format(num_images))
  160.   while (num_images >= 0):
  161.       total_tic = time.time()#当前时间
  162.       if webcam_num == -1:#如果不用摄像头
  163.         num_images -= 1
  165.       # Get image from the webcam
  166.       #从电脑摄像头读取图片
  167.       if webcam_num >= 0:
  168.         if not cap.isOpened():#摄像头开启失败
  169.           raise RuntimeError("Webcam could not open. Please check connection.")
  171.         #ret 为True 或者False,代表有没有读取到图片
  172.         #frame表示截取到一帧的图片
  173.         ret, frame = cap.read()
  174.         im_in = np.array(frame)
  176.       # Load the demo image
  177.       else:
  178.         #图片路径
  179.         im_file = os.path.join(args.image_dir, imglist[num_images])
  180.         # im = cv2.imread(im_file)
  181.         #读取的的图片 存储为numpy数组
  182.         im_in = np.array(imread(im_file))
  184.       if len(im_in.shape) == 2:
  185.         #np.newaxis的作用就是在这一位置增加一个一维，
  186.         #这一位置指的是np.newaxis所在的位置，比较抽象，需要配合例子理解。
  187.         '''
  188.         example:
  189.         x1 = np.array([1, 2, 3, 4, 5])
  190.         the shape of x1 is (5,)
  191.         x1_new = x1[:, np.newaxis]
  192.         now, the shape of x1_new is (5, 1)
  193.         array([[1],
  194.                [2],
  195.                [3],
  196.                [4],
  197.                [5]])
  198.         x1_new = x1[np.newaxis,:]
  199.         now, the shape of x1_new is (1, 5)
  200.         array([[1, 2, 3, 4, 5]])
  201.         '''
  202.         im_in = im_in[:,:,np.newaxis]
  203.         im_in = np.concatenate((im_in,im_in,im_in), axis=2)
  204.         '''
  205.         数组拼接
  206.         若axis=0，则要求除了a.shape[0]和b.shape[0]可以不等之外，其它维度必须相等
  207.         若axis=0，则要求除了a.shape[0]和b.shape[0]可以不等之外，其它维度必须相等
  208.         axis>=2 的情况以此类推，axis的值必须小于数组的维度
  209.         '''
  210.         # 可以理解为批处理
  212.       # rgb -> bgr
  213.       im = im_in[:,:,::-1]
  216.       blobs, im_scales = _get_image_blob(im)
  217.       #图片变换 该文件上面定义的函数，返回处理后的值 和尺度
  219.       assert len(im_scales) == 1, "Only single-image batch implemented"
  220.       im_blob = blobs #处理后的值,图像信息，长、宽、尺度
  221.       im_info_np = np.array([[im_blob.shape[1], 
  222.                               im_blob.shape[2], 
  223.                               im_scales[0]]], dtype=np.float32)
  224.       #从numpy变为Tensor
  225.       im_data_pt = torch.from_numpy(im_blob)
  226.       #permute 将tensor的维度换位。
  227.       im_data_pt = im_data_pt.permute(0, 3, 1, 2)
  228.       #图像信息也变为tensor
  229.       im_info_pt = torch.from_numpy(im_info_np)
  231.       with torch.no_grad():
  232.         '''
  233.         将上面定义的一些tensor大小调整为指定大小
  234.         如果元素个数比当前的内存大小大，就将底层存储大小调整为与新元素数目一致的大小。
  235.         '''
  236.               im_data.resize_(im_data_pt.size()).copy_(im_data_pt)
  237.               im_info.resize_(im_info_pt.size()).copy_(im_info_pt)
  238.               gt_boxes.resize_(1, 1, 5).zero_()
  239.               num_boxes.resize_(1).zero_()
  241.       # pdb.set_trace()
  242.       det_tic = time.time()#当前时间
  244.       rois, cls_prob, bbox_pred, \
  245.       rpn_loss_cls, rpn_loss_box, \
  246.       RCNN_loss_cls, RCNN_loss_bbox, \
  247.       rois_label = fasterRCNN(im_data, im_info, gt_boxes, num_boxes)
  248.     '''
  249.     rois:rois blob: holds R regions of interest, each is a 5-tuple
  250.          (n, x1, y1, x2, y2) specifying an image batch index n and a
  251.          rectangle (x1, y1, x2, y2)
  252.          top[0].reshape(1, 5)
  253.     cls_prob: softmax得到的概率值
  254.     bbox_pred: 偏移
  255.     rpn_loss_cls:分类损失，计算softmax的损失，
  256.                  输入labels和cls layer的18个输出（中间reshape了一下），输出损失函数的具体值
  257.     rpn_loss_box 计算的框回归损失函数具体的值
  258.     '''
  260.       scores = cls_prob.data #分类概率值
  261.       boxes = rois.data[:, :, 1:5] # 输出rois的坐标值
  263.       if cfg.TEST.BBOX_REG:　#Train bounding-box regressors TRUE or FALSE
  264.           # Apply bounding-box regression deltas
  266.           box_deltas = bbox_pred.data #偏移值
  267.           if cfg.TRAIN.BBOX_NORMALIZE_TARGETS_PRECOMPUTED:
  268.           # Optionally normalize targets by a precomputed mean and stdev
  269.             if args.class_agnostic:
  270.                 if args.cuda > 0:
  271.                     #box_deltas.view改变维度
  272.                     box_deltas = box_deltas.view(-1, 4) * torch.FloatTensor(cfg.TRAIN.BBOX_NORMALIZE_STDS).cuda() \
  273.                                + torch.FloatTensor(cfg.TRAIN.BBOX_NORMALIZE_MEANS).cuda()
  274.                 else:
  275.                     box_deltas = box_deltas.view(-1, 4) * torch.FloatTensor(cfg.TRAIN.BBOX_NORMALIZE_STDS) \
  276.                                + torch.FloatTensor(cfg.TRAIN.BBOX_NORMALIZE_MEANS)
  278.                 box_deltas = box_deltas.view(1, -1, 4)
  279.             else:
  280.                 if args.cuda > 0:
  281.                     box_deltas = box_deltas.view(-1, 4) * torch.FloatTensor(cfg.TRAIN.BBOX_NORMALIZE_STDS).cuda() \
  282.                                + torch.FloatTensor(cfg.TRAIN.BBOX_NORMALIZE_MEANS).cuda()
  283.                 else:
  284.                     box_deltas = box_deltas.view(-1, 4) * torch.FloatTensor(cfg.TRAIN.BBOX_NORMALIZE_STDS) \
  285.                                + torch.FloatTensor(cfg.TRAIN.BBOX_NORMALIZE_MEANS)
  286.                 box_deltas = box_deltas.view(1, -1, 4 * len(pascal_classes))
  288.           '''
  289.           model.rpn.bbox_transform 根据anchor和偏移量计算proposals
  290.           最后返回的是左上和右下顶点的坐标[x1,y1,x2,y2]。 
  291.           '''
  292.           pred_boxes = bbox_transform_inv(boxes, box_deltas, 1)
  293.             '''
  294.             model.rpn.bbox_transform
  295.             将改变坐标信息后超过图像边界的框的边框裁剪一下,使之在图像边界之内
  296.             '''
  297.           pred_boxes = clip_boxes(pred_boxes, im_info.data, 1)
  300.       else:
  301.           # Simply repeat the boxes, once for each class
  302.           # Numpy的 tile() 函数,就是将原矩阵横向、纵向地复制，这里是横向
  303.           pred_boxes = np.tile(boxes, (1, scores.shape[1]))
  305.       pred_boxes /= im_scales[0]
  306.         #squeeze 函数：从数组的形状中删除单维度条目，即把shape中为1的维度去掉
  307.       scores = scores.squeeze()
  308.       pred_boxes = pred_boxes.squeeze()
  309.       det_toc = time.time()
  310.       detect_time = det_toc - det_tic #detect_time
  311.       misc_tic = time.time()
  312.       if vis:
  313.           im2show = np.copy(im)
  314.       for j in xrange(1, len(pascal_classes)): #所有类别
  315.         '''
  316.         torch.nonzero
  317.         返回一个包含输入input中非零元素索引的张量，输出张量中的每行包含输入中非零元素的索引
  318.         若输入input有n维，则输出的索引张量output形状为z * n, 这里z是输入张量input中所有非零元素的个数
  319.         '''
  320.           inds = torch.nonzero(scores[:,j]>thresh).view(-1)
  321.             #参数中的-1就代表这个位置由其他位置的数字来推断
  322.           # if there is det
  323.              #torch.numel() 返回一个tensor变量内所有元素个数，可以理解为矩阵内元素的个数
  324.           if inds.numel() > 0:
  325.             cls_scores = scores[:,j][inds]
  326.             #torch.sort(input, dim=None, descending=False, out=None)有true，
  327.             #则表示降序，默认升序,沿第0列降序
  328.             _, order = torch.sort(cls_scores, 0, True)
  329.             if args.class_agnostic: #两类
  330.               cls_boxes = pred_boxes[inds, :]
  331.             else:
  332.               cls_boxes = pred_boxes[inds][:, j * 4:(j + 1) * 4]
  335.             #按行连接起来，torch.unsqueeze()这个函数主要是对数据维度进行扩充
  336.             cls_dets = torch.cat((cls_boxes, cls_scores.unsqueeze(1)), 1)
  337.             # cls_dets = torch.cat((cls_boxes, cls_scores), 1)
  338.             cls_dets = cls_dets[order]
  339.             # keep = nms(cls_dets, cfg.TEST.NMS, force_cpu=not cfg.USE_GPU_NMS)
  340.             keep = nms(cls_boxes[order, :], cls_scores[order], cfg.TEST.NMS)
  341.             cls_dets = cls_dets[keep.view(-1).long()]
  342.             if vis:
  343.               im2show = vis_detections(im2show, pascal_classes[j], cls_dets.cpu().numpy(), 0.5)
  345.       misc_toc = time.time()
  346.       nms_time = misc_toc - misc_tic
  348.       if webcam_num == -1:
  349.           sys.stdout.write('im_detect: {:d}/{:d} {:.3f}s {:.3f}s   \r' \
  350.                            .format(num_images + 1, len(imglist), detect_time, nms_time))
  351.           sys.stdout.flush()
  353.       if vis and webcam_num == -1:
  354.           # cv2.imshow('test', im2show)
  355.           # cv2.waitKey(0)
  356.           result_path = os.path.join(args.image_dir, imglist[num_images][:-4] + "_det.jpg")
  357.           cv2.imwrite(result_path, im2show)
  358.       else:
  359.           im2showRGB = cv2.cvtColor(im2show, cv2.COLOR_BGR2RGB)
  360.           cv2.imshow("frame", im2showRGB)
  361.           total_toc = time.time()
  362.           total_time = total_toc - total_tic
  363.           frame_rate = 1 / total_time
  364.           print('Frame rate:', frame_rate)
  365.           if cv2.waitKey(1) & 0xFF == ord('q'):
  366.               break
  367.   if webcam_num >= 0:
  368.       cap.release()
  369.       cv2.destroyAllWindows()

5.运行demo.py，查看检测结果

这里有一个巨坑！！！！！！！！！！

不要直接运行demo.py，因为文件里没有！！！！！没有！！！！　模型！！！！！

此处说的模型不是指Vgg或Resnet在分类数据集ImageNet下训好的Transfer模型，而是指的是在目标检测集VOC或COCO下进行fine-tune的模型。对于VOC2007数据集，训练好后该模型大概1个G，所以代码作者没有上传到github，要不你就自己训练，要不你就跟训好的人要，不过建议你自己训练，跑trainval_net.py。