readnetfromtensorflow调用ssd模型发生异常_SSD-master 代码详解(1)

本文所使用的SSD-master基于PyTorch 1.0，源码地址：lufficc/SSD

这篇文章写给渴望跑通自己第一个深度学习模型的小白们，可做入门参考。

在上手代码之前阅读SSD :Single Shot MultiBox Detector论文是必要的，对于原理的理解很重要。

---

写在前面：接下来将从test的角度出发将整个流程进行一次（包括网络构建、模型读取、数据集构建、图片预处理、检测、后处理、计算AP和mAP等等）。代码中注释标为#*num则表明此处调用了别的文件中的函数或者类，在该段代码后将会紧接着介绍所调用内容的功能。行文顺序基本上按着程序执行顺序展开。

整个工程如图所示：

SSD-master 工程文件

首先强调一下ssd/config/defaults.py和configs/*.yaml的重要性，做为整个工程的配置文件，其内参数具有全局性，可能在工程中不同的地方用到，参数的意义会在其使用的地方说明。

eval_ssd.py相当于test文件，直接从它入手看起：

import argparse
import logging
import os

import torch
import torch.utils.data

from ssd.config import cfg
from ssd.engine.inference import do_evaluation
from ssd.modeling.vgg_ssd import build_ssd_model
from ssd.utils import distributed_util
from ssd.utils.logger import setup_logger


def main():
    # argparse是python标准库里面用来处理命令行参数的库
    # import argparse导入模块；parser = argparse.ArgumentParser()创建一个解析对象
    # parser.add_argument()向该对象中添加你要关注的命令行参数和选项; parser.parse_args()进行解析
    parser = argparse.ArgumentParser(description='SSD Evaluation on VOC and COCO dataset.')
    parser.add_argument(
        "--config-file",
        default="configs/ssd512_voc0712.yaml",
        metavar="FILE",  #metavar - 参数在帮助信息中的名字。
        help="path to config file",  # help中的内容说明了参数的意义
        type=str,
    )
    parser.add_argument("--local_rank", type=int, default=0)
    parser.add_argument("--weights", type=str, help="Trained weights.")
    parser.add_argument("--output_dir", default="eval_results", type=str, help="The directory to store evaluation results.")

    parser.add_argument(
        "opts",
        help="Modify config options using the command-line",
        default=None,
        nargs=argparse.REMAINDER, # argparse.REMAINDER 命令行参数保存到一个list中
    )
    args = parser.parse_args()

    # gpu数量，若大于一个可启用分布式训练
    num_gpus = int(os.environ["WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1
    distributed = num_gpus > 1

    if torch.cuda.is_available():
        # This flag allows you to enable the inbuilt cudnn auto-tuner to
        # find the best algorithm to use for your hardware.
        torch.backends.cudnn.benchmark = True
    if distributed:
        torch.cuda.set_device(args.local_rank)
        torch.distributed.init_process_group(backend="nccl", init_method="env://")

    # update the config options with the config file
    cfg.merge_from_file(args.config_file)
    # manual override some options
    cfg.merge_from_list(args.opts)
    cfg.freeze()

    # 设置日志。 logger.info向屏幕打印信息。
    logger = setup_logger("SSD", distributed_util.get_rank()) #*1
    logger.info("Using {} GPUs".format(num_gpus))
    logger.info(args)

    logger.info("Loaded configuration file {}".format(args.config_file))
    # 打开配置文件，读取、打印其内容
    with open(args.config_file, "r") as cf:
        config_str = "n" + cf.read()
        logger.info(config_str)
    logger.info("Running with config:n{}".format(cfg))
    evaluation(cfg, weights_file=args.weights, output_dir=args.output_dir, distributed=distributed) #*调用evaluation()函数


def evaluation(cfg, weights_file, output_dir, distributed):
    if not os.path.exists(output_dir): #The directory to store evaluation results.
        os.makedirs(output_dir)
    # torch.device代表将torch.Tensor分配到的设备的对象,包含一个设备类型（'cpu'或'cuda'）和可选的设备的序号
    device = torch.device(cfg.MODEL.DEVICE)
    model = build_ssd_model(cfg)  #*2
    model.load(weights_file) # 读取权重文件
    logger = logging.getLogger("SSD.inference") # logger：日志对象，logging模块中最基础的对象，用logging.getLogger(name)方法进行初始化
    logger.info('Loaded weights from {}.'.format(weights_file))
    model.to(device) # 模型加载
    do_evaluation(cfg, model, output_dir, distributed)  #*9


if __name__ == '__main__':
    main()

eval_ssd.py的#*1处调用了 ssd/utils/logger.py 中的 setup_logger函数，主要用于设置日志，如下：

import logging
import sys

# logging是python的一个日志模块
def setup_logger(name, distributed_rank):
    logger = logging.getLogger(name)  # 设置日志名字
    logger.setLevel(logging.DEBUG) # 设置日志级别，日志级别大小关系为：CRITICAL > ERROR > WARNING > INFO > DEBUG > NOTSET，也可以自己定义日志级别。
    # don't log results for the non-master process
    if distributed_rank > 0:
        return logger
    
    # print函数是对sys.stdout的高级封装,在python中调用print时，事实上调用了sys.stdout.write(obj+'n')
    # 如果需要更好的控制输出，而print不能满足需求，可以使用sys.stdout，sys.stdin，sys.stderr
    # logging.StreamHandler: 日志输出到流，可以是sys.stderr、sys.stdout或者文件
    stream_handler = logging.StreamHandler(stream=sys.stdout)
    stream_handler.setLevel(logging.DEBUG)
    
    # format: 指定输出的格式和内容, %(asctime)s: 打印日志的时间,%(name)s:打印日志名字,%(levelname)s: 打印日志级别名称,%(message)s: 打印日志信息
    formatter = logging.Formatter("%(asctime)s %(name)s %(levelname)s: %(message)s")
    stream_handler.setFormatter(formatter)
    
    # logging有一个日志处理的主对象，其它处理方式都是通过addHandler添加进去的
    logger.addHandler(stream_handler)
    
    return logger

eval_ssd.py的#*2处调用了ssd/modeling/vgg_ssd.py中的build_ssd_model函数，完成SSD网络的搭建，如下：

import torch.nn as nn
from ssd.modeling.ssd import SSD


# borrowed from https://github.com/amdegroot/ssd.pytorch/blob/master/ssd.py
# 定义主干网VGG
def add_vgg(cfg, batch_norm=False):
    layers = []  # 用于存放vgg网络的list
    in_channels = 3  # 默认RGB图像，因此通道数=3
    for v in cfg:  # 多层循环，数据信息存放在字典vgg_base中
        if v == 'M':  # maxpooling，
            layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
        elif v == 'C':  # maxpooling，边缘补NAN
            layers += [nn.MaxPool2d(kernel_size=2, stride=2, ceil_mode=True)]
        else:  # 卷积前后维度读取字典中数据
            conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1)
            if batch_norm:  #BN层
                layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU(inplace=True)]
            else:  #ReLU层
                layers += [conv2d, nn.ReLU(inplace=True)]
            in_channels = v
    pool5 = nn.MaxPool2d(kernel_size=3, stride=1, padding=1)
    conv6 = nn.Conv2d(512, 1024, kernel_size=3, padding=6, dilation=6) # 空洞卷积，扩张率为6（可以扩大卷积感受野的范围，但没有增加卷积size）
    conv7 = nn.Conv2d(1024, 1024, kernel_size=1)
    layers += [pool5, conv6,
               nn.ReLU(inplace=True), conv7, nn.ReLU(inplace=True)]
    return layers

# 定义新添加的特征层
def add_extras(cfg, i, size=300):
    # Extra layers added to VGG for feature scaling
    layers = []
    in_channels = i
    flag = False
    for k, v in enumerate(cfg):   # 多层循环，数据信息存放在字典extras_base中
        if in_channels != 'S':  # S代表stride，为2时候就相当于缩小feature map
            if v == 'S':
                layers += [nn.Conv2d(in_channels, cfg[k + 1], kernel_size=(1, 3)[flag], stride=2, padding=1)]
            else:
                layers += [nn.Conv2d(in_channels, v, kernel_size=(1, 3)[flag])]
            flag = not flag
        in_channels = v
    if size == 512:  # 对于SSD512额外添加的层
        layers.append(nn.Conv2d(in_channels, 128, kernel_size=1, stride=1))
        layers.append(nn.Conv2d(128, 256, kernel_size=4, stride=1, padding=1))
    return layers


# regression_headers的输出维度是default box的种类(4or6)*4
# classification_headers的输出维度是default box的种类(4or6)*num_class
# 定义需要进行位置回归和输出置信分数的层
def add_header(vgg, extra_layers, boxes_per_location, num_classes):
    regression_headers = []
    classification_headers = []
    vgg_source = [21, -2]
    # 预测分支是全卷积的，4对应bbox坐标，num_classes对应预测目标类别，如VOC = 21
    for k, v in enumerate(vgg_source): # 第21层和倒数第二层
        regression_headers += [nn.Conv2d(vgg[v].out_channels,
                                         boxes_per_location[k] * 4, kernel_size=3, padding=1)]
        classification_headers += [nn.Conv2d(vgg[v].out_channels,
                                             boxes_per_location[k] * num_classes, kernel_size=3, padding=1)]
    # 对应的参与检测的分支数
    for k, v in enumerate(extra_layers[1::2], 2): # 找到对应的层
        regression_headers += [nn.Conv2d(v.out_channels, boxes_per_location[k]
                                         * 4, kernel_size=3, padding=1)]
        classification_headers += [nn.Conv2d(v.out_channels, boxes_per_location[k]
                                             *