SYMBOL INDEX (610 symbols across 83 files)

FILE: detectron/core/config.py
  function assert_and_infer_cfg (line 1085) | def assert_and_infer_cfg(cache_urls=True, make_immutable=True):
  function cache_cfg_urls (line 1103) | def cache_cfg_urls():
  function get_output_dir (line 1117) | def get_output_dir(datasets, training=True):
  function load_cfg (line 1131) | def load_cfg(cfg_to_load):
  function merge_cfg_from_file (line 1148) | def merge_cfg_from_file(cfg_filename):
  function merge_cfg_from_cfg (line 1155) | def merge_cfg_from_cfg(cfg_other):
  function merge_cfg_from_list (line 1160) | def merge_cfg_from_list(cfg_list):
  function _merge_a_into_b (line 1184) | def _merge_a_into_b(a, b, stack=None):
  function _key_is_deprecated (line 1219) | def _key_is_deprecated(full_key):
  function _key_is_renamed (line 1228) | def _key_is_renamed(full_key):
  function _raise_key_rename_error (line 1232) | def _raise_key_rename_error(full_key):
  function _decode_cfg_value (line 1245) | def _decode_cfg_value(v):
  function _check_and_coerce_cfg_value_type (line 1278) | def _check_and_coerce_cfg_value_type(value_a, value_b, key, full_key):

FILE: detectron/core/rpn_generator.py
  function generate_rpn_on_dataset (line 55) | def generate_rpn_on_dataset(
  function multi_gpu_generate_rpn_on_dataset (line 87) | def multi_gpu_generate_rpn_on_dataset(
  function generate_rpn_on_range (line 121) | def generate_rpn_on_range(
  function generate_proposals_on_roidb (line 170) | def generate_proposals_on_roidb(
  function im_proposals (line 208) | def im_proposals(model, im):
  function get_roidb (line 253) | def get_roidb(dataset_name, ind_range):
  function evaluate_proposal_file (line 272) | def evaluate_proposal_file(dataset, proposal_file, output_dir):

FILE: detectron/core/test.py
  function im_detect_all (line 52) | def im_detect_all(model, im, box_proposals, timers=None):
  function im_conv_body_only (line 111) | def im_conv_body_only(model, im, target_scale, target_max_size):
  function im_detect_bbox (line 121) | def im_detect_bbox(model, im, target_scale, target_max_size, boxes=None):
  function im_detect_bbox_aug (line 197) | def im_detect_bbox_aug(model, im, box_proposals=None):
  function im_detect_bbox_hflip (line 294) | def im_detect_bbox_hflip(
  function im_detect_bbox_scale (line 319) | def im_detect_bbox_scale(
  function im_detect_bbox_aspect_ratio (line 336) | def im_detect_bbox_aspect_ratio(
  function im_detect_mask (line 373) | def im_detect_mask(model, im_scale, boxes):
  function im_detect_mask_aug (line 416) | def im_detect_mask_aug(model, im, boxes):
  function im_detect_mask_hflip (line 489) | def im_detect_mask_hflip(model, im, target_scale, target_max_size, boxes):
  function im_detect_mask_scale (line 506) | def im_detect_mask_scale(
  function im_detect_mask_aspect_ratio (line 520) | def im_detect_mask_aspect_ratio(model, im, aspect_ratio, boxes, hflip=Fa...
  function im_detect_keypoints (line 540) | def im_detect_keypoints(model, im_scale, boxes):
  function im_detect_keypoints_aug (line 581) | def im_detect_keypoints_aug(model, im, boxes):
  function im_detect_keypoints_hflip (line 668) | def im_detect_keypoints_hflip(model, im, target_scale, target_max_size, ...
  function im_detect_keypoints_scale (line 685) | def im_detect_keypoints_scale(
  function im_detect_keypoints_aspect_ratio (line 699) | def im_detect_keypoints_aspect_ratio(
  function combine_heatmaps_size_dep (line 721) | def combine_heatmaps_size_dep(hms_ts, ds_ts, us_ts, boxes, heur_f):
  function box_results_with_nms_and_limit (line 749) | def box_results_with_nms_and_limit(scores, boxes):
  function segm_results (line 812) | def segm_results(cls_boxes, masks, ref_boxes, im_h, im_w):
  function keypoint_results (line 870) | def keypoint_results(cls_boxes, pred_heatmaps, ref_boxes):
  function _get_rois_blob (line 889) | def _get_rois_blob(im_rois, im_scale):
  function _project_im_rois (line 905) | def _project_im_rois(im_rois, scales):
  function _add_multilevel_rois_for_test (line 921) | def _add_multilevel_rois_for_test(blobs, name):
  function _get_blobs (line 942) | def _get_blobs(im, rois, target_scale, target_max_size):

FILE: detectron/core/test_engine.py
  function get_eval_functions (line 51) | def get_eval_functions():
  function get_inference_dataset (line 65) | def get_inference_dataset(index, is_parent=True):
  function run_inference (line 84) | def run_inference(
  function test_net_on_dataset (line 139) | def test_net_on_dataset(
  function multi_gpu_test_net_on_dataset (line 168) | def multi_gpu_test_net_on_dataset(
  function test_net (line 217) | def test_net(
  function initialize_model_from_cfg (line 323) | def initialize_model_from_cfg(weights_file, gpu_id=0):
  function get_roidb_and_dataset (line 341) | def get_roidb_and_dataset(dataset_name, proposal_file, ind_range):
  function empty_results (line 367) | def empty_results(num_classes, num_images):
  function extend_results (line 389) | def extend_results(index, all_res, im_res):

FILE: detectron/core/test_retinanet.py
  function _create_cell_anchors (line 38) | def _create_cell_anchors():
  function im_detect_bbox (line 67) | def im_detect_bbox(model, im, timers=None):

FILE: detectron/datasets/cityscapes_json_dataset_evaluator.py
  function evaluate_masks (line 36) | def evaluate_masks(

FILE: detectron/datasets/coco_to_cityscapes_id.py
  function cityscapes_to_coco (line 38) | def cityscapes_to_coco(cityscapes_id):
  function cityscapes_to_coco_with_rider (line 53) | def cityscapes_to_coco_with_rider(cityscapes_id):
  function cityscapes_to_coco_without_person_rider (line 68) | def cityscapes_to_coco_without_person_rider(cityscapes_id):
  function cityscapes_to_coco_all_random (line 83) | def cityscapes_to_coco_all_random(cityscapes_id):

FILE: detectron/datasets/dataset_catalog.py
  function datasets (line 208) | def datasets():
  function contains (line 213) | def contains(name):
  function get_im_dir (line 218) | def get_im_dir(name):
  function get_ann_fn (line 223) | def get_ann_fn(name):
  function get_im_prefix (line 228) | def get_im_prefix(name):
  function get_devkit_dir (line 233) | def get_devkit_dir(name):
  function get_raw_dir (line 238) | def get_raw_dir(name):

FILE: detectron/datasets/dummy_datasets.py
  function get_coco_dataset (line 28) | def get_coco_dataset():

FILE: detectron/datasets/json_dataset.py
  class JsonDataset (line 51) | class JsonDataset:
    method __init__ (line 54) | def __init__(self, name):
    method get_roidb (line 83) | def get_roidb(
    method _prep_roidb_entry (line 128) | def _prep_roidb_entry(self, entry):
    method _add_gt_annotations (line 161) | def _add_gt_annotations(self, entry):
    method _add_proposals_from_file (line 249) | def _add_proposals_from_file(
    method _init_keypoints (line 282) | def _init_keypoints(self):
    method _get_gt_keypoints (line 311) | def _get_gt_keypoints(self, obj):
  function add_proposals (line 331) | def add_proposals(roidb, rois, scales, crowd_thresh):
  function _merge_proposal_boxes_into_roidb (line 347) | def _merge_proposal_boxes_into_roidb(roidb, box_list):
  function _filter_crowd_proposals (line 411) | def _filter_crowd_proposals(roidb, crowd_thresh):
  function _add_class_assignments (line 431) | def _add_class_assignments(roidb):
  function _sort_proposals (line 452) | def _sort_proposals(proposals, id_field):
  function _remove_proposals_not_in_roidb (line 460) | def _remove_proposals_not_in_roidb(proposals, roidb, id_field):

FILE: detectron/datasets/json_dataset_evaluator.py
  function evaluate_masks (line 39) | def evaluate_masks(
  function _write_coco_segms_results_file (line 70) | def _write_coco_segms_results_file(
  function _coco_segms_results_one_category (line 103) | def _coco_segms_results_one_category(json_dataset, boxes, segms, cat_id):
  function _do_segmentation_eval (line 129) | def _do_segmentation_eval(json_dataset, res_file, output_dir):
  function evaluate_boxes (line 141) | def evaluate_boxes(
  function _write_coco_bbox_results_file (line 166) | def _write_coco_bbox_results_file(json_dataset, all_boxes, res_file):
  function _coco_bbox_results_one_category (line 186) | def _coco_bbox_results_one_category(json_dataset, boxes, cat_id):
  function _do_detection_eval (line 210) | def _do_detection_eval(json_dataset, res_file, output_dir):
  function _log_detection_eval_metrics (line 222) | def _log_detection_eval_metrics(json_dataset, coco_eval):
  function evaluate_box_proposals (line 255) | def evaluate_box_proposals(
  function evaluate_keypoints (line 357) | def evaluate_keypoints(
  function _write_coco_keypoint_results_file (line 388) | def _write_coco_keypoint_results_file(
  function _coco_kp_results_one_category (line 410) | def _coco_kp_results_one_category(json_dataset, boxes, kps, cat_id):
  function _do_keypoint_eval (line 458) | def _do_keypoint_eval(json_dataset, res_file, output_dir):

FILE: detectron/datasets/roidb.py
  function combined_roidb_for_training (line 36) | def combined_roidb_for_training(dataset_names, proposal_files):
  function extend_with_flipped_entries (line 76) | def extend_with_flipped_entries(roidb, dataset):
  function filter_for_training (line 111) | def filter_for_training(roidb):
  function add_bbox_regression_targets (line 139) | def add_bbox_regression_targets(roidb):
  function compute_bbox_regression_targets (line 145) | def compute_bbox_regression_targets(entry):
  function _compute_and_log_stats (line 179) | def _compute_and_log_stats(roidb):

FILE: detectron/datasets/task_evaluation.py
  function evaluate_all (line 53) | def evaluate_all(
  function evaluate_boxes (line 74) | def evaluate_boxes(dataset, all_boxes, output_dir, use_matlab=False):
  function evaluate_masks (line 103) | def evaluate_masks(dataset, all_boxes, all_segms, output_dir):
  function evaluate_keypoints (line 134) | def evaluate_keypoints(dataset, all_boxes, all_keyps, output_dir):
  function evaluate_box_proposals (line 152) | def evaluate_box_proposals(dataset, roidb):
  function log_box_proposal_results (line 170) | def log_box_proposal_results(results):
  function log_copy_paste_friendly_results (line 180) | def log_copy_paste_friendly_results(results):
  function check_expected_results (line 194) | def check_expected_results(results, atol=0.005, rtol=0.1):
  function _use_json_dataset_evaluator (line 270) | def _use_json_dataset_evaluator(dataset):
  function _use_cityscapes_evaluator (line 275) | def _use_cityscapes_evaluator(dataset):
  function _use_voc_evaluator (line 280) | def _use_voc_evaluator(dataset):
  function _coco_eval_to_box_results (line 301) | def _coco_eval_to_box_results(coco_eval):
  function _coco_eval_to_mask_results (line 314) | def _coco_eval_to_mask_results(coco_eval):
  function _coco_eval_to_keypoint_results (line 327) | def _coco_eval_to_keypoint_results(coco_eval):
  function _voc_eval_to_box_results (line 339) | def _voc_eval_to_box_results(voc_eval):
  function _cs_eval_to_mask_results (line 344) | def _cs_eval_to_mask_results(cs_eval):
  function _empty_box_results (line 349) | def _empty_box_results():
  function _empty_mask_results (line 365) | def _empty_mask_results():
  function _empty_keypoint_results (line 381) | def _empty_keypoint_results():
  function _empty_box_proposal_results (line 396) | def _empty_box_proposal_results():

FILE: detectron/datasets/voc_dataset_evaluator.py
  function evaluate_boxes (line 37) | def evaluate_boxes(
  function _write_voc_results_files (line 57) | def _write_voc_results_files(json_dataset, all_boxes, salt):
  function _get_voc_results_file_template (line 94) | def _get_voc_results_file_template(json_dataset, salt):
  function _do_python_eval (line 104) | def _do_python_eval(json_dataset, salt, output_dir='output'):
  function _do_matlab_eval (line 145) | def _do_matlab_eval(json_dataset, salt, output_dir='output'):
  function voc_info (line 163) | def voc_info(json_dataset):

FILE: detectron/datasets/voc_eval.py
  function parse_rec (line 36) | def parse_rec(filename):
  function voc_ap (line 56) | def voc_ap(rec, prec, use_07_metric=False):
  function voc_eval (line 88) | def voc_eval(detpath,

FILE: detectron/modeling/FPN.py
  function add_fpn_ResNet50_conv5_body (line 46) | def add_fpn_ResNet50_conv5_body(model):
  function add_fpn_ResNet50_conv5_P2only_body (line 52) | def add_fpn_ResNet50_conv5_P2only_body(model):
  function add_fpn_ResNet101_conv5_body (line 61) | def add_fpn_ResNet101_conv5_body(model):
  function add_fpn_ResNet101_conv5_P2only_body (line 67) | def add_fpn_ResNet101_conv5_P2only_body(model):
  function add_fpn_ResNet152_conv5_body (line 76) | def add_fpn_ResNet152_conv5_body(model):
  function add_fpn_ResNet152_conv5_P2only_body (line 82) | def add_fpn_ResNet152_conv5_P2only_body(model):
  function add_fpn_onto_conv_body (line 95) | def add_fpn_onto_conv_body(
  function add_fpn (line 117) | def add_fpn(model, fpn_level_info):
  function add_topdown_lateral_module (line 259) | def add_topdown_lateral_module(
  function get_min_max_levels (line 301) | def get_min_max_levels():
  function add_fpn_rpn_outputs (line 323) | def add_fpn_rpn_outputs(model, blobs_in, dim_in, spatial_scales):
  function add_fpn_rpn_losses (line 440) | def add_fpn_rpn_losses(model):
  function map_rois_to_fpn_levels (line 493) | def map_rois_to_fpn_levels(rois, k_min, k_max):
  function add_multilevel_roi_blobs (line 508) | def add_multilevel_roi_blobs(
  function fpn_level_info_ResNet50_conv5 (line 547) | def fpn_level_info_ResNet50_conv5():
  function fpn_level_info_ResNet101_conv5 (line 555) | def fpn_level_info_ResNet101_conv5():
  function fpn_level_info_ResNet152_conv5 (line 563) | def fpn_level_info_ResNet152_conv5():

FILE: detectron/modeling/ResNet.py
  function add_ResNet50_conv4_body (line 35) | def add_ResNet50_conv4_body(model):
  function add_ResNet50_conv5_body (line 39) | def add_ResNet50_conv5_body(model):
  function add_ResNet101_conv4_body (line 43) | def add_ResNet101_conv4_body(model):
  function add_ResNet101_conv5_body (line 47) | def add_ResNet101_conv5_body(model):
  function add_ResNet152_conv5_body (line 51) | def add_ResNet152_conv5_body(model):
  function add_stage (line 60) | def add_stage(
  function add_ResNet_convX_body (line 91) | def add_ResNet_convX_body(model, block_counts):
  function add_ResNet_roi_conv5_head (line 129) | def add_ResNet_roi_conv5_head(model, blob_in, dim_in, spatial_scale):
  function add_residual_block (line 153) | def add_residual_block(
  function basic_bn_shortcut (line 203) | def basic_bn_shortcut(model, prefix, blob_in, dim_in, dim_out, stride):
  function basic_gn_shortcut (line 223) | def basic_gn_shortcut(model, prefix, blob_in, dim_in, dim_out, stride):
  function basic_bn_stem (line 246) | def basic_bn_stem(model, data, **kwargs):
  function basic_gn_stem (line 259) | def basic_gn_stem(model, data, **kwargs):
  function bottleneck_transformation (line 276) | def bottleneck_transformation(
  function bottleneck_gn_transformation (line 336) | def bottleneck_gn_transformation(

FILE: detectron/modeling/VGG16.py
  function add_VGG16_conv5_body (line 26) | def add_VGG16_conv5_body(model):
  function add_VGG16_roi_fc_head (line 61) | def add_VGG16_roi_fc_head(model, blob_in, dim_in, spatial_scale):

FILE: detectron/modeling/VGG_CNN_M_1024.py
  function add_VGG_CNN_M_1024_conv5_body (line 26) | def add_VGG_CNN_M_1024_conv5_body(model):
  function add_VGG_CNN_M_1024_roi_fc_head (line 47) | def add_VGG_CNN_M_1024_roi_fc_head(model, blob_in, dim_in, spatial_scale):

FILE: detectron/modeling/detector.py
  class DetectionModelHelper (line 43) | class DetectionModelHelper(cnn.CNNModelHelper):
    method __init__ (line 44) | def __init__(self, **kwargs):
    method TrainableParams (line 68) | def TrainableParams(self, gpu_id=-1):
    method AffineChannel (line 81) | def AffineChannel(self, blob_in, blob_out, dim, inplace=False):
    method GenerateProposals (line 107) | def GenerateProposals(self, blobs_in, blobs_out, anchors, spatial_scale):
    method GenerateProposalLabels (line 170) | def GenerateProposalLabels(self, blobs_in):
    method CollectAndDistributeFpnRpnProposals (line 202) | def CollectAndDistributeFpnRpnProposals(self):
    method DropoutIfTraining (line 258) | def DropoutIfTraining(self, blob_in, dropout_rate):
    method RoIFeatureTransform (line 268) | def RoIFeatureTransform(
    method ConvShared (line 333) | def ConvShared(
    method BilinearInterpolation (line 368) | def BilinearInterpolation(
    method ConvAffine (line 414) | def ConvAffine(  # args in the same order of Conv()
    method ConvGN (line 444) | def ConvGN(  # args in the same order of Conv()
    method DisableCudnn (line 486) | def DisableCudnn(self):
    method RestorePreviousUseCudnn (line 490) | def RestorePreviousUseCudnn(self):
    method UpdateWorkspaceLr (line 495) | def UpdateWorkspaceLr(self, cur_iter, new_lr):
    method _SetNewLr (line 513) | def _SetNewLr(self, cur_lr, new_lr):
    method _CorrectMomentum (line 525) | def _CorrectMomentum(self, correction):
    method GetLossScale (line 547) | def GetLossScale(self):
    method AddLosses (line 554) | def AddLosses(self, losses):
    method AddMetrics (line 561) | def AddMetrics(self, metrics):
  function _get_lr_change_ratio (line 567) | def _get_lr_change_ratio(cur_lr, new_lr):

FILE: detectron/modeling/fast_rcnn_heads.py
  function add_fast_rcnn_outputs (line 46) | def add_fast_rcnn_outputs(model, blob_in, dim):
  function add_fast_rcnn_losses (line 75) | def add_fast_rcnn_losses(model):
  function add_roi_2mlp_head (line 100) | def add_roi_2mlp_head(model, blob_in, dim_in, spatial_scale):
  function add_roi_Xconv1fc_head (line 120) | def add_roi_Xconv1fc_head(model, blob_in, dim_in, spatial_scale):
  function add_roi_Xconv1fc_gn_head (line 151) | def add_roi_Xconv1fc_gn_head(model, blob_in, dim_in, spatial_scale):

FILE: detectron/modeling/generate_anchors.py
  function generate_anchors (line 54) | def generate_anchors(
  function _generate_anchors (line 68) | def _generate_anchors(base_size, scales, aspect_ratios):
  function _whctrs (line 80) | def _whctrs(anchor):
  function _mkanchors (line 89) | def _mkanchors(ws, hs, x_ctr, y_ctr):
  function _ratio_enum (line 106) | def _ratio_enum(anchor, ratios):
  function _scale_enum (line 117) | def _scale_enum(anchor, scales):

FILE: detectron/modeling/keypoint_rcnn_heads.py
  function add_keypoint_outputs (line 46) | def add_keypoint_outputs(model, blob_in, dim):
  function add_keypoint_losses (line 110) | def add_keypoint_losses(model):
  function add_ResNet_roi_conv5_head_for_keypoints (line 156) | def add_ResNet_roi_conv5_head_for_keypoints(
  function add_roi_pose_head_v1convX (line 187) | def add_roi_pose_head_v1convX(model, blob_in, dim_in, spatial_scale):

FILE: detectron/modeling/mask_rcnn_heads.py
  function add_mask_rcnn_outputs (line 47) | def add_mask_rcnn_outputs(model, blob_in, dim):
  function add_mask_rcnn_losses (line 96) | def add_mask_rcnn_losses(model, blob_mask):
  function mask_rcnn_fcn_head_v1up4convs (line 112) | def mask_rcnn_fcn_head_v1up4convs(model, blob_in, dim_in, spatial_scale):
  function mask_rcnn_fcn_head_v1up4convs_gn (line 119) | def mask_rcnn_fcn_head_v1up4convs_gn(model, blob_in, dim_in, spatial_sca...
  function mask_rcnn_fcn_head_v1up (line 126) | def mask_rcnn_fcn_head_v1up(model, blob_in, dim_in, spatial_scale):
  function mask_rcnn_fcn_head_v1upXconvs (line 133) | def mask_rcnn_fcn_head_v1upXconvs(
  function mask_rcnn_fcn_head_v1upXconvs_gn (line 183) | def mask_rcnn_fcn_head_v1upXconvs_gn(
  function mask_rcnn_fcn_head_v0upshare (line 233) | def mask_rcnn_fcn_head_v0upshare(model, blob_in, dim_in, spatial_scale):
  function mask_rcnn_fcn_head_v0up (line 275) | def mask_rcnn_fcn_head_v0up(model, blob_in, dim_in, spatial_scale):
  function add_ResNet_roi_conv5_head_for_masks (line 302) | def add_ResNet_roi_conv5_head_for_masks(model, blob_in, dim_in, spatial_...

FILE: detectron/modeling/model_builder.py
  function generalized_rcnn (line 74) | def generalized_rcnn(model):
  function rfcn (line 93) | def rfcn(model):
  function retinanet (line 98) | def retinanet(model):
  function create (line 107) | def create(model_type_func, train=False, gpu_id=0):
  function get_func (line 127) | def get_func(func_name):
  function build_generic_detection_model (line 155) | def build_generic_detection_model(
  function _narrow_to_fpn_roi_levels (line 233) | def _narrow_to_fpn_roi_levels(blobs, spatial_scales):
  function _add_fast_rcnn_head (line 249) | def _add_fast_rcnn_head(
  function _add_roi_mask_head (line 264) | def _add_roi_mask_head(
  function _add_roi_keypoint_head (line 294) | def _add_roi_keypoint_head(
  function build_generic_rfcn_model (line 324) | def build_generic_rfcn_model(model, add_conv_body_func, dim_reduce=None):
  function build_generic_retinanet_model (line 341) | def build_generic_retinanet_model(
  function add_training_inputs (line 368) | def add_training_inputs(model, roidb=None):
  function add_inference_inputs (line 406) | def add_inference_inputs(model):
  function fast_rcnn (line 439) | def fast_rcnn(model):
  function mask_rcnn (line 444) | def mask_rcnn(model):
  function keypoint_rcnn (line 452) | def keypoint_rcnn(model):
  function mask_and_keypoint_rcnn (line 460) | def mask_and_keypoint_rcnn(model):
  function rpn (line 468) | def rpn(model):
  function fpn_rpn (line 476) | def fpn_rpn(model):
  function faster_rcnn (line 484) | def faster_rcnn(model):
  function fast_rcnn_frozen_features (line 492) | def fast_rcnn_frozen_features(model):
  function rpn_frozen_features (line 502) | def rpn_frozen_features(model):
  function fpn_rpn_frozen_features (line 509) | def fpn_rpn_frozen_features(model):
  function mask_rcnn_frozen_features (line 516) | def mask_rcnn_frozen_features(model):
  function keypoint_rcnn_frozen_features (line 527) | def keypoint_rcnn_frozen_features(model):
  function VGG_CNN_M_1024_fast_rcnn (line 543) | def VGG_CNN_M_1024_fast_rcnn(model):
  function VGG16_fast_rcnn (line 550) | def VGG16_fast_rcnn(model):
  function ResNet50_fast_rcnn (line 556) | def ResNet50_fast_rcnn(model):
  function ResNet101_fast_rcnn (line 562) | def ResNet101_fast_rcnn(model):
  function ResNet50_fast_rcnn_frozen_features (line 568) | def ResNet50_fast_rcnn_frozen_features(model):
  function ResNet101_fast_rcnn_frozen_features (line 577) | def ResNet101_fast_rcnn_frozen_features(model):
  function VGG_CNN_M_1024_rpn (line 591) | def VGG_CNN_M_1024_rpn(model):
  function VGG16_rpn (line 597) | def VGG16_rpn(model):
  function ResNet50_rpn_conv4 (line 601) | def ResNet50_rpn_conv4(model):
  function ResNet101_rpn_conv4 (line 605) | def ResNet101_rpn_conv4(model):
  function VGG_CNN_M_1024_rpn_frozen_features (line 609) | def VGG_CNN_M_1024_rpn_frozen_features(model):
  function VGG16_rpn_frozen_features (line 617) | def VGG16_rpn_frozen_features(model):
  function ResNet50_rpn_conv4_frozen_features (line 623) | def ResNet50_rpn_conv4_frozen_features(model):
  function ResNet101_rpn_conv4_frozen_features (line 629) | def ResNet101_rpn_conv4_frozen_features(model):
  function VGG16_faster_rcnn (line 640) | def VGG16_faster_rcnn(model):
  function ResNet50_faster_rcnn (line 647) | def ResNet50_faster_rcnn(model):
  function ResNet101_faster_rcnn (line 654) | def ResNet101_faster_rcnn(model):
  function ResNet50_rfcn (line 666) | def ResNet50_rfcn(model):
  function ResNet101_rfcn (line 672) | def ResNet101_rfcn(model):

FILE: detectron/modeling/name_compat.py
  function get_new_name (line 59) | def get_new_name(func_name):

FILE: detectron/modeling/optimizer.py
  function build_data_parallel_model (line 33) | def build_data_parallel_model(model, single_gpu_build_func):
  function _build_forward_graph (line 57) | def _build_forward_graph(model, single_gpu_build_func):
  function _add_allreduce_graph (line 67) | def _add_allreduce_graph(model):
  function add_single_gpu_param_update_ops (line 90) | def add_single_gpu_param_update_ops(model, gpu_id):

FILE: detectron/modeling/retinanet_heads.py
  function get_retinanet_bias_init (line 29) | def get_retinanet_bias_init(model):
  function add_fpn_retinanet_outputs (line 63) | def add_fpn_retinanet_outputs(model, blobs_in, dim_in, spatial_scales):
  function add_fpn_retinanet_losses (line 248) | def add_fpn_retinanet_losses(model):

FILE: detectron/modeling/rfcn_heads.py
  function add_rfcn_outputs (line 30) | def add_rfcn_outputs(model, blob_in, dim_in, dim_reduce, spatial_scale):

FILE: detectron/modeling/rpn_heads.py
  function add_generic_rpn_outputs (line 33) | def add_generic_rpn_outputs(model, blob_in, dim_in, spatial_scale_in):
  function add_single_scale_rpn_outputs (line 55) | def add_single_scale_rpn_outputs(model, blob_in, dim_in, spatial_scale):
  function add_single_scale_rpn_losses (line 125) | def add_single_scale_rpn_losses(model):

FILE: detectron/ops/collect_and_distribute_fpn_rpn_proposals.py
  class CollectAndDistributeFpnRpnProposalsOp (line 31) | class CollectAndDistributeFpnRpnProposalsOp:
    method __init__ (line 32) | def __init__(self, train):
    method forward (line 35) | def forward(self, inputs, outputs):
  function collect (line 71) | def collect(inputs, is_training):
  function distribute (line 91) | def distribute(rois, label_blobs, outputs, train):

FILE: detectron/ops/generate_proposal_labels.py
  class GenerateProposalLabelsOp (line 31) | class GenerateProposalLabelsOp:
    method forward (line 33) | def forward(self, inputs, outputs):

FILE: detectron/ops/generate_proposals.py
  class GenerateProposalsOp (line 30) | class GenerateProposalsOp:
    method __init__ (line 38) | def __init__(self, anchors, spatial_scale, train, reg_weights=(1.0, 1....
    method forward (line 45) | def forward(self, inputs, outputs):
    method proposals_for_one_image (line 110) | def proposals_for_one_image(
  function _filter_boxes (line 174) | def _filter_boxes(boxes, min_size, im_info):

FILE: detectron/ops/zero_even_op.cc
  type caffe2 (line 19) | namespace caffe2 {

FILE: detectron/ops/zero_even_op.h
  function namespace (line 23) | namespace caffe2 {

FILE: detectron/roi_data/data_utils.py
  function get_field_of_anchors (line 50) | def get_field_of_anchors(
  function unmap (line 104) | def unmap(data, count, inds, fill=0):
  function compute_targets (line 121) | def compute_targets(ex_rois, gt_rois, weights=(1.0, 1.0, 1.0, 1.0)):

FILE: detectron/roi_data/fast_rcnn.py
  function get_fast_rcnn_blob_names (line 40) | def get_fast_rcnn_blob_names(is_training=True):
  function add_fast_rcnn_blobs (line 108) | def add_fast_rcnn_blobs(blobs, im_scales, roidb):
  function _sample_rois (line 132) | def _sample_rois(roidb, im_scale, batch_idx):
  function _expand_bbox_targets (line 209) | def _expand_bbox_targets(bbox_target_data):
  function _add_multilevel_rois (line 238) | def _add_multilevel_rois(blobs):

FILE: detectron/roi_data/keypoint_rcnn.py
  function add_keypoint_rcnn_blobs (line 37) | def add_keypoint_rcnn_blobs(
  function finalize_keypoint_minibatch (line 94) | def finalize_keypoint_minibatch(blobs, valid):
  function _within_box (line 114) | def _within_box(points, boxes):

FILE: detectron/roi_data/loader.py
  class RoIDataLoader (line 66) | class RoIDataLoader:
    method __init__ (line 67) | def __init__(
    method minibatch_loader_thread (line 97) | def minibatch_loader_thread(self):
    method enqueue_blobs_thread (line 115) | def enqueue_blobs_thread(self, gpu_id, blob_names):
    method get_next_minibatch (line 128) | def get_next_minibatch(self):
    method _shuffle_roidb_inds (line 137) | def _shuffle_roidb_inds(self):
    method _get_next_minibatch_inds (line 163) | def _get_next_minibatch_inds(self):
    method get_output_names (line 177) | def get_output_names(self):
    method enqueue_blobs (line 180) | def enqueue_blobs(self, gpu_id, blob_names, blobs):
    method create_threads (line 205) | def create_threads(self):
    method start (line 225) | def start(self, prefill=False):
    method has_stopped (line 244) | def has_stopped(self):
    method shutdown (line 247) | def shutdown(self):
    method create_blobs_queues (line 254) | def create_blobs_queues(self):
    method close_blobs_queues (line 267) | def close_blobs_queues(self):
    method create_enqueue_blobs (line 277) | def create_enqueue_blobs(self):
    method register_sigint_handler (line 288) | def register_sigint_handler(self):

FILE: detectron/roi_data/mask_rcnn.py
  function add_mask_rcnn_blobs (line 37) | def add_mask_rcnn_blobs(blobs, sampled_boxes, roidb, im_scale, batch_idx):
  function _expand_to_class_specific_mask_targets (line 105) | def _expand_to_class_specific_mask_targets(masks, mask_class_labels):

FILE: detectron/roi_data/minibatch.py
  function get_minibatch_blob_names (line 44) | def get_minibatch_blob_names(is_training=True):
  function get_minibatch (line 64) | def get_minibatch(roidb):
  function _get_image_blob (line 89) | def _get_image_blob(roidb):

FILE: detectron/roi_data/retinanet.py
  function get_retinanet_blob_names (line 34) | def get_retinanet_blob_names(is_training=True):
  function add_retinanet_blobs (line 78) | def add_retinanet_blobs(blobs, im_scales, roidb, image_width, image_heig...
  function _get_retinanet_blobs (line 182) | def _get_retinanet_blobs(

FILE: detectron/roi_data/rpn.py
  function get_rpn_blob_names (line 35) | def get_rpn_blob_names(is_training=True):
  function add_rpn_blobs (line 62) | def add_rpn_blobs(blobs, im_scales, roidb):
  function _get_rpn_blobs (line 131) | def _get_rpn_blobs(im_height, im_width, foas, all_anchors, gt_boxes):

FILE: detectron/tests/data_loader_benchmark.py
  function parse_args (line 51) | def parse_args():
  function loader_loop (line 80) | def loader_loop(roi_data_loader):
  function main (line 91) | def main(opts):

FILE: detectron/tests/test_batch_permutation_op.py
  class BatchPermutationOpTest (line 33) | class BatchPermutationOpTest(unittest.TestCase):
    method _run_op_test (line 34) | def _run_op_test(self, X, I, check_grad=False):
    method _run_speed_test (line 55) | def _run_speed_test(self, iters=5, N=1024):
    method test_forward_and_gradient (line 81) | def test_forward_and_gradient(self):
    method test_size_exceptions (line 94) | def test_size_exceptions(self):

FILE: detectron/tests/test_bbox_transform.py
  function random_boxes (line 29) | def random_boxes(mean_box, stdev, N):
  class TestBboxTransform (line 34) | class TestBboxTransform(unittest.TestCase):
    method test_bbox_transform_and_inverse (line 35) | def test_bbox_transform_and_inverse(self):
    method test_bbox_dataset_to_prediction_roundtrip (line 49) | def test_bbox_dataset_to_prediction_roundtrip(self):
    method test_cython_bbox_iou_against_coco_api_bbox_iou (line 77) | def test_cython_bbox_iou_against_coco_api_bbox_iou(self):

FILE: detectron/tests/test_cfg.py
  class TestAttrDict (line 32) | class TestAttrDict(unittest.TestCase):
    method test_immutability (line 33) | def test_immutability(self):
  class TestCfg (line 67) | class TestCfg(unittest.TestCase):
    method test_copy_cfg (line 68) | def test_copy_cfg(self):
    method test_merge_cfg_from_cfg (line 74) | def test_merge_cfg_from_cfg(self):
    method test_merge_cfg_from_file (line 120) | def test_merge_cfg_from_file(self):
    method test_merge_cfg_from_list (line 129) | def test_merge_cfg_from_list(self):
    method test_deprecated_key_from_list (line 144) | def test_deprecated_key_from_list(self):
    method test_deprecated_key_from_file (line 158) | def test_deprecated_key_from_file(self):
    method test_renamed_key_from_list (line 171) | def test_renamed_key_from_list(self):
    method test_renamed_key_from_file (line 181) | def test_renamed_key_from_file(self):

FILE: detectron/tests/test_loader.py
  function get_roidb_blobs (line 37) | def get_roidb_blobs(roidb):
  function get_net (line 43) | def get_net(data_loader, name):
  function get_roidb_sample_data (line 61) | def get_roidb_sample_data(sample_data):
  function create_loader_and_network (line 68) | def create_loader_and_network(sample_data, name):
  function run_net (line 77) | def run_net(net):
  class TestRoIDataLoader (line 87) | class TestRoIDataLoader(unittest.TestCase):
    method test_two_parallel_loaders (line 96) | def test_two_parallel_loaders(self, _1, _2):

FILE: detectron/tests/test_restore_checkpoint.py
  function get_params (line 41) | def get_params(model):
  function add_momentum_init_ops (line 60) | def add_momentum_init_ops(model):
  function init_weights (line 66) | def init_weights(model):
  function test_restore_checkpoint (line 72) | def test_restore_checkpoint():

FILE: detectron/tests/test_smooth_l1_loss_op.py
  class SmoothL1LossTest (line 33) | class SmoothL1LossTest(unittest.TestCase):
    method test_forward_and_gradient (line 34) | def test_forward_and_gradient(self):

FILE: detectron/tests/test_spatial_narrow_as_op.py
  class SpatialNarrowAsOpTest (line 33) | class SpatialNarrowAsOpTest(unittest.TestCase):
    method _run_test (line 34) | def _run_test(self, A, B, check_grad=False):
    method test_small_forward_and_gradient (line 56) | def test_small_forward_and_gradient(self):
    method test_large_forward (line 65) | def test_large_forward(self):
    method test_size_exceptions (line 74) | def test_size_exceptions(self):

FILE: detectron/tests/test_zero_even_op.py
  class ZeroEvenOpTest (line 31) | class ZeroEvenOpTest(unittest.TestCase):
    method _run_zero_even_op (line 33) | def _run_zero_even_op(self, X):
    method _run_zero_even_op_gpu (line 40) | def _run_zero_even_op_gpu(self, X):
    method test_throws_on_non_1D_arrays (line 48) | def test_throws_on_non_1D_arrays(self):
    method test_handles_empty_arrays (line 53) | def test_handles_empty_arrays(self):
    method test_sets_vals_at_even_inds_to_zero (line 59) | def test_sets_vals_at_even_inds_to_zero(self):
    method test_preserves_vals_at_odd_inds (line 65) | def test_preserves_vals_at_odd_inds(self):
    method test_handles_even_length_arrays (line 71) | def test_handles_even_length_arrays(self):
    method test_handles_odd_length_arrays (line 78) | def test_handles_odd_length_arrays(self):
    method test_gpu_throws_on_non_1D_arrays (line 85) | def test_gpu_throws_on_non_1D_arrays(self):
    method test_gpu_handles_empty_arrays (line 90) | def test_gpu_handles_empty_arrays(self):
    method test_gpu_sets_vals_at_even_inds_to_zero (line 96) | def test_gpu_sets_vals_at_even_inds_to_zero(self):
    method test_gpu_preserves_vals_at_odd_inds (line 102) | def test_gpu_preserves_vals_at_odd_inds(self):
    method test_gpu_handles_even_length_arrays (line 108) | def test_gpu_handles_even_length_arrays(self):
    method test_gpu_handles_odd_length_arrays (line 115) | def test_gpu_handles_odd_length_arrays(self):

FILE: detectron/utils/blob.py
  function get_image_blob (line 40) | def get_image_blob(im, target_scale, target_max_size):
  function im_list_to_blob (line 67) | def im_list_to_blob(ims):
  function prep_im_for_blob (line 100) | def prep_im_for_blob(im, pixel_means, target_size, max_size):
  function zeros (line 128) | def zeros(shape, int32=False):
  function ones (line 135) | def ones(shape, int32=False):
  function py_op_copy_blob (line 142) | def py_op_copy_blob(blob_in, blob_out):
  function get_loss_gradients (line 161) | def get_loss_gradients(model, loss_blobs):
  function serialize (line 170) | def serialize(obj):
  function deserialize (line 177) | def deserialize(arr):

FILE: detectron/utils/boxes.py
  function boxes_area (line 57) | def boxes_area(boxes):
  function unique_boxes (line 66) | def unique_boxes(boxes, scale=1.0):
  function xywh_to_xyxy (line 74) | def xywh_to_xyxy(xywh):
  function xyxy_to_xywh (line 92) | def xyxy_to_xywh(xyxy):
  function filter_small_boxes (line 108) | def filter_small_boxes(boxes, min_size):
  function clip_boxes_to_image (line 116) | def clip_boxes_to_image(boxes, height, width):
  function clip_xyxy_to_image (line 123) | def clip_xyxy_to_image(x1, y1, x2, y2, height, width):
  function clip_tiled_boxes (line 132) | def clip_tiled_boxes(boxes, im_shape):
  function bbox_transform (line 150) | def bbox_transform(boxes, deltas, weights=(1.0, 1.0, 1.0, 1.0)):
  function bbox_transform_inv (line 193) | def bbox_transform_inv(boxes, gt_boxes, weights=(1.0, 1.0, 1.0, 1.0)):
  function expand_boxes (line 227) | def expand_boxes(boxes, scale):
  function flip_boxes (line 246) | def flip_boxes(boxes, im_width):
  function aspect_ratio (line 254) | def aspect_ratio(boxes, aspect_ratio):
  function box_voting (line 262) | def box_voting(top_dets, all_dets, thresh, scoring_method='ID', beta=1.0):
  function nms (line 314) | def nms(dets, thresh):
  function soft_nms (line 321) | def soft_nms(

FILE: detectron/utils/c2.py
  function import_contrib_ops (line 36) | def import_contrib_ops():
  function import_detectron_ops (line 41) | def import_detectron_ops():
  function import_custom_ops (line 47) | def import_custom_ops():
  function SuffixNet (line 53) | def SuffixNet(name, net, prefix_len, outputs):
  function BlobReferenceList (line 82) | def BlobReferenceList(blob_ref_or_list):
  function UnscopeName (line 97) | def UnscopeName(possibly_scoped_name):
  function NamedCudaScope (line 106) | def NamedCudaScope(gpu_id):
  function GpuNameScope (line 115) | def GpuNameScope(gpu_id):
  function CudaScope (line 122) | def CudaScope(gpu_id):
  function CpuScope (line 130) | def CpuScope():
  function CudaDevice (line 137) | def CudaDevice(gpu_id):
  function gauss_fill (line 142) | def gauss_fill(std):
  function const_fill (line 147) | def const_fill(value):
  function get_nvidia_info (line 152) | def get_nvidia_info():
  function get_nvidia_smi_output (line 160) | def get_nvidia_smi_output():

FILE: detectron/utils/collections.py
  class AttrDict (line 24) | class AttrDict(dict):
    method __init__ (line 28) | def __init__(self, *args, **kwargs):
    method __getattr__ (line 32) | def __getattr__(self, name):
    method __setattr__ (line 40) | def __setattr__(self, name, value):
    method immutable (line 52) | def immutable(self, is_immutable):
    method is_immutable (line 65) | def is_immutable(self):

FILE: detectron/utils/colormap.py
  function colormap (line 26) | def colormap(rgb=False):

FILE: detectron/utils/coordinator.py
  class Coordinator (line 32) | class Coordinator:
    method __init__ (line 34) | def __init__(self):
    method request_stop (line 37) | def request_stop(self):
    method should_stop (line 41) | def should_stop(self):
    method wait_for_stop (line 44) | def wait_for_stop(self):
    method stop_on_exception (line 48) | def stop_on_exception(self):
  function coordinated_get (line 57) | def coordinated_get(coordinator, queue):
  function coordinated_put (line 66) | def coordinated_put(coordinator, queue, element):

FILE: detectron/utils/env.py
  function get_runtime_dir (line 33) | def get_runtime_dir():
  function get_py_bin_ext (line 38) | def get_py_bin_ext():
  function set_up_matplotlib (line 43) | def set_up_matplotlib():
  function exit_on_error (line 50) | def exit_on_error():
  function import_nccl_ops (line 55) | def import_nccl_ops():
  function get_detectron_ops_lib (line 62) | def get_detectron_ops_lib():
  function get_custom_ops_lib (line 78) | def get_custom_ops_lib():

FILE: detectron/utils/image.py
  function aspect_ratio_rel (line 27) | def aspect_ratio_rel(im, aspect_ratio):
  function aspect_ratio_abs (line 35) | def aspect_ratio_abs(im, aspect_ratio):

FILE: detectron/utils/io.py
  function save_object (line 39) | def save_object(obj, file_name, pickle_format=2):
  function load_object (line 72) | def load_object(file_name):
  function cache_url (line 86) | def cache_url(url_or_file, cache_dir):
  function assert_cache_file_is_ok (line 118) | def assert_cache_file_is_ok(url, file_path):
  function _progress_bar (line 132) | def _progress_bar(count, total):
  function download_url (line 152) | def download_url(
  function _get_file_md5sum (line 180) | def _get_file_md5sum(file_name):
  function _get_reference_md5sum (line 188) | def _get_reference_md5sum(url):

FILE: detectron/utils/keypoints.py
  function get_keypoints (line 30) | def get_keypoints():
  function get_person_class_index (line 66) | def get_person_class_index():
  function flip_keypoints (line 71) | def flip_keypoints(keypoints, keypoint_flip_map, keypoint_coords, width):
  function flip_heatmaps (line 90) | def flip_heatmaps(heatmaps):
  function heatmaps_to_keypoints (line 103) | def heatmaps_to_keypoints(maps, rois):
  function keypoints_to_heatmap_labels (line 160) | def keypoints_to_heatmap_labels(keypoints, rois):
  function scores_to_probs (line 214) | def scores_to_probs(scores):
  function nms_oks (line 225) | def nms_oks(kp_predictions, rois, thresh):
  function compute_oks (line 243) | def compute_oks(src_keypoints, src_roi, dst_keypoints, dst_roi):

FILE: detectron/utils/logging.py
  function log_json_stats (line 32) | def log_json_stats(stats, sort_keys=True):
  class SmoothedValue (line 41) | class SmoothedValue:
    method __init__ (line 46) | def __init__(self, window_size):
    method AddValue (line 52) | def AddValue(self, value):
    method GetMedianValue (line 58) | def GetMedianValue(self):
    method GetAverageValue (line 61) | def GetAverageValue(self):
    method GetGlobalAverageValue (line 64) | def GetGlobalAverageValue(self):
  function send_email (line 68) | def send_email(subject, body, to):
  function setup_logging (line 76) | def setup_logging(name):

FILE: detectron/utils/lr_policy.py
  function get_lr_at_iter (line 28) | def get_lr_at_iter(it):
  function lr_func_steps_with_lrs (line 50) | def lr_func_steps_with_lrs(cur_iter):
  function lr_func_steps_with_decay (line 67) | def lr_func_steps_with_decay(cur_iter):
  function lr_func_step (line 86) | def lr_func_step(cur_iter):
  function lr_func_cosine_decay (line 94) | def lr_func_cosine_decay(cur_iter):
  function lr_func_exp_decay (line 102) | def lr_func_exp_decay(cur_iter):
  function get_step_index (line 115) | def get_step_index(cur_iter):
  function get_lr_func (line 125) | def get_lr_func():

FILE: detectron/utils/model_convert_utils.py
  class OpFilter (line 31) | class OpFilter:
    method __init__ (line 32) | def __init__(self, **kwargs):
    method check (line 45) | def check(self, op):
  function filter_op (line 64) | def filter_op(op, **kwargs):
  function op_filter (line 69) | def op_filter(**filter_args):
  function op_func_chain (line 81) | def op_func_chain(convert_func_list):
  function convert_op_in_ops (line 95) | def convert_op_in_ops(ops_ref, func_or_list):
  function convert_op_in_proto (line 112) | def convert_op_in_proto(proto, func_or_list):
  function get_op_arg (line 116) | def get_op_arg(op, arg_name):
  function get_op_arg_valf (line 123) | def get_op_arg_valf(op, arg_name, default_val):
  function update_mobile_engines (line 128) | def update_mobile_engines(net):
  function pairwise (line 136) | def pairwise(iterable):
  function blob_uses (line 144) | def blob_uses(net, blob):
  function fuse_first_affine (line 152) | def fuse_first_affine(net, params, removed_tensors):
  function fuse_affine (line 238) | def fuse_affine(net, params, ignore_failure):
  function fuse_net (line 255) | def fuse_net(fuse_func, net, blobs, ignore_failure=False):
  function fuse_net_affine (line 270) | def fuse_net_affine(net, blobs):
  function add_tensor (line 274) | def add_tensor(net, name, blob):
  function gen_init_net_from_blobs (line 307) | def gen_init_net_from_blobs(blobs, blobs_to_use=None, excluded_blobs=None):
  function get_ws_blobs (line 327) | def get_ws_blobs(blob_names=None):
  function get_device_option_cpu (line 338) | def get_device_option_cpu():
  function get_device_option_cuda (line 343) | def get_device_option_cuda(gpu_id=0):
  function create_input_blobs_for_net (line 350) | def create_input_blobs_for_net(net_def):
  function compare_model (line 357) | def compare_model(model1_func, model2_func, test_image, check_blobs):
  function save_graph (line 390) | def save_graph(net, file_name, graph_name="net", op_only=True):

FILE: detectron/utils/net.py
  function initialize_from_weights_file (line 43) | def initialize_from_weights_file(model, weights_file, broadcast=True):
  function initialize_gpu_from_weights_file (line 53) | def initialize_gpu_from_weights_file(model, weights_file, gpu_id=0):
  function save_model_to_weights_file (line 136) | def save_model_to_weights_file(weights_file, model):
  function broadcast_parameters (line 172) | def broadcast_parameters(model):
  function sum_multi_gpu_blob (line 198) | def sum_multi_gpu_blob(blob_name):
  function average_multi_gpu_blob (line 206) | def average_multi_gpu_blob(blob_name):
  function print_net (line 211) | def print_net(model, namescope='gpu_0'):
  function configure_bbox_reg_weights (line 257) | def configure_bbox_reg_weights(model, saved_cfg):
  function get_group_gn (line 282) | def get_group_gn(dim):

FILE: detectron/utils/segms.py
  function is_poly (line 40) | def is_poly(segm):
  function flip_segms (line 47) | def flip_segms(segms, height, width):
  function polys_to_mask (line 75) | def polys_to_mask(polygons, height, width):
  function mask_to_bbox (line 89) | def mask_to_bbox(mask):
  function polys_to_mask_wrt_box (line 104) | def polys_to_mask_wrt_box(polygons, box, M):
  function polys_to_boxes (line 131) | def polys_to_boxes(polys):
  function rle_mask_voting (line 145) | def rle_mask_voting(
  function rle_mask_nms (line 209) | def rle_mask_nms(masks, dets, thresh, mode='IOU'):
  function rle_masks_to_boxes (line 254) | def rle_masks_to_boxes(masks):

FILE: detectron/utils/subprocess.py
  function process_in_parallel (line 39) | def process_in_parallel(
  function log_subprocess_output (line 106) | def log_subprocess_output(i, p, output_dir, tag, start, end):

FILE: detectron/utils/timer.py
  class Timer (line 34) | class Timer:
    method __init__ (line 37) | def __init__(self):
    method tic (line 40) | def tic(self):
    method toc (line 45) | def toc(self, average=True):
    method reset (line 55) | def reset(self):

FILE: detectron/utils/train.py
  function train_model (line 51) | def train_model():
  function handle_critical_error (line 96) | def handle_critical_error(model, msg):
  function create_model (line 103) | def create_model():
  function optimize_memory (line 153) | def optimize_memory(model):
  function setup_model_for_training (line 167) | def setup_model_for_training(model, weights_file, output_dir):
  function add_model_training_inputs (line 189) | def add_model_training_inputs(model):
  function dump_proto_files (line 200) | def dump_proto_files(model, output_dir):

FILE: detectron/utils/training_stats.py
  class TrainingStats (line 37) | class TrainingStats:
    method __init__ (line 40) | def __init__(self, model):
    method IterTic (line 59) | def IterTic(self):
    method IterToc (line 62) | def IterToc(self):
    method ResetIterTimer (line 65) | def ResetIterTimer(self):
    method UpdateIterStats (line 68) | def UpdateIterStats(self):
    method LogIterStats (line 85) | def LogIterStats(self, cur_iter, lr):
    method GetStats (line 92) | def GetStats(self, cur_iter, lr):

FILE: detectron/utils/vis.py
  function kp_connections (line 47) | def kp_connections(keypoints):
  function convert_from_cls_format (line 68) | def convert_from_cls_format(cls_boxes, cls_segms, cls_keyps):
  function get_class_string (line 91) | def get_class_string(class_index, score, dataset):
  function vis_mask (line 97) | def vis_mask(img, mask, col, alpha=0.4, show_border=True, border_thick=1):
  function vis_class (line 114) | def vis_class(img, pos, class_str, font_scale=0.35):
  function vis_bbox (line 132) | def vis_bbox(img, bbox, thick=1):
  function vis_keypoints (line 142) | def vis_keypoints(img, kps, kp_thresh=2, alpha=0.7):
  function vis_one_image_opencv (line 203) | def vis_one_image_opencv(
  function vis_one_image (line 253) | def vis_one_image(

FILE: tools/convert_cityscapes_to_coco.py
  function parse_args (line 36) | def parse_args():
  function convert_coco_stuff_mat (line 51) | def convert_coco_stuff_mat(data_dir, out_dir):
  function getLabelID (line 92) | def getLabelID(self, instID):
  function convert_cityscapes_instance_only (line 99) | def convert_cityscapes_instance_only(

FILE: tools/convert_coco_model_to_cityscapes.py
  function parse_args (line 41) | def parse_args():
  function convert_coco_blobs_to_cityscape_blobs (line 65) | def convert_coco_blobs_to_cityscape_blobs(model_dict):
  function convert_coco_blob_to_cityscapes_blob (line 80) | def convert_coco_blob_to_cityscapes_blob(coco_blob, convert_func):
  function remove_momentum (line 106) | def remove_momentum(model_dict):
  function load_and_convert_coco_model (line 112) | def load_and_convert_coco_model(args):

FILE: tools/convert_pkl_to_pb.py
  function parse_args (line 69) | def parse_args():
  function unscope_name (line 144) | def unscope_name(name):
  function reset_names (line 148) | def reset_names(names):
  function convert_collect_and_distribute (line 153) | def convert_collect_and_distribute(
  function convert_gen_proposals (line 188) | def convert_gen_proposals(
  function get_anchors (line 224) | def get_anchors(spatial_scale, anchor_sizes):
  function reset_blob_names (line 233) | def reset_blob_names(blobs):
  function convert_net (line 239) | def convert_net(args, net, blobs):
  function add_bbox_ops (line 338) | def add_bbox_ops(args, net, blobs):
  function convert_model_gpu (line 375) | def convert_model_gpu(args, net, init_net):
  function gen_init_net (line 416) | def gen_init_net(net, blobs, empty_blobs):
  function _save_image_graphs (line 425) | def _save_image_graphs(args, all_net, all_init_net):
  function _save_models (line 433) | def _save_models(all_net, all_init_net, args):
  function load_model (line 450) | def load_model(args):
  function _get_result_blobs (line 457) | def _get_result_blobs(check_blobs):
  function _sort_results (line 469) | def _sort_results(boxes, segms, keypoints, classes):
  function run_model_cfg (line 486) | def run_model_cfg(args, im, check_blobs):
  function _prepare_blobs (line 518) | def _prepare_blobs(im, pixel_means, target_size, max_size):
  function run_model_pb (line 545) | def run_model_pb(args, net, init_net, im, check_blobs):
  function verify_model (line 592) | def verify_model(args, model_pb, test_img_file):
  function _export_to_logfiledb (line 609) | def _export_to_logfiledb(args, net, init_net, inputs, out_file, extra_ou...
  function main (line 631) | def main():

FILE: tools/generate_testdev_from_test.py
  function parse_args (line 38) | def parse_args():
  function convert (line 55) | def convert(json_file, output_dir):

FILE: tools/infer.py
  function parse_args (line 66) | def parse_args():
  function get_rpn_box_proposals (line 104) | def get_rpn_box_proposals(im, args):
  function main (line 119) | def main(args):
  function check_args (line 173) | def check_args(args):

FILE: tools/infer_simple.py
  function parse_args (line 56) | def parse_args():
  function main (line 122) | def main(args):

FILE: tools/pickle_caffe_blobs.py
  function parse_args (line 41) | def parse_args():
  function normalize_resnet_name (line 75) | def normalize_resnet_name(name):
  function pickle_weights (line 91) | def pickle_weights(out_file_name, weights):
  function add_missing_biases (line 101) | def add_missing_biases(caffenet_weights):
  function remove_spatial_bn_layers (line 112) | def remove_spatial_bn_layers(caffenet, caffenet_weights):
  function remove_layers_without_parameters (line 159) | def remove_layers_without_parameters(caffenet, caffenet_weights):
  function normalize_shape (line 175) | def normalize_shape(caffenet_weights):
  function load_and_convert_caffe_model (line 191) | def load_and_convert_caffe_model(prototxt_file_name, caffemodel_file_name):

FILE: tools/reval.py
  function parse_args (line 45) | def parse_args():
  function do_reval (line 85) | def do_reval(dataset_name, output_dir, args):

FILE: tools/test_net.py
  function parse_args (line 49) | def parse_args():

FILE: tools/train_net.py
  function parse_args (line 51) | def parse_args():
  function main (line 86) | def main():
  function test_model (line 120) | def test_model(model_file, multi_gpu_testing, opts=None):

FILE: tools/visualize_results.py
  function parse_args (line 39) | def parse_args():
  function vis (line 83) | def vis(dataset, detections_pkl, thresh, output_dir, limit=0):