SYMBOL INDEX (634 symbols across 85 files)

FILE: challenge/2019_COCO_DensePose/densepose_cocoeval.py
  class denseposeCOCOeval (line 26) | class denseposeCOCOeval:
    method __init__ (line 76) | def __init__(self, evalDataDir, cocoGt=None, cocoDt=None, iouType='seg...
    method _loadGEval (line 105) | def _loadGEval(self):
    method _decodeUvData (line 140) | def _decodeUvData(self, dt):
    method _prepare (line 152) | def _prepare(self):
    method evaluate (line 261) | def evaluate(self, calc_mode='GPSm', tracking=True, UB_geo_iuvgt=False,
    method computeIoU (line 332) | def computeIoU(self, imgId, catId):
    method GetDensePoseMask (line 361) | def GetDensePoseMask(self, Polys):
    method computeDPIoU (line 369) | def computeDPIoU(self, imgId, catId):
    method computeOks (line 450) | def computeOks(self, imgId, catId):
    method computeOgps (line 493) | def computeOgps(self, imgId, catId):
    method computeOgpsDraft (line 573) | def computeOgpsDraft(self, imgId, catId):
    method evaluateImg (line 658) | def evaluateImg(self, imgId, catId, aRng, maxDet, check_scores):
    method accumulate (line 784) | def accumulate(self, p = None):
    method summarize (line 889) | def summarize(self):
    method __str__ (line 990) | def __str__(self):
    method findAllClosestVerts (line 994) | def findAllClosestVerts(self, gt, U_points, V_points, Index_points):
    method findAllClosestVertsIUV (line 1026) | def findAllClosestVertsIUV(self, U_gt, V_gt, I_gt, U_points, V_points,...
    method findAllClosestVertsSingleImage (line 1059) | def findAllClosestVertsSingleImage(self, U_points, V_points, Index_poi...
    method getDistances (line 1074) | def getDistances(self, cVertsGT, cVerts):
    method getDistancesPair (line 1113) | def getDistancesPair(self, cVerts00, cVerts01):
  class Params (line 1151) | class Params:
    method setDetParams (line 1155) | def setDetParams(self):
    method setKpParams (line 1166) | def setKpParams(self):
    method setUvParams (line 1177) | def setUvParams(self):
    method __init__ (line 1197) | def __init__(self, iouType='segm'):

FILE: challenge/encode_results_for_competition.py
  function _parseArguments (line 23) | def _parseArguments():
  function _encodePngData (line 33) | def _encodePngData(arr):
  function _statusStr (line 54) | def _statusStr(i, dataLen):
  function _savePngJson (line 65) | def _savePngJson(hInPklResultsFile, hOutJsonPackedFile):
  function main (line 82) | def main():

FILE: detectron/core/config.py
  function assert_and_infer_cfg (line 1106) | def assert_and_infer_cfg(cache_urls=True, make_immutable=True):
  function cache_cfg_urls (line 1124) | def cache_cfg_urls():
  function get_output_dir (line 1138) | def get_output_dir(datasets, training=True):
  function load_cfg (line 1152) | def load_cfg(cfg_to_load):
  function merge_cfg_from_file (line 1166) | def merge_cfg_from_file(cfg_filename):
  function merge_cfg_from_cfg (line 1173) | def merge_cfg_from_cfg(cfg_other):
  function merge_cfg_from_list (line 1178) | def merge_cfg_from_list(cfg_list):
  function _merge_a_into_b (line 1202) | def _merge_a_into_b(a, b, stack=None):
  function _key_is_deprecated (line 1237) | def _key_is_deprecated(full_key):
  function _key_is_renamed (line 1246) | def _key_is_renamed(full_key):
  function _raise_key_rename_error (line 1250) | def _raise_key_rename_error(full_key):
  function _decode_cfg_value (line 1263) | def _decode_cfg_value(v):
  function _check_and_coerce_cfg_value_type (line 1296) | 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 48) | def generate_rpn_on_dataset(
  function multi_gpu_generate_rpn_on_dataset (line 80) | def multi_gpu_generate_rpn_on_dataset(
  function generate_rpn_on_range (line 114) | def generate_rpn_on_range(
  function generate_proposals_on_roidb (line 163) | def generate_proposals_on_roidb(
  function im_proposals (line 201) | def im_proposals(model, im):
  function get_roidb (line 246) | def get_roidb(dataset_name, ind_range):
  function evaluate_proposal_file (line 265) | def evaluate_proposal_file(dataset, proposal_file, output_dir):

FILE: detectron/core/test.py
  function im_detect_all (line 44) | 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 im_detect_body_uv (line 889) | def im_detect_body_uv(model, im_scale, boxes):
  function _get_rois_blob (line 971) | def _get_rois_blob(im_rois, im_scale):
  function _project_im_rois (line 987) | def _project_im_rois(im_rois, scales):
  function _add_multilevel_rois_for_test (line 1003) | def _add_multilevel_rois_for_test(blobs, name):
  function _get_blobs (line 1024) | def _get_blobs(im, rois, target_scale, target_max_size):

FILE: detectron/core/test_engine.py
  function get_eval_functions (line 44) | def get_eval_functions():
  function get_inference_dataset (line 58) | def get_inference_dataset(index, is_parent=True):
  function run_inference (line 77) | def run_inference(
  function test_net_on_dataset (line 132) | def test_net_on_dataset(
  function multi_gpu_test_net_on_dataset (line 163) | def multi_gpu_test_net_on_dataset(
  function test_net (line 216) | def test_net(
  function initialize_model_from_cfg (line 330) | def initialize_model_from_cfg(weights_file, gpu_id=0):
  function get_roidb_and_dataset (line 350) | def get_roidb_and_dataset(dataset_name, proposal_file, ind_range):
  function empty_results (line 376) | def empty_results(num_classes, num_images):
  function extend_results (line 401) | def extend_results(index, all_res, im_res):

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

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

FILE: detectron/datasets/coco_to_cityscapes_id.py
  function cityscapes_to_coco (line 30) | def cityscapes_to_coco(cityscapes_id):
  function cityscapes_to_coco_with_rider (line 45) | def cityscapes_to_coco_with_rider(cityscapes_id):
  function cityscapes_to_coco_without_person_rider (line 60) | def cityscapes_to_coco_without_person_rider(cityscapes_id):
  function cityscapes_to_coco_all_random (line 75) | def cityscapes_to_coco_all_random(cityscapes_id):

FILE: detectron/datasets/dataset_catalog.py
  function datasets (line 237) | def datasets():
  function contains (line 242) | def contains(name):
  function get_im_dir (line 247) | def get_im_dir(name):
  function get_ann_fn (line 252) | def get_ann_fn(name):
  function get_im_prefix (line 257) | def get_im_prefix(name):
  function get_devkit_dir (line 262) | def get_devkit_dir(name):
  function get_raw_dir (line 267) | def get_raw_dir(name):

FILE: detectron/datasets/densepose_cocoeval.py
  class denseposeCOCOeval (line 23) | class denseposeCOCOeval:
    method __init__ (line 73) | def __init__(self, cocoGt=None, cocoDt=None, iouType='segm', sigma=1.):
    method _loadGEval (line 101) | def _loadGEval(self):
    method _prepare (line 137) | def _prepare(self):
    method evaluate (line 239) | def evaluate(self):
    method computeIoU (line 284) | def computeIoU(self, imgId, catId):
    method computeOks (line 313) | def computeOks(self, imgId, catId):
    method computeOgps (line 356) | def computeOgps(self, imgId, catId):
    method evaluateImg (line 421) | def evaluateImg(self, imgId, catId, aRng, maxDet):
    method accumulate (line 540) | def accumulate(self, p = None):
    method summarize (line 645) | def summarize(self):
    method __str__ (line 746) | def __str__(self):
    method findAllClosestVerts (line 750) | def findAllClosestVerts(self, gt, U_points, V_points, Index_points):
    method getDistances (line 783) | def getDistances(self, cVertsGT, cVerts):
  class Params (line 823) | class Params:
    method setDetParams (line 827) | def setDetParams(self):
    method setKpParams (line 838) | def setKpParams(self):
    method setUvParams (line 849) | def setUvParams(self):
    method __init__ (line 859) | def __init__(self, iouType='segm'):

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

FILE: detectron/datasets/json_dataset.py
  class JsonDataset (line 42) | class JsonDataset(object):
    method __init__ (line 45) | def __init__(self, name):
    method get_roidb (line 74) | def get_roidb(
    method _prep_roidb_entry (line 119) | def _prep_roidb_entry(self, entry):
    method _add_gt_annotations (line 164) | def _add_gt_annotations(self, entry):
    method _add_proposals_from_file (line 295) | def _add_proposals_from_file(
    method _init_keypoints (line 326) | def _init_keypoints(self):
    method _get_gt_keypoints (line 355) | def _get_gt_keypoints(self, obj):
  function add_proposals (line 375) | def add_proposals(roidb, rois, scales, crowd_thresh):
  function _merge_proposal_boxes_into_roidb (line 391) | def _merge_proposal_boxes_into_roidb(roidb, box_list):
  function _filter_crowd_proposals (line 455) | def _filter_crowd_proposals(roidb, crowd_thresh):
  function _add_class_assignments (line 475) | def _add_class_assignments(roidb):
  function _sort_proposals (line 496) | def _sort_proposals(proposals, id_field):

FILE: detectron/datasets/json_dataset_evaluator.py
  function evaluate_masks (line 33) | def evaluate_masks(
  function _write_coco_segms_results_file (line 60) | def _write_coco_segms_results_file(
  function _coco_segms_results_one_category (line 83) | def _coco_segms_results_one_category(json_dataset, boxes, segms, cat_id):
  function _do_segmentation_eval (line 109) | def _do_segmentation_eval(json_dataset, res_file, output_dir):
  function evaluate_boxes (line 121) | def evaluate_boxes(
  function _write_coco_bbox_results_file (line 142) | def _write_coco_bbox_results_file(json_dataset, all_boxes, res_file):
  function _coco_bbox_results_one_category (line 162) | def _coco_bbox_results_one_category(json_dataset, boxes, cat_id):
  function _do_detection_eval (line 186) | def _do_detection_eval(json_dataset, res_file, output_dir):
  function _log_detection_eval_metrics (line 198) | def _log_detection_eval_metrics(json_dataset, coco_eval):
  function evaluate_box_proposals (line 231) | def evaluate_box_proposals(
  function evaluate_keypoints (line 315) | def evaluate_keypoints(
  function _write_coco_keypoint_results_file (line 342) | def _write_coco_keypoint_results_file(
  function _coco_kp_results_one_category (line 364) | def _coco_kp_results_one_category(json_dataset, boxes, kps, cat_id):
  function _do_keypoint_eval (line 412) | def _do_keypoint_eval(json_dataset, res_file, output_dir):
  function evaluate_body_uv (line 428) | def evaluate_body_uv(
  function _write_coco_body_uv_results_file (line 459) | def _write_coco_body_uv_results_file(
  function _coco_body_uv_results_one_category (line 492) | def _coco_body_uv_results_one_category(json_dataset, boxes, body_uvs, ca...
  function _do_body_uv_eval (line 531) | def _do_body_uv_eval(json_dataset, res_file, output_dir):

FILE: detectron/datasets/roidb.py
  function combined_roidb_for_training (line 28) | def combined_roidb_for_training(dataset_names, proposal_files):
  function extend_with_flipped_entries (line 68) | def extend_with_flipped_entries(roidb, dataset):
  function filter_for_training (line 103) | def filter_for_training(roidb):
  function add_bbox_regression_targets (line 134) | def add_bbox_regression_targets(roidb):
  function compute_bbox_regression_targets (line 140) | def compute_bbox_regression_targets(entry):
  function _compute_and_log_stats (line 174) | def _compute_and_log_stats(roidb):

FILE: detectron/datasets/task_evaluation.py
  function evaluate_all (line 45) | def evaluate_all(
  function evaluate_boxes (line 71) | def evaluate_boxes(dataset, all_boxes, output_dir, use_matlab=False):
  function evaluate_masks (line 100) | def evaluate_masks(dataset, all_boxes, all_segms, output_dir):
  function evaluate_keypoints (line 131) | def evaluate_keypoints(dataset, all_boxes, all_keyps, output_dir):
  function evaluate_body_uv (line 149) | def evaluate_body_uv(dataset, all_boxes, all_bodys, output_dir):
  function evaluate_box_proposals (line 165) | def evaluate_box_proposals(dataset, roidb):
  function log_box_proposal_results (line 179) | def log_box_proposal_results(results):
  function log_copy_paste_friendly_results (line 189) | def log_copy_paste_friendly_results(results):
  function check_expected_results (line 203) | def check_expected_results(results, atol=0.005, rtol=0.1):
  function _use_json_dataset_evaluator (line 259) | def _use_json_dataset_evaluator(dataset):
  function _use_cityscapes_evaluator (line 264) | def _use_cityscapes_evaluator(dataset):
  function _use_voc_evaluator (line 269) | def _use_voc_evaluator(dataset):
  function _coco_eval_to_box_results (line 294) | def _coco_eval_to_box_results(coco_eval):
  function _coco_eval_to_mask_results (line 307) | def _coco_eval_to_mask_results(coco_eval):
  function _coco_eval_to_keypoint_results (line 320) | def _coco_eval_to_keypoint_results(coco_eval):
  function _coco_eval_to_body_uv_results (line 332) | def _coco_eval_to_body_uv_results(coco_eval):
  function _voc_eval_to_box_results (line 344) | def _voc_eval_to_box_results(voc_eval):
  function _cs_eval_to_mask_results (line 349) | def _cs_eval_to_mask_results(cs_eval):
  function _empty_box_results (line 354) | def _empty_box_results():
  function _empty_mask_results (line 370) | def _empty_mask_results():
  function _empty_keypoint_results (line 386) | def _empty_keypoint_results():
  function _empty_body_uv_results (line 401) | def _empty_body_uv_results():
  function _empty_box_proposal_results (line 416) | def _empty_box_proposal_results():

FILE: detectron/datasets/voc_dataset_evaluator.py
  function evaluate_boxes (line 29) | def evaluate_boxes(
  function _write_voc_results_files (line 49) | def _write_voc_results_files(json_dataset, all_boxes, salt):
  function _get_voc_results_file_template (line 86) | def _get_voc_results_file_template(json_dataset, salt):
  function _do_python_eval (line 96) | def _do_python_eval(json_dataset, salt, output_dir='output'):
  function _do_matlab_eval (line 137) | def _do_matlab_eval(json_dataset, salt, output_dir='output'):
  function voc_info (line 155) | def voc_info(json_dataset):

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

FILE: detectron/modeling/FPN.py
  function add_fpn_ResNet50_conv5_body (line 38) | def add_fpn_ResNet50_conv5_body(model):
  function add_fpn_ResNet50_conv5_P2only_body (line 44) | def add_fpn_ResNet50_conv5_P2only_body(model):
  function add_fpn_ResNet101_conv5_body (line 53) | def add_fpn_ResNet101_conv5_body(model):
  function add_fpn_ResNet101_conv5_P2only_body (line 59) | def add_fpn_ResNet101_conv5_P2only_body(model):
  function add_fpn_ResNet152_conv5_body (line 68) | def add_fpn_ResNet152_conv5_body(model):
  function add_fpn_ResNet152_conv5_P2only_body (line 74) | def add_fpn_ResNet152_conv5_P2only_body(model):
  function add_fpn_onto_conv_body (line 87) | def add_fpn_onto_conv_body(
  function add_fpn (line 109) | def add_fpn(model, fpn_level_info):
  function add_topdown_lateral_module (line 251) | def add_topdown_lateral_module(
  function get_min_max_levels (line 293) | def get_min_max_levels():
  function add_fpn_rpn_outputs (line 315) | def add_fpn_rpn_outputs(model, blobs_in, dim_in, spatial_scales):
  function add_fpn_rpn_losses (line 432) | def add_fpn_rpn_losses(model):
  function map_rois_to_fpn_levels (line 485) | def map_rois_to_fpn_levels(rois, k_min, k_max):
  function add_multilevel_roi_blobs (line 500) | def add_multilevel_roi_blobs(
  function fpn_level_info_ResNet50_conv5 (line 539) | def fpn_level_info_ResNet50_conv5():
  function fpn_level_info_ResNet101_conv5 (line 547) | def fpn_level_info_ResNet101_conv5():
  function fpn_level_info_ResNet152_conv5 (line 555) | def fpn_level_info_ResNet152_conv5():

FILE: detectron/modeling/ResNet.py
  function add_ResNet50_conv4_body (line 27) | def add_ResNet50_conv4_body(model):
  function add_ResNet50_conv5_body (line 31) | def add_ResNet50_conv5_body(model):
  function add_ResNet101_conv4_body (line 35) | def add_ResNet101_conv4_body(model):
  function add_ResNet101_conv5_body (line 39) | def add_ResNet101_conv5_body(model):
  function add_ResNet152_conv5_body (line 43) | def add_ResNet152_conv5_body(model):
  function add_stage (line 52) | def add_stage(
  function add_ResNet_convX_body (line 83) | def add_ResNet_convX_body(model, block_counts, freeze_at=2):
  function add_ResNet_roi_conv5_head (line 120) | def add_ResNet_roi_conv5_head(model, blob_in, dim_in, spatial_scale):
  function add_residual_block (line 144) | def add_residual_block(
  function basic_bn_shortcut (line 194) | def basic_bn_shortcut(model, prefix, blob_in, dim_in, dim_out, stride):
  function basic_gn_shortcut (line 214) | def basic_gn_shortcut(model, prefix, blob_in, dim_in, dim_out, stride):
  function basic_bn_stem (line 237) | def basic_bn_stem(model, data, **kwargs):
  function basic_gn_stem (line 250) | def basic_gn_stem(model, data, **kwargs):
  function bottleneck_transformation (line 267) | def bottleneck_transformation(
  function bottleneck_gn_transformation (line 327) | def bottleneck_gn_transformation(

FILE: detectron/modeling/VGG16.py
  function add_VGG16_conv5_body (line 18) | def add_VGG16_conv5_body(model):
  function add_VGG16_roi_fc_head (line 53) | 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 18) | def add_VGG_CNN_M_1024_conv5_body(model):
  function add_VGG_CNN_M_1024_roi_fc_head (line 39) | def add_VGG_CNN_M_1024_roi_fc_head(model, blob_in, dim_in, spatial_scale):

FILE: detectron/modeling/body_uv_rcnn_heads.py
  function add_body_uv_outputs (line 24) | def add_body_uv_outputs(model, blob_in, dim, pref=''):
  function add_body_uv_losses (line 54) | def add_body_uv_losses(model, pref=''):
  function add_ResNet_roi_conv5_head_for_bodyUV (line 158) | def add_ResNet_roi_conv5_head_for_bodyUV(
  function add_roi_body_uv_head_v1convX (line 186) | def add_roi_body_uv_head_v1convX(model, blob_in, dim_in, spatial_scale):

FILE: detectron/modeling/detector.py
  class DetectionModelHelper (line 35) | class DetectionModelHelper(cnn.CNNModelHelper):
    method __init__ (line 36) | def __init__(self, **kwargs):
    method TrainableParams (line 60) | def TrainableParams(self, gpu_id=-1):
    method AffineChannel (line 73) | def AffineChannel(self, blob_in, blob_out, dim, inplace=False):
    method GenerateProposals (line 99) | def GenerateProposals(self, blobs_in, blobs_out, anchors, spatial_scale):
    method GenerateProposalLabels (line 132) | def GenerateProposalLabels(self, blobs_in):
    method CollectAndDistributeFpnRpnProposals (line 164) | def CollectAndDistributeFpnRpnProposals(self):
    method DropoutIfTraining (line 220) | def DropoutIfTraining(self, blob_in, dropout_rate):
    method RoIFeatureTransform (line 230) | def RoIFeatureTransform(
    method ConvShared (line 295) | def ConvShared(
    method BilinearInterpolation (line 330) | def BilinearInterpolation(
    method ConvAffine (line 376) | def ConvAffine(  # args in the same order of Conv()
    method ConvGN (line 406) | def ConvGN(  # args in the same order of Conv()
    method DisableCudnn (line 448) | def DisableCudnn(self):
    method RestorePreviousUseCudnn (line 452) | def RestorePreviousUseCudnn(self):
    method UpdateWorkspaceLr (line 457) | def UpdateWorkspaceLr(self, cur_iter, new_lr):
    method _SetNewLr (line 475) | def _SetNewLr(self, cur_lr, new_lr):
    method _CorrectMomentum (line 487) | def _CorrectMomentum(self, correction):
    method GetLossScale (line 509) | def GetLossScale(self):
    method AddLosses (line 516) | def AddLosses(self, losses):
    method AddMetrics (line 523) | def AddMetrics(self, metrics):
  function _get_lr_change_ratio (line 529) | def _get_lr_change_ratio(cur_lr, new_lr):

FILE: detectron/modeling/fast_rcnn_heads.py
  function add_fast_rcnn_outputs (line 38) | def add_fast_rcnn_outputs(model, blob_in, dim):
  function add_fast_rcnn_losses (line 67) | def add_fast_rcnn_losses(model):
  function add_roi_2mlp_head (line 92) | def add_roi_2mlp_head(model, blob_in, dim_in, spatial_scale):
  function add_roi_Xconv1fc_head (line 112) | def add_roi_Xconv1fc_head(model, blob_in, dim_in, spatial_scale):
  function add_roi_Xconv1fc_gn_head (line 143) | def add_roi_Xconv1fc_gn_head(model, blob_in, dim_in, spatial_scale):

FILE: detectron/modeling/generate_anchors.py
  function generate_anchors (line 46) | def generate_anchors(
  function _generate_anchors (line 60) | def _generate_anchors(base_size, scales, aspect_ratios):
  function _whctrs (line 72) | def _whctrs(anchor):
  function _mkanchors (line 81) | def _mkanchors(ws, hs, x_ctr, y_ctr):
  function _ratio_enum (line 98) | def _ratio_enum(anchor, ratios):
  function _scale_enum (line 109) | def _scale_enum(anchor, scales):

FILE: detectron/modeling/keypoint_rcnn_heads.py
  function add_keypoint_outputs (line 38) | def add_keypoint_outputs(model, blob_in, dim):
  function add_keypoint_losses (line 102) | def add_keypoint_losses(model):
  function add_ResNet_roi_conv5_head_for_keypoints (line 148) | def add_ResNet_roi_conv5_head_for_keypoints(
  function add_roi_pose_head_v1convX (line 179) | 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 39) | def add_mask_rcnn_outputs(model, blob_in, dim):
  function add_mask_rcnn_losses (line 87) | def add_mask_rcnn_losses(model, blob_mask):
  function mask_rcnn_fcn_head_v1up4convs (line 103) | def mask_rcnn_fcn_head_v1up4convs(model, blob_in, dim_in, spatial_scale):
  function mask_rcnn_fcn_head_v1up4convs_gn (line 110) | def mask_rcnn_fcn_head_v1up4convs_gn(model, blob_in, dim_in, spatial_sca...
  function mask_rcnn_fcn_head_v1up (line 117) | def mask_rcnn_fcn_head_v1up(model, blob_in, dim_in, spatial_scale):
  function mask_rcnn_fcn_head_v1upXconvs (line 124) | def mask_rcnn_fcn_head_v1upXconvs(
  function mask_rcnn_fcn_head_v1upXconvs_gn (line 174) | def mask_rcnn_fcn_head_v1upXconvs_gn(
  function mask_rcnn_fcn_head_v0upshare (line 224) | def mask_rcnn_fcn_head_v0upshare(model, blob_in, dim_in, spatial_scale):
  function mask_rcnn_fcn_head_v0up (line 266) | def mask_rcnn_fcn_head_v0up(model, blob_in, dim_in, spatial_scale):
  function add_ResNet_roi_conv5_head_for_masks (line 293) | def add_ResNet_roi_conv5_head_for_masks(model, blob_in, dim_in, spatial_...

FILE: detectron/modeling/model_builder.py
  function generalized_rcnn (line 68) | def generalized_rcnn(model):
  function rfcn (line 88) | def rfcn(model):
  function retinanet (line 93) | def retinanet(model):
  function create (line 102) | def create(model_type_func, train=False, gpu_id=0):
  function get_func (line 122) | def get_func(func_name):
  function build_generic_detection_model (line 150) | def build_generic_detection_model(
  function _narrow_to_fpn_roi_levels (line 237) | def _narrow_to_fpn_roi_levels(blobs, spatial_scales):
  function _add_fast_rcnn_head (line 253) | def _add_fast_rcnn_head(
  function _add_roi_mask_head (line 268) | def _add_roi_mask_head(
  function _add_roi_keypoint_head (line 298) | def _add_roi_keypoint_head(
  function _add_roi_body_uv_head (line 328) | def _add_roi_body_uv_head(
  function build_generic_rfcn_model (line 358) | def build_generic_rfcn_model(model, add_conv_body_func, dim_reduce=None):
  function build_generic_retinanet_model (line 375) | def build_generic_retinanet_model(
  function add_training_inputs (line 402) | def add_training_inputs(model, roidb=None):
  function add_inference_inputs (line 440) | def add_inference_inputs(model):
  function fast_rcnn (line 475) | def fast_rcnn(model):
  function mask_rcnn (line 480) | def mask_rcnn(model):
  function keypoint_rcnn (line 488) | def keypoint_rcnn(model):
  function mask_and_keypoint_rcnn (line 496) | def mask_and_keypoint_rcnn(model):
  function rpn (line 504) | def rpn(model):
  function fpn_rpn (line 512) | def fpn_rpn(model):
  function faster_rcnn (line 520) | def faster_rcnn(model):
  function fast_rcnn_frozen_features (line 528) | def fast_rcnn_frozen_features(model):
  function rpn_frozen_features (line 538) | def rpn_frozen_features(model):
  function fpn_rpn_frozen_features (line 545) | def fpn_rpn_frozen_features(model):
  function mask_rcnn_frozen_features (line 552) | def mask_rcnn_frozen_features(model):
  function keypoint_rcnn_frozen_features (line 563) | def keypoint_rcnn_frozen_features(model):
  function VGG_CNN_M_1024_fast_rcnn (line 579) | def VGG_CNN_M_1024_fast_rcnn(model):
  function VGG16_fast_rcnn (line 586) | def VGG16_fast_rcnn(model):
  function ResNet50_fast_rcnn (line 592) | def ResNet50_fast_rcnn(model):
  function ResNet101_fast_rcnn (line 598) | def ResNet101_fast_rcnn(model):
  function ResNet50_fast_rcnn_frozen_features (line 604) | def ResNet50_fast_rcnn_frozen_features(model):
  function ResNet101_fast_rcnn_frozen_features (line 613) | def ResNet101_fast_rcnn_frozen_features(model):
  function VGG_CNN_M_1024_rpn (line 627) | def VGG_CNN_M_1024_rpn(model):
  function VGG16_rpn (line 633) | def VGG16_rpn(model):
  function ResNet50_rpn_conv4 (line 637) | def ResNet50_rpn_conv4(model):
  function ResNet101_rpn_conv4 (line 641) | def ResNet101_rpn_conv4(model):
  function VGG_CNN_M_1024_rpn_frozen_features (line 645) | def VGG_CNN_M_1024_rpn_frozen_features(model):
  function VGG16_rpn_frozen_features (line 653) | def VGG16_rpn_frozen_features(model):
  function ResNet50_rpn_conv4_frozen_features (line 659) | def ResNet50_rpn_conv4_frozen_features(model):
  function ResNet101_rpn_conv4_frozen_features (line 665) | def ResNet101_rpn_conv4_frozen_features(model):
  function VGG16_faster_rcnn (line 676) | def VGG16_faster_rcnn(model):
  function ResNet50_faster_rcnn (line 683) | def ResNet50_faster_rcnn(model):
  function ResNet101_faster_rcnn (line 690) | def ResNet101_faster_rcnn(model):
  function ResNet50_rfcn (line 702) | def ResNet50_rfcn(model):
  function ResNet101_rfcn (line 708) | def ResNet101_rfcn(model):

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

FILE: detectron/modeling/optimizer.py
  function build_data_parallel_model (line 25) | def build_data_parallel_model(model, single_gpu_build_func):
  function _build_forward_graph (line 49) | def _build_forward_graph(model, single_gpu_build_func):
  function _add_allreduce_graph (line 59) | def _add_allreduce_graph(model):
  function add_single_gpu_param_update_ops (line 82) | def add_single_gpu_param_update_ops(model, gpu_id):

FILE: detectron/modeling/retinanet_heads.py
  function get_retinanet_bias_init (line 21) | def get_retinanet_bias_init(model):
  function add_fpn_retinanet_outputs (line 55) | def add_fpn_retinanet_outputs(model, blobs_in, dim_in, spatial_scales):
  function add_fpn_retinanet_losses (line 240) | def add_fpn_retinanet_losses(model):

FILE: detectron/modeling/rfcn_heads.py
  function add_rfcn_outputs (line 22) | 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 25) | def add_generic_rpn_outputs(model, blob_in, dim_in, spatial_scale_in):
  function add_single_scale_rpn_outputs (line 47) | def add_single_scale_rpn_outputs(model, blob_in, dim_in, spatial_scale):
  function add_single_scale_rpn_losses (line 117) | def add_single_scale_rpn_losses(model):

FILE: detectron/ops/collect_and_distribute_fpn_rpn_proposals.py
  class CollectAndDistributeFpnRpnProposalsOp (line 23) | class CollectAndDistributeFpnRpnProposalsOp(object):
    method __init__ (line 24) | def __init__(self, train):
    method forward (line 27) | def forward(self, inputs, outputs):
  function collect (line 63) | def collect(inputs, is_training):
  function distribute (line 83) | def distribute(rois, label_blobs, outputs, train):

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

FILE: detectron/ops/generate_proposals.py
  class GenerateProposalsOp (line 25) | class GenerateProposalsOp(object):
    method __init__ (line 30) | def __init__(self, anchors, spatial_scale, train):
    method forward (line 36) | def forward(self, inputs, outputs):
    method proposals_for_one_image (line 101) | def proposals_for_one_image(
  function _filter_boxes (line 166) | def _filter_boxes(boxes, min_size, im_info):

FILE: detectron/ops/pool_points_interp.cc
  type caffe2 (line 12) | namespace caffe2 {
    class GetPoolPointsInterpGradient (line 26) | class GetPoolPointsInterpGradient : public GradientMakerBase {
      method GetGradientDefs (line 28) | vector<OperatorDef> GetGradientDefs() override {

FILE: detectron/ops/pool_points_interp.h
  function namespace (line 17) | namespace caffe2 {

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

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

FILE: detectron/roi_data/body_uv_rcnn.py
  function add_body_uv_rcnn_blobs (line 35) | def add_body_uv_rcnn_blobs(blobs, sampled_boxes, roidb, im_scale, batch_...

FILE: detectron/roi_data/data_utils.py
  function get_field_of_anchors (line 42) | def get_field_of_anchors(
  function unmap (line 96) | def unmap(data, count, inds, fill=0):
  function compute_targets (line 113) | 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 34) | def get_fast_rcnn_blob_names(is_training=True):
  function add_fast_rcnn_blobs (line 124) | def add_fast_rcnn_blobs(blobs, im_scales, roidb):
  function _sample_rois (line 148) | def _sample_rois(roidb, im_scale, batch_idx):
  function _expand_bbox_targets (line 231) | def _expand_bbox_targets(bbox_target_data):
  function _add_multilevel_rois (line 260) | def _add_multilevel_rois(blobs):

FILE: detectron/roi_data/keypoint_rcnn.py
  function add_keypoint_rcnn_blobs (line 29) | def add_keypoint_rcnn_blobs(
  function finalize_keypoint_minibatch (line 86) | def finalize_keypoint_minibatch(blobs, valid):
  function _within_box (line 106) | def _within_box(points, boxes):

FILE: detectron/roi_data/loader.py
  class RoIDataLoader (line 58) | class RoIDataLoader(object):
    method __init__ (line 59) | def __init__(
    method minibatch_loader_thread (line 89) | def minibatch_loader_thread(self):
    method enqueue_blobs_thread (line 107) | def enqueue_blobs_thread(self, gpu_id, blob_names):
    method get_next_minibatch (line 120) | def get_next_minibatch(self):
    method _shuffle_roidb_inds (line 129) | def _shuffle_roidb_inds(self):
    method _get_next_minibatch_inds (line 155) | def _get_next_minibatch_inds(self):
    method get_output_names (line 169) | def get_output_names(self):
    method enqueue_blobs (line 172) | def enqueue_blobs(self, gpu_id, blob_names, blobs):
    method create_threads (line 197) | def create_threads(self):
    method start (line 217) | def start(self, prefill=False):
    method shutdown (line 235) | def shutdown(self):
    method create_blobs_queues (line 242) | def create_blobs_queues(self):
    method close_blobs_queues (line 255) | def close_blobs_queues(self):
    method create_enqueue_blobs (line 265) | def create_enqueue_blobs(self):
    method register_sigint_handler (line 276) | def register_sigint_handler(self):

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

FILE: detectron/roi_data/minibatch.py
  function get_minibatch_blob_names (line 36) | def get_minibatch_blob_names(is_training=True):
  function get_minibatch (line 56) | def get_minibatch(roidb):
  function _get_image_blob (line 81) | def _get_image_blob(roidb):

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

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

FILE: detectron/tests/data_loader_benchmark.py
  function parse_args (line 43) | def parse_args():
  function loader_loop (line 72) | def loader_loop(roi_data_loader):
  function main (line 83) | def main(opts):

FILE: detectron/tests/test_batch_permutation_op.py
  class BatchPermutationOpTest (line 25) | class BatchPermutationOpTest(unittest.TestCase):
    method _run_op_test (line 26) | def _run_op_test(self, X, I, check_grad=False):
    method _run_speed_test (line 47) | def _run_speed_test(self, iters=5, N=1024):
    method test_forward_and_gradient (line 73) | def test_forward_and_gradient(self):
    method test_size_exceptions (line 86) | def test_size_exceptions(self):

FILE: detectron/tests/test_bbox_transform.py
  function random_boxes (line 21) | def random_boxes(mean_box, stdev, N):
  class TestBboxTransform (line 26) | class TestBboxTransform(unittest.TestCase):
    method test_bbox_transform_and_inverse (line 27) | def test_bbox_transform_and_inverse(self):
    method test_bbox_dataset_to_prediction_roundtrip (line 41) | def test_bbox_dataset_to_prediction_roundtrip(self):
    method test_cython_bbox_iou_against_coco_api_bbox_iou (line 69) | def test_cython_bbox_iou_against_coco_api_bbox_iou(self):

FILE: detectron/tests/test_cfg.py
  class TestAttrDict (line 24) | class TestAttrDict(unittest.TestCase):
    method test_immutability (line 25) | def test_immutability(self):
  class TestCfg (line 59) | class TestCfg(unittest.TestCase):
    method test_copy_cfg (line 60) | def test_copy_cfg(self):
    method test_merge_cfg_from_cfg (line 66) | def test_merge_cfg_from_cfg(self):
    method test_merge_cfg_from_file (line 112) | def test_merge_cfg_from_file(self):
    method test_merge_cfg_from_list (line 121) | def test_merge_cfg_from_list(self):
    method test_deprecated_key_from_list (line 136) | def test_deprecated_key_from_list(self):
    method test_deprecated_key_from_file (line 150) | def test_deprecated_key_from_file(self):
    method test_renamed_key_from_list (line 163) | def test_renamed_key_from_list(self):
    method test_renamed_key_from_file (line 173) | def test_renamed_key_from_file(self):

FILE: detectron/tests/test_loader.py
  function get_roidb_blobs (line 29) | def get_roidb_blobs(roidb):
  function get_net (line 35) | def get_net(data_loader, name):
  function get_roidb_sample_data (line 53) | def get_roidb_sample_data(sample_data):
  function create_loader_and_network (line 60) | def create_loader_and_network(sample_data, name):
  function run_net (line 69) | def run_net(net):
  class TestRoIDataLoader (line 79) | class TestRoIDataLoader(unittest.TestCase):
    method test_two_parallel_loaders (line 88) | def test_two_parallel_loaders(self, _1, _2):

FILE: detectron/tests/test_restore_checkpoint.py
  function get_params (line 33) | def get_params(model):
  function add_momentum_init_ops (line 52) | def add_momentum_init_ops(model):
  function init_weights (line 58) | def init_weights(model):
  function test_restore_checkpoint (line 64) | def test_restore_checkpoint():

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

FILE: detectron/tests/test_spatial_narrow_as_op.py
  class SpatialNarrowAsOpTest (line 25) | class SpatialNarrowAsOpTest(unittest.TestCase):
    method _run_test (line 26) | def _run_test(self, A, B, check_grad=False):
    method test_small_forward_and_gradient (line 48) | def test_small_forward_and_gradient(self):
    method test_large_forward (line 57) | def test_large_forward(self):
    method test_size_exceptions (line 66) | def test_size_exceptions(self):

FILE: detectron/tests/test_zero_even_op.py
  class ZeroEvenOpTest (line 23) | class ZeroEvenOpTest(unittest.TestCase):
    method _run_zero_even_op (line 25) | def _run_zero_even_op(self, X):
    method _run_zero_even_op_gpu (line 32) | def _run_zero_even_op_gpu(self, X):
    method test_throws_on_non_1D_arrays (line 40) | def test_throws_on_non_1D_arrays(self):
    method test_handles_empty_arrays (line 45) | def test_handles_empty_arrays(self):
    method test_sets_vals_at_even_inds_to_zero (line 51) | def test_sets_vals_at_even_inds_to_zero(self):
    method test_preserves_vals_at_odd_inds (line 57) | def test_preserves_vals_at_odd_inds(self):
    method test_handles_even_length_arrays (line 63) | def test_handles_even_length_arrays(self):
    method test_handles_odd_length_arrays (line 70) | def test_handles_odd_length_arrays(self):
    method test_gpu_throws_on_non_1D_arrays (line 77) | def test_gpu_throws_on_non_1D_arrays(self):
    method test_gpu_handles_empty_arrays (line 82) | def test_gpu_handles_empty_arrays(self):
    method test_gpu_sets_vals_at_even_inds_to_zero (line 88) | def test_gpu_sets_vals_at_even_inds_to_zero(self):
    method test_gpu_preserves_vals_at_odd_inds (line 94) | def test_gpu_preserves_vals_at_odd_inds(self):
    method test_gpu_handles_even_length_arrays (line 100) | def test_gpu_handles_even_length_arrays(self):
    method test_gpu_handles_odd_length_arrays (line 107) | def test_gpu_handles_odd_length_arrays(self):

FILE: detectron/utils/blob.py
  function get_image_blob (line 32) | def get_image_blob(im, target_scale, target_max_size):
  function im_list_to_blob (line 59) | def im_list_to_blob(ims):
  function prep_im_for_blob (line 92) | def prep_im_for_blob(im, pixel_means, target_size, max_size):
  function zeros (line 120) | def zeros(shape, int32=False):
  function ones (line 127) | def ones(shape, int32=False):
  function py_op_copy_blob (line 134) | def py_op_copy_blob(blob_in, blob_out):
  function get_loss_gradients (line 153) | def get_loss_gradients(model, loss_blobs):
  function serialize (line 162) | def serialize(obj):
  function deserialize (line 169) | def deserialize(arr):

FILE: detectron/utils/boxes.py
  function boxes_area (line 49) | def boxes_area(boxes):
  function unique_boxes (line 58) | def unique_boxes(boxes, scale=1.0):
  function xywh_to_xyxy (line 66) | def xywh_to_xyxy(xywh):
  function xyxy_to_xywh (line 84) | def xyxy_to_xywh(xyxy):
  function filter_small_boxes (line 100) | def filter_small_boxes(boxes, min_size):
  function clip_boxes_to_image (line 108) | def clip_boxes_to_image(boxes, height, width):
  function clip_xyxy_to_image (line 115) | def clip_xyxy_to_image(x1, y1, x2, y2, height, width):
  function clip_tiled_boxes (line 124) | def clip_tiled_boxes(boxes, im_shape):
  function bbox_transform (line 142) | def bbox_transform(boxes, deltas, weights=(1.0, 1.0, 1.0, 1.0)):
  function bbox_transform_inv (line 185) | def bbox_transform_inv(boxes, gt_boxes, weights=(1.0, 1.0, 1.0, 1.0)):
  function expand_boxes (line 219) | def expand_boxes(boxes, scale):
  function flip_boxes (line 238) | def flip_boxes(boxes, im_width):
  function aspect_ratio (line 246) | def aspect_ratio(boxes, aspect_ratio):
  function box_voting (line 254) | def box_voting(top_dets, all_dets, thresh, scoring_method='ID', beta=1.0):
  function nms (line 306) | def nms(dets, thresh):
  function soft_nms (line 313) | def soft_nms(

FILE: detectron/utils/c2.py
  function import_contrib_ops (line 26) | def import_contrib_ops():
  function import_detectron_ops (line 31) | def import_detectron_ops():
  function import_custom_ops (line 37) | def import_custom_ops():
  function SuffixNet (line 43) | def SuffixNet(name, net, prefix_len, outputs):
  function BlobReferenceList (line 72) | def BlobReferenceList(blob_ref_or_list):
  function UnscopeName (line 87) | def UnscopeName(possibly_scoped_name):
  function NamedCudaScope (line 96) | def NamedCudaScope(gpu_id):
  function GpuNameScope (line 105) | def GpuNameScope(gpu_id):
  function CudaScope (line 112) | def CudaScope(gpu_id):
  function CpuScope (line 120) | def CpuScope():
  function CudaDevice (line 127) | def CudaDevice(gpu_id):
  function gauss_fill (line 132) | def gauss_fill(std):
  function const_fill (line 137) | def const_fill(value):

FILE: detectron/utils/collections.py
  class AttrDict (line 16) | class AttrDict(dict):
    method __init__ (line 20) | def __init__(self, *args, **kwargs):
    method __getattr__ (line 24) | def __getattr__(self, name):
    method __setattr__ (line 32) | def __setattr__(self, name, value):
    method immutable (line 44) | def immutable(self, is_immutable):
    method is_immutable (line 57) | def is_immutable(self):

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

FILE: detectron/utils/coordinator.py
  class Coordinator (line 24) | class Coordinator(object):
    method __init__ (line 26) | def __init__(self):
    method request_stop (line 29) | def request_stop(self):
    method should_stop (line 33) | def should_stop(self):
    method wait_for_stop (line 36) | def wait_for_stop(self):
    method stop_on_exception (line 40) | def stop_on_exception(self):
  function coordinated_get (line 49) | def coordinated_get(coordinator, queue):
  function coordinated_put (line 58) | def coordinated_put(coordinator, queue, element):

FILE: detectron/utils/densepose_methods.py
  class DensePoseMethods (line 15) | class DensePoseMethods:
    method __init__ (line 16) | def __init__(self):
    method get_symmetric_densepose (line 31) | def get_symmetric_densepose(self,I,U,V,x,y,Mask):
    method barycentric_coordinates_exists (line 62) | def barycentric_coordinates_exists(self,P0, P1, P2, P):
    method barycentric_coordinates (line 84) | def barycentric_coordinates(self,P0, P1, P2, P):
    method IUV2FBC (line 101) | def IUV2FBC( self, I_point , U_point, V_point):
    method FBC2PointOnSurface (line 134) | def FBC2PointOnSurface( self, FaceIndex, bc1,bc2,bc3,Vertices ):

FILE: detectron/utils/env.py
  function get_runtime_dir (line 22) | def get_runtime_dir():
  function get_py_bin_ext (line 27) | def get_py_bin_ext():
  function set_up_matplotlib (line 32) | def set_up_matplotlib():
  function exit_on_error (line 39) | def exit_on_error():
  function import_nccl_ops (line 44) | def import_nccl_ops():
  function get_detectron_ops_lib (line 51) | def get_detectron_ops_lib():
  function get_custom_ops_lib (line 68) | def get_custom_ops_lib():

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

FILE: detectron/utils/io.py
  function save_object (line 26) | def save_object(obj, file_name):
  function cache_url (line 33) | def cache_url(url_or_file, cache_dir):
  function assert_cache_file_is_ok (line 63) | def assert_cache_file_is_ok(url, file_path):
  function _progress_bar (line 77) | def _progress_bar(count, total):
  function download_url (line 97) | def download_url(
  function _get_file_md5sum (line 122) | def _get_file_md5sum(file_name):
  function _get_reference_md5sum (line 130) | def _get_reference_md5sum(url):

FILE: detectron/utils/keypoints.py
  function get_keypoints (line 22) | def get_keypoints():
  function get_person_class_index (line 58) | def get_person_class_index():
  function flip_keypoints (line 63) | def flip_keypoints(keypoints, keypoint_flip_map, keypoint_coords, width):
  function flip_heatmaps (line 82) | def flip_heatmaps(heatmaps):
  function heatmaps_to_keypoints (line 95) | def heatmaps_to_keypoints(maps, rois):
  function keypoints_to_heatmap_labels (line 152) | def keypoints_to_heatmap_labels(keypoints, rois):
  function scores_to_probs (line 206) | def scores_to_probs(scores):
  function nms_oks (line 217) | def nms_oks(kp_predictions, rois, thresh):
  function compute_oks (line 235) | def compute_oks(src_keypoints, src_roi, dst_keypoints, dst_roi):

FILE: detectron/utils/logging.py
  function log_json_stats (line 27) | def log_json_stats(stats, sort_keys=True):
  class SmoothedValue (line 31) | class SmoothedValue(object):
    method __init__ (line 36) | def __init__(self, window_size):
    method AddValue (line 42) | def AddValue(self, value):
    method GetMedianValue (line 48) | def GetMedianValue(self):
    method GetAverageValue (line 51) | def GetAverageValue(self):
    method GetGlobalAverageValue (line 54) | def GetGlobalAverageValue(self):
  function send_email (line 58) | def send_email(subject, body, to):
  function setup_logging (line 66) | def setup_logging(name):

FILE: detectron/utils/lr_policy.py
  function get_lr_at_iter (line 20) | def get_lr_at_iter(it):
  function lr_func_steps_with_lrs (line 42) | def lr_func_steps_with_lrs(cur_iter):
  function lr_func_steps_with_decay (line 59) | def lr_func_steps_with_decay(cur_iter):
  function lr_func_step (line 78) | def lr_func_step(cur_iter):
  function get_step_index (line 90) | def get_step_index(cur_iter):
  function get_lr_func (line 100) | def get_lr_func():

FILE: detectron/utils/model_convert_utils.py
  class OpFilter (line 23) | class OpFilter(object):
    method __init__ (line 24) | def __init__(self, **kwargs):
    method check (line 37) | def check(self, op):
  function filter_op (line 56) | def filter_op(op, **kwargs):
  function op_filter (line 61) | def op_filter(**filter_args):
  function op_func_chain (line 73) | def op_func_chain(convert_func_list):
  function convert_op_in_ops (line 87) | def convert_op_in_ops(ops_ref, func_or_list):
  function convert_op_in_proto (line 104) | def convert_op_in_proto(proto, func_or_list):
  function get_op_arg (line 108) | def get_op_arg(op, arg_name):
  function get_op_arg_valf (line 115) | def get_op_arg_valf(op, arg_name, default_val):
  function update_mobile_engines (line 120) | def update_mobile_engines(net):
  function pairwise (line 128) | def pairwise(iterable):
  function blob_uses (line 136) | def blob_uses(net, blob):
  function fuse_first_affine (line 144) | def fuse_first_affine(net, params, removed_tensors):
  function fuse_affine (line 230) | def fuse_affine(net, params, ignore_failure):
  function fuse_net (line 247) | def fuse_net(fuse_func, net, blobs, ignore_failure=False):
  function fuse_net_affine (line 262) | def fuse_net_affine(net, blobs):
  function add_tensor (line 266) | def add_tensor(net, name, blob):
  function gen_init_net_from_blobs (line 299) | def gen_init_net_from_blobs(blobs, blobs_to_use=None, excluded_blobs=None):
  function get_ws_blobs (line 319) | def get_ws_blobs(blob_names=None):
  function get_device_option_cpu (line 330) | def get_device_option_cpu():
  function get_device_option_cuda (line 335) | def get_device_option_cuda(gpu_id=0):
  function create_input_blobs_for_net (line 342) | def create_input_blobs_for_net(net_def):
  function compare_model (line 349) | def compare_model(model1_func, model2_func, test_image, check_blobs):
  function save_graph (line 382) | def save_graph(net, file_name, graph_name="net", op_only=True):

FILE: detectron/utils/net.py
  function initialize_from_weights_file (line 34) | def initialize_from_weights_file(model, weights_file, broadcast=True):
  function initialize_gpu_from_weights_file (line 44) | def initialize_gpu_from_weights_file(model, weights_file, gpu_id=0):
  function save_model_to_weights_file (line 127) | def save_model_to_weights_file(weights_file, model):
  function broadcast_parameters (line 163) | def broadcast_parameters(model):
  function sum_multi_gpu_blob (line 189) | def sum_multi_gpu_blob(blob_name):
  function average_multi_gpu_blob (line 197) | def average_multi_gpu_blob(blob_name):
  function print_net (line 202) | def print_net(model, namescope='gpu_0'):
  function configure_bbox_reg_weights (line 248) | def configure_bbox_reg_weights(model, saved_cfg):
  function get_group_gn (line 273) | def get_group_gn(dim):

FILE: detectron/utils/segms.py
  function GetDensePoseMask (line 27) | def GetDensePoseMask(Polys):
  function flip_segms (line 36) | def flip_segms(segms, height, width):
  function polys_to_mask (line 65) | def polys_to_mask(polygons, height, width):
  function mask_to_bbox (line 79) | def mask_to_bbox(mask):
  function polys_to_mask_wrt_box (line 94) | def polys_to_mask_wrt_box(polygons, box, M):
  function polys_to_boxes (line 121) | def polys_to_boxes(polys):
  function rle_mask_voting (line 135) | def rle_mask_voting(
  function rle_mask_nms (line 199) | def rle_mask_nms(masks, dets, thresh, mode='IOU'):
  function rle_masks_to_boxes (line 244) | def rle_masks_to_boxes(masks):

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

FILE: detectron/utils/timer.py
  class Timer (line 26) | class Timer(object):
    method __init__ (line 29) | def __init__(self):
    method tic (line 32) | def tic(self):
    method toc (line 37) | def toc(self, average=True):
    method reset (line 47) | def reset(self):

FILE: detectron/utils/train.py
  function train_model (line 42) | def train_model():
  function create_model (line 88) | def create_model():
  function optimize_memory (line 132) | def optimize_memory(model):
  function setup_model_for_training (line 146) | def setup_model_for_training(model, weights_file, output_dir):
  function add_model_training_inputs (line 168) | def add_model_training_inputs(model):
  function dump_proto_files (line 179) | def dump_proto_files(model, output_dir):

FILE: detectron/utils/training_stats.py
  class TrainingStats (line 27) | class TrainingStats(object):
    method __init__ (line 30) | def __init__(self, model):
    method IterTic (line 49) | def IterTic(self):
    method IterToc (line 52) | def IterToc(self):
    method ResetIterTimer (line 55) | def ResetIterTimer(self):
    method UpdateIterStats (line 58) | def UpdateIterStats(self):
    method LogIterStats (line 75) | def LogIterStats(self, cur_iter, lr):
    method GetStats (line 82) | def GetStats(self, cur_iter, lr):

FILE: detectron/utils/vis.py
  function kp_connections (line 39) | def kp_connections(keypoints):
  function convert_from_cls_format (line 60) | def convert_from_cls_format(cls_boxes, cls_segms, cls_keyps):
  function get_class_string (line 83) | def get_class_string(class_index, score, dataset):
  function vis_mask (line 89) | def vis_mask(img, mask, col, alpha=0.4, show_border=True, border_thick=1):
  function vis_class (line 106) | def vis_class(img, pos, class_str, font_scale=0.35):
  function vis_bbox (line 123) | def vis_bbox(img, bbox, thick=1):
  function vis_keypoints (line 132) | def vis_keypoints(img, kps, kp_thresh=2, alpha=0.7):
  function vis_one_image_opencv (line 193) | def vis_one_image_opencv(
  function vis_one_image (line 243) | def vis_one_image(

FILE: tools/infer.py
  function parse_args (line 55) | def parse_args():
  function get_rpn_box_proposals (line 93) | def get_rpn_box_proposals(im, args):
  function main (line 108) | def main(args):
  function check_args (line 172) | def check_args(args):

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

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

FILE: tools/train_net.py
  function parse_args (line 42) | def parse_args():
  function main (line 77) | def main():
  function test_model (line 107) | def test_model(model_file, multi_gpu_testing, opts=None):

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