SYMBOL INDEX (736 symbols across 119 files)

FILE: demo/fcos_demo.py
  function main (line 11) | def main():

FILE: demo/predictor.py
  class COCODemo (line 14) | class COCODemo(object):
    method __init__ (line 100) | def __init__(
    method build_transform (line 132) | def build_transform(self):
    method run_on_opencv_image (line 162) | def run_on_opencv_image(self, image):
    method compute_prediction (line 187) | def compute_prediction(self, original_image):
    method select_top_predictions (line 224) | def select_top_predictions(self, predictions):
    method compute_colors_for_labels (line 247) | def compute_colors_for_labels(self, labels):
    method overlay_boxes (line 255) | def overlay_boxes(self, image, predictions):
    method overlay_mask (line 278) | def overlay_mask(self, image, predictions):
    method overlay_keypoints (line 304) | def overlay_keypoints(self, image, predictions):
    method create_mask_montage (line 313) | def create_mask_montage(self, image, predictions):
    method overlay_class_names (line 349) | def overlay_class_names(self, image, predictions):
  function vis_keypoints (line 378) | def vis_keypoints(img, kps, kp_thresh=2, alpha=0.7):

FILE: demo/webcam.py
  function main (line 11) | def main():

FILE: maskrcnn_benchmark/config/paths_catalog.py
  class DatasetCatalog (line 7) | class DatasetCatalog(object):
    method get (line 110) | def get(name):
  class ModelCatalog (line 136) | class ModelCatalog(object):
    method get (line 163) | def get(name):
    method get_c2_imagenet_pretrained (line 171) | def get_c2_imagenet_pretrained(name):
    method get_c2_detectron_12_2017_baselines (line 179) | def get_c2_detectron_12_2017_baselines(name):

FILE: maskrcnn_benchmark/csrc/cpu/ROIAlign_cpu.cpp
  type PreCalc (line 6) | struct PreCalc {
  function pre_calc_for_bilinear_interpolate (line 18) | void pre_calc_for_bilinear_interpolate(
  function ROIAlignForward_cpu_kernel (line 114) | void ROIAlignForward_cpu_kernel(
  function ROIAlign_forward_cpu (line 221) | at::Tensor ROIAlign_forward_cpu(const at::Tensor& input,

FILE: maskrcnn_benchmark/csrc/cpu/nms_cpu.cpp
  function nms_cpu_kernel (line 6) | at::Tensor nms_cpu_kernel(const at::Tensor& dets,
  function nms_cpu (line 67) | at::Tensor nms_cpu(const at::Tensor& dets,

FILE: maskrcnn_benchmark/csrc/nms.h
  function threshold (line 12) | float threshold) {

FILE: maskrcnn_benchmark/csrc/vision.cpp
  function PYBIND11_MODULE (line 7) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: maskrcnn_benchmark/data/build.py
  function build_dataset (line 17) | def build_dataset(dataset_list, transforms, dataset_catalog, is_train=Tr...
  function make_data_sampler (line 59) | def make_data_sampler(dataset, shuffle, distributed):
  function _quantize (line 69) | def _quantize(x, bins):
  function _compute_aspect_ratios (line 76) | def _compute_aspect_ratios(dataset):
  function make_batch_data_sampler (line 85) | def make_batch_data_sampler(
  function make_data_loader (line 107) | def make_data_loader(cfg, is_train=True, is_distributed=False, start_ite...

FILE: maskrcnn_benchmark/data/collate_batch.py
  class BatchCollator (line 5) | class BatchCollator(object):
    method __init__ (line 12) | def __init__(self, size_divisible=0):
    method __call__ (line 15) | def __call__(self, batch):

FILE: maskrcnn_benchmark/data/datasets/coco.py
  function _count_visible_keypoints (line 13) | def _count_visible_keypoints(anno):
  function _has_only_empty_bbox (line 17) | def _has_only_empty_bbox(anno):
  function has_valid_annotation (line 21) | def has_valid_annotation(anno):
  class COCODataset (line 39) | class COCODataset(torchvision.datasets.coco.CocoDetection):
    method __init__ (line 40) | def __init__(
    method __getitem__ (line 66) | def __getitem__(self, idx):
    method get_img_info (line 98) | def get_img_info(self, index):

FILE: maskrcnn_benchmark/data/datasets/concat_dataset.py
  class ConcatDataset (line 7) | class ConcatDataset(_ConcatDataset):
    method get_idxs (line 13) | def get_idxs(self, idx):
    method get_img_info (line 21) | def get_img_info(self, idx):

FILE: maskrcnn_benchmark/data/datasets/evaluation/__init__.py
  function evaluate (line 7) | def evaluate(dataset, predictions, output_folder, **kwargs):

FILE: maskrcnn_benchmark/data/datasets/evaluation/coco/__init__.py
  function coco_evaluation (line 4) | def coco_evaluation(

FILE: maskrcnn_benchmark/data/datasets/evaluation/coco/coco_eval.py
  function do_coco_evaluation (line 13) | def do_coco_evaluation(
  function prepare_for_coco_detection (line 70) | def prepare_for_coco_detection(predictions, dataset):
  function prepare_for_coco_segmentation (line 104) | def prepare_for_coco_segmentation(predictions, dataset):
  function prepare_for_coco_keypoint (line 158) | def prepare_for_coco_keypoint(predictions, dataset):
  function evaluate_box_proposals (line 189) | def evaluate_box_proposals(
  function evaluate_predictions_on_coco (line 305) | def evaluate_predictions_on_coco(
  function compute_thresholds_for_classes (line 329) | def compute_thresholds_for_classes(coco_eval):
  class COCOResults (line 358) | class COCOResults(object):
    method __init__ (line 375) | def __init__(self, *iou_types):
    method update (line 385) | def update(self, coco_eval):
    method __repr__ (line 398) | def __repr__(self):
  function check_expected_results (line 403) | def check_expected_results(results, expected_results, sigma_tol):

FILE: maskrcnn_benchmark/data/datasets/evaluation/voc/__init__.py
  function voc_evaluation (line 6) | def voc_evaluation(dataset, predictions, output_folder, box_only, **_):

FILE: maskrcnn_benchmark/data/datasets/evaluation/voc/voc_eval.py
  function do_voc_evaluation (line 12) | def do_voc_evaluation(dataset, predictions, output_folder, logger):
  function eval_detection_voc (line 48) | def eval_detection_voc(pred_boxlists, gt_boxlists, iou_thresh=0.5, use_0...
  function calc_detection_voc_prec_rec (line 68) | def calc_detection_voc_prec_rec(gt_boxlists, pred_boxlists, iou_thresh=0...
  function calc_detection_voc_ap (line 160) | def calc_detection_voc_ap(prec, rec, use_07_metric=False):

FILE: maskrcnn_benchmark/data/datasets/list_dataset.py
  class ListDataset (line 11) | class ListDataset(object):
    method __init__ (line 12) | def __init__(self, image_lists, transforms=None):
    method __getitem__ (line 16) | def __getitem__(self, item):
    method __len__ (line 28) | def __len__(self):
    method get_img_info (line 31) | def get_img_info(self, item):

FILE: maskrcnn_benchmark/data/datasets/voc.py
  class PascalVOCDataset (line 17) | class PascalVOCDataset(torch.utils.data.Dataset):
    method __init__ (line 43) | def __init__(self, data_dir, split, use_difficult=False, transforms=No...
    method __getitem__ (line 61) | def __getitem__(self, index):
    method __len__ (line 73) | def __len__(self):
    method get_groundtruth (line 76) | def get_groundtruth(self, index):
    method _preprocess_annotation (line 87) | def _preprocess_annotation(self, target):
    method get_img_info (line 126) | def get_img_info(self, index):
    method map_class_id_to_class_name (line 133) | def map_class_id_to_class_name(self, class_id):

FILE: maskrcnn_benchmark/data/samplers/distributed.py
  class DistributedSampler (line 10) | class DistributedSampler(Sampler):
    method __init__ (line 25) | def __init__(self, dataset, num_replicas=None, rank=None, shuffle=True):
    method __iter__ (line 42) | def __iter__(self):
    method __len__ (line 62) | def __len__(self):
    method set_epoch (line 65) | def set_epoch(self, epoch):

FILE: maskrcnn_benchmark/data/samplers/grouped_batch_sampler.py
  class GroupedBatchSampler (line 9) | class GroupedBatchSampler(BatchSampler):
    method __init__ (line 24) | def __init__(self, sampler, group_ids, batch_size, drop_uneven=False):
    method _prepare_batches (line 40) | def _prepare_batches(self):
    method __iter__ (line 102) | def __iter__(self):
    method __len__ (line 111) | def __len__(self):

FILE: maskrcnn_benchmark/data/samplers/iteration_based_batch_sampler.py
  class IterationBasedBatchSampler (line 5) | class IterationBasedBatchSampler(BatchSampler):
    method __init__ (line 11) | def __init__(self, batch_sampler, num_iterations, start_iter=0):
    method __iter__ (line 16) | def __iter__(self):
    method __len__ (line 30) | def __len__(self):

FILE: maskrcnn_benchmark/data/transforms/build.py
  function build_transforms (line 5) | def build_transforms(cfg, is_train=True):

FILE: maskrcnn_benchmark/data/transforms/transforms.py
  class Compose (line 9) | class Compose(object):
    method __init__ (line 10) | def __init__(self, transforms):
    method __call__ (line 13) | def __call__(self, image, target):
    method __repr__ (line 18) | def __repr__(self):
  class Resize (line 27) | class Resize(object):
    method __init__ (line 28) | def __init__(self, min_size, max_size):
    method get_size (line 35) | def get_size(self, image_size):
    method __call__ (line 57) | def __call__(self, image, target):
  class RandomHorizontalFlip (line 64) | class RandomHorizontalFlip(object):
    method __init__ (line 65) | def __init__(self, prob=0.5):
    method __call__ (line 68) | def __call__(self, image, target):
  class ToTensor (line 75) | class ToTensor(object):
    method __call__ (line 76) | def __call__(self, image, target):
  class Normalize (line 80) | class Normalize(object):
    method __init__ (line 81) | def __init__(self, mean, std, to_bgr255=True):
    method __call__ (line 86) | def __call__(self, image, target):

FILE: maskrcnn_benchmark/engine/inference.py
  function compute_on_dataset (line 16) | def compute_on_dataset(model, data_loader, device, timer=None):
  function _accumulate_predictions_from_multiple_gpus (line 37) | def _accumulate_predictions_from_multiple_gpus(predictions_per_gpu):
  function inference (line 59) | def inference(

FILE: maskrcnn_benchmark/engine/trainer.py
  function reduce_loss_dict (line 13) | def reduce_loss_dict(loss_dict):
  function do_train (line 38) | def do_train(

FILE: maskrcnn_benchmark/layers/_utils.py
  function _load_C_extensions (line 14) | def _load_C_extensions():

FILE: maskrcnn_benchmark/layers/batch_norm.py
  class FrozenBatchNorm2d (line 6) | class FrozenBatchNorm2d(nn.Module):
    method __init__ (line 12) | def __init__(self, n):
    method forward (line 19) | def forward(self, x):

FILE: maskrcnn_benchmark/layers/iou_loss.py
  class IOULoss (line 5) | class IOULoss(nn.Module):
    method __init__ (line 6) | def __init__(self, loc_loss_type):
    method forward (line 10) | def forward(self, pred, target, weight=None):

FILE: maskrcnn_benchmark/layers/misc.py
  class _NewEmptyTensorOp (line 17) | class _NewEmptyTensorOp(torch.autograd.Function):
    method forward (line 19) | def forward(ctx, x, new_shape):
    method backward (line 24) | def backward(ctx, grad):
  class Conv2d (line 29) | class Conv2d(torch.nn.Conv2d):
    method forward (line 30) | def forward(self, x):
  class ConvTranspose2d (line 45) | class ConvTranspose2d(torch.nn.ConvTranspose2d):
    method forward (line 46) | def forward(self, x):
  class BatchNorm2d (line 66) | class BatchNorm2d(torch.nn.BatchNorm2d):
    method forward (line 67) | def forward(self, x):
  function interpolate (line 75) | def interpolate(

FILE: maskrcnn_benchmark/layers/roi_align.py
  class _ROIAlign (line 11) | class _ROIAlign(Function):
    method forward (line 13) | def forward(ctx, input, roi, output_size, spatial_scale, sampling_ratio):
    method backward (line 26) | def backward(ctx, grad_output):
  class ROIAlign (line 50) | class ROIAlign(nn.Module):
    method __init__ (line 51) | def __init__(self, output_size, spatial_scale, sampling_ratio):
    method forward (line 57) | def forward(self, input, rois):
    method __repr__ (line 62) | def __repr__(self):

FILE: maskrcnn_benchmark/layers/roi_pool.py
  class _ROIPool (line 11) | class _ROIPool(Function):
    method forward (line 13) | def forward(ctx, input, roi, output_size, spatial_scale):
    method backward (line 25) | def backward(ctx, grad_output):
  class ROIPool (line 49) | class ROIPool(nn.Module):
    method __init__ (line 50) | def __init__(self, output_size, spatial_scale):
    method forward (line 55) | def forward(self, input, rois):
    method __repr__ (line 58) | def __repr__(self):

FILE: maskrcnn_benchmark/layers/scale.py
  class Scale (line 5) | class Scale(nn.Module):
    method __init__ (line 6) | def __init__(self, init_value=1.0):
    method forward (line 10) | def forward(self, input):

FILE: maskrcnn_benchmark/layers/sigmoid_focal_loss.py
  class _SigmoidFocalLoss (line 9) | class _SigmoidFocalLoss(Function):
    method forward (line 11) | def forward(ctx, logits, targets, gamma, alpha):
    method backward (line 25) | def backward(ctx, d_loss):
  function sigmoid_focal_loss_cpu (line 40) | def sigmoid_focal_loss_cpu(logits, targets, gamma, alpha):
  class SigmoidFocalLoss (line 55) | class SigmoidFocalLoss(nn.Module):
    method __init__ (line 56) | def __init__(self, gamma, alpha):
    method forward (line 61) | def forward(self, logits, targets):
    method __repr__ (line 71) | def __repr__(self):

FILE: maskrcnn_benchmark/layers/smooth_l1_loss.py
  function smooth_l1_loss (line 6) | def smooth_l1_loss(input, target, beta=1. / 9, size_average=True):

FILE: maskrcnn_benchmark/modeling/backbone/backbone.py
  function build_resnet_backbone (line 17) | def build_resnet_backbone(cfg):
  function build_resnet_fpn_backbone (line 27) | def build_resnet_fpn_backbone(cfg):
  function build_resnet_fpn_p3p7_backbone (line 51) | def build_resnet_fpn_p3p7_backbone(cfg):
  function build_mnv2_fpn_backbone (line 76) | def build_mnv2_fpn_backbone(cfg):
  function build_backbone (line 98) | def build_backbone(cfg):

FILE: maskrcnn_benchmark/modeling/backbone/fbnet.py
  function create_builder (line 21) | def create_builder(cfg):
  function _get_trunk_cfg (line 71) | def _get_trunk_cfg(arch_def):
  class FBNetTrunk (line 79) | class FBNetTrunk(nn.Module):
    method __init__ (line 80) | def __init__(
    method forward (line 89) | def forward(self, x):
  function add_conv_body (line 97) | def add_conv_body(cfg, dim_in=3):
  function _get_rpn_stage (line 107) | def _get_rpn_stage(arch_def, num_blocks):
  class FBNetRPNHead (line 121) | class FBNetRPNHead(nn.Module):
    method __init__ (line 122) | def __init__(
    method forward (line 138) | def forward(self, x):
  function add_rpn_head (line 144) | def add_rpn_head(cfg, in_channels, num_anchors):
  function _get_head_stage (line 157) | def _get_head_stage(arch, head_name, blocks):
  class FBNetROIHead (line 174) | class FBNetROIHead(nn.Module):
    method __init__ (line 175) | def __init__(
    method forward (line 204) | def forward(self, x, proposals):
  function add_roi_head (line 211) | def add_roi_head(cfg, in_channels):
  function add_roi_head_keypoints (line 226) | def add_roi_head_keypoints(cfg, in_channels):
  function add_roi_head_mask (line 241) | def add_roi_head_mask(cfg, in_channels):

FILE: maskrcnn_benchmark/modeling/backbone/fbnet_builder.py
  function _py2_round (line 26) | def _py2_round(x):
  function _get_divisible_by (line 30) | def _get_divisible_by(num, divisible_by, min_val):
  class Identity (line 195) | class Identity(nn.Module):
    method __init__ (line 196) | def __init__(self, C_in, C_out, stride):
    method forward (line 213) | def forward(self, x):
  class CascadeConv3x3 (line 221) | class CascadeConv3x3(nn.Sequential):
    method __init__ (line 222) | def __init__(self, C_in, C_out, stride):
    method forward (line 234) | def forward(self, x):
  class Shift (line 241) | class Shift(nn.Module):
    method __init__ (line 242) | def __init__(self, C, kernel_size, stride, padding):
    method forward (line 269) | def forward(self, x):
  class ShiftBlock5x5 (line 295) | class ShiftBlock5x5(nn.Sequential):
    method __init__ (line 296) | def __init__(self, C_in, C_out, expansion, stride):
    method forward (line 315) | def forward(self, x):
  class ChannelShuffle (line 322) | class ChannelShuffle(nn.Module):
    method __init__ (line 323) | def __init__(self, groups):
    method forward (line 327) | def forward(self, x):
  class ConvBNRelu (line 342) | class ConvBNRelu(nn.Sequential):
    method __init__ (line 343) | def __init__(
  class SEModule (line 397) | class SEModule(nn.Module):
    method __init__ (line 400) | def __init__(self, C):
    method forward (line 410) | def forward(self, x):
  class Upsample (line 414) | class Upsample(nn.Module):
    method __init__ (line 415) | def __init__(self, scale_factor, mode, align_corners=None):
    method forward (line 421) | def forward(self, x):
  function _get_upsample_op (line 428) | def _get_upsample_op(stride):
  class IRFBlock (line 445) | class IRFBlock(nn.Module):
    method __init__ (line 446) | def __init__(
    method forward (line 549) | def forward(self, x):
  function _expand_block_cfg (line 563) | def _expand_block_cfg(block_cfg):
  function expand_stage_cfg (line 574) | def expand_stage_cfg(stage_cfg):
  function expand_stages_cfg (line 583) | def expand_stages_cfg(stage_cfgs):
  function _block_cfgs_to_list (line 592) | def _block_cfgs_to_list(block_cfgs):
  function _add_to_arch (line 603) | def _add_to_arch(arch, info, name):
  function unify_arch_def (line 641) | def unify_arch_def(arch_def):
  function get_num_stages (line 671) | def get_num_stages(arch_def):
  function get_blocks (line 679) | def get_blocks(arch_def, stage_indices=None, block_indices=None):
  class FBNetBuilder (line 693) | class FBNetBuilder(object):
    method __init__ (line 694) | def __init__(
    method add_first (line 709) | def add_first(self, stage_info, dim_in=3, pad=True):
    method add_blocks (line 732) | def add_blocks(self, blocks):
    method add_last (line 754) | def add_last(self, stage_info):
    method _add_ir_block (line 795) | def _add_ir_block(
    method add_ir_block (line 811) | def add_ir_block(self, tcns, block_op_types, **kwargs):
    method _get_divisible_width (line 827) | def _get_divisible_width(self, width):

FILE: maskrcnn_benchmark/modeling/backbone/fbnet_modeldef.py
  function add_archs (line 4) | def add_archs(archs):

FILE: maskrcnn_benchmark/modeling/backbone/fpn.py
  class FPN (line 7) | class FPN(nn.Module):
    method __init__ (line 14) | def __init__(
    method forward (line 43) | def forward(self, x):
  class LastLevelMaxPool (line 77) | class LastLevelMaxPool(nn.Module):
    method forward (line 78) | def forward(self, x):
  class LastLevelP6P7 (line 82) | class LastLevelP6P7(nn.Module):
    method __init__ (line 86) | def __init__(self, in_channels, out_channels):
    method forward (line 95) | def forward(self, c5, p5):

FILE: maskrcnn_benchmark/modeling/backbone/mobilenet.py
  function conv_bn (line 11) | def conv_bn(inp, oup, stride):
  function conv_1x1_bn (line 19) | def conv_1x1_bn(inp, oup):
  class InvertedResidual (line 27) | class InvertedResidual(nn.Module):
    method __init__ (line 28) | def __init__(self, inp, oup, stride, expand_ratio):
    method forward (line 61) | def forward(self, x):
  class MobileNetV2 (line 68) | class MobileNetV2(nn.Module):
    method __init__ (line 72) | def __init__(self, cfg, n_class=1000, input_size=224, width_mult=1.):
    method _freeze_backbone (line 108) | def _freeze_backbone(self, freeze_at):
    method forward (line 113) | def forward(self, x):
    method _initialize_weights (line 121) | def _initialize_weights(self):

FILE: maskrcnn_benchmark/modeling/backbone/resnet.py
  class ResNet (line 80) | class ResNet(nn.Module):
    method __init__ (line 81) | def __init__(self, cfg):
    method _freeze_backbone (line 127) | def _freeze_backbone(self, freeze_at):
    method forward (line 138) | def forward(self, x):
  class ResNetHead (line 148) | class ResNetHead(nn.Module):
    method __init__ (line 149) | def __init__(
    method forward (line 192) | def forward(self, x):
  function _make_stage (line 198) | def _make_stage(
  class Bottleneck (line 228) | class Bottleneck(nn.Module):
    method __init__ (line 229) | def __init__(
    method forward (line 295) | def forward(self, x):
  class BaseStem (line 318) | class BaseStem(nn.Module):
    method __init__ (line 319) | def __init__(self, cfg, norm_func):
    method forward (line 332) | def forward(self, x):
  class BottleneckWithFixedBatchNorm (line 340) | class BottleneckWithFixedBatchNorm(Bottleneck):
    method __init__ (line 341) | def __init__(
  class StemWithFixedBatchNorm (line 363) | class StemWithFixedBatchNorm(BaseStem):
    method __init__ (line 364) | def __init__(self, cfg):
  class BottleneckWithGN (line 370) | class BottleneckWithGN(Bottleneck):
    method __init__ (line 371) | def __init__(
  class StemWithGN (line 393) | class StemWithGN(BaseStem):
    method __init__ (line 394) | def __init__(self, cfg):

FILE: maskrcnn_benchmark/modeling/balanced_positive_negative_sampler.py
  class BalancedPositiveNegativeSampler (line 5) | class BalancedPositiveNegativeSampler(object):
    method __init__ (line 10) | def __init__(self, batch_size_per_image, positive_fraction):
    method __call__ (line 19) | def __call__(self, matched_idxs):

FILE: maskrcnn_benchmark/modeling/box_coder.py
  class BoxCoder (line 7) | class BoxCoder(object):
    method __init__ (line 13) | def __init__(self, weights, bbox_xform_clip=math.log(1000. / 16)):
    method encode (line 22) | def encode(self, reference_boxes, proposals):
    method decode (line 52) | def decode(self, rel_codes, boxes):

FILE: maskrcnn_benchmark/modeling/detector/detectors.py
  function build_detection_model (line 8) | def build_detection_model(cfg):

FILE: maskrcnn_benchmark/modeling/detector/generalized_rcnn.py
  class GeneralizedRCNN (line 16) | class GeneralizedRCNN(nn.Module):
    method __init__ (line 26) | def __init__(self, cfg):
    method forward (line 33) | def forward(self, images, targets=None):

FILE: maskrcnn_benchmark/modeling/make_layers.py
  function get_group_gn (line 14) | def get_group_gn(dim, dim_per_gp, num_groups):
  function group_norm (line 31) | def group_norm(out_channels, affine=True, divisor=1):
  function make_conv3x3 (line 44) | def make_conv3x3(
  function make_fc (line 80) | def make_fc(dim_in, hidden_dim, use_gn=False):
  function conv_with_kaiming_uniform (line 95) | def conv_with_kaiming_uniform(use_gn=False, use_relu=False):

FILE: maskrcnn_benchmark/modeling/matcher.py
  class Matcher (line 5) | class Matcher(object):
    method __init__ (line 23) | def __init__(self, high_threshold, low_threshold, allow_low_quality_ma...
    method __call__ (line 42) | def __call__(self, match_quality_matrix):
    method set_low_quality_matches_ (line 83) | def set_low_quality_matches_(self, matches, all_matches, match_quality...

FILE: maskrcnn_benchmark/modeling/poolers.py
  class LevelMapper (line 11) | class LevelMapper(object):
    method __init__ (line 16) | def __init__(self, k_min, k_max, canonical_scale=224, canonical_level=...
    method __call__ (line 31) | def __call__(self, boxlists):
  class Pooler (line 45) | class Pooler(nn.Module):
    method __init__ (line 55) | def __init__(self, output_size, scales, sampling_ratio):
    method convert_to_roi_format (line 78) | def convert_to_roi_format(self, boxes):
    method forward (line 91) | def forward(self, x, boxes):
  function make_pooler (line 124) | def make_pooler(cfg, head_name):

FILE: maskrcnn_benchmark/modeling/roi_heads/box_head/box_head.py
  class ROIBoxHead (line 11) | class ROIBoxHead(torch.nn.Module):
    method __init__ (line 16) | def __init__(self, cfg, in_channels):
    method forward (line 24) | def forward(self, features, proposals, targets=None):
  function build_roi_box_head (line 65) | def build_roi_box_head(cfg, in_channels):

FILE: maskrcnn_benchmark/modeling/roi_heads/box_head/inference.py
  class PostProcessor (line 12) | class PostProcessor(nn.Module):
    method __init__ (line 19) | def __init__(
    method forward (line 43) | def forward(self, x, boxes):
    method prepare_boxlist (line 86) | def prepare_boxlist(self, boxes, scores, image_shape):
    method filter_results (line 105) | def filter_results(self, boxlist, num_classes):
  function make_roi_box_post_processor (line 149) | def make_roi_box_post_processor(cfg):

FILE: maskrcnn_benchmark/modeling/roi_heads/box_head/loss.py
  class FastRCNNLossComputation (line 15) | class FastRCNNLossComputation(object):
    method __init__ (line 21) | def __init__(
    method match_targets_to_proposals (line 39) | def match_targets_to_proposals(self, proposal, target):
    method prepare_targets (line 52) | def prepare_targets(self, proposals, targets):
    method subsample (line 82) | def subsample(self, proposals, targets):
    method __call__ (line 118) | def __call__(self, class_logits, box_regression):
  function make_roi_box_loss_evaluator (line 170) | def make_roi_box_loss_evaluator(cfg):

FILE: maskrcnn_benchmark/modeling/roi_heads/box_head/roi_box_feature_extractors.py
  class ResNet50Conv5ROIFeatureExtractor (line 14) | class ResNet50Conv5ROIFeatureExtractor(nn.Module):
    method __init__ (line 15) | def __init__(self, config, in_channels):
    method forward (line 43) | def forward(self, x, proposals):
  class FPN2MLPFeatureExtractor (line 50) | class FPN2MLPFeatureExtractor(nn.Module):
    method __init__ (line 55) | def __init__(self, cfg, in_channels):
    method forward (line 74) | def forward(self, x, proposals):
  class FPNXconv1fcFeatureExtractor (line 85) | class FPNXconv1fcFeatureExtractor(nn.Module):
    method __init__ (line 90) | def __init__(self, cfg, in_channels):
    method forward (line 139) | def forward(self, x, proposals):
  function make_roi_box_feature_extractor (line 147) | def make_roi_box_feature_extractor(cfg, in_channels):

FILE: maskrcnn_benchmark/modeling/roi_heads/box_head/roi_box_predictors.py
  class FastRCNNPredictor (line 7) | class FastRCNNPredictor(nn.Module):
    method __init__ (line 8) | def __init__(self, config, in_channels):
    method forward (line 26) | def forward(self, x):
  class FPNPredictor (line 35) | class FPNPredictor(nn.Module):
    method __init__ (line 36) | def __init__(self, cfg, in_channels):
    method forward (line 50) | def forward(self, x):
  function make_roi_box_predictor (line 60) | def make_roi_box_predictor(cfg, in_channels):

FILE: maskrcnn_benchmark/modeling/roi_heads/keypoint_head/inference.py
  class KeypointPostProcessor (line 5) | class KeypointPostProcessor(nn.Module):
    method __init__ (line 6) | def __init__(self, keypointer=None):
    method forward (line 10) | def forward(self, x, boxes):
  function heatmaps_to_keypoints (line 40) | def heatmaps_to_keypoints(maps, rois):
  class Keypointer (line 101) | class Keypointer(object):
    method __init__ (line 107) | def __init__(self, padding=0):
    method __call__ (line 110) | def __call__(self, masks, boxes):
  function make_roi_keypoint_post_processor (line 122) | def make_roi_keypoint_post_processor(cfg):

FILE: maskrcnn_benchmark/modeling/roi_heads/keypoint_head/keypoint_head.py
  class ROIKeypointHead (line 9) | class ROIKeypointHead(torch.nn.Module):
    method __init__ (line 10) | def __init__(self, cfg, in_channels):
    method forward (line 19) | def forward(self, features, proposals, targets=None):
  function build_roi_keypoint_head (line 50) | def build_roi_keypoint_head(cfg, in_channels):

FILE: maskrcnn_benchmark/modeling/roi_heads/keypoint_head/loss.py
  function project_keypoints_to_heatmap (line 17) | def project_keypoints_to_heatmap(keypoints, proposals, discretization_si...
  function cat_boxlist_with_keypoints (line 24) | def cat_boxlist_with_keypoints(boxlists):
  function _within_box (line 39) | def _within_box(points, boxes):
  class KeypointRCNNLossComputation (line 54) | class KeypointRCNNLossComputation(object):
    method __init__ (line 55) | def __init__(self, proposal_matcher, fg_bg_sampler, discretization_size):
    method match_targets_to_proposals (line 66) | def match_targets_to_proposals(self, proposal, target):
    method prepare_targets (line 79) | def prepare_targets(self, proposals, targets):
    method subsample (line 111) | def subsample(self, proposals, targets):
    method __call__ (line 145) | def __call__(self, proposals, keypoint_logits):
  function make_roi_keypoint_loss_evaluator (line 172) | def make_roi_keypoint_loss_evaluator(cfg):

FILE: maskrcnn_benchmark/modeling/roi_heads/keypoint_head/roi_keypoint_feature_extractors.py
  class KeypointRCNNFeatureExtractor (line 11) | class KeypointRCNNFeatureExtractor(nn.Module):
    method __init__ (line 12) | def __init__(self, cfg, in_channels):
    method forward (line 39) | def forward(self, x, proposals):
  function make_roi_keypoint_feature_extractor (line 46) | def make_roi_keypoint_feature_extractor(cfg, in_channels):

FILE: maskrcnn_benchmark/modeling/roi_heads/keypoint_head/roi_keypoint_predictors.py
  class KeypointRCNNPredictor (line 8) | class KeypointRCNNPredictor(nn.Module):
    method __init__ (line 9) | def __init__(self, cfg, in_channels):
    method forward (line 28) | def forward(self, x):
  function make_roi_keypoint_predictor (line 36) | def make_roi_keypoint_predictor(cfg, in_channels):

FILE: maskrcnn_benchmark/modeling/roi_heads/mask_head/inference.py
  class MaskPostProcessor (line 12) | class MaskPostProcessor(nn.Module):
    method __init__ (line 23) | def __init__(self, masker=None):
    method forward (line 27) | def forward(self, x, boxes):
  class MaskPostProcessorCOCOFormat (line 64) | class MaskPostProcessorCOCOFormat(MaskPostProcessor):
    method forward (line 71) | def forward(self, x, boxes):
  function expand_boxes (line 91) | def expand_boxes(boxes, scale):
  function expand_masks (line 108) | def expand_masks(mask, padding):
  function paste_mask_in_image (line 118) | def paste_mask_in_image(mask, box, im_h, im_w, thresh=0.5, padding=1):
  class Masker (line 157) | class Masker(object):
    method __init__ (line 163) | def __init__(self, threshold=0.5, padding=1):
    method forward_single_image (line 167) | def forward_single_image(self, masks, boxes):
    method __call__ (line 180) | def __call__(self, masks, boxes):
  function make_roi_mask_post_processor (line 197) | def make_roi_mask_post_processor(cfg):

FILE: maskrcnn_benchmark/modeling/roi_heads/mask_head/loss.py
  function project_masks_on_boxes (line 11) | def project_masks_on_boxes(segmentation_masks, proposals, discretization...
  class MaskRCNNLossComputation (line 45) | class MaskRCNNLossComputation(object):
    method __init__ (line 46) | def __init__(self, proposal_matcher, discretization_size):
    method match_targets_to_proposals (line 55) | def match_targets_to_proposals(self, proposal, target):
    method prepare_targets (line 68) | def prepare_targets(self, proposals, targets):
    method __call__ (line 102) | def __call__(self, proposals, mask_logits, targets):
  function make_roi_mask_loss_evaluator (line 131) | def make_roi_mask_loss_evaluator(cfg):

FILE: maskrcnn_benchmark/modeling/roi_heads/mask_head/mask_head.py
  function keep_only_positive_boxes (line 13) | def keep_only_positive_boxes(boxes):
  class ROIMaskHead (line 36) | class ROIMaskHead(torch.nn.Module):
    method __init__ (line 37) | def __init__(self, cfg, in_channels):
    method forward (line 46) | def forward(self, features, proposals, targets=None):
  function build_roi_mask_head (line 82) | def build_roi_mask_head(cfg, in_channels):

FILE: maskrcnn_benchmark/modeling/roi_heads/mask_head/roi_mask_feature_extractors.py
  class MaskRCNNFPNFeatureExtractor (line 17) | class MaskRCNNFPNFeatureExtractor(nn.Module):
    method __init__ (line 22) | def __init__(self, cfg, in_channels):
    method forward (line 59) | def forward(self, x, proposals):
  function make_roi_mask_feature_extractor (line 68) | def make_roi_mask_feature_extractor(cfg, in_channels):

FILE: maskrcnn_benchmark/modeling/roi_heads/mask_head/roi_mask_predictors.py
  class MaskRCNNC4Predictor (line 11) | class MaskRCNNC4Predictor(nn.Module):
    method __init__ (line 12) | def __init__(self, cfg, in_channels):
    method forward (line 29) | def forward(self, x):
  class MaskRCNNConv1x1Predictor (line 35) | class MaskRCNNConv1x1Predictor(nn.Module):
    method __init__ (line 36) | def __init__(self, cfg, in_channels):
    method forward (line 51) | def forward(self, x):
  function make_roi_mask_predictor (line 55) | def make_roi_mask_predictor(cfg, in_channels):

FILE: maskrcnn_benchmark/modeling/roi_heads/roi_heads.py
  class CombinedROIHeads (line 9) | class CombinedROIHeads(torch.nn.ModuleDict):
    method __init__ (line 15) | def __init__(self, cfg, heads):
    method forward (line 23) | def forward(self, features, proposals, targets=None):
  function build_roi_heads (line 58) | def build_roi_heads(cfg, in_channels):

FILE: maskrcnn_benchmark/modeling/rpn/anchor_generator.py
  class BufferList (line 11) | class BufferList(nn.Module):
    method __init__ (line 16) | def __init__(self, buffers=None):
    method extend (line 21) | def extend(self, buffers):
    method __len__ (line 27) | def __len__(self):
    method __iter__ (line 30) | def __iter__(self):
  class AnchorGenerator (line 34) | class AnchorGenerator(nn.Module):
    method __init__ (line 40) | def __init__(
    method num_anchors_per_location (line 70) | def num_anchors_per_location(self):
    method grid_anchors (line 73) | def grid_anchors(self, grid_sizes):
    method add_visibility_to (line 97) | def add_visibility_to(self, boxlist):
    method forward (line 112) | def forward(self, image_list, feature_maps):
  function make_anchor_generator (line 128) | def make_anchor_generator(config):
  function make_anchor_generator_retinanet (line 146) | def make_anchor_generator_retinanet(config):
  function generate_anchors (line 220) | def generate_anchors(
  function _generate_anchors (line 234) | def _generate_anchors(base_size, scales, aspect_ratios):
  function _whctrs (line 246) | def _whctrs(anchor):
  function _mkanchors (line 255) | def _mkanchors(ws, hs, x_ctr, y_ctr):
  function _ratio_enum (line 272) | def _ratio_enum(anchor, ratios):
  function _scale_enum (line 283) | def _scale_enum(anchor, scales):

FILE: maskrcnn_benchmark/modeling/rpn/fcos/fcos.py
  class FCOSHead (line 12) | class FCOSHead(torch.nn.Module):
    method __init__ (line 13) | def __init__(self, cfg, in_channels):
    method forward (line 80) | def forward(self, x):
  class FCOSModule (line 94) | class FCOSModule(torch.nn.Module):
    method __init__ (line 100) | def __init__(self, cfg, in_channels):
    method forward (line 114) | def forward(self, images, features, targets=None):
    method _forward_train (line 144) | def _forward_train(self, locations, box_cls, box_regression, centernes...
    method _forward_test (line 155) | def _forward_test(self, locations, box_cls, box_regression, centerness...
    method compute_locations (line 162) | def compute_locations(self, features):
    method compute_locations_per_level (line 173) | def compute_locations_per_level(self, h, w, stride, device):
    method get_dense_locations (line 189) | def get_dense_locations(self, locations, stride, device):
  function build_fcos (line 211) | def build_fcos(cfg, in_channels):

FILE: maskrcnn_benchmark/modeling/rpn/fcos/inference.py
  class FCOSPostProcessor (line 14) | class FCOSPostProcessor(torch.nn.Module):
    method __init__ (line 19) | def __init__(self, pre_nms_thresh, pre_nms_top_n, nms_thresh,
    method forward_for_single_feature_map (line 40) | def forward_for_single_feature_map(
    method forward (line 107) | def forward(self, locations, box_cls, box_regression, centerness, imag...
    method select_over_all_levels (line 136) | def select_over_all_levels(self, boxlists):
  function make_fcos_postprocessor (line 182) | def make_fcos_postprocessor(config):

FILE: maskrcnn_benchmark/modeling/rpn/fcos/loss.py
  class FCOSLossComputation (line 22) | class FCOSLossComputation(object):
    method __init__ (line 27) | def __init__(self, cfg):
    method get_sample_region (line 42) | def get_sample_region(self, gt, strides, num_points_per, gt_xs, gt_ys,...
    method prepare_targets (line 74) | def prepare_targets(self, points, targets):
    method compute_targets_for_locations (line 114) | def compute_targets_for_locations(self, locations, targets, object_siz...
    method compute_centerness_targets (line 165) | def compute_centerness_targets(self, reg_targets):
    method __call__ (line 172) | def __call__(self, locations, box_cls, box_regression, centerness, tar...
  function make_fcos_loss_evaluator (line 235) | def make_fcos_loss_evaluator(cfg):

FILE: maskrcnn_benchmark/modeling/rpn/inference.py
  class RPNPostProcessor (line 13) | class RPNPostProcessor(torch.nn.Module):
    method __init__ (line 19) | def __init__(
    method add_gt_proposals (line 51) | def add_gt_proposals(self, proposals, targets):
    method forward_for_single_feature_map (line 74) | def forward_for_single_feature_map(self, anchors, objectness, box_regr...
    method forward (line 123) | def forward(self, anchors, objectness, box_regression, targets=None):
    method select_over_all_levels (line 152) | def select_over_all_levels(self, boxlists):
  function make_rpn_postprocessor (line 182) | def make_rpn_postprocessor(config, rpn_box_coder, is_train):

FILE: maskrcnn_benchmark/modeling/rpn/loss.py
  class RPNLossComputation (line 21) | class RPNLossComputation(object):
    method __init__ (line 26) | def __init__(self, proposal_matcher, fg_bg_sampler, box_coder,
    method match_targets_to_anchors (line 42) | def match_targets_to_anchors(self, anchor, target, copied_fields=[]):
    method prepare_targets (line 56) | def prepare_targets(self, anchors, targets):
    method __call__ (line 92) | def __call__(self, anchors, objectness, box_regression, targets):
  function generate_rpn_labels (line 134) | def generate_rpn_labels(matched_targets):
  function make_rpn_loss_evaluator (line 140) | def make_rpn_loss_evaluator(cfg, box_coder):

FILE: maskrcnn_benchmark/modeling/rpn/retinanet/inference.py
  class RetinaNetPostProcessor (line 14) | class RetinaNetPostProcessor(RPNPostProcessor):
    method __init__ (line 19) | def __init__(
    method add_gt_proposals (line 53) | def add_gt_proposals(self, proposals, targets):
    method forward_for_single_feature_map (line 59) | def forward_for_single_feature_map(
    method select_over_all_levels (line 131) | def select_over_all_levels(self, boxlists):
  function make_retinanet_postprocessor (line 177) | def make_retinanet_postprocessor(config, rpn_box_coder, is_train):

FILE: maskrcnn_benchmark/modeling/rpn/retinanet/loss.py
  class RetinaNetLossComputation (line 19) | class RetinaNetLossComputation(RPNLossComputation):
    method __init__ (line 24) | def __init__(self, proposal_matcher, box_coder,
    method __call__ (line 43) | def __call__(self, anchors, box_cls, box_regression, targets):
  function generate_retinanet_labels (line 83) | def generate_retinanet_labels(matched_targets):
  function make_retinanet_loss_evaluator (line 88) | def make_retinanet_loss_evaluator(cfg, box_coder):

FILE: maskrcnn_benchmark/modeling/rpn/retinanet/retinanet.py
  class RetinaNetHead (line 13) | class RetinaNetHead(torch.nn.Module):
    method __init__ (line 18) | def __init__(self, cfg, in_channels):
    method forward (line 79) | def forward(self, x):
  class RetinaNetModule (line 88) | class RetinaNetModule(torch.nn.Module):
    method __init__ (line 94) | def __init__(self, cfg, in_channels):
    method forward (line 112) | def forward(self, images, features, targets=None):
    method _forward_train (line 135) | def _forward_train(self, anchors, box_cls, box_regression, targets):
    method _forward_test (line 146) | def _forward_test(self, anchors, box_cls, box_regression):
  function build_retinanet (line 151) | def build_retinanet(cfg, in_channels):

FILE: maskrcnn_benchmark/modeling/rpn/rpn.py
  class RPNHeadConvRegressor (line 15) | class RPNHeadConvRegressor(nn.Module):
    method __init__ (line 20) | def __init__(self, cfg, in_channels, num_anchors):
    method forward (line 37) | def forward(self, x):
  class RPNHeadFeatureSingleConv (line 45) | class RPNHeadFeatureSingleConv(nn.Module):
    method __init__ (line 50) | def __init__(self, cfg, in_channels):
    method forward (line 67) | def forward(self, x):
  class RPNHead (line 75) | class RPNHead(nn.Module):
    method __init__ (line 80) | def __init__(self, cfg, in_channels, num_anchors):
    method forward (line 100) | def forward(self, x):
  class RPNModule (line 110) | class RPNModule(torch.nn.Module):
    method __init__ (line 116) | def __init__(self, cfg, in_channels):
    method forward (line 141) | def forward(self, images, features, targets=None):
    method _forward_train (line 164) | def _forward_train(self, anchors, objectness, rpn_box_regression, targ...
    method _forward_test (line 187) | def _forward_test(self, anchors, objectness, rpn_box_regression):
  function build_rpn (line 201) | def build_rpn(cfg, in_channels):

FILE: maskrcnn_benchmark/modeling/rpn/utils.py
  function permute_and_flatten (line 10) | def permute_and_flatten(layer, N, A, C, H, W):
  function concat_box_prediction_layers (line 17) | def concat_box_prediction_layers(box_cls, box_regression):

FILE: maskrcnn_benchmark/modeling/utils.py
  function cat (line 9) | def cat(tensors, dim=0):

FILE: maskrcnn_benchmark/solver/build.py
  function make_optimizer (line 7) | def make_optimizer(cfg, model):
  function make_lr_scheduler (line 23) | def make_lr_scheduler(cfg, optimizer):

FILE: maskrcnn_benchmark/solver/lr_scheduler.py
  class WarmupMultiStepLR (line 10) | class WarmupMultiStepLR(torch.optim.lr_scheduler._LRScheduler):
    method __init__ (line 11) | def __init__(
    method get_lr (line 39) | def get_lr(self):

FILE: maskrcnn_benchmark/structures/bounding_box.py
  class BoxList (line 9) | class BoxList(object):
    method __init__ (line 19) | def __init__(self, bbox, image_size, mode="xyxy"):
    method add_field (line 39) | def add_field(self, field, field_data):
    method get_field (line 42) | def get_field(self, field):
    method has_field (line 45) | def has_field(self, field):
    method fields (line 48) | def fields(self):
    method _copy_extra_fields (line 51) | def _copy_extra_fields(self, bbox):
    method convert (line 55) | def convert(self, mode):
    method _split_into_xyxy (line 75) | def _split_into_xyxy(self):
    method resize (line 91) | def resize(self, size, *args, **kwargs):
    method transpose (line 129) | def transpose(self, method):
    method crop (line 167) | def crop(self, box):
    method to (line 197) | def to(self, device):
    method __getitem__ (line 205) | def __getitem__(self, item):
    method __len__ (line 211) | def __len__(self):
    method clip_to_image (line 214) | def clip_to_image(self, remove_empty=True):
    method area (line 226) | def area(self):
    method copy_with_fields (line 238) | def copy_with_fields(self, fields, skip_missing=False):
    method __repr__ (line 249) | def __repr__(self):

FILE: maskrcnn_benchmark/structures/boxlist_ops.py
  function boxlist_nms (line 9) | def boxlist_nms(boxlist, nms_thresh, max_proposals=-1, score_field="scor...
  function remove_small_boxes (line 34) | def remove_small_boxes(boxlist, min_size):
  function boxlist_iou (line 53) | def boxlist_iou(boxlist1, boxlist2):
  function _cat (line 92) | def _cat(tensors, dim=0):
  function cat_boxlist (line 102) | def cat_boxlist(bboxes):

FILE: maskrcnn_benchmark/structures/image_list.py
  class ImageList (line 7) | class ImageList(object):
    method __init__ (line 15) | def __init__(self, tensors, image_sizes):
    method to (line 24) | def to(self, *args, **kwargs):
  function to_image_list (line 29) | def to_image_list(tensors, size_divisible=0):

FILE: maskrcnn_benchmark/structures/keypoint.py
  class Keypoints (line 8) | class Keypoints(object):
    method __init__ (line 9) | def __init__(self, keypoints, size, mode=None):
    method crop (line 26) | def crop(self, box):
    method resize (line 29) | def resize(self, size, *args, **kwargs):
    method transpose (line 40) | def transpose(self, method):
    method to (line 61) | def to(self, *args, **kwargs):
    method __getitem__ (line 69) | def __getitem__(self, item):
    method add_field (line 75) | def add_field(self, field, field_data):
    method get_field (line 78) | def get_field(self, field):
    method __repr__ (line 81) | def __repr__(self):
  function _create_flip_indices (line 89) | def _create_flip_indices(names, flip_map):
  class PersonKeypoints (line 97) | class PersonKeypoints(Keypoints):
  function kp_connections (line 131) | def kp_connections(keypoints):
  function keypoints_to_heat_map (line 154) | def keypoints_to_heat_map(keypoints, rois, heatmap_size):

FILE: maskrcnn_benchmark/structures/segmentation_mask.py
  class BinaryMaskList (line 33) | class BinaryMaskList(object):
    method __init__ (line 38) | def __init__(self, masks, size):
    method transpose (line 84) | def transpose(self, method):
    method crop (line 89) | def crop(self, box):
    method resize (line 110) | def resize(self, size):
    method convert_to_polygon (line 131) | def convert_to_polygon(self):
    method to (line 135) | def to(self, *args, **kwargs):
    method _findContours (line 138) | def _findContours(self):
    method __len__ (line 155) | def __len__(self):
    method __getitem__ (line 158) | def __getitem__(self, index):
    method __iter__ (line 164) | def __iter__(self):
    method __repr__ (line 167) | def __repr__(self):
  class PolygonInstance (line 175) | class PolygonInstance(object):
    method __init__ (line 182) | def __init__(self, polygons, size):
    method transpose (line 215) | def transpose(self, method):
    method crop (line 238) | def crop(self, box):
    method resize (line 266) | def resize(self, size):
    method convert_to_binarymask (line 290) | def convert_to_binarymask(self):
    method __len__ (line 300) | def __len__(self):
    method __repr__ (line 303) | def __repr__(self):
  class PolygonList (line 311) | class PolygonList(object):
    method __init__ (line 316) | def __init__(self, polygons, size):
    method transpose (line 365) | def transpose(self, method):
    method crop (line 377) | def crop(self, box):
    method resize (line 386) | def resize(self, size):
    method to (line 394) | def to(self, *args, **kwargs):
    method convert_to_binarymask (line 397) | def convert_to_binarymask(self):
    method __len__ (line 406) | def __len__(self):
    method __getitem__ (line 409) | def __getitem__(self, item):
    method __iter__ (line 425) | def __iter__(self):
    method __repr__ (line 428) | def __repr__(self):
  class SegmentationMask (line 436) | class SegmentationMask(object):
    method __init__ (line 443) | def __init__(self, instances, size, mode="poly"):
    method transpose (line 472) | def transpose(self, method):
    method crop (line 476) | def crop(self, box):
    method resize (line 481) | def resize(self, size, *args, **kwargs):
    method to (line 486) | def to(self, *args, **kwargs):
    method convert (line 489) | def convert(self, mode):
    method get_mask_tensor (line 502) | def get_mask_tensor(self):
    method __len__ (line 509) | def __len__(self):
    method __getitem__ (line 512) | def __getitem__(self, item):
    method __iter__ (line 516) | def __iter__(self):
    method __next__ (line 520) | def __next__(self):
    method __repr__ (line 527) | def __repr__(self):

FILE: maskrcnn_benchmark/utils/c2_model_loading.py
  function _rename_basic_resnet_weights (line 12) | def _rename_basic_resnet_weights(layer_keys):
  function _rename_fpn_weights (line 64) | def _rename_fpn_weights(layer_keys, stage_names):
  function _rename_weights_for_resnet (line 84) | def _rename_weights_for_resnet(weights, stage_names):
  function _load_c2_pickled_weights (line 133) | def _load_c2_pickled_weights(file_path):
  function load_resnet_c2_format (line 164) | def load_resnet_c2_format(cfg, f):
  function load_c2_format (line 174) | def load_c2_format(cfg, f):

FILE: maskrcnn_benchmark/utils/checkpoint.py
  class Checkpointer (line 13) | class Checkpointer(object):
    method __init__ (line 14) | def __init__(
    method save (line 32) | def save(self, name, **kwargs):
    method load (line 52) | def load(self, f=None):
    method has_checkpoint (line 73) | def has_checkpoint(self):
    method get_checkpoint_file (line 77) | def get_checkpoint_file(self):
    method tag_last_checkpoint (line 89) | def tag_last_checkpoint(self, last_filename):
    method _load_file (line 94) | def _load_file(self, f):
    method _load_model (line 97) | def _load_model(self, checkpoint):
  class DetectronCheckpointer (line 101) | class DetectronCheckpointer(Checkpointer):
    method __init__ (line 102) | def __init__(
    method _load_file (line 117) | def _load_file(self, f):

FILE: maskrcnn_benchmark/utils/collect_env.py
  function get_pil_version (line 7) | def get_pil_version():
  function collect_env_info (line 11) | def collect_env_info():

FILE: maskrcnn_benchmark/utils/comm.py
  function get_world_size (line 13) | def get_world_size():
  function get_rank (line 21) | def get_rank():
  function is_main_process (line 29) | def is_main_process():
  function synchronize (line 33) | def synchronize():
  function all_gather (line 48) | def all_gather(data):
  function reduce_dict (line 91) | def reduce_dict(input_dict, average=True):
  function is_pytorch_1_1_0_or_later (line 120) | def is_pytorch_1_1_0_or_later():

FILE: maskrcnn_benchmark/utils/cv2_util.py
  function findContours (line 8) | def findContours(*args, **kwargs):

FILE: maskrcnn_benchmark/utils/env.py
  function setup_environment (line 7) | def setup_environment():
  function setup_custom_environment (line 20) | def setup_custom_environment(custom_module_path):

FILE: maskrcnn_benchmark/utils/imports.py
  function import_file (line 11) | def import_file(module_name, file_path, make_importable=False):
  function import_file (line 21) | def import_file(module_name, file_path, make_importable=None):

FILE: maskrcnn_benchmark/utils/logger.py
  function setup_logger (line 7) | def setup_logger(name, save_dir, distributed_rank, filename="log.txt"):

FILE: maskrcnn_benchmark/utils/metric_logger.py
  class SmoothedValue (line 8) | class SmoothedValue(object):
    method __init__ (line 13) | def __init__(self, window_size=20):
    method update (line 19) | def update(self, value):
    method median (line 26) | def median(self):
    method avg (line 31) | def avg(self):
    method global_avg (line 36) | def global_avg(self):
  class MetricLogger (line 40) | class MetricLogger(object):
    method __init__ (line 41) | def __init__(self, delimiter="\t"):
    method update (line 45) | def update(self, **kwargs):
    method __getattr__ (line 52) | def __getattr__(self, attr):
    method __str__ (line 60) | def __str__(self):

FILE: maskrcnn_benchmark/utils/miscellaneous.py
  function mkdir (line 6) | def mkdir(path):

FILE: maskrcnn_benchmark/utils/model_serialization.py
  function align_and_update_state_dicts (line 10) | def align_and_update_state_dicts(model_state_dict, loaded_state_dict):
  function strip_prefix_if_present (line 61) | def strip_prefix_if_present(state_dict, prefix):
  function load_state_dict (line 71) | def load_state_dict(model, loaded_state_dict):

FILE: maskrcnn_benchmark/utils/model_zoo.py
  function cache_url (line 20) | def cache_url(url, model_dir=None, progress=True):

FILE: maskrcnn_benchmark/utils/registry.py
  function _register_generic (line 4) | def _register_generic(module_dict, module_name, module):
  class Registry (line 9) | class Registry(dict):
    method __init__ (line 31) | def __init__(self, *args, **kwargs):
    method register (line 34) | def register(self, module_name, module=None):

FILE: maskrcnn_benchmark/utils/timer.py
  class Timer (line 8) | class Timer(object):
    method __init__ (line 9) | def __init__(self):
    method average_time (line 13) | def average_time(self):
    method tic (line 16) | def tic(self):
    method toc (line 21) | def toc(self, average=True):
    method add (line 28) | def add(self, time_diff):
    method reset (line 33) | def reset(self):
    method avg_time_str (line 39) | def avg_time_str(self):
  function get_time_str (line 44) | def get_time_str(time_diff):

FILE: setup.py
  function get_extensions (line 17) | def get_extensions():

FILE: tests/checkpoint.py
  class TestCheckpointer (line 14) | class TestCheckpointer(unittest.TestCase):
    method create_model (line 15) | def create_model(self):
    method create_complex_model (line 18) | def create_complex_model(self):
    method test_from_last_checkpoint_model (line 36) | def test_from_last_checkpoint_model(self):
    method test_from_name_file_model (line 71) | def test_from_name_file_model(self):
    method test_complex_model_loaded (line 103) | def test_complex_model_loaded(self):

FILE: tests/env_tests/env.py
  function get_config_root_path (line 6) | def get_config_root_path():

FILE: tests/test_backbones.py
  class TestBackbones (line 23) | class TestBackbones(unittest.TestCase):
    method test_build_backbones (line 24) | def test_build_backbones(self):

FILE: tests/test_box_coder.py
  class TestBoxCoder (line 10) | class TestBoxCoder(unittest.TestCase):
    method test_box_decoder (line 11) | def test_box_decoder(self):

FILE: tests/test_configs.py
  class TestConfigs (line 9) | class TestConfigs(unittest.TestCase):
    method test_configs_load (line 10) | def test_configs_load(self):

FILE: tests/test_data_samplers.py
  class SubsetSampler (line 15) | class SubsetSampler(Sampler):
    method __init__ (line 16) | def __init__(self, indices):
    method __iter__ (line 19) | def __iter__(self):
    method __len__ (line 22) | def __len__(self):
  class TestGroupedBatchSampler (line 26) | class TestGroupedBatchSampler(unittest.TestCase):
    method test_respect_order_simple (line 27) | def test_respect_order_simple(self):
    method test_respect_order (line 40) | def test_respect_order(self):
    method test_respect_order_drop_uneven (line 59) | def test_respect_order_drop_uneven(self):
    method test_subset_sampler (line 72) | def test_subset_sampler(self):
    method test_permute_subset_sampler (line 85) | def test_permute_subset_sampler(self):
    method test_permute_subset_sampler_drop_uneven (line 98) | def test_permute_subset_sampler_drop_uneven(self):
    method test_len (line 111) | def test_len(self):
  class TestIterationBasedBatchSampler (line 130) | class TestIterationBasedBatchSampler(unittest.TestCase):
    method test_number_of_iters_and_elements (line 131) | def test_number_of_iters_and_elements(self):

FILE: tests/test_detectors.py
  function get_config_files (line 52) | def get_config_files(file_list, exclude_folders):
  function create_model (line 69) | def create_model(cfg, device):
  function create_random_input (line 77) | def create_random_input(cfg, device):
  function _test_build_detectors (line 86) | def _test_build_detectors(self, device):
  function _test_run_selected_detectors (line 99) | def _test_run_selected_detectors(self, cfg_files, device):
  class TestDetectors (line 116) | class TestDetectors(unittest.TestCase):
    method test_build_detectors (line 117) | def test_build_detectors(self):
    method test_build_detectors_cuda (line 122) | def test_build_detectors_cuda(self):
    method test_run_selected_detectors (line 126) | def test_run_selected_detectors(self):
    method test_run_selected_detectors_cuda (line 134) | def test_run_selected_detectors_cuda(self):

FILE: tests/test_fbnet.py
  function _test_primitive (line 13) | def _test_primitive(self, device, op_name, op_func, N, C_in, C_out, expa...
  class TestFBNetBuilder (line 23) | class TestFBNetBuilder(unittest.TestCase):
    method test_identity (line 24) | def test_identity(self):
    method test_primitives (line 35) | def test_primitives(self):
    method test_primitives_cuda (line 47) | def test_primitives_cuda(self):
    method test_primitives_empty_batch (line 58) | def test_primitives_empty_batch(self):
    method test_primitives_cuda_empty_batch (line 71) | def test_primitives_cuda_empty_batch(self):

FILE: tests/test_feature_extractors.py
  function _test_feature_extractors (line 25) | def _test_feature_extractors(
  class TestFeatureExtractors (line 63) | class TestFeatureExtractors(unittest.TestCase):
    method test_roi_box_feature_extractors (line 64) | def test_roi_box_feature_extractors(self):
    method test_roi_keypoints_feature_extractors (line 73) | def test_roi_keypoints_feature_extractors(self):
    method test_roi_mask_feature_extractors (line 82) | def test_roi_mask_feature_extractors(self):

FILE: tests/test_metric_logger.py
  class TestMetricLogger (line 7) | class TestMetricLogger(unittest.TestCase):
    method test_update (line 8) | def test_update(self):
    method test_no_attr (line 19) | def test_no_attr(self):

FILE: tests/test_nms.py
  class TestNMS (line 10) | class TestNMS(unittest.TestCase):
    method test_nms_cpu (line 11) | def test_nms_cpu(self):
    method test_nms1_cpu (line 60) | def test_nms1_cpu(self):

FILE: tests/test_predictors.py
  function _test_predictors (line 23) | def _test_predictors(
  class TestPredictors (line 52) | class TestPredictors(unittest.TestCase):
    method test_roi_box_predictors (line 53) | def test_roi_box_predictors(self):
    method test_roi_keypoints_predictors (line 70) | def test_roi_keypoints_predictors(self):
    method test_roi_mask_predictors (line 83) | def test_roi_mask_predictors(self):

FILE: tests/test_rpn_heads.py
  class TestRPNHeads (line 19) | class TestRPNHeads(unittest.TestCase):
    method test_build_rpn_heads (line 20) | def test_build_rpn_heads(self):

FILE: tests/test_segmentation_mask.py
  class TestSegmentationMask (line 7) | class TestSegmentationMask(unittest.TestCase):
    method __init__ (line 8) | def __init__(self, method_name='runTest'):
    method L1 (line 24) | def L1(self, A, B):
    method test_convert (line 30) | def test_convert(self):
    method test_crop (line 41) | def test_crop(self):
    method test_resize (line 47) | def test_resize(self):
    method test_transpose (line 59) | def test_transpose(self):

FILE: tests/utils.py
  function get_config_root_path (line 14) | def get_config_root_path():
  function load_config (line 18) | def load_config(rel_path):
  function load_config_from_file (line 24) | def load_config_from_file(file_path):

FILE: tools/cityscapes/convert_cityscapes_to_coco.py
  function parse_args (line 35) | def parse_args():
  function poly_to_box (line 50) | def poly_to_box(poly):
  function xyxy_to_xywh (line 60) | def xyxy_to_xywh(xyxy_box):
  function convert_coco_stuff_mat (line 67) | def convert_coco_stuff_mat(data_dir, out_dir):
  function getLabelID (line 108) | def getLabelID(self, instID):
  function convert_cityscapes_instance_only (line 115) | def convert_cityscapes_instance_only(

FILE: tools/cityscapes/instances2dict_with_polygons.py
  function instances2dict_with_polygons (line 19) | def instances2dict_with_polygons(imageFileList, verbose=False):
  function main (line 72) | def main(argv):

FILE: tools/remove_solver_states.py
  function main (line 9) | def main():

FILE: tools/test_net.py
  function main (line 21) | def main():

FILE: tools/train_net.py
  function train (line 30) | def train(cfg, local_rank, distributed):
  function run_test (line 85) | def run_test(cfg, model, distributed):
  function main (line 117) | def main():