DensePose（四）：config.py

DensePose是在Detectron平台上做的密集姿态估计，此处Detectron的confg.py 文件相比较于原来MR-CNN以及KR-CNN时用的config.py做了一些添加与改进。如果之前对于Detectron比较熟悉，可以直接看 18.DensePose R-CNN options

下面是一些关于config.py写在前面的注释：

"""
Detectron配置系统.

这对于Detectron文件指定默认的配置选项。你不应该变化值在这个文件中。

相反,你应该写一个配置文件(yaml)，使用merge_cfg_from_file(yaml_file)
加载和覆盖默认的选项。

大多数工具在工具目录中——cfg选项指定一个覆盖

覆盖的文件和一个可选列表(键,值)对:
- See tools/{train,test}_net.py 的代码示例来使用merge_cfg_from_file
- See configs/*/*.yaml 的示例来编写config文件
Detectron支持很多不同的模型类型,每一种都有很多不同的选择。结果是一组巨大的
配置选项。"""

#import一系列的相关包，此处不赘述
#注意关于__future__的import要写到文件最前面


from detectron.utils.collections import AttrDict
from detectron.utils.io import cache_url
logger = logging.getLogger(__name__)

__C = AttrDict()
# Consumers can get config by:（用户可以获得config通过）
#   from detectron.core.config import cfg
cfg = __C
#避免使用 '.ON' 作为参数配置中的 key.
#因为 yaml 会将其转化为 True. 可使用 'ENABLED' 取代 '.ON'.

1. 训练默认参数

# ---------------------------------------------------------------------------- #
# 训练默认参数
# ---------------------------------------------------------------------------- #
__C.TRAIN = AttrDict()

# 从 .pkl 文件初始化网络权重参数；.pkl 可以是预训练模型.
__C.TRAIN.WEIGHTS = b''

# 训练数据集 Datasets
# 训练数据集列表设定：detectron.datasets.dataset_catalog.datasets()
# 如果设定了多个 datasets，则会在其并集上进行模型训练.
__C.TRAIN.DATASETS = ()

# 训练所采用的缩放尺度 Scales
# 每一个 scale 是图像短边的像素值
# 如果给定了多个 scales 值，则对于每个训练图片随机选取一个 scale，如尺度抖动数据增强scale jitter data augmentation
__C.TRAIN.SCALES = (600, )

# 缩放后输入图片最长边的最大像素值
__C.TRAIN.MAX_SIZE = 1000

# 训练 mini-batch 每张 GPU 的图片数
# 每个 mini-batch 的总图片数 = 每张 GPU 的图片数 * GPUs 数
# Total images per minibatch = TRAIN.IMS_PER_BATCH * NUM_GPUS
__C.TRAIN.IMS_PER_BATCH = 2

# 每张图片的 RoI mini-batch，即每张图片的 RoIs 数.
# 每张训练 mini-batch 中总的 RoIs 数 = 每张图片 mini-batch RoIs 数 * mini-batch 图片数 * GPUs 数
# 典型配置： 512 * 2 * 8 = 8192
# RoI minibatch size *per image* (number of regions of interest [ROIs])
# Total number of RoIs per training minibatch =
#   TRAIN.BATCH_SIZE_PER_IM * TRAIN.IMS_PER_BATCH * NUM_GPUS
__C.TRAIN.BATCH_SIZE_PER_IM = 64

# mini-batch 中被标记为 foreground RoIs(i.e. class > 0) 的目标分数Target fraction 
__C.TRAIN.FG_FRACTION = 0.25

# RoI 的重叠区域大于 FG_THRESH 则被标记为 foreground
__C.TRAIN.FG_THRESH = 0.5

# RoI 的重叠区域在 [LO, HI] 区间内则被标记为 background (i.e. class = 0)
__C.TRAIN.BG_THRESH_HI = 0.5
__C.TRAIN.BG_THRESH_LO = 0.0

# 训练是否水平翻转图片
__C.TRAIN.USE_FLIPPED = True

# 如果 RoI 和 groundtruth box 的重叠区域大于阈值BBOX_THRESH，则(RoI gt_box)对作为边界框 bounding-box 回归训练样本.
__C.TRAIN.BBOX_THRESH = 0.5

# 模型保存周期，即多少次迭代进行一次模型断点保存.
# 需要除以 GPUs 数 NUM_GPUS，e.g., 20000/8 => 2500 iters
__C.TRAIN.SNAPSHOT_ITERS = 20000

# 训练采用指定的 proposals 
# 训练过程中，所有的 proposals 是在 proposal 文件中指定的.
# proposals 文件与 TRAIN.DATASETS 数据集相对应.
__C.TRAIN.PROPOSAL_FILES = ()

# 确保图片 mini-batches 具有相同的长宽比，(i.e. both tall and thin or both short and wide)
# 对于节省内存很重要，可以稍微加快训练.
__C.TRAIN.ASPECT_GROUPING = True

2. RPN 训练参数

# ---------------------------------------------------------------------------- #
# RPN 训练默认参数
# ---------------------------------------------------------------------------- #

# 如果 anchor 和 groundtruth box 的最小重叠区域大于阈值 RPN_POSITIVE_OVERLAP， 
# 则 (anchor, gt_box) 对作为 positive 训练样本
# (IOU >= thresh ==> positive RPN example)
__C.TRAIN.RPN_POSITIVE_OVERLAP = 0.7

# 如果 anchor 和 groundtruth box 的最大重叠区域小于阈值 RPN_NEGATIVE_OVERLAP， 
# 则 (anchor, gt_box) 对作为 negative 训练样本
# (IOU < thresh ==> negative RPN example)
__C.TRAIN.RPN_NEGATIVE_OVERLAP = 0.3

# 每个 RPN mini-batch 中被标记为 foreground (positive) 样本的目标分数Target fraction
__C.TRAIN.RPN_FG_FRACTION = 0.5

# 每张图片的 RPN 样本总数
__C.TRAIN.RPN_BATCH_SIZE_PER_IM = 256

# RPN proposals 所采用的 NMS 阈值 (end-to-end training with RPN 时使用)
__C.TRAIN.RPN_NMS_THRESH = 0.7

# NMS 处理前，top 分数的 RPN proposals 数
# When FPN is used, this is *per FPN level* (not total)
__C.TRAIN.RPN_PRE_NMS_TOP_N = 12000

# NMS 处理后，保留的 top 分数的 RPN proposals 数
# 所产生的 RPN proposals 总数(FPN 和 non-FPN 一样)
__C.TRAIN.RPN_POST_NMS_TOP_N = 2000

# 设定阈值像素值 RPN_STRADDLE_THRESH，丢弃超出图片边界的 PRN anchors
# 设定 RPN_STRADDLE_THRESH = -1 或 RPN_STRADDLE_THRESH = Large_Value(e.g. 100000)，则不进行 anchors 裁剪.
__C.TRAIN.RPN_STRADDLE_THRESH = 0

# proposal 的 height 和 width 需要同时大于阈值RPN_MIN_SIZE
# (相对于原始图片尺度，不是训练或测试时的尺度)
__C.TRAIN.RPN_MIN_SIZE = 0

# 根据阈值CROWD_FILTER_THRESH 过滤在 crowd 区域的 proposals.
# "Inside" 的度量：proposal-with-crowd 交叉区域面积除以 proposal面积.
# "Inside" is measured as: proposal-with-crowd intersection area divided by proposal area.
__C.TRAIN.CROWD_FILTER_THRESH = 0.7

# 忽略面积小于阈值GT_MIN_AREA 的 groundtruth 物体
__C.TRAIN.GT_MIN_AREA = -1

# 如果FREEZE_CONV_BODY设定为 True，则冻结骨干backbone网络结构参数
__C.TRAIN.FREEZE_CONV_BODY = False

# 设定AUTO_RESUME=True 时，从输出路径中的最近模型断点snapshot 恢复训练
__C.TRAIN.AUTO_RESUME = True

3. 数据加载默认参数

# ---------------------------------------------------------------------------- #
# 数据加载选项 (see detectron/roi_data/loader.py for more info)
# ---------------------------------------------------------------------------- #
__C.DATA_LOADER = AttrDict()

# 数据加载所用的 Python 线程数threads (warning: using too many
# 注：如果使用过多的线程，会出现 GIL 锁，导致训练变慢，实验发现 4 线程最佳.)
__C.DATA_LOADER.NUM_THREADS = 4

# 共享minibatch队列的大小
__C.DATA_LOADER.MINIBATCH_QUEUE_SIZE = 64

# 每块GPU blobs队列的容量
__C.DATA_LOADER.BLOBS_QUEUE_CAPACITY = 8

4. 推断/测试参数

# ---------------------------------------------------------------------------- #
# Inference ('test') options
# ---------------------------------------------------------------------------- #
__C.TEST = AttrDict()

# 从.pkl文件中初始化网络的权重
__C.TEST.WEIGHTS = b''

# 测试数据集
# 可用数据集列表设置：detectron.datasets.dataset_catalog.datasets()
# 如果有多个训练集，则依次在每个数据集上进行
__C.TEST.DATASETS = ()

# 测试时所使用的尺度
__C.TEST.SCALE = 600

# 尺度缩放后输入图片的长边最大像素值
__C.TEST.MAX_SIZE = 1000

# NMS 的重叠阈值(suppress boxes with IoU >= this threshold)
__C.TEST.NMS = 0.3

# 如果 BBOX_REG 设定为 True，则采用类似于 Faster R-CNN bounding-box 回归的形式.
__C.TEST.BBOX_REG = True

# 利用给定 proposals 文件进行测试(must correspond with TEST.DATASETS)
__C.TEST.PROPOSAL_FILES = ()

# 限定推断时每张图片的 proposals 数
__C.TEST.PROPOSAL_LIMIT = 2000

# NMS threshold used on RPN proposals
__C.TEST.RPN_NMS_THRESH = 0.7

# NMS 处理前，top 分数的 RPN proposals 数
# 当FPN被用到时, this is *per FPN level* (not total)
__C.TEST.RPN_PRE_NMS_TOP_N = 12000

# NMS 处理后，保留的 top 分数的 RPN proposals 数
# 所产生的 RPN proposals 总数(FPN 和 non-FPN 一样)
__C.TEST.RPN_POST_NMS_TOP_N = 2000

# proposal 的 height 和 width 需要同时大于阈值RPN_MIN_SIZE
# (相对于原始图片尺度，不是训练或测试时的尺度)
__C.TEST.RPN_MIN_SIZE = 0

# 每张图片返回的检测结果的最大数量(100 是根据 COCO 数据集的获取限定设定的)
__C.TEST.DETECTIONS_PER_IM = 100

# 最小分数阈值(假设分数已经归一化到 [0,1] 范围)
# 选定一个阈值，平衡 recall 和 precision
# 高recall（召回率）且不太低的precision（准确率）的检测结果会减慢推断的后处理过程(like NMS)
__C.TEST.SCORE_THRESH = 0.05

# if True，则保存检测结果文件
# If false, 则运行后不会保存结果文件
__C.TEST.COMPETITION_MODE = True

# 利用 COCO json 数据集的 eval code 来评估检测结果，即使不是 COCO 数据集的评估code 
# (e.g. 用 COCO API 以 COCO 形式的 AP 来评估 PASCAL VOC 结果）
__C.TEST.FORCE_JSON_DATASET_EVAL = False

# [Inferred value; do not set directly in a config]
# Indicates if precomputed proposals are used at test time
# Not set for 1-stage models and 2-stage models with RPN subnetwork enabled
__C.TEST.PRECOMPUTED_PROPOSALS = True

5. bbox检测 测试时间增强

# ---------------------------------------------------------------------------- #
# bbox检测 测试时间增强
# See configs/test_time_aug/e2e_mask_rcnn_R-50-FPN_2x.yaml for an example
# ---------------------------------------------------------------------------- #
__C.TEST.BBOX_AUG = AttrDict()

# bounding box detection测试时间增强 if True
__C.TEST.BBOX_AUG.ENABLED = False

# 用于组合预测box分数的启发式
#   可选参数: ('ID', 'AVG', 'UNION')
__C.TEST.BBOX_AUG.SCORE_HEUR = b'UNION'

# 用于组合预测box坐标的启发式
#   Valid options: ('ID', 'AVG', 'UNION')
__C.TEST.BBOX_AUG.COORD_HEUR = b'UNION'

# 以原缩放尺度scale 水平翻转(id transform)
__C.TEST.BBOX_AUG.H_FLIP = False

# 每个缩放尺度scale 是图片短边的像素尺寸
__C.TEST.BBOX_AUG.SCALES = ()

# 长边的最大像素尺寸
__C.TEST.BBOX_AUG.MAX_SIZE = 4000

# 在每个缩放尺度scale 水平翻转
__C.TEST.BBOX_AUG.SCALE_H_FLIP = False

# 基于物体object 尺寸应用缩放scaling
__C.TEST.BBOX_AUG.SCALE_SIZE_DEP = False
__C.TEST.BBOX_AUG.AREA_TH_LO = 50**2
__C.TEST.BBOX_AUG.AREA_TH_HI = 180**2

# 相对于图片宽度的每个长宽比aspect ratio
__C.TEST.BBOX_AUG.ASPECT_RATIOS = ()

# 在每个长宽比aspect ratio 水平翻转
__C.TEST.BBOX_AUG.ASPECT_RATIO_H_FLIP = False

6. Mask检测的测试时间增强

# ---------------------------------------------------------------------------- #
# Mask检测的测试时间增强Test-time augmentations for mask detection
# 例如 configs/test_time_aug/e2e_mask_rcnn_R-50-FPN_2x.yaml for an example
# ---------------------------------------------------------------------------- #
__C.TEST.MASK_AUG = AttrDict()

# True，开启实例分割的测试时间增强 instance mask detection
__C.TEST.MASK_AUG.ENABLED = False

# 用于组合 maks 检测的启发式
#   可选参数: ('SOFT_AVG', 'SOFT_MAX', 'LOGIT_AVG')
#   SOFT 前缀表示在 soft masks 进行计算
__C.TEST.MASK_AUG.HEUR = b'SOFT_AVG'

# 在原缩放尺度scale 水平翻转(id transform)
__C.TEST.MASK_AUG.H_FLIP = False

# 每个缩放尺度scale 是图片短边的像素尺寸
__C.TEST.MASK_AUG.SCALES = ()

# 长边的最大像素尺寸
__C.TEST.MASK_AUG.MAX_SIZE = 4000

# 在每个缩放尺度scale 水平翻转
__C.TEST.MASK_AUG.SCALE_H_FLIP = False

# 基于物体object 尺寸应用缩放尺度scale
__C.TEST.MASK_AUG.SCALE_SIZE_DEP = False
__C.TEST.MASK_AUG.AREA_TH = 180**2

# 每个长宽比相对于图片宽度
__C.TEST.MASK_AUG.ASPECT_RATIOS = ()

# 在每个长宽比aspect ratio 水平翻转
__C.TEST.MASK_AUG.ASPECT_RATIO_H_FLIP = False

7. Keypoint检测测试增强

# ---------------------------------------------------------------------------- #
# 关键点检测测试增强Test-augmentations for keypoints detection
# 如 configs/test_time_aug/keypoint_rcnn_R-50-FPN_1x.yaml
# ---------------------------------------------------------------------------- #
__C.TEST.KPS_AUG = AttrDict()

# True，开启关键点检测测试时间增强
__C.TEST.KPS_AUG.ENABLED = False

# 用于组合关键点预测的启发式
#   可选参数: ('HM_AVG', 'HM_MAX')
__C.TEST.KPS_AUG.HEUR = b'HM_AVG'

# 在原始缩放尺度scale 水平翻转(id transform)
__C.TEST.KPS_AUG.H_FLIP = False

# 每个缩放尺度scale 是图片短边的像素尺寸
__C.TEST.KPS_AUG.SCALES = ()

# 长边的最大像素尺寸
__C.TEST.KPS_AUG.MAX_SIZE = 4000

# 在每个缩放尺度scale 水平翻转
__C.TEST.KPS_AUG.SCALE_H_FLIP = False

# 基于物体object 尺寸应用缩放尺度scaling
__C.TEST.KPS_AUG.SCALE_SIZE_DEP = False
__C.TEST.KPS_AUG.AREA_TH = 180**2

# 每个长宽比aspect ratio相对于图片宽带
__C.TEST.KPS_AUG.ASPECT_RATIOS = ()

# 在每个长宽比aspect ratio 水平翻转
__C.TEST.KPS_AUG.ASPECT_RATIO_H_FLIP = False

8. Soft NMS

# ---------------------------------------------------------------------------- #
# Soft NMS
# ---------------------------------------------------------------------------- #
__C.TEST.SOFT_NMS = AttrDict()

# True，采用 soft NMS 代替 standard NMS
__C.TEST.SOFT_NMS.ENABLED = False
# 这一选项的具体信息请参照Soft NMS paper
__C.TEST.SOFT_NMS.METHOD = b'linear'
__C.TEST.SOFT_NMS.SIGMA = 0.5
# For the soft NMS overlap threshold, we simply use TEST.NMS

9. Bounding box voting

# ---------------------------------------------------------------------------- #
# Bounding box voting (from the Multi-Region CNN paper)
# ---------------------------------------------------------------------------- #
__C.TEST.BBOX_VOTE = AttrDict()

# True，使用 box voting
__C.TEST.BBOX_VOTE.ENABLED = False

# NMS步骤 使用的 TEST.NMS 阈值
#   对每个NMS得到的 box，VOTE_TH 重叠阈值用于选择投票 boxes (IoU >= VOTE_TH)
__C.TEST.BBOX_VOTE.VOTE_TH = 0.8

# 边界框投票时组合分数的方法
#  可选参数： ('ID', 'AVG', 'IOU_AVG', 'GENERALIZED_AVG', 'QUASI_SUM')
__C.TEST.BBOX_VOTE.SCORING_METHOD = b'ID'

# scoring方法的超参数(不同方法，意义不同)
__C.TEST.BBOX_VOTE.SCORING_METHOD_BETA = 1.0

10. Model options

# ---------------------------------------------------------------------------- #
# Model options
# ---------------------------------------------------------------------------- #
__C.MODEL = AttrDict()

# 使用模型的类型
# 字符串形式，与 modeling.model_builder 内的对应函数名一致，
# (e.g., 'generalized_rcnn', 'mask_rcnn', ...)
__C.MODEL.TYPE = b''

# 使用的 backbone conv body
# 字符串形式，与 modeling.model_builder 内的对应函数名一致，
# (e.g., 'FPN.add_fpn_ResNet101_conv5_body' 指定 ResNet-101-FPN 为骨干网络backbone)
__C.MODEL.CONV_BODY = b''

# 数据集内的类别classes 数；必须设定
# E.g., 81 for COCO (80 foreground + 1 background)
__C.MODEL.NUM_CLASSES = -1

# 采用类别未知边界框回归器(class agnostic bounding box regressor)；
# 而不是默认逐类回归器(default per-class regressor)
__C.MODEL.CLS_AGNOSTIC_BBOX_REG = False

# (dx, dy, dw, dh)的默认权重，用于归一化 bbox 回归目标targets
# 经验值，逼近到单位方差目标(unit variance targets)
__C.MODEL.BBOX_REG_WEIGHTS = (10., 10., 5., 5.)

# FASTER_RCNN 的意思取决于其内容(training vs. inference):
# 1) 训练时，FASTER_RCNN = True 表示使用 end-to-end 训练方式联合训练 RPN 子网络和 Fast R-CNN 子网络
#    (Faster R-CNN = RPN + Fast R-CNN).
# 2) 推断时，FASTER_RCNN = True 表示使用模型的 RPN 子网络来生成 proposals，而不是预先计算的 proposals.
#    即使 Faster R-CNN 模型是逐阶段训练的(即，交替训练 RPN 和 Fast R-CNN 得到的)，
#    也可以在推断时使用 FASTER_RCNN = True.
__C.MODEL.FASTER_RCNN = False

# True，表示模型输出示例分割预测结果 instance mask predictions (如 Mask R-CNN)
__C.MODEL.MASK_ON = False

# True，表示模型输出关键点预测结果 keypoint predictions (如 Mask R-CNN for keypoints)
__C.MODEL.KEYPOINTS_ON = False

# True，表示模型输出 body UV predictions (如 DensePose R-CNN)
__C.MODEL.BODY_UV_ON = False

# True，表示模型的计算终止于生成 RPN proposals
# (i.e., 只输出 proposals，不进行真正的目标检测)
__C.MODEL.RPN_ONLY = False

# Caffe2 网络net 执行类型
# 使用 'prof_dag' 进行分析统计
__C.MODEL.EXECUTION_TYPE = b'dag'

11. RetinaNet options

# ----------------------------------------------------------------------------#
# RetinaNet options
# ----------------------------------------------------------------------------#
__C.RETINANET = AttrDict()

# True，使用 RetinaNet (instead of Fast/er/Mask R-CNN/R-FCN/RPN)
__C.RETINANET.RETINANET_ON = False

# 所使用的 Anchor 长宽比aspect ratios
__C.RETINANET.ASPECT_RATIOS = (0.5, 1.0, 2.0)

# 每个 octave 的 Anchor 缩放尺度scale
__C.RETINANET.SCALES_PER_OCTAVE = 3

# 在每个 FPN 层次，基于其缩放尺度scale、长宽比aspect_ratio、层次步长stride of the level 生成 anchors,
# 并对得到的 anchor 乘以因子 ANCHOR_SCALE
__C.RETINANET.ANCHOR_SCALE = 4

# cls 和 bbox 使用的卷积数
# NOTE: this doesn't include the last conv for logits
__C.RETINANET.NUM_CONVS = 4

# bbox_regress loss 的权重
__C.RETINANET.BBOX_REG_WEIGHT = 1.0

# bbox regression 的 Smooth L1 loss beta
__C.RETINANET.BBOX_REG_BETA = 0.11

# 推断时，每个 FPN 层，在NMS处理前，基于 cls score 选择的 #locs
# During inference, #locs to select based on cls score before NMS is performed
# per FPN level
__C.RETINANET.PRE_NMS_TOP_N = 1000

# 标记 anchor 为 positive 的 IoU 重叠率
# Anchors with >= iou overlap 标记为 positive
__C.RETINANET.POSITIVE_OVERLAP = 0.5

# 标记 anchor 为 negative 的 IoU 重叠率
# Anchors with < iou overlap 标记为 negative
__C.RETINANET.NEGATIVE_OVERLAP = 0.4

# Focal loss 参数： alpha
__C.RETINANET.LOSS_ALPHA = 0.25

# Focal loss 参数： gamma
__C.RETINANET.LOSS_GAMMA = 2.0

# 训练开始时的 positives 的先验概率Prior prob
# 用于设置logits layer 的bias 初始化
__C.RETINANET.PRIOR_PROB = 0.01

# 是否共享 classification 和 bbox 分支
__C.RETINANET.SHARE_CLS_BBOX_TOWER = False

# 使用类别特定边界框回归(class specific bounding box regression)，
# 而不是默认类别位置回归(default class agnostic regression)
__C.RETINANET.CLASS_SPECIFIC_BBOX = False

# classification 分支训练是否使用 softmax
__C.RETINANET.SOFTMAX = False

# 推断时的 cls score 阈值
# anchors with score > INFERENCE_TH 用于推断
__C.RETINANET.INFERENCE_TH = 0.05

12. Solver options

# ---------------------------------------------------------------------------- #
# Solver options
# Note: 
# 所有的 solver 参数被精确指定；意味着，如果训练从 1 GPU 切换到 N GPUs，必须调整对应的 solver 参数.
# solver configuration accordingly. We suggest using gradual warmup and the
# linear learning rate scaling rule as described in
# "Accurate, Large Minibatch SGD: Training ImageNet in 1 Hour" Goyal et al.
# https://arxiv.org/abs/1706.02677
# ---------------------------------------------------------------------------- #
__C.SOLVER = AttrDict()

# 指定方案的基础学习率Base learning rate
__C.SOLVER.BASE_LR = 0.001

# 学习率策略，如 utils.lr_policy 中参数的对应函数)
# E.g., 'step', 'steps_with_decay', ...
__C.SOLVER.LR_POLICY = b'step'

# 一些 LR 策略例示:
# 'step'
#   lr = SOLVER.BASE_LR * SOLVER.GAMMA ** (cur_iter // SOLVER.STEP_SIZE)
# 'steps_with_decay'
#   SOLVER.STEPS = [0, 60000, 80000]
#   SOLVER.GAMMA = 0.1
#   lr = SOLVER.BASE_LR * SOLVER.GAMMA ** current_step
#   iters [0, 59999] are in current_step = 0, iters [60000, 79999] are in
#   current_step = 1, and so on
# 'steps_with_lrs'
#   SOLVER.STEPS = [0, 60000, 80000]
#   SOLVER.LRS = [0.02, 0.002, 0.0002]
#   lr = LRS[current_step]

# 指定方案的超参数
# 对于 'step',在每一步，当前 LR 乘以因子 SOLVER.GAMMA
__C.SOLVER.GAMMA = 0.1

# 'steps'策略均匀化步长Uniform step size
__C.SOLVER.STEP_SIZE = 30000

# 'steps_with_decay' 和 'steps_with_lrs'策略非均匀化步长 Non-uniform step iterations
__C.SOLVER.STEPS = []

# 采用 'steps_with_lrs' 策略的学习率
__C.SOLVER.LRS = []

# SGD 迭代的最多次数
__C.SOLVER.MAX_ITER = 40000

# SGD 动量 Momentum
__C.SOLVER.MOMENTUM = 0.9

# L2 正则化参数
__C.SOLVER.WEIGHT_DECAY = 0.0005

# SOLVER.BASE_LR 热身的 SGD 迭代次数
__C.SOLVER.WARM_UP_ITERS = 500

# 从 SOLVER.BASE_LR * SOLVER.WARM_UP_FACTOR 开始热身
__C.SOLVER.WARM_UP_FACTOR = 1.0 / 3.0

# WARM_UP_METHOD 方法可以是 'constant' 或 'linear' (i.e., gradual)
__C.SOLVER.WARM_UP_METHOD = 'linear'

# 当更新学习率时，采用 new_lr / old_lr 对动量momentum更新历史的缩放尺度scale：
# (this is correct given MomentumSGDUpdateOp)
__C.SOLVER.SCALE_MOMENTUM = True
# 仅当相对 LR 变化大于阈值时，才进行修正
# (避免小因子缩放动量momentum 时 linear warm up 所发生的变换；
#  如果 LR 变换较大时，momentum 缩放才比较重要)
# prevents ever change in linear warm up from scaling the momentum by a tiny
# amount; momentum scaling is only important if the LR change is large)
__C.SOLVER.SCALE_MOMENTUM_THRESHOLD = 1.1

# Suppress logging of changes to LR unless the relative change exceeds this
# threshold (prevents linear warm up from spamming the training log)
__C.SOLVER.LOG_LR_CHANGE_THRESHOLD = 1.1

13. Fast R-CNN options

# ---------------------------------------------------------------------------- 
# Fast R-CNN options
# ---------------------------------------------------------------------------- #
__C.FAST_RCNN = AttrDict()

# 用于边界框分类和回归的 RoI head 类型
# 字符串形式，必须与  modeling.model_builder 中对应的函数一致
# (e.g., 'head_builder.add_roi_2mlp_head' 指定了两个隐层的 MLP)
__C.FAST_RCNN.ROI_BOX_HEAD = b''

# 当使用 MLP 作为 RoI box head 时的隐层维度
__C.FAST_RCNN.MLP_HEAD_DIM = 1024

# RoI 变换函数(e.g., RoIPool or RoIAlign)
# (RoIPoolF 与 RoIPool 相同; 忽略尾部的 'F')
__C.FAST_RCNN.ROI_XFORM_METHOD = b'RoIPoolF'

# RoIAlign 中，网格采样(grid sampling points)点数(一般为 2)
# 只在 RoIAlign 中使用
__C.FAST_RCNN.ROI_XFORM_SAMPLING_RATIO = 0

# RoI 变换的输出分辨率
# 注：某些模型可能对于其可以使用什么有约束；
# e.g. 利用预训练好的FC网络如VGG16, and will ignore this option
__C.FAST_RCNN.ROI_XFORM_RESOLUTION = 14

14. RPN options

# ----------------------------------------------------------------------------#
# RPN options
# ----------------------------------------------------------------------------#
__C.RPN = AttrDict()

# [推测值：不直接在 config 中设定]
# True，表示模型包含 RPN 子网络
__C.RPN.RPN_ON = False

# 关于缩放网络输入的 RPN anchor 尺寸，以绝对像素值的形式
# RPN anchor sizes given in absolute pixels w.r.t. the scaled network input
# Note: these options are *not* used by FPN RPN; see FPN.RPN* options
__C.RPN.SIZES = (64, 128, 256, 512)

# RPN attached 的特征图步长
__C.RPN.STRIDE = 16

# RPN anchor 的长宽比aspect ratios
__C.RPN.ASPECT_RATIOS = (0.5, 1, 2)

15. FPN options

# --------------------------------------------------------------------------- #
# FPN options
# --------------------------------------------------------------------------- #
__C.FPN = AttrDict()

# True，开启 FPN
__C.FPN.FPN_ON = False

# FPN 特征层的通道维度Channel dimension
__C.FPN.DIM = 256

# True，初始化侧向连接lateral connections 输出 0
__C.FPN.ZERO_INIT_LATERAL = False

# 最粗糙coarsest FPN 层的步长
# 用于将输入正确地补零，是需要的
__C.FPN.COARSEST_STRIDE = 32

#
# FPN 可以只是 RPN、或只是目标检测，或两者都用.
#

# True, 采用 FPN 用于目标检测 RoI 变换
__C.FPN.MULTILEVEL_ROIS = False
# RoI-to-FPN 层的映射启发式 超参数
__C.FPN.ROI_CANONICAL_SCALE = 224  # s0
__C.FPN.ROI_CANONICAL_LEVEL = 4  # k0: where s0 maps to
# FPN 金字塔pyramid 的最粗糙层Coarsest level
__C.FPN.ROI_MAX_LEVEL = 5
# FPN 金字塔pyramid 的最精细层Finest level
__C.FPN.ROI_MIN_LEVEL = 2

# True，在 RPN 中使用 FPN
__C.FPN.MULTILEVEL_RPN = False
# FPN 金字塔pyramid 的最粗糙层Coarsest level
__C.FPN.RPN_MAX_LEVEL = 6
# FPN 金字塔pyramid 的最精细层Finest level
__C.FPN.RPN_MIN_LEVEL = 2
# FPN RPN anchor 长宽比aspect ratios
__C.FPN.RPN_ASPECT_RATIOS = (0.5, 1, 2)
# 在 RPN_MIN_LEVEL 上 RPN anchors 开始的尺寸
# RPN anchors start at this size on RPN_MIN_LEVEL
# The anchor size doubled each level after that
# With a default of 32 and levels 2 to 6, we get anchor sizes of 32 to 512
__C.FPN.RPN_ANCHOR_START_SIZE = 32
# 使用额外的 FPN 层levels, as done in the RetinaNet paper
__C.FPN.EXTRA_CONV_LEVELS = False

16. Mask R-CNN options

# --------------------------------------------------------------------------- #
# Mask R-CNN 参数 ("MRCNN" means Mask R-CNN)
# --------------------------------------------------------------------------- #
__C.MRCNN = AttrDict()

# 实例 mask 预测所用的 RoI head 类型
# 字符串形式，与 modeling.model_builder 对应的函数一致
# (e.g., 'mask_rcnn_heads.ResNet_mask_rcnn_fcn_head_v1up4convs')
__C.MRCNN.ROI_MASK_HEAD = b''

# 预测 mask 的分辨率
__C.MRCNN.RESOLUTION = 14

# RoI 变换函数和相关参数
__C.MRCNN.ROI_XFORM_METHOD = b'RoIAlign'

# RoI 变换函数 (e.g., RoIPool or RoIAlign)
__C.MRCNN.ROI_XFORM_RESOLUTION = 7

# RoIAlign 中网格采样点(grid sampling points)数(通常为2)
# 只用于 RoIAlign
__C.MRCNN.ROI_XFORM_SAMPLING_RATIO = 0

# mask head 中的通道channels 数
__C.MRCNN.DIM_REDUCED = 256

# mask head 中使用 dilated convolution
__C.MRCNN.DILATION = 2

# 预测 masks 的上采样因子
__C.MRCNN.UPSAMPLE_RATIO = 1

# True，采用全连接FC 层来预测最终的 masks
# False，采用卷积conv 层来预测最终的 masks
__C.MRCNN.USE_FC_OUTPUT = False

# mask head 和mask 输出层的权重初始化方法
__C.MRCNN.CONV_INIT = b'GaussianFill'

# True，使用类别特定 mask 预测(class specific mask predictions)
# False，使用类别未知 mask 预测(class agnostic mask predictions)
__C.MRCNN.CLS_SPECIFIC_MASK = True

# masks 的 multi-task loss 的权重
__C.MRCNN.WEIGHT_LOSS_MASK = 1.0

# soft masks 转换为 hard masks 的二值化阈值(Binarization threshold)
__C.MRCNN.THRESH_BINARIZE = 0.5

17. Keyoint Mask R-CNN options

# --------------------------------------------------------------------------- #
# Keyoint Mask R-CNN 参数 ("KRCNN" = Mask R-CNN with Keypoint support)
# --------------------------------------------------------------------------- #
__C.KRCNN = AttrDict()

# 实例关键点预测的 RoI head 的类型
# 字符串形式，与 modeling.model_builder 对应的函数一致
# (e.g., 'keypoint_rcnn_heads.add_roi_pose_head_v1convX')
__C.KRCNN.ROI_KEYPOINTS_HEAD = b''

# 输出 feature map 的尺寸(计算 loss 的尺寸) e.g., 56x56
__C.KRCNN.HEATMAP_SIZE = -1

# 使用双线性插值(bilinear interpolation)来上采用最终的 heatmap
__C.KRCNN.UP_SCALE = -1

# 对关键点 head 先验(prior) 计算的特征表示，采用 ConvTranspose 层处理，
# 以预测每个关键点的 heatmaps.
__C.KRCNN.USE_DECONV = False
# ConvTranspose 层产生的隐特征表示的通道维度(Channel dimension)
__C.KRCNN.DECONV_DIM = 256

# 采用 ConvTranspose 层来预测每个关键点的 heatmaps
__C.KRCNN.USE_DECONV_OUTPUT = False

# 在关键点 head 中使用 dilation
__C.KRCNN.DILATION = 1

# 所有的 ConvTranspose 操作的 kernels size
__C.KRCNN.DECONV_KERNEL = 4

# 数据集中关键点数(e.g., 17 for COCO)
__C.KRCNN.NUM_KEYPOINTS = -1

# 关键点 hrad 中的 stacked Conv layers 数
__C.KRCNN.NUM_STACKED_CONVS = 8

# 关键点 head 输出的特征表示的维度
__C.KRCNN.CONV_HEAD_DIM = 256

# 关键点 head 使用的 Conv kernel size
__C.KRCNN.CONV_HEAD_KERNEL = 3
# Conv 权重初始化
# Conv kernel weight filling function
__C.KRCNN.CONV_INIT = b'GaussianFill'

# True，基于 OKS 使用 NMS
__C.KRCNN.NMS_OKS = False

# Source of keypoint confidence
#   可选参数: ('bbox', 'logit', 'prob')
__C.KRCNN.KEYPOINT_CONFIDENCE = b'bbox'

# 标准的 RoI XFROM 参数 (如 FAST_RCNN 或 MRCNN 参数)
__C.KRCNN.ROI_XFORM_METHOD = b'RoIAlign'
__C.KRCNN.ROI_XFORM_RESOLUTION = 7
__C.KRCNN.ROI_XFORM_SAMPLING_RATIO = 0

# mini-batch 中必须存在的标记关键点的最小数
# 如果少于 MIN_KEYPOINT_COUNT_FOR_VALID_MINIBATCH，则丢弃该 mini-batch
__C.KRCNN.MIN_KEYPOINT_COUNT_FOR_VALID_MINIBATCH = 20

# 当从 heatmap 中推断关键点位置时，对低于最小尺寸INFERENCE_MIN_SIZE 的heatmap不进行缩放scale
__C.KRCNN.INFERENCE_MIN_SIZE = 0

# 用于关键点的 multi-task loss 权重
# 推荐值:
#   - use 1.0 if KRCNN.NORMALIZE_BY_VISIBLE_KEYPOINTS is True
#   - use 4.0 if KRCNN.NORMALIZE_BY_VISIBLE_KEYPOINTS is False
__C.KRCNN.LOSS_WEIGHT = 1.0

# True，根据 mini-batch 内可见(visible)关键点总数进行归一化
# False，根据 mini-batch 内存在的关键点总数进行归一化
__C.KRCNN.NORMALIZE_BY_VISIBLE_KEYPOINTS = True

18. Body UV R-CNN options

__C.BODY_UV_RCNN = AttrDict()

# body UV prediction 的 RoI head类型
__C.BODY_UV_RCNN.ROI_HEAD = b''

# Output size (and size loss is computed on), e.g., 56x56
__C.BODY_UV_RCNN.HEATMAP_SIZE = -1

# 用双线性差值来上采样最终的heatmap
__C.BODY_UV_RCNN.UP_SCALE = -1

# 用 ConvTranspose layer 来特征先验(prior)表示 heatmaps
__C.KRCNN.USE_DECONV = False
# 通过 ConvTranspose 产生的隐特征表示的通道维度
__C.BODY_UV_RCNN.DECONV_DIM = 256
# Use a ConvTranspose layer to predict the heatmaps
__C.BODY_UV_RCNN.USE_DECONV_OUTPUT = False
# Use dilation in the body UV head
__C.BODY_UV_RCNN.DILATION = 1
# Size of the kernels to use in all ConvTranspose operations
__C.BODY_UV_RCNN.DECONV_KERNEL = 4

# 数据集中的patch数
__C.BODY_UV_RCNN.NUM_PATCHES = -1

# Number of stacked Conv layers in body UV head
__C.BODY_UV_RCNN.NUM_STACKED_CONVS = 8
# Dimension of the hidden representation output by the body UV head
__C.BODY_UV_RCNN.CONV_HEAD_DIM = 256
# Conv kernel size used in the body UV head
__C.BODY_UV_RCNN.CONV_HEAD_KERNEL = 3
# Conv kernel weight filling function
__C.BODY_UV_RCNN.CONV_INIT = b'GaussianFill'

# 标准 ROI XFORM 参数 (see FAST_RCNN or MRCNN options)
__C.BODY_UV_RCNN.ROI_XFORM_METHOD = b'RoIAlign'
__C.BODY_UV_RCNN.ROI_XFORM_RESOLUTION = 7
__C.BODY_UV_RCNN.ROI_XFORM_SAMPLING_RATIO = 0

# Weights
__C.BODY_UV_RCNN.INDEX_WEIGHTS = 5.0
__C.BODY_UV_RCNN.PART_WEIGHTS = 1.0
__C.BODY_UV_RCNN.POINT_REGRESSION_WEIGHTS = 0.001

# Train only with images that have body uv annotations
__C.BODY_UV_RCNN.BODY_UV_IMS = False

19. R-FCN options

# --------------------------------------------------------------------------- #
# R-FCN options
# --------------------------------------------------------------------------- #
__C.RFCN = AttrDict()

# Position-sensitive RoI pooling output grid size (height and width)
__C.RFCN.PS_GRID_SIZE = 3

20. ResNets options

# --------------------------------------------------------------------------- #
# ResNets 参数 ("ResNets" = ResNet and ResNeXt)
# --------------------------------------------------------------------------- #
__C.RESNETS = AttrDict()

# groups 数; 1 ==> ResNet; > 1 ==> ResNeXt
__C.RESNETS.NUM_GROUPS = 1

# 每个 group 的 aseline width
__C.RESNETS.WIDTH_PER_GROUP = 64

# 在 1x1 filter 放置 stride 2 的 conv
# True, 只用于原始的 MSRA ResNet；
# False, 用于 C2 和 Torch 模型 
__C.RESNETS.STRIDE_1X1 = True

# 残差变换函数
# Residual transformation function
__C.RESNETS.TRANS_FUNC = b'bottleneck_transformation'

# 在 stage "res5" 采用 dilation
__C.RESNETS.RES5_DILATION = 1

21. Misc options

# --------------------------------------------------------------------------- #
# Misc 参数
# --------------------------------------------------------------------------- #

# GPUs 数 (同时用于 training 和 testing)
__C.NUM_GPUS = 1

# True， 使用 NCCL 加速；可能遇到 deadlocks 问题
# False，使用 muji
__C.USE_NCCL = False

# 图片坐标到特征图 feature map 坐标映射时，一些在图片空间不同坐标的 boxes 的 feature 坐标可能相同.
# 如果 DEDUP_BOXES > 0，DEDUP_BOXES 作为识别重复 boxes 的缩放因子scale factor.
# 1/16 is correct for {Alex,Caffe}Net, VGG_CNN_M_1024, and VGG16
__C.DEDUP_BOXES = 1 / 16.

# 修剪边界框变换预测结果(bounding box transformation predictions)，以避免 np.exp 出现溢出(overflowing).
# 基于将 16 pixel anchor 缩放scale 到 10000 pixels 的启发式值
__C.BBOX_XFORM_CLIP = np.log(1000. / 16.)

# 像素均值(BGR 顺序) - (1, 1, 3) array数组形式
# 对于所有网络采用相同的像素均值，即使不是很精确
# "Fun" fact: the history of where these values comes from is lost
__C.PIXEL_MEANS = np.array([[[102.9801, 115.9465, 122.7717]]])

# 用于重复实现结果
# For reproducibility...but not really because modern fast GPU libraries use
# non-deterministic op implementations
__C.RNG_SEED = 3

# A small number that's used many times
__C.EPS = 1e-14

# 项目根目录
__C.ROOT_DIR = os.getcwd()

# Output basedir
__C.OUTPUT_DIR = b'/tmp'

# matlab 
# Name (or path to) the matlab executable
__C.MATLAB = b'matlab'

# 基于 memonger gradient blob sharing 减少内存占用
# Reduce memory usage with memonger gradient blob sharing
__C.MEMONGER = True

# 如果 forward pass 激活可以共享，可以进一步优化内存
# Futher reduce memory by allowing forward pass activations to be shared when
# possible. Note that this will cause activation blob inspection (values,
# shapes, etc.) to be meaningless when activation blobs are reused.
__C.MEMONGER_SHARE_ACTIVATIONS = False

# 检测结果可视化 Dump detection visualizations
__C.VIS = False

# 可视化的score阈值
# Score threshold for visualization
__C.VIS_TH = 0.9

# Expected 检测，列表list 形式，每一元素有四个值：(dataset, task, metric, expected value)
# 如: [['coco_2014_minival', 'box_proposal', 'AR@1000', 0.387]]
__C.EXPECTED_RESULTS = []
# 与 EXPECTED_RESULTS 相比的绝对和相对偏差tolerance
__C.EXPECTED_RESULTS_RTOL = 0.1
__C.EXPECTED_RESULTS_ATOL = 0.005
# 如果 EXPECTED_RESULTS 失败，发送邮件
__C.EXPECTED_RESULTS_EMAIL = b''

# URL 下载的模型Models 和 proposals 的缓存目录
__C.DOWNLOAD_CACHE = b'/tmp/detectron-download-cache'

22. Cluster options

# --------------------------------------------------------------------------- #
# Cluster options
# --------------------------------------------------------------------------- #
__C.CLUSTER = AttrDict()

# True，表示 code 以聚类环境运行
# Flag to indicate if the code is running in a cluster environment
__C.CLUSTER.ON_CLUSTER = False

关于后面剩下的参数，不做详细介绍了。
又花了一下午时间写博客