SYMBOL INDEX (2934 symbols across 398 files)

FILE: code/cocoapi/lvis/lvis/colormap.py
  function colormap (line 6) | def colormap(rgb=False):

FILE: code/cocoapi/lvis/lvis/eval.py
  class LVISEval (line 13) | class LVISEval:
    method __init__ (line 14) | def __init__(self, lvis_gt, lvis_dt, iou_type='segm'):
    method _to_mask (line 54) | def _to_mask(self, anns, lvis):
    method _prepare (line 59) | def _prepare(self):
    method _prepare_freq_group (line 110) | def _prepare_freq_group(self):
    method evaluate (line 118) | def evaluate(self):
    method _get_gt_dt (line 146) | def _get_gt_dt(self, img_id, cat_id):
    method compute_iou (line 165) | def compute_iou(self, img_id, cat_id):
    method evaluate_img (line 191) | def evaluate_img(self, img_id, cat_id, area_rng):
    method accumulate (line 288) | def accumulate(self):
    method _summarize (line 411) | def _summarize(self,
    method summarize (line 443) | def summarize(self):
    method run (line 467) | def run(self):
    method print_results (line 473) | def print_results(self):
    method get_results (line 506) | def get_results(self):
  class Params (line 512) | class Params:
    method __init__ (line 513) | def __init__(self, iou_type):

FILE: code/cocoapi/lvis/lvis/lvis.py
  class LVIS (line 18) | class LVIS:
    method __init__ (line 19) | def __init__(self, annotation_path):
    method _load_json (line 34) | def _load_json(self, path):
    method _create_index (line 38) | def _create_index(self):
    method get_ann_ids (line 63) | def get_ann_ids(self, img_ids=None, cat_ids=None, area_rng=None):
    method get_cat_ids (line 97) | def get_cat_ids(self):
    method get_img_ids (line 105) | def get_img_ids(self):
    method _load_helper (line 113) | def _load_helper(self, _dict, ids):
    method load_anns (line 119) | def load_anns(self, ids=None):
    method load_cats (line 130) | def load_cats(self, ids):
    method load_imgs (line 142) | def load_imgs(self, ids):
    method download (line 153) | def download(self, save_dir, img_ids=None):
    method ann_to_rle (line 169) | def ann_to_rle(self, ann):
    method ann_to_mask (line 193) | def ann_to_mask(self, ann):

FILE: code/cocoapi/lvis/lvis/results.py
  class LVISResults (line 10) | class LVISResults(LVIS):
    method __init__ (line 11) | def __init__(self, lvis_gt, results, max_dets=300):
    method limit_dets_per_image (line 75) | def limit_dets_per_image(self, anns, max_dets):
    method get_top_results (line 88) | def get_top_results(self, img_id, score_thrs):

FILE: code/cocoapi/lvis/lvis/vis.py
  class LVISVis (line 14) | class LVISVis:
    method __init__ (line 15) | def __init__(self, lvis_gt, lvis_dt=None, img_dir=None, dpi=75):
    method coco_segm_to_poly (line 53) | def coco_segm_to_poly(self, _list):
    method get_synset (line 59) | def get_synset(self, idx):
    method setup_figure (line 65) | def setup_figure(self, img, title='', dpi=75):
    method vis_bbox (line 75) | def vis_bbox(self, ax, bbox, box_alpha=0.5, edgecolor='g', linestyle='...
    method vis_text (line 89) | def vis_text(self, ax, bbox, text, color='w'):
    method vis_mask (line 101) | def vis_mask(self, ax, segm, color):
    method get_color (line 111) | def get_color(self, idx):
    method load_img (line 115) | def load_img(self, img_id):
    method vis_img (line 124) | def vis_img(self,
    method vis_result (line 162) | def vis_result(self,

FILE: code/cocoapi/pycocotools/common/gason.cpp
  function isspace (line 52) | static inline bool isspace(char c) {
  function isdelim (line 56) | static inline bool isdelim(char c) {
  function isdigit (line 60) | static inline bool isdigit(char c) {
  function isxdigit (line 64) | static inline bool isxdigit(char c) {
  function char2int (line 68) | static inline int char2int(char c) {
  function string2double (line 74) | static double string2double(char *s, char **endptr) {
  function JsonNode (line 120) | static inline JsonNode *insertAfter(JsonNode *tail, JsonNode *node) {
  function JsonValue (line 128) | static inline JsonValue listToValue(JsonTag tag, JsonNode *tail) {
  function jsonParse (line 137) | int jsonParse(char *s, char **endptr, JsonValue *value, JsonAllocator &a...

FILE: code/cocoapi/pycocotools/common/gason.h
  type JsonTag (line 8) | enum JsonTag {
  type JsonNode (line 18) | struct JsonNode
  function JsonNode (line 54) | JsonNode *toNode() const {
  type JsonNode (line 60) | struct JsonNode {
  type JsonIterator (line 66) | struct JsonIterator {
  function JsonIterator (line 86) | inline JsonIterator end(JsonValue) {

FILE: code/cocoapi/pycocotools/common/maskApi.c
  function uint (line 11) | uint umin( uint a, uint b ) { return (a<b) ? a : b; }
  function uint (line 12) | uint umax( uint a, uint b ) { return (a>b) ? a : b; }
  function rleInit (line 14) | void rleInit( RLE *R, siz h, siz w, siz m, uint *cnts ) {
  function rleFree (line 19) | void rleFree( RLE *R ) {
  function rlesInit (line 23) | void rlesInit( RLE **R, siz n ) {
  function rlesFree (line 28) | void rlesFree( RLE **R, siz n ) {
  function rleEncode (line 32) | void rleEncode( RLE *R, const byte *M, siz h, siz w, siz n ) {
  function rleDecode (line 43) | void rleDecode( const RLE *R, byte *M, siz n ) {
  function rleMerge (line 49) | void rleMerge( const RLE *R, RLE *M, siz n, int intersect ) {
  function rleArea (line 72) | void rleArea( const RLE *R, siz n, uint *a ) {
  function rleIou (line 77) | void rleIou( RLE *dt, RLE *gt, siz m, siz n, byte *iscrowd, double *o ) {
  function rleNms (line 98) | void rleNms( RLE *dt, siz n, uint *keep, double thr ) {
  function bbIou (line 109) | void bbIou( BB dt, BB gt, siz m, siz n, byte *iscrowd, double *o ) {
  function bbNms (line 122) | void bbNms( BB dt, siz n, uint *keep, double thr ) {
  function rleToBbox (line 133) | void rleToBbox( const RLE *R, BB bb, siz n ) {
  function rleFrBbox (line 149) | void rleFrBbox( RLE *R, const BB bb, siz h, siz w, siz n ) {
  function uintCompare (line 158) | int uintCompare(const void *a, const void *b) {
  function rleFrPoly (line 162) | void rleFrPoly( RLE *R, const double *xy, siz k, siz h, siz w ) {
  function rleFrString (line 218) | void rleFrString( RLE *R, char *s, siz h, siz w ) {

FILE: code/cocoapi/pycocotools/common/maskApi.h
  type uint (line 9) | typedef unsigned int uint;
  type siz (line 10) | typedef unsigned long siz;
  type byte (line 11) | typedef unsigned char byte;
  type RLE (line 13) | typedef struct { siz h, w, m; uint *cnts; } RLE;

FILE: code/cocoapi/pycocotools/pycocotools/coco.py
  function _isArrayLike (line 64) | def _isArrayLike(obj):
  class COCO (line 68) | class COCO:
    method __init__ (line 69) | def __init__(self, annotation_file=None):
    method createIndex (line 96) | def createIndex(self):
    method info (line 127) | def info(self):
    method getAnnIds (line 135) | def getAnnIds(self, imgIds=[], catIds=[], areaRng=[], iscrowd=None):
    method get_ann_ids (line 174) | def get_ann_ids(self, img_ids=[], cat_ids=[], area_rng=[], iscrowd=None):
    method getCatIds (line 177) | def getCatIds(self, catNms=[], supNms=[], catIds=[]):
    method get_cat_ids (line 205) | def get_cat_ids(self, cat_names=[], sup_names=[], cat_ids=[]):
    method getImgIds (line 208) | def getImgIds(self, imgIds=[], catIds=[]):
    method get_img_ids (line 229) | def get_img_ids(self, img_ids=[], cat_ids=[]):
    method loadAnns (line 232) | def loadAnns(self, ids=[]):
    method loadCats (line 245) | def loadCats(self, ids=[]):
    method loadImgs (line 258) | def loadImgs(self, ids=[]):
    method showAnns (line 271) | def showAnns(self, anns, draw_bbox=False):
    method loadRes (line 367) | def loadRes(self, resFile):
    method download (line 436) | def download(self, tarDir=None, imgIds=[]):
    method loadNumpyAnnotations (line 462) | def loadNumpyAnnotations(self, data):
    method annToRLE (line 486) | def annToRLE(self, ann):
    method annToMask (line 509) | def annToMask(self, ann):

FILE: code/cocoapi/pycocotools/pycocotools/cocoeval.py
  class COCOeval (line 13) | class COCOeval:
    method __init__ (line 63) | def __init__(self, cocoGt=None, cocoDt=None, iouType='segm'):
    method _prepare (line 87) | def _prepare(self):
    method evaluate (line 128) | def evaluate(self):
    method computeIoU (line 170) | def computeIoU(self, imgId, catId):
    method computeOks (line 199) | def computeOks(self, imgId, catId):
    method evaluateImg (line 250) | def evaluateImg(self, imgId, catId, aRng, maxDet):
    method accumulate (line 334) | def accumulate(self, p=None):
    method summarize (line 456) | def summarize(self):
    method __str__ (line 551) | def __str__(self):
  class Params (line 555) | class Params:
    method setDetParams (line 559) | def setDetParams(self):
    method setKpParams (line 578) | def setKpParams(self):
    method __init__ (line 600) | def __init__(self, iouType='segm'):

FILE: code/cocoapi/pycocotools/pycocotools/mask.py
  function encode (line 84) | def encode(bimask):
  function decode (line 92) | def decode(rleObjs):
  function area (line 99) | def area(rleObjs):
  function toBbox (line 106) | def toBbox(rleObjs):

FILE: code/mmcv/examples/resnet_cifar.py
  class BasicBlock (line 8) | class BasicBlock(nn.Module):
    method __init__ (line 11) | def __init__(self, in_planes, planes, stride=1):
    method forward (line 35) | def forward(self, x):
  class Bottleneck (line 43) | class Bottleneck(nn.Module):
    method __init__ (line 46) | def __init__(self, in_planes, planes, stride=1):
    method forward (line 72) | def forward(self, x):
  class ResNet (line 81) | class ResNet(nn.Module):
    method __init__ (line 83) | def __init__(self, block, num_blocks, num_classes=10):
    method _make_layer (line 96) | def _make_layer(self, block, planes, num_blocks, stride):
    method forward (line 104) | def forward(self, x):
  function resnet18 (line 116) | def resnet18():
  function resnet34 (line 120) | def resnet34():
  function resnet50 (line 124) | def resnet50():
  function resnet101 (line 128) | def resnet101():
  function resnet152 (line 132) | def resnet152():

FILE: code/mmcv/examples/train_cifar10.py
  function accuracy (line 20) | def accuracy(output, target, topk=(1, )):
  function batch_processor (line 37) | def batch_processor(model, data, train_mode):
  function get_logger (line 51) | def get_logger(log_level):
  function init_dist (line 58) | def init_dist(backend='nccl', **kwargs):
  function parse_args (line 67) | def parse_args():
  function main (line 79) | def main():

FILE: code/mmcv/mmcv/arraymisc/quantization.py
  function quantize (line 5) | def quantize(arr, min_val, max_val, levels, dtype=np.int64):
  function dequantize (line 32) | def dequantize(arr, min_val, max_val, levels, dtype=np.float64):

FILE: code/mmcv/mmcv/cnn/alexnet.py
  class AlexNet (line 9) | class AlexNet(nn.Module):
    method __init__ (line 16) | def __init__(self, num_classes=-1):
    method init_weights (line 45) | def init_weights(self, pretrained=None):
    method forward (line 55) | def forward(self, x):

FILE: code/mmcv/mmcv/cnn/bricks/activation.py
  function build_activation_layer (line 13) | def build_activation_layer(cfg):

FILE: code/mmcv/mmcv/cnn/bricks/conv.py
  function build_conv_layer (line 11) | def build_conv_layer(cfg, *args, **kwargs):

FILE: code/mmcv/mmcv/cnn/bricks/conv_module.py
  class ConvModule (line 12) | class ConvModule(nn.Module):
    method __init__ (line 57) | def __init__(self,
    method norm (line 151) | def norm(self):
    method init_weights (line 154) | def init_weights(self):
    method forward (line 174) | def forward(self, x, activate=True, norm=True):

FILE: code/mmcv/mmcv/cnn/bricks/hsigmoid.py
  class HSigmoid (line 7) | class HSigmoid(nn.Module):
    method __init__ (line 15) | def __init__(self):
    method forward (line 18) | def forward(self, x):

FILE: code/mmcv/mmcv/cnn/bricks/hswish.py
  class HSwish (line 7) | class HSwish(nn.Module):
    method __init__ (line 19) | def __init__(self, inplace=False):
    method forward (line 23) | def forward(self, x):

FILE: code/mmcv/mmcv/cnn/bricks/non_local.py
  class _NonLocalNd (line 10) | class _NonLocalNd(nn.Module, metaclass=ABCMeta):
    method __init__ (line 32) | def __init__(self,
    method init_weights (line 82) | def init_weights(self, std=0.01, zeros_init=True):
    method embedded_gaussian (line 96) | def embedded_gaussian(self, theta_x, phi_x):
    method dot_product (line 107) | def dot_product(self, theta_x, phi_x):
    method forward (line 115) | def forward(self, x):
  class NonLocal1d (line 160) | class NonLocal1d(_NonLocalNd):
    method __init__ (line 172) | def __init__(self,
  class NonLocal2d (line 188) | class NonLocal2d(_NonLocalNd):
    method __init__ (line 200) | def __init__(self,
  class NonLocal3d (line 216) | class NonLocal3d(_NonLocalNd):
    method __init__ (line 228) | def __init__(self,

FILE: code/mmcv/mmcv/cnn/bricks/norm.py
  function infer_abbr (line 22) | def infer_abbr(class_type):
  function build_norm_layer (line 71) | def build_norm_layer(cfg, num_features, postfix=''):
  function is_norm (line 121) | def is_norm(layer, exclude=None):

FILE: code/mmcv/mmcv/cnn/bricks/padding.py
  function build_padding_layer (line 10) | def build_padding_layer(cfg, *args, **kwargs):

FILE: code/mmcv/mmcv/cnn/bricks/scale.py
  class Scale (line 5) | class Scale(nn.Module):
    method __init__ (line 15) | def __init__(self, scale=1.0):
    method forward (line 19) | def forward(self, x):

FILE: code/mmcv/mmcv/cnn/bricks/upsample.py
  class PixelShufflePack (line 13) | class PixelShufflePack(nn.Module):
    method __init__ (line 27) | def __init__(self, in_channels, out_channels, scale_factor,
    method init_weights (line 41) | def init_weights(self):
    method forward (line 44) | def forward(self, x):
  function build_upsample_layer (line 50) | def build_upsample_layer(cfg, *args, **kwargs):

FILE: code/mmcv/mmcv/cnn/resnet.py
  function conv3x3 (line 11) | def conv3x3(in_planes, out_planes, stride=1, dilation=1):
  class BasicBlock (line 23) | class BasicBlock(nn.Module):
    method __init__ (line 26) | def __init__(self,
    method forward (line 46) | def forward(self, x):
  class Bottleneck (line 65) | class Bottleneck(nn.Module):
    method __init__ (line 68) | def __init__(self,
    method forward (line 111) | def forward(self, x):
  function make_res_layer (line 144) | def make_res_layer(block,
  class ResNet (line 182) | class ResNet(nn.Module):
    method __init__ (line 211) | def __init__(self,
    method init_weights (line 266) | def init_weights(self, pretrained=None):
    method forward (line 279) | def forward(self, x):
    method train (line 295) | def train(self, mode=True):

FILE: code/mmcv/mmcv/cnn/utils/flops_counter.py
  function get_model_complexity_info (line 34) | def get_model_complexity_info(model,
  function flops_to_string (line 114) | def flops_to_string(flops, units='GFLOPs', precision=2):
  function params_to_string (line 157) | def params_to_string(num_params, units=None, precision=2):
  function print_model_with_flops (line 194) | def print_model_with_flops(model,
  function get_model_parameters_number (line 303) | def get_model_parameters_number(model):
  function add_flops_counting_methods (line 316) | def add_flops_counting_methods(net_main_module):
  function compute_average_flops_cost (line 333) | def compute_average_flops_cost(self):
  function start_flops_count (line 351) | def start_flops_count(self):
  function stop_flops_count (line 374) | def stop_flops_count(self):
  function reset_flops_count (line 385) | def reset_flops_count(self):
  function empty_flops_counter_hook (line 396) | def empty_flops_counter_hook(module, input, output):
  function upsample_flops_counter_hook (line 400) | def upsample_flops_counter_hook(module, input, output):
  function relu_flops_counter_hook (line 409) | def relu_flops_counter_hook(module, input, output):
  function linear_flops_counter_hook (line 414) | def linear_flops_counter_hook(module, input, output):
  function pool_flops_counter_hook (line 421) | def pool_flops_counter_hook(module, input, output):
  function bn_flops_counter_hook (line 426) | def bn_flops_counter_hook(module, input, output):
  function deconv_flops_counter_hook (line 435) | def deconv_flops_counter_hook(conv_module, input, output):
  function conv_flops_counter_hook (line 462) | def conv_flops_counter_hook(conv_module, input, output):
  function batch_counter_hook (line 493) | def batch_counter_hook(module, input, output):
  function add_batch_counter_variables_or_reset (line 506) | def add_batch_counter_variables_or_reset(module):
  function add_batch_counter_hook_function (line 511) | def add_batch_counter_hook_function(module):
  function remove_batch_counter_hook_function (line 519) | def remove_batch_counter_hook_function(module):
  function add_flops_counter_variable_or_reset (line 525) | def add_flops_counter_variable_or_reset(module):
  function is_supported_instance (line 535) | def is_supported_instance(module):
  function remove_flops_counter_hook_function (line 541) | def remove_flops_counter_hook_function(module):

FILE: code/mmcv/mmcv/cnn/utils/weight_init.py
  function constant_init (line 6) | def constant_init(module, val, bias=0):
  function xavier_init (line 13) | def xavier_init(module, gain=1, bias=0, distribution='normal'):
  function normal_init (line 23) | def normal_init(module, mean=0, std=1, bias=0):
  function uniform_init (line 29) | def uniform_init(module, a=0, b=1, bias=0):
  function kaiming_init (line 35) | def kaiming_init(module,
  function caffe2_xavier_init (line 52) | def caffe2_xavier_init(module, bias=0):
  function bias_init_with_prob (line 63) | def bias_init_with_prob(prior_prob):

FILE: code/mmcv/mmcv/cnn/vgg.py
  function conv3x3 (line 10) | def conv3x3(in_planes, out_planes, dilation=1):
  function make_vgg_layer (line 20) | def make_vgg_layer(inplanes,
  class VGG (line 38) | class VGG(nn.Module):
    method __init__ (line 62) | def __init__(self,
    method init_weights (line 126) | def init_weights(self, pretrained=None):
    method forward (line 141) | def forward(self, x):
    method train (line 159) | def train(self, mode=True):

FILE: code/mmcv/mmcv/fileio/file_client.py
  class BaseStorageBackend (line 6) | class BaseStorageBackend(metaclass=ABCMeta):
    method get (line 15) | def get(self, filepath):
    method get_text (line 19) | def get_text(self, filepath):
  class CephBackend (line 23) | class CephBackend(BaseStorageBackend):
    method __init__ (line 32) | def __init__(self, path_mapping=None):
    method get (line 43) | def get(self, filepath):
    method get_text (line 52) | def get_text(self, filepath):
  class PetrelBackend (line 56) | class PetrelBackend(BaseStorageBackend):
    method __init__ (line 66) | def __init__(self, path_mapping=None, enable_mc=True):
    method get (line 77) | def get(self, filepath):
    method get_text (line 86) | def get_text(self, filepath):
  class MemcachedBackend (line 90) | class MemcachedBackend(BaseStorageBackend):
    method __init__ (line 100) | def __init__(self, server_list_cfg, client_cfg, sys_path=None):
    method get (line 117) | def get(self, filepath):
    method get_text (line 124) | def get_text(self, filepath):
  class LmdbBackend (line 128) | class LmdbBackend(BaseStorageBackend):
    method __init__ (line 146) | def __init__(self,
    method get (line 165) | def get(self, filepath):
    method get_text (line 176) | def get_text(self, filepath):
  class HardDiskBackend (line 180) | class HardDiskBackend(BaseStorageBackend):
    method get (line 183) | def get(self, filepath):
    method get_text (line 189) | def get_text(self, filepath):
  class FileClient (line 196) | class FileClient:
    method __init__ (line 217) | def __init__(self, backend='disk', **kwargs):
    method _register_backend (line 226) | def _register_backend(cls, name, backend, force=False):
    method register_backend (line 244) | def register_backend(cls, name, backend=None, force=False):
    method get (line 293) | def get(self, filepath):
    method get_text (line 296) | def get_text(self, filepath):

FILE: code/mmcv/mmcv/fileio/handlers/base.py
  class BaseFileHandler (line 5) | class BaseFileHandler(metaclass=ABCMeta):
    method load_from_fileobj (line 8) | def load_from_fileobj(self, file, **kwargs):
    method dump_to_fileobj (line 12) | def dump_to_fileobj(self, obj, file, **kwargs):
    method dump_to_str (line 16) | def dump_to_str(self, obj, **kwargs):
    method load_from_path (line 19) | def load_from_path(self, filepath, mode='r', **kwargs):
    method dump_to_path (line 23) | def dump_to_path(self, obj, filepath, mode='w', **kwargs):

FILE: code/mmcv/mmcv/fileio/handlers/json_handler.py
  class JsonHandler (line 7) | class JsonHandler(BaseFileHandler):
    method load_from_fileobj (line 9) | def load_from_fileobj(self, file):
    method dump_to_fileobj (line 12) | def dump_to_fileobj(self, obj, file, **kwargs):
    method dump_to_str (line 15) | def dump_to_str(self, obj, **kwargs):

FILE: code/mmcv/mmcv/fileio/handlers/pickle_handler.py
  class PickleHandler (line 7) | class PickleHandler(BaseFileHandler):
    method load_from_fileobj (line 9) | def load_from_fileobj(self, file, **kwargs):
    method load_from_path (line 12) | def load_from_path(self, filepath, **kwargs):
    method dump_to_str (line 16) | def dump_to_str(self, obj, **kwargs):
    method dump_to_fileobj (line 20) | def dump_to_fileobj(self, obj, file, **kwargs):
    method dump_to_path (line 24) | def dump_to_path(self, obj, filepath, **kwargs):

FILE: code/mmcv/mmcv/fileio/handlers/yaml_handler.py
  class YamlHandler (line 12) | class YamlHandler(BaseFileHandler):
    method load_from_fileobj (line 14) | def load_from_fileobj(self, file, **kwargs):
    method dump_to_fileobj (line 18) | def dump_to_fileobj(self, obj, file, **kwargs):
    method dump_to_str (line 22) | def dump_to_str(self, obj, **kwargs):

FILE: code/mmcv/mmcv/fileio/io.py
  function load (line 16) | def load(file, file_format=None, **kwargs):
  function dump (line 49) | def dump(obj, file=None, file_format=None, **kwargs):
  function _register_handler (line 87) | def _register_handler(handler, file_formats):
  function register_handler (line 106) | def register_handler(file_formats, **kwargs):

FILE: code/mmcv/mmcv/fileio/parse.py
  function list_from_file (line 2) | def list_from_file(filename, prefix='', offset=0, max_num=0):
  function dict_from_file (line 28) | def dict_from_file(filename, key_type=str):

FILE: code/mmcv/mmcv/image/colorspace.py
  function imconvert (line 6) | def imconvert(img, src, dst):
  function bgr2gray (line 22) | def bgr2gray(img, keepdim=False):
  function rgb2gray (line 39) | def rgb2gray(img, keepdim=False):
  function gray2bgr (line 56) | def gray2bgr(img):
  function gray2rgb (line 70) | def gray2rgb(img):
  function _convert_input_type_range (line 84) | def _convert_input_type_range(img):
  function _convert_output_type_range (line 112) | def _convert_output_type_range(img, dst_type):
  function rgb2ycbcr (line 143) | def rgb2ycbcr(img, y_only=False):
  function bgr2ycbcr (line 177) | def bgr2ycbcr(img, y_only=False):
  function ycbcr2rgb (line 211) | def ycbcr2rgb(img):
  function ycbcr2bgr (line 243) | def ycbcr2bgr(img):
  function convert_color_factory (line 275) | def convert_color_factory(src, dst):

FILE: code/mmcv/mmcv/image/geometric.py
  function _scale_size (line 6) | def _scale_size(size, scale):
  function imresize (line 29) | def imresize(img,
  function imresize_like (line 59) | def imresize_like(img, dst_img, return_scale=False, interpolation='bilin...
  function rescale_size (line 76) | def rescale_size(old_size, scale, return_scale=False):
  function imrescale (line 113) | def imrescale(img, scale, return_scale=False, interpolation='bilinear'):
  function imflip (line 138) | def imflip(img, direction='horizontal'):
  function imflip_ (line 155) | def imflip_(img, direction='horizontal'):
  function imrotate (line 172) | def imrotate(img,
  function bbox_clip (line 216) | def bbox_clip(bboxes, img_shape):
  function bbox_scaling (line 234) | def bbox_scaling(bboxes, scale, clip_shape=None):
  function imcrop (line 260) | def imcrop(img, bboxes, scale=1.0, pad_fill=None):
  function impad (line 314) | def impad(img, shape, pad_val=0):
  function impad_to_multiple (line 339) | def impad_to_multiple(img, divisor, pad_val=0):

FILE: code/mmcv/mmcv/image/io.py
  function use_backend (line 34) | def use_backend(backend):
  function _jpegflag (line 56) | def _jpegflag(flag='color', channel_order='bgr'):
  function _pillow2array (line 72) | def _pillow2array(img, flag='color', channel_order='bgr'):
  function imread (line 123) | def imread(img_or_path, flag='color', channel_order='bgr', backend=None):
  function imfrombytes (line 178) | def imfrombytes(content, flag='color', channel_order='bgr', backend=None):
  function imwrite (line 217) | def imwrite(img, file_path, params=None, auto_mkdir=True):

FILE: code/mmcv/mmcv/image/photometric.py
  function imnormalize (line 5) | def imnormalize(img, mean, std, to_rgb=True):
  function imnormalize_ (line 21) | def imnormalize_(img, mean, std, to_rgb=True):
  function imdenormalize (line 44) | def imdenormalize(img, mean, std, to_bgr=True):
  function iminvert (line 55) | def iminvert(img):
  function solarize (line 67) | def solarize(img, thr=128):
  function posterize (line 81) | def posterize(img, bits):

FILE: code/mmcv/mmcv/parallel/_functions.py
  function scatter (line 6) | def scatter(input, devices, streams=None):
  function synchronize_stream (line 30) | def synchronize_stream(output, devices, streams):
  function get_input_device (line 47) | def get_input_device(input):
  class Scatter (line 60) | class Scatter:
    method forward (line 63) | def forward(target_gpus, input):

FILE: code/mmcv/mmcv/parallel/collate.py
  function collate (line 11) | def collate(batch, samples_per_gpu=1):

FILE: code/mmcv/mmcv/parallel/data_container.py
  function assert_tensor_type (line 7) | def assert_tensor_type(func):
  class DataContainer (line 20) | class DataContainer:
    method __init__ (line 37) | def __init__(self,
    method __repr__ (line 50) | def __repr__(self):
    method __len__ (line 53) | def __len__(self):
    method data (line 57) | def data(self):
    method datatype (line 61) | def datatype(self):
    method cpu_only (line 68) | def cpu_only(self):
    method stack (line 72) | def stack(self):
    method padding_value (line 76) | def padding_value(self):
    method pad_dims (line 80) | def pad_dims(self):
    method size (line 84) | def size(self, *args, **kwargs):
    method dim (line 88) | def dim(self):

FILE: code/mmcv/mmcv/parallel/data_parallel.py
  class MMDataParallel (line 9) | class MMDataParallel(DataParallel):
    method scatter (line 11) | def scatter(self, inputs, kwargs, device_ids):
    method train_step (line 14) | def train_step(self, *inputs, **kwargs):
    method val_step (line 33) | def val_step(self, *inputs, **kwargs):

FILE: code/mmcv/mmcv/parallel/distributed.py
  class MMDistributedDataParallel (line 10) | class MMDistributedDataParallel(DistributedDataParallel):
    method scatter (line 20) | def scatter(self, inputs, kwargs, device_ids):
    method train_step (line 23) | def train_step(self, *inputs, **kwargs):
    method val_step (line 55) | def val_step(self, *inputs, **kwargs):

FILE: code/mmcv/mmcv/parallel/distributed_deprecated.py
  class MMDistributedDataParallel (line 14) | class MMDistributedDataParallel(nn.Module):
    method __init__ (line 16) | def __init__(self,
    method _dist_broadcast_coalesced (line 29) | def _dist_broadcast_coalesced(self, tensors, buffer_size):
    method _sync_params (line 37) | def _sync_params(self):
    method scatter (line 51) | def scatter(self, inputs, kwargs, device_ids):
    method forward (line 54) | def forward(self, *inputs, **kwargs):
    method train_step (line 59) | def train_step(self, *inputs, **kwargs):
    method val_step (line 65) | def val_step(self, *inputs, **kwargs):

FILE: code/mmcv/mmcv/parallel/scatter_gather.py
  function scatter (line 9) | def scatter(inputs, target_gpus, dim=0):
  function scatter_kwargs (line 45) | def scatter_kwargs(inputs, kwargs, target_gpus, dim=0):

FILE: code/mmcv/mmcv/parallel/utils.py
  function is_module_wrapper (line 5) | def is_module_wrapper(module):

FILE: code/mmcv/mmcv/runner/base_runner.py
  class BaseRunner (line 20) | class BaseRunner(metaclass=ABCMeta):
    method __init__ (line 48) | def __init__(self,
    method model_name (line 130) | def model_name(self):
    method rank (line 135) | def rank(self):
    method world_size (line 140) | def world_size(self):
    method hooks (line 146) | def hooks(self):
    method epoch (line 151) | def epoch(self):
    method iter (line 156) | def iter(self):
    method inner_iter (line 161) | def inner_iter(self):
    method max_epochs (line 166) | def max_epochs(self):
    method max_iters (line 171) | def max_iters(self):
    method train (line 176) | def train(self):
    method val (line 180) | def val(self):
    method run (line 184) | def run(self, data_loaders, workflow, **kwargs):
    method save_checkpoint (line 188) | def save_checkpoint(self,
    method current_lr (line 196) | def current_lr(self):
    method current_momentum (line 215) | def current_momentum(self):
    method register_hook (line 246) | def register_hook(self, hook, priority='NORMAL'):
    method call_hook (line 274) | def call_hook(self, fn_name):
    method load_checkpoint (line 284) | def load_checkpoint(self, filename, map_location='cpu', strict=False):
    method resume (line 289) | def resume(self,
    method register_lr_hook (line 309) | def register_lr_hook(self, lr_config):
    method register_momentum_hook (line 327) | def register_momentum_hook(self, momentum_config):
    method register_optimizer_hook (line 347) | def register_optimizer_hook(self, optimizer_config):
    method register_checkpoint_hook (line 357) | def register_checkpoint_hook(self, checkpoint_config):
    method register_logger_hooks (line 367) | def register_logger_hooks(self, log_config):
    method register_training_hooks (line 374) | def register_training_hooks(self,

FILE: code/mmcv/mmcv/runner/checkpoint.py
  function _get_mmcv_home (line 26) | def _get_mmcv_home():
  function load_state_dict (line 37) | def load_state_dict(module, state_dict, strict=False, logger=None):
  function load_url_dist (line 105) | def load_url_dist(url, model_dir=None):
  function get_torchvision_models (line 119) | def get_torchvision_models():
  function get_external_models (line 131) | def get_external_models():
  function get_deprecated_model_names (line 145) | def get_deprecated_model_names():
  function _load_checkpoint (line 154) | def _load_checkpoint(filename, map_location=None):
  function load_checkpoint (line 204) | def load_checkpoint(model,
  function weights_to_cpu (line 242) | def weights_to_cpu(state_dict):
  function save_checkpoint (line 257) | def save_checkpoint(model, filename, optimizer=None, meta=None):

FILE: code/mmcv/mmcv/runner/dist_utils.py
  function init_dist (line 13) | def init_dist(launcher, backend='nccl', **kwargs):
  function _init_dist_pytorch (line 26) | def _init_dist_pytorch(backend, **kwargs):
  function _init_dist_mpi (line 34) | def _init_dist_mpi(backend, **kwargs):
  function _init_dist_slurm (line 38) | def _init_dist_slurm(backend, port=None):
  function get_dist_info (line 70) | def get_dist_info():
  function master_only (line 87) | def master_only(func):

FILE: code/mmcv/mmcv/runner/epoch_based_runner.py
  class EpochBasedRunner (line 14) | class EpochBasedRunner(BaseRunner):
    method train (line 20) | def train(self, data_loader, **kwargs):
    method val (line 49) | def val(self, data_loader, **kwargs):
    method run (line 76) | def run(self, data_loaders, workflow, max_epochs, **kwargs):
    method save_checkpoint (line 127) | def save_checkpoint(self,
  class Runner (line 163) | class Runner(EpochBasedRunner):
    method __init__ (line 166) | def __init__(self, *args, **kwargs):

FILE: code/mmcv/mmcv/runner/hooks/checkpoint.py
  class CheckpointHook (line 9) | class CheckpointHook(Hook):
    method __init__ (line 29) | def __init__(self,
    method after_train_epoch (line 44) | def after_train_epoch(self, runner):
    method after_train_iter (line 67) | def after_train_iter(self, runner):

FILE: code/mmcv/mmcv/runner/hooks/closure.py
  class ClosureHook (line 6) | class ClosureHook(Hook):
    method __init__ (line 8) | def __init__(self, fn_name, fn):

FILE: code/mmcv/mmcv/runner/hooks/hook.py
  class Hook (line 7) | class Hook:
    method before_run (line 9) | def before_run(self, runner):
    method after_run (line 12) | def after_run(self, runner):
    method before_epoch (line 15) | def before_epoch(self, runner):
    method after_epoch (line 18) | def after_epoch(self, runner):
    method before_iter (line 21) | def before_iter(self, runner):
    method after_iter (line 24) | def after_iter(self, runner):
    method before_train_epoch (line 27) | def before_train_epoch(self, runner):
    method before_val_epoch (line 30) | def before_val_epoch(self, runner):
    method after_train_epoch (line 33) | def after_train_epoch(self, runner):
    method after_val_epoch (line 36) | def after_val_epoch(self, runner):
    method before_train_iter (line 39) | def before_train_iter(self, runner):
    method before_val_iter (line 42) | def before_val_iter(self, runner):
    method after_train_iter (line 45) | def after_train_iter(self, runner):
    method after_val_iter (line 48) | def after_val_iter(self, runner):
    method every_n_epochs (line 51) | def every_n_epochs(self, runner, n):
    method every_n_inner_iters (line 54) | def every_n_inner_iters(self, runner, n):
    method every_n_iters (line 57) | def every_n_iters(self, runner, n):
    method end_of_epoch (line 60) | def end_of_epoch(self, runner):

FILE: code/mmcv/mmcv/runner/hooks/iter_timer.py
  class IterTimerHook (line 8) | class IterTimerHook(Hook):
    method before_epoch (line 10) | def before_epoch(self, runner):
    method before_iter (line 13) | def before_iter(self, runner):
    method after_iter (line 16) | def after_iter(self, runner):

FILE: code/mmcv/mmcv/runner/hooks/logger/base.py
  class LoggerHook (line 7) | class LoggerHook(Hook):
    method __init__ (line 20) | def __init__(self,
    method log (line 31) | def log(self, runner):
    method before_run (line 34) | def before_run(self, runner):
    method before_epoch (line 40) | def before_epoch(self, runner):
    method after_train_iter (line 43) | def after_train_iter(self, runner):
    method after_train_epoch (line 57) | def after_train_epoch(self, runner):
    method after_val_epoch (line 63) | def after_val_epoch(self, runner):

FILE: code/mmcv/mmcv/runner/hooks/logger/mlflow.py
  class MlflowLoggerHook (line 10) | class MlflowLoggerHook(LoggerHook):
    method __init__ (line 12) | def __init__(self,
    method import_mlflow (line 47) | def import_mlflow(self):
    method before_run (line 58) | def before_run(self, runner):
    method log (line 65) | def log(self, runner):
    method after_run (line 78) | def after_run(self, runner):

FILE: code/mmcv/mmcv/runner/hooks/logger/pavi.py
  function is_scalar (line 13) | def is_scalar(val, include_np=True, include_torch=True):
  class PaviLoggerHook (line 35) | class PaviLoggerHook(LoggerHook):
    method __init__ (line 37) | def __init__(self,
    method before_run (line 52) | def before_run(self, runner):
    method log (line 71) | def log(self, runner):
    method after_run (line 96) | def after_run(self, runner):

FILE: code/mmcv/mmcv/runner/hooks/logger/tensorboard.py
  class TensorboardLoggerHook (line 11) | class TensorboardLoggerHook(LoggerHook):
    method __init__ (line 13) | def __init__(self,
    method before_run (line 24) | def before_run(self, runner):
    method log (line 45) | def log(self, runner):
    method after_run (line 74) | def after_run(self, runner):

FILE: code/mmcv/mmcv/runner/hooks/logger/text.py
  class TextLoggerHook (line 15) | class TextLoggerHook(LoggerHook):
    method __init__ (line 32) | def __init__(self,
    method before_run (line 44) | def before_run(self, runner):
    method _get_max_memory (line 52) | def _get_max_memory(self, runner):
    method _log_info (line 61) | def _log_info(self, log_dict, runner):
    method _dump_log (line 123) | def _dump_log(self, log_dict, runner):
    method _round_float (line 134) | def _round_float(self, items):
    method log (line 142) | def log(self, runner):

FILE: code/mmcv/mmcv/runner/hooks/logger/wandb.py
  class WandbLoggerHook (line 10) | class WandbLoggerHook(LoggerHook):
    method __init__ (line 12) | def __init__(self,
    method import_wandb (line 22) | def import_wandb(self):
    method before_run (line 31) | def before_run(self, runner):
    method log (line 40) | def log(self, runner):
    method after_run (line 54) | def after_run(self, runner):

FILE: code/mmcv/mmcv/runner/hooks/lr_updater.py
  class LrUpdaterHook (line 7) | class LrUpdaterHook(Hook):
    method __init__ (line 23) | def __init__(self,
    method _set_lr (line 56) | def _set_lr(self, runner, lr_groups):
    method get_lr (line 66) | def get_lr(self, runner, base_lr):
    method get_regular_lr (line 69) | def get_regular_lr(self, runner):
    method get_warmup_lr (line 83) | def get_warmup_lr(self, cur_iters):
    method before_run (line 94) | def before_run(self, runner):
    method before_train_epoch (line 113) | def before_train_epoch(self, runner):
    method before_train_iter (line 123) | def before_train_iter(self, runner):
  class FixedLrUpdaterHook (line 143) | class FixedLrUpdaterHook(LrUpdaterHook):
    method __init__ (line 145) | def __init__(self, **kwargs):
    method get_lr (line 148) | def get_lr(self, runner, base_lr):
  class StepLrUpdaterHook (line 153) | class StepLrUpdaterHook(LrUpdaterHook):
    method __init__ (line 155) | def __init__(self, step, gamma=0.1, **kwargs):
    method get_lr (line 168) | def get_lr(self, runner, base_lr):
  class ExpLrUpdaterHook (line 183) | class ExpLrUpdaterHook(LrUpdaterHook):
    method __init__ (line 185) | def __init__(self, gamma, **kwargs):
    method get_lr (line 189) | def get_lr(self, runner, base_lr):
  class PolyLrUpdaterHook (line 195) | class PolyLrUpdaterHook(LrUpdaterHook):
    method __init__ (line 197) | def __init__(self, power=1., min_lr=0., **kwargs):
    method get_lr (line 202) | def get_lr(self, runner, base_lr):
  class InvLrUpdaterHook (line 214) | class InvLrUpdaterHook(LrUpdaterHook):
    method __init__ (line 216) | def __init__(self, gamma, power=1., **kwargs):
    method get_lr (line 221) | def get_lr(self, runner, base_lr):
  class CosineAnealingLrUpdaterHook (line 227) | class CosineAnealingLrUpdaterHook(LrUpdaterHook):
    method __init__ (line 229) | def __init__(self, min_lr=None, min_lr_ratio=None, **kwargs):
    method get_lr (line 235) | def get_lr(self, runner, base_lr):
  class CosineRestartLrUpdaterHook (line 251) | class CosineRestartLrUpdaterHook(LrUpdaterHook):
    method __init__ (line 264) | def __init__(self,
    method get_lr (line 283) | def get_lr(self, runner, base_lr):
  function get_position_from_periods (line 303) | def get_position_from_periods(iteration, cumulative_periods):
  class CyclicLrUpdaterHook (line 327) | class CyclicLrUpdaterHook(LrUpdaterHook):
    method __init__ (line 347) | def __init__(self,
    method before_run (line 376) | def before_run(self, runner):
    method get_lr (line 389) | def get_lr(self, runner, base_lr):
  function annealing_cos (line 401) | def annealing_cos(start, end, factor, weight=1):

FILE: code/mmcv/mmcv/runner/hooks/memory.py
  class EmptyCacheHook (line 8) | class EmptyCacheHook(Hook):
    method __init__ (line 10) | def __init__(self, before_epoch=False, after_epoch=True, after_iter=Fa...
    method after_iter (line 15) | def after_iter(self, runner):
    method before_epoch (line 19) | def before_epoch(self, runner):
    method after_epoch (line 23) | def after_epoch(self, runner):

FILE: code/mmcv/mmcv/runner/hooks/momentum_updater.py
  class MomentumUpdaterHook (line 5) | class MomentumUpdaterHook(Hook):
    method __init__ (line 7) | def __init__(self,
    method _set_momentum (line 33) | def _set_momentum(self, runner, momentum_groups):
    method get_momentum (line 41) | def get_momentum(self, runner, base_momentum):
    method get_regular_momentum (line 44) | def get_regular_momentum(self, runner):
    method get_warmup_momentum (line 50) | def get_warmup_momentum(self, cur_iters):
    method before_run (line 66) | def before_run(self, runner):
    method before_train_epoch (line 80) | def before_train_epoch(self, runner):
    method before_train_iter (line 86) | def before_train_iter(self, runner):
  class CosineAnealingMomentumUpdaterHook (line 106) | class CosineAnealingMomentumUpdaterHook(MomentumUpdaterHook):
    method __init__ (line 108) | def __init__(self, min_momentum=None, min_momentum_ratio=None, **kwargs):
    method get_momentum (line 114) | def get_momentum(self, runner, base_momentum):
  class CyclicMomentumUpdaterHook (line 130) | class CyclicMomentumUpdaterHook(MomentumUpdaterHook):
    method __init__ (line 149) | def __init__(self,
    method before_run (line 178) | def before_run(self, runner):
    method get_momentum (line 191) | def get_momentum(self, runner, base_momentum):

FILE: code/mmcv/mmcv/runner/hooks/optimizer.py
  class OptimizerHook (line 8) | class OptimizerHook(Hook):
    method __init__ (line 10) | def __init__(self, grad_clip=None):
    method clip_grads (line 13) | def clip_grads(self, params):
    method after_train_iter (line 19) | def after_train_iter(self, runner):

FILE: code/mmcv/mmcv/runner/hooks/sampler_seed.py
  class DistSamplerSeedHook (line 6) | class DistSamplerSeedHook(Hook):
    method before_epoch (line 8) | def before_epoch(self, runner):

FILE: code/mmcv/mmcv/runner/iter_based_runner.py
  class IterLoader (line 15) | class IterLoader:
    method __init__ (line 17) | def __init__(self, dataloader):
    method epoch (line 23) | def epoch(self):
    method __next__ (line 26) | def __next__(self):
    method __len__ (line 38) | def __len__(self):
  class IterBasedRunner (line 42) | class IterBasedRunner(BaseRunner):
    method train (line 48) | def train(self, data_loader, **kwargs):
    method val (line 65) | def val(self, data_loader, **kwargs):
    method run (line 80) | def run(self, data_loaders, workflow, max_iters, **kwargs):
    method resume (line 125) | def resume(self,
    method save_checkpoint (line 160) | def save_checkpoint(self,
    method register_training_hooks (line 197) | def register_training_hooks(self,

FILE: code/mmcv/mmcv/runner/log_buffer.py
  class LogBuffer (line 7) | class LogBuffer:
    method __init__ (line 9) | def __init__(self):
    method clear (line 15) | def clear(self):
    method clear_output (line 20) | def clear_output(self):
    method update (line 24) | def update(self, vars, count=1):
    method average (line 33) | def average(self, n=0):

FILE: code/mmcv/mmcv/runner/optimizer/builder.py
  function register_torch_optimizers (line 12) | def register_torch_optimizers():
  function build_optimizer_constructor (line 28) | def build_optimizer_constructor(cfg):
  function build_optimizer (line 32) | def build_optimizer(model, cfg):

FILE: code/mmcv/mmcv/runner/optimizer/default_constructor.py
  class DefaultOptimizerConstructor (line 11) | class DefaultOptimizerConstructor:
    method __init__ (line 75) | def __init__(self, optimizer_cfg, paramwise_cfg=None):
    method _validate_cfg (line 85) | def _validate_cfg(self):
    method _is_in (line 108) | def _is_in(self, param_group, param_group_list):
    method add_params (line 117) | def add_params(self, params, module, prefix=''):
    method __call__ (line 191) | def __call__(self, model):

FILE: code/mmcv/mmcv/runner/priority.py
  class Priority (line 5) | class Priority(Enum):
  function get_priority (line 36) | def get_priority(priority):

FILE: code/mmcv/mmcv/runner/utils.py
  function get_host_info (line 10) | def get_host_info():
  function get_time_str (line 14) | def get_time_str():
  function obj_from_dict (line 18) | def obj_from_dict(info, parent=None, default_args=None):

FILE: code/mmcv/mmcv/utils/config.py
  class ConfigDict (line 21) | class ConfigDict(Dict):
    method __missing__ (line 23) | def __missing__(self, name):
    method __getattr__ (line 26) | def __getattr__(self, name):
  function add_args (line 39) | def add_args(parser, cfg, prefix=''):
  class Config (line 58) | class Config:
    method _validate_py_syntax (line 85) | def _validate_py_syntax(filename):
    method _file2dict (line 95) | def _file2dict(filename):
    method _merge_a_into_b (line 158) | def _merge_a_into_b(a, b):
    method fromfile (line 177) | def fromfile(filename):
    method auto_argparser (line 182) | def auto_argparser(description=None):
    method __init__ (line 194) | def __init__(self, cfg_dict=None, cfg_text=None, filename=None):
    method filename (line 216) | def filename(self):
    method text (line 220) | def text(self):
    method pretty_text (line 224) | def pretty_text(self):
    method __repr__ (line 317) | def __repr__(self):
    method __len__ (line 320) | def __len__(self):
    method __getattr__ (line 323) | def __getattr__(self, name):
    method __getitem__ (line 326) | def __getitem__(self, name):
    method __setattr__ (line 329) | def __setattr__(self, name, value):
    method __setitem__ (line 334) | def __setitem__(self, name, value):
    method __iter__ (line 339) | def __iter__(self):
    method dump (line 342) | def dump(self, file=None):
    method merge_from_dict (line 358) | def merge_from_dict(self, options):
  class DictAction (line 390) | class DictAction(Action):
    method _parse_int_float_bool (line 398) | def _parse_int_float_bool(val):
    method __call__ (line 411) | def __call__(self, parser, namespace, values, option_string=None):

FILE: code/mmcv/mmcv/utils/logging.py
  function get_logger (line 8) | def get_logger(name, log_file=None, log_level=logging.INFO):
  function print_log (line 68) | def print_log(msg, logger=None, level=logging.INFO):

FILE: code/mmcv/mmcv/utils/misc.py
  function is_str (line 9) | def is_str(x):
  function iter_cast (line 17) | def iter_cast(inputs, dst_type, return_type=None):
  function list_cast (line 42) | def list_cast(inputs, dst_type):
  function tuple_cast (line 50) | def tuple_cast(inputs, dst_type):
  function is_seq_of (line 58) | def is_seq_of(seq, expected_type, seq_type=None):
  function is_list_of (line 82) | def is_list_of(seq, expected_type):
  function is_tuple_of (line 90) | def is_tuple_of(seq, expected_type):
  function slice_list (line 98) | def slice_list(in_list, lens):
  function concat_list (line 124) | def concat_list(in_list):
  function check_prerequisites (line 136) | def check_prerequisites(
  function _check_py_package (line 174) | def _check_py_package(package):
  function _check_executable (line 183) | def _check_executable(cmd):
  function requires_package (line 190) | def requires_package(prerequisites):
  function requires_executable (line 206) | def requires_executable(prerequisites):

FILE: code/mmcv/mmcv/utils/parrots_wrapper.py
  function _get_cuda_home (line 8) | def _get_cuda_home():
  function get_build_config (line 16) | def get_build_config():
  function _get_conv (line 24) | def _get_conv():
  function _get_dataloader (line 32) | def _get_dataloader():
  function _get_extension (line 41) | def _get_extension():
  function _get_pool (line 52) | def _get_pool():
  function _get_norm (line 64) | def _get_norm():
  class SyncBatchNorm (line 83) | class SyncBatchNorm(SyncBatchNorm_):
    method _specify_ddp_gpu_num (line 85) | def _specify_ddp_gpu_num(self, gpu_size):
    method _check_input_dim (line 89) | def _check_input_dim(self, input):

FILE: code/mmcv/mmcv/utils/path.py
  function is_filepath (line 9) | def is_filepath(x):
  function fopen (line 13) | def fopen(filepath, *args, **kwargs):
  function check_file_exist (line 21) | def check_file_exist(filename, msg_tmpl='file "{}" does not exist'):
  function mkdir_or_exist (line 26) | def mkdir_or_exist(dir_name, mode=0o777):
  function symlink (line 33) | def symlink(src, dst, overwrite=True, **kwargs):
  function scandir (line 39) | def scandir(dir_path, suffix=None, recursive=False):
  function find_vcs_root (line 80) | def find_vcs_root(path, markers=('.git', )):

FILE: code/mmcv/mmcv/utils/progressbar.py
  class ProgressBar (line 10) | class ProgressBar:
    method __init__ (line 13) | def __init__(self, task_num=0, bar_width=50, start=True, file=sys.stdo...
    method terminal_width (line 22) | def terminal_width(self):
    method start (line 26) | def start(self):
    method update (line 35) | def update(self):
  function track_progress (line 63) | def track_progress(func, tasks, bar_width=50, file=sys.stdout, **kwargs):
  function init_pool (line 97) | def init_pool(process_num, initializer=None, initargs=None):
  function track_parallel_progress (line 108) | def track_parallel_progress(func,
  function track_iter_progress (line 178) | def track_iter_progress(tasks, bar_width=50, file=sys.stdout):

FILE: code/mmcv/mmcv/utils/registry.py
  class Registry (line 8) | class Registry:
    method __init__ (line 15) | def __init__(self, name):
    method __len__ (line 19) | def __len__(self):
    method __contains__ (line 22) | def __contains__(self, key):
    method __repr__ (line 25) | def __repr__(self):
    method name (line 32) | def name(self):
    method module_dict (line 36) | def module_dict(self):
    method get (line 39) | def get(self, key):
    method _register_module (line 50) | def _register_module(self, module_class, module_name=None, force=False):
    method deprecated_register_module (line 62) | def deprecated_register_module(self, cls=None, force=False):
    method register_module (line 72) | def register_module(self, name=None, force=False, module=None):
  function build_from_cfg (line 128) | def build_from_cfg(cfg, registry, default_args=None):

FILE: code/mmcv/mmcv/utils/timer.py
  class TimerError (line 5) | class TimerError(Exception):
    method __init__ (line 7) | def __init__(self, message):
  class Timer (line 12) | class Timer:
    method __init__ (line 38) | def __init__(self, start=True, print_tmpl=None):
    method is_running (line 45) | def is_running(self):
    method __enter__ (line 49) | def __enter__(self):
    method __exit__ (line 53) | def __exit__(self, type, value, traceback):
    method start (line 57) | def start(self):
    method since_start (line 64) | def since_start(self):
    method since_last_check (line 74) | def since_last_check(self):
  function check_time (line 92) | def check_time(timer_id):

FILE: code/mmcv/mmcv/video/io.py
  class Cache (line 14) | class Cache:
    method __init__ (line 16) | def __init__(self, capacity):
    method capacity (line 23) | def capacity(self):
    method size (line 27) | def size(self):
    method put (line 30) | def put(self, key, val):
    method get (line 37) | def get(self, key, default=None):
  class VideoReader (line 42) | class VideoReader:
    method __init__ (line 64) | def __init__(self, filename, cache_capacity=10):
    method vcap (line 78) | def vcap(self):
    method opened (line 83) | def opened(self):
    method width (line 88) | def width(self):
    method height (line 93) | def height(self):
    method resolution (line 98) | def resolution(self):
    method fps (line 103) | def fps(self):
    method frame_cnt (line 108) | def frame_cnt(self):
    method fourcc (line 113) | def fourcc(self):
    method position (line 118) | def position(self):
    method _get_real_position (line 122) | def _get_real_position(self):
    method _set_real_position (line 125) | def _set_real_position(self, frame_id):
    method read (line 132) | def read(self):
    method get_frame (line 158) | def get_frame(self, frame_id):
    method current_frame (line 185) | def current_frame(self):
    method cvt2frames (line 196) | def cvt2frames(self,
    method __len__ (line 241) | def __len__(self):
    method __getitem__ (line 244) | def __getitem__(self, index):
    method __iter__ (line 257) | def __iter__(self):
    method __next__ (line 261) | def __next__(self):
    method __enter__ (line 270) | def __enter__(self):
    method __exit__ (line 273) | def __exit__(self, exc_type, exc_value, traceback):
  function frames2video (line 277) | def frames2video(frame_dir,

FILE: code/mmcv/mmcv/video/optflow.py
  function flowread (line 10) | def flowread(flow_or_path, quantize=False, concat_axis=0, *args, **kwargs):
  function flowwrite (line 59) | def flowwrite(flow, filename, quantize=False, concat_axis=0, *args, **kw...
  function quantize_flow (line 89) | def quantize_flow(flow, max_val=0.02, norm=True):
  function dequantize_flow (line 117) | def dequantize_flow(dx, dy, max_val=0.02, denorm=True):
  function flow_warp (line 141) | def flow_warp(img, flow, filling_value=0, interpolate_mode='nearest'):

FILE: code/mmcv/mmcv/video/optflow_warp/flow_warp.cpp
  function FlowWarp (line 4) | void FlowWarp(double* img, double* flow, double* out, const int height,
  function BilinearInterpolate (line 34) | void BilinearInterpolate(const double* img, int width, int height, int c...
  function NNInterpolate (line 56) | void NNInterpolate(const double* img, int width, int height, int channels,

FILE: code/mmcv/mmcv/video/optflow_warp/flow_warp.hpp
  function T (line 18) | inline T __min__(T a, T b) {
  function T (line 23) | inline T __max__(T a, T b) {
  function T (line 28) | inline T EnforceRange(const T x, const int MaxValue) {

FILE: code/mmcv/mmcv/video/processing.py
  function convert_video (line 11) | def convert_video(in_file,
  function resize_video (line 55) | def resize_video(in_file,
  function cut_video (line 93) | def cut_video(in_file,
  function concat_video (line 128) | def concat_video(video_list,

FILE: code/mmcv/mmcv/visualization/color.py
  class Color (line 9) | class Color(Enum):
  function color_val (line 24) | def color_val(color):

FILE: code/mmcv/mmcv/visualization/image.py
  function imshow (line 30) | def imshow(img, win_name='', wait_time=0):
  function imshow_bboxes (line 51) | def imshow_bboxes(img,
  function imshow_det_bboxes (line 99) | def imshow_det_bboxes(img,
  function imshow_extremes (line 164) | def imshow_extremes(img,
  function imshow_polygons (line 226) | def imshow_polygons(img,
  function imshow_pose (line 276) | def imshow_pose(img,

FILE: code/mmcv/mmcv/visualization/optflow.py
  function flowshow (line 11) | def flowshow(flow, win_name='', wait_time=0):
  function flow2rgb (line 24) | def flow2rgb(flow, color_wheel=None, unknown_thr=1e6):
  function make_color_wheel (line 76) | def make_color_wheel(bins=None):

FILE: code/mmcv/setup.py
  function choose_requirement (line 12) | def choose_requirement(primary, secondary):
  function readme (line 25) | def readme():
  function get_version (line 31) | def get_version():
  function parse_requirements (line 38) | def parse_requirements(fname='requirements.txt', with_version=True):

FILE: code/mmcv/tests/test_arraymisc.py
  function test_quantize (line 10) | def test_quantize():
  function test_dequantize (line 35) | def test_dequantize():
  function test_joint (line 58) | def test_joint():

FILE: code/mmcv/tests/test_cnn/test_build_layers.py
  function test_build_conv_layer (line 15) | def test_build_conv_layer():
  function test_infer_abbr (line 59) | def test_infer_abbr():
  function test_build_norm_layer (line 96) | def test_build_norm_layer():
  function test_build_activation_layer (line 151) | def test_build_activation_layer():
  function test_build_padding_layer (line 174) | def test_build_padding_layer():
  function test_upsample_layer (line 202) | def test_upsample_layer():
  function test_pixel_shuffle_pack (line 258) | def test_pixel_shuffle_pack():
  function test_is_norm (line 266) | def test_is_norm():

FILE: code/mmcv/tests/test_cnn/test_conv_module.py
  class ExampleConv (line 11) | class ExampleConv(nn.Module):
    method __init__ (line 13) | def __init__(self,
    method forward (line 39) | def forward(self, x):
    method init_weights (line 43) | def init_weights(self):
  function test_conv_module (line 47) | def test_conv_module():
  function test_bias (line 139) | def test_bias():
  function conv_forward (line 160) | def conv_forward(self, x):
  function bn_forward (line 164) | def bn_forward(self, x):
  function relu_forward (line 168) | def relu_forward(self, x):
  function test_order (line 175) | def test_order():

FILE: code/mmcv/tests/test_cnn/test_flops_counter.py
  class ExampleModel (line 45) | class ExampleModel(nn.Module):
    method __init__ (line 47) | def __init__(self):
    method forward (line 51) | def forward(self, imgs):
  function input_constructor (line 56) | def input_constructor(x):
  function test_flops_counter (line 60) | def test_flops_counter():
  function test_flops_to_string (line 115) | def test_flops_to_string():
  function test_params_to_string (line 133) | def test_params_to_string():

FILE: code/mmcv/tests/test_cnn/test_hsigmoid.py
  function test_hsigmoid (line 6) | def test_hsigmoid():

FILE: code/mmcv/tests/test_cnn/test_hswish.py
  function test_hswish (line 7) | def test_hswish():

FILE: code/mmcv/tests/test_cnn/test_non_local.py
  function test_nonlocal (line 9) | def test_nonlocal():

FILE: code/mmcv/tests/test_cnn/test_scale.py
  function test_scale (line 6) | def test_scale():

FILE: code/mmcv/tests/test_cnn/test_weight_init.py
  function test_constant_init (line 11) | def test_constant_init():
  function test_xavier_init (line 23) | def test_xavier_init():
  function test_normal_init (line 35) | def test_normal_init():
  function test_uniform_init (line 45) | def test_uniform_init():
  function test_kaiming_init (line 54) | def test_kaiming_init():
  function test_caffe_xavier_init (line 66) | def test_caffe_xavier_init():
  function test_bias_init_with_prob (line 71) | def test_bias_init_with_prob():

FILE: code/mmcv/tests/test_config.py
  function test_construct (line 13) | def test_construct():
  function test_fromfile (line 64) | def test_fromfile():
  function test_merge_from_base (line 79) | def test_merge_from_base():
  function test_merge_from_multiple_bases (line 99) | def test_merge_from_multiple_bases():
  function test_merge_recursive_bases (line 117) | def test_merge_recursive_bases():
  function test_merge_from_dict (line 129) | def test_merge_from_dict():
  function test_merge_delete (line 138) | def test_merge_delete():
  function test_merge_intermediate_variable (line 149) | def test_merge_intermediate_variable():
  function test_fromfile_in_config (line 163) | def test_fromfile_in_config():
  function test_dict (line 174) | def test_dict():
  function test_setattr (line 219) | def test_setattr():
  function test_pretty_text (line 232) | def test_pretty_text():
  function test_dict_action (line 243) | def test_dict_action():
  function test_dump_mapping (line 259) | def test_dump_mapping():
  function test_reserved_key (line 271) | def test_reserved_key():
  function test_syntax_error (line 277) | def test_syntax_error():

FILE: code/mmcv/tests/test_fileclient.py
  class MockS3Client (line 16) | class MockS3Client:
    method __init__ (line 18) | def __init__(self, enable_mc=True):
    method Get (line 21) | def Get(self, filepath):
  class MockMemcachedClient (line 27) | class MockMemcachedClient:
    method __init__ (line 29) | def __init__(self, server_list_cfg, client_cfg):
    method Get (line 32) | def Get(self, filepath, buffer):
  class TestFileClient (line 37) | class TestFileClient:
    method setup_class (line 40) | def setup_class(cls):
    method test_error (line 46) | def test_error(self):
    method test_disk_backend (line 50) | def test_disk_backend(self):
    method test_ceph_backend (line 72) | def test_ceph_backend(self):
    method test_petrel_backend (line 110) | def test_petrel_backend(self):
    method test_memcached_backend (line 147) | def test_memcached_backend(self):
    method test_lmdb_backend (line 167) | def test_lmdb_backend(self):
    method test_register_backend (line 188) | def test_register_backend(self):

FILE: code/mmcv/tests/test_fileio.py
  function _test_handler (line 11) | def _test_handler(file_format, test_obj, str_checker, mode='r+'):
  function test_json (line 47) | def test_json():
  function test_yaml (line 57) | def test_yaml():
  function test_pickle (line 68) | def test_pickle():
  function test_exception (line 77) | def test_exception():
  function test_register_handler (line 87) | def test_register_handler():
  function test_list_from_file (line 124) | def test_list_from_file():
  function test_dict_from_file (line 138) | def test_dict_from_file():

FILE: code/mmcv/tests/test_image/test_colorspace.py
  function test_bgr2gray (line 12) | def test_bgr2gray():
  function test_rgb2gray (line 24) | def test_rgb2gray():
  function test_gray2bgr (line 36) | def test_gray2bgr():
  function test_gray2rgb (line 44) | def test_gray2rgb():
  function test_bgr2rgb (line 52) | def test_bgr2rgb():
  function test_rgb2bgr (line 61) | def test_rgb2bgr():
  function test_bgr2hsv (line 70) | def test_bgr2hsv():
  function test_convert_input_type_range (line 92) | def test_convert_input_type_range():
  function test_convert_output_type_range (line 109) | def test_convert_output_type_range():
  function test_rgb2ycbcr (line 126) | def test_rgb2ycbcr():
  function test_bgr2ycbcr (line 184) | def test_bgr2ycbcr():
  function test_ycbcr2rgb (line 238) | def test_ycbcr2rgb():
  function test_ycbcr2bgr (line 276) | def test_ycbcr2bgr():
  function test_bgr2hls (line 309) | def test_bgr2hls():
  function test_imconvert (line 347) | def test_imconvert(src, dst, ref):

FILE: code/mmcv/tests/test_image/test_geometric.py
  class TestGeometric (line 12) | class TestGeometric:
    method setup_class (line 15) | def setup_class(cls):
    method test_imresize (line 21) | def test_imresize(self):
    method test_imresize_like (line 38) | def test_imresize_like(self):
    method test_rescale_size (line 43) | def test_rescale_size(self):
    method test_imrescale (line 71) | def test_imrescale(self):
    method test_imflip (line 98) | def test_imflip(self):
    method test_imflip_ (line 130) | def test_imflip_(self):
    method test_imcrop (line 181) | def test_imcrop(self):
    method test_impad (line 223) | def test_impad(self):
    method test_impad_to_multiple (line 259) | def test_impad_to_multiple(self):
    method test_imrotate (line 270) | def test_imrotate(self):

FILE: code/mmcv/tests/test_image/test_io.py
  class TestIO (line 16) | class TestIO:
    method setup_class (line 19) | def setup_class(cls):
    method assert_img_equal (line 31) | def assert_img_equal(self, img, ref_img, ratio_thr=0.999):
    method test_imread (line 38) | def test_imread(self):
    method test_imfrombytes (line 177) | def test_imfrombytes(self):
    method test_imwrite (line 271) | def test_imwrite(self):
    method test_no_turbojpeg (line 284) | def test_no_turbojpeg(self):
    method test_no_pillow (line 291) | def test_no_pillow(self):

FILE: code/mmcv/tests/test_image/test_photometric.py
  class TestPhotometric (line 11) | class TestPhotometric:
    method setup_class (line 14) | def setup_class(cls):
    method test_imnormalize (line 21) | def test_imnormalize(self):
    method test_imnormalize_ (line 31) | def test_imnormalize_(self):
    method test_imdenormalize (line 43) | def test_imdenormalize(self):
    method test_iminvert (line 52) | def test_iminvert(self):
    method test_solarize (line 59) | def test_solarize(self):
    method test_posterize (line 69) | def test_posterize(self):

FILE: code/mmcv/tests/test_load_model_zoo.py
  function test_set_mmcv_home (line 17) | def test_set_mmcv_home():
  function test_default_mmcv_home (line 25) | def test_default_mmcv_home():
  function test_get_external_models (line 36) | def test_get_external_models():
  function test_get_deprecated_models (line 50) | def test_get_deprecated_models():
  function load_url_dist (line 61) | def load_url_dist(url):
  function load (line 65) | def load(filepath, map_location=None):
  function test_load_external_url (line 72) | def test_load_external_url():

FILE: code/mmcv/tests/test_logging.py
  function test_get_logger_rank0 (line 14) | def test_get_logger_rank0():
  function test_get_logger_rank1 (line 43) | def test_get_logger_rank1():
  function test_print_log_print (line 57) | def test_print_log_print(capsys):
  function test_print_log_silent (line 63) | def test_print_log_silent(capsys, caplog):
  function test_print_log_logger (line 70) | def test_print_log_logger(caplog):
  function test_print_log_exception (line 89) | def test_print_log_exception():

FILE: code/mmcv/tests/test_misc.py
  function test_iter_cast (line 7) | def test_iter_cast():
  function test_is_seq_of (line 19) | def test_is_seq_of():
  function test_slice_list (line 30) | def test_slice_list():
  function test_concat_list (line 40) | def test_concat_list():
  function test_requires_package (line 45) | def test_requires_package(capsys):
  function test_requires_executable (line 75) | def test_requires_executable(capsys):

FILE: code/mmcv/tests/test_optimizer.py
  class SubModel (line 12) | class SubModel(nn.Module):
    method __init__ (line 14) | def __init__(self):
    method forward (line 20) | def forward(self, x):
  class ExampleModel (line 24) | class ExampleModel(nn.Module):
    method __init__ (line 26) | def __init__(self):
    method forward (line 34) | def forward(self, x):
  class ExampleDuplicateModel (line 38) | class ExampleDuplicateModel(nn.Module):
    method __init__ (line 40) | def __init__(self):
    method forward (line 50) | def forward(self, x):
  class PseudoDataParallel (line 54) | class PseudoDataParallel(nn.Module):
    method __init__ (line 56) | def __init__(self):
    method forward (line 60) | def forward(self, x):
  function check_default_optimizer (line 69) | def check_default_optimizer(optimizer, model, prefix=''):
  function check_optimizer (line 87) | def check_optimizer(optimizer,
  function test_default_optimizer_constructor (line 152) | def test_default_optimizer_constructor():
  function test_torch_optimizers (line 494) | def test_torch_optimizers():
  function test_build_optimizer_constructor (line 502) | def test_build_optimizer_constructor():
  function test_build_optimizer (line 563) | def test_build_optimizer():

FILE: code/mmcv/tests/test_parallel.py
  function test_is_module_wrapper (line 15) | def test_is_module_wrapper():

FILE: code/mmcv/tests/test_path.py
  function test_is_filepath (line 10) | def test_is_filepath():
  function test_fopen (line 17) | def test_fopen():
  function test_check_file_exist (line 22) | def test_check_file_exist():
  function test_scandir (line 28) | def test_scandir():

FILE: code/mmcv/tests/test_progressbar.py
  function reset_string_io (line 18) | def reset_string_io(io):
  class TestProgressBar (line 23) | class TestProgressBar:
    method test_start (line 25) | def test_start(self):
    method test_update (line 49) | def test_update(self):
    method test_adaptive_length (line 67) | def test_adaptive_length(self):
  function sleep_1s (line 88) | def sleep_1s(num):
  function test_track_progress_list (line 93) | def test_track_progress_list():
  function test_track_progress_iterator (line 104) | def test_track_progress_iterator():
  function test_track_iter_progress (line 116) | def test_track_iter_progress():
  function test_track_enum_progress (line 129) | def test_track_enum_progress():
  function test_track_parallel_progress_list (line 146) | def test_track_parallel_progress_list():
  function test_track_parallel_progress_iterator (line 159) | def test_track_parallel_progress_iterator():

FILE: code/mmcv/tests/test_registry.py
  function test_registry (line 6) | def test_registry():
  function test_build_from_cfg (line 124) | def test_build_from_cfg():

FILE: code/mmcv/tests/test_runner/test_dist_utils.py
  function test_init_dist (line 13) | def test_init_dist(mock_getoutput, mock_dist_init, mock_set_device,

FILE: code/mmcv/tests/test_runner/test_hooks.py
  function test_pavi_hook (line 30) | def test_pavi_hook():
  function test_momentum_runner_hook (line 51) | def test_momentum_runner_hook():
  function test_cosine_runner_hook (line 101) | def test_cosine_runner_hook():
  function test_cosine_restart_lr_update_hook (line 148) | def test_cosine_restart_lr_update_hook():
  function test_mlflow_hook (line 227) | def test_mlflow_hook(log_model):
  function test_wandb_hook (line 252) | def test_wandb_hook():
  function _build_demo_runner (line 271) | def _build_demo_runner():

FILE: code/mmcv/tests/test_runner/test_runner.py
  class OldStyleModel (line 17) | class OldStyleModel(nn.Module):
    method __init__ (line 19) | def __init__(self):
  class Model (line 24) | class Model(OldStyleModel):
    method train_step (line 26) | def train_step(self):
    method val_step (line 29) | def val_step(self):
  function test_epoch_based_runner (line 33) | def test_epoch_based_runner():
  function test_runner_with_parallel (line 108) | def test_runner_with_parallel():
  function test_save_checkpoint (line 130) | def test_save_checkpoint():
  function test_build_lr_momentum_hook (line 147) | def test_build_lr_momentum_hook():

FILE: code/mmcv/tests/test_timer.py
  function test_timer_init (line 9) | def test_timer_init():
  function test_timer_run (line 18) | def test_timer_run():
  function test_timer_context (line 32) | def test_timer_context(capsys):

FILE: code/mmcv/tests/test_video/test_optflow.py
  function test_flowread (line 13) | def test_flowread():
  function test_flowwrite (line 50) | def test_flowwrite():
  function test_quantize_flow (line 75) | def test_quantize_flow():
  function test_dequantize_flow (line 102) | def test_dequantize_flow():
  function test_flow2rgb (line 126) | def test_flow2rgb():
  function test_flow_warp (line 142) | def test_flow_warp():
  function test_make_color_wheel (line 182) | def test_make_color_wheel():

FILE: code/mmcv/tests/test_video/test_processing.py
  class TestVideoEditor (line 9) | class TestVideoEditor:
    method setup_class (line 12) | def setup_class(cls):
    method test_cut_concat_video (line 16) | def test_cut_concat_video(self):
    method test_resize_video (line 34) | def test_resize_video(self):

FILE: code/mmcv/tests/test_video/test_reader.py
  class TestCache (line 13) | class TestCache:
    method test_init (line 15) | def test_init(self):
    method test_put (line 22) | def test_put(self):
    method test_get (line 34) | def test_get(self):
  class TestVideoReader (line 42) | class TestVideoReader:
    method setup_class (line 45) | def setup_class(cls):
    method test_load (line 49) | def test_load(self):
    method test_read (line 60) | def test_read(self):
    method test_slice (line 81) | def test_slice(self):
    method test_current_frame (line 108) | def test_current_frame(self):
    method test_position (line 115) | def test_position(self):
    method test_iterator (line 124) | def test_iterator(self):
    method test_with (line 131) | def test_with(self):
    method test_cvt2frames (line 136) | def test_cvt2frames(self):
    method test_frames2video (line 168) | def test_frames2video(self):

FILE: code/mmcv/tests/test_visualization.py
  function test_color (line 8) | def test_color():

FILE: code/mmdet/apis/inference.py
  function init_detector (line 15) | def init_detector(config, checkpoint=None, device='cuda:0'):
  class LoadImage (line 49) | class LoadImage(object):
    method __call__ (line 52) | def __call__(self, results):
  function inference_detector (line 76) | def inference_detector(model, img):
  function async_inference_detector (line 118) | async def async_inference_detector(model, img):
  function show_result_pyplot (line 146) | def show_result_pyplot(model, img, result, score_thr=0.3, fig_size=(15, ...

FILE: code/mmdet/apis/test.py
  function single_gpu_test (line 16) | def single_gpu_test(model,
  function multi_gpu_test (line 77) | def multi_gpu_test(model, data_loader, tmpdir=None, gpu_collect=False, b...
  function collect_results_cpu (line 135) | def collect_results_cpu(result_part, size, tmpdir=None):
  function collect_results_gpu (line 177) | def collect_results_gpu(result_part, size):

FILE: code/mmdet/apis/train.py
  function set_random_seed (line 14) | def set_random_seed(seed, deterministic=False):
  function train_detector (line 33) | def train_detector(model,

FILE: code/mmdet/core/anchor/anchor_generator.py
  class AnchorGenerator (line 10) | class AnchorGenerator(object):
    method __init__ (line 58) | def __init__(self,
    method num_base_anchors (line 113) | def num_base_anchors(self):
    method num_levels (line 118) | def num_levels(self):
    method gen_base_anchors (line 122) | def gen_base_anchors(self):
    method gen_single_level_base_anchors (line 142) | def gen_single_level_base_anchors(self,
    method _meshgrid (line 187) | def _meshgrid(self, x, y, row_major=True):
    method grid_anchors (line 206) | def grid_anchors(self, featmap_sizes, device='cuda'):
    method single_level_grid_anchors (line 232) | def single_level_grid_anchors(self,
    method valid_flags (line 269) | def valid_flags(self, featmap_sizes, pad_shape, device='cuda'):
    method single_level_valid_flags (line 296) | def single_level_valid_flags(self,
    method __repr__ (line 327) | def __repr__(self):
  class SSDAnchorGenerator (line 347) | class SSDAnchorGenerator(AnchorGenerator):
    method __init__ (line 363) | def __init__(self,
    method gen_base_anchors (line 432) | def gen_base_anchors(self):
    method __repr__ (line 453) | def __repr__(self):
  class LegacyAnchorGenerator (line 471) | class LegacyAnchorGenerator(AnchorGenerator):
    method gen_single_level_base_anchors (line 518) | def gen_single_level_base_anchors(self,
  class LegacySSDAnchorGenerator (line 569) | class LegacySSDAnchorGenerator(SSDAnchorGenerator, LegacyAnchorGenerator):
    method __init__ (line 576) | def __init__(self,

FILE: code/mmdet/core/anchor/builder.py
  function build_anchor_generator (line 6) | def build_anchor_generator(cfg, default_args=None):

FILE: code/mmdet/core/anchor/point_generator.py
  class PointGenerator (line 7) | class PointGenerator(object):
    method _meshgrid (line 9) | def _meshgrid(self, x, y, row_major=True):
    method grid_points (line 17) | def grid_points(self, featmap_size, stride=16, device='cuda'):
    method valid_flags (line 27) | def valid_flags(self, featmap_size, valid_size, device='cuda'):

FILE: code/mmdet/core/anchor/utils.py
  function images_to_levels (line 4) | def images_to_levels(target, num_levels):
  function anchor_inside_flags (line 20) | def anchor_inside_flags(flat_anchors,
  function calc_region (line 49) | def calc_region(bbox, ratio, featmap_size=None):

FILE: code/mmdet/core/bbox/assigners/approx_max_iou_assigner.py
  class ApproxMaxIoUAssigner (line 9) | class ApproxMaxIoUAssigner(MaxIoUAssigner):
    method __init__ (line 39) | def __init__(self,
    method assign (line 59) | def assign(self,

FILE: code/mmdet/core/bbox/assigners/assign_result.py
  class AssignResult (line 6) | class AssignResult(util_mixins.NiceRepr):
    method __init__ (line 43) | def __init__(self, num_gts, gt_inds, max_overlaps, labels=None):
    method num_preds (line 52) | def num_preds(self):
    method set_extra_property (line 56) | def set_extra_property(self, key, value):
    method get_extra_property (line 61) | def get_extra_property(self, key):
    method info (line 66) | def info(self):
    method __nice__ (line 78) | def __nice__(self):
    method random (line 98) | def random(cls, **kwargs):
    method add_gt_ (line 191) | def add_gt_(self, gt_labels):

FILE: code/mmdet/core/bbox/assigners/atss_assigner.py
  class ATSSAssigner (line 10) | class ATSSAssigner(BaseAssigner):
    method __init__ (line 23) | def __init__(self, topk, iou_calculator=dict(type='BboxOverlaps2D')):
    method assign (line 29) | def assign(self,

FILE: code/mmdet/core/bbox/assigners/base_assigner.py
  class BaseAssigner (line 4) | class BaseAssigner(metaclass=ABCMeta):
    method assign (line 8) | def assign(self, bboxes, gt_bboxes, gt_bboxes_ignore=None, gt_labels=N...

FILE: code/mmdet/core/bbox/assigners/center_region_assigner.py
  function scale_boxes (line 9) | def scale_boxes(bboxes, scale):
  function is_located_in (line 36) | def is_located_in(points, bboxes):
  function bboxes_area (line 54) | def bboxes_area(bboxes):
  class CenterRegionAssigner (line 72) | class CenterRegionAssigner(BaseAssigner):
    method __init__ (line 91) | def __init__(self,
    method get_gt_priorities (line 103) | def get_gt_priorities(self, gt_bboxes):
    method assign (line 121) | def assign(self, bboxes, gt_bboxes, gt_bboxes_ignore=None, gt_labels=N...
    method assign_one_hot_gt_indices (line 247) | def assign_one_hot_gt_indices(self,

FILE: code/mmdet/core/bbox/assigners/centroid_assigner.py
  class CentroidAssigner (line 10) | class CentroidAssigner(BaseAssigner):
    method __init__ (line 21) | def __init__(self, scale=4, pos_num=3, iou_type='center'):
    method assign (line 26) | def assign(self, points, gt_bboxes, gt_extreme_pts, gt_bboxes_ignore=N...
    method gen_centroid (line 95) | def gen_centroid(self, pts, num_gts):

FILE: code/mmdet/core/bbox/assigners/fcos_assigner.py
  class FCOSAssigner (line 10) | class FCOSAssigner(BaseAssigner):
    method __init__ (line 21) | def __init__(self, strides=[8, 16, 32, 64, 128],
    method assign (line 31) | def assign(self, points, num_points_per_lvl, gt_bboxes, gt_bboxes_igno...

FILE: code/mmdet/core/bbox/assigners/max_iou_assigner.py
  class MaxIoUAssigner (line 10) | class MaxIoUAssigner(BaseAssigner):
    method __init__ (line 40) | def __init__(self,
    method assign (line 60) | def assign(self, bboxes, gt_bboxes, gt_bboxes_ignore=None, gt_labels=N...
    method assign_wrt_overlaps (line 127) | def assign_wrt_overlaps(self, overlaps, gt_labels=None):

FILE: code/mmdet/core/bbox/assigners/point_assigner.py
  class PointAssigner (line 9) | class PointAssigner(BaseAssigner):
    method __init__ (line 20) | def __init__(self, scale=4, pos_num=3):
    method assign (line 24) | def assign(self, points, gt_bboxes, gt_bboxes_ignore=None, gt_labels=N...

FILE: code/mmdet/core/bbox/assigners/point_assigner_v2.py
  class PointAssignerV2 (line 9) | class PointAssignerV2(BaseAssigner):
    method __init__ (line 20) | def __init__(self, scale=4, pos_num=3):
    method assign (line 24) | def assign(self, points, gt_bboxes, gt_bboxes_ignore=None, gt_labels=N...

FILE: code/mmdet/core/bbox/assigners/point_ct_assigner.py
  class PointCTAssigner (line 13) | class PointCTAssigner(BaseAssigner):
    method assign (line 23) | def assign(self, points, gt_bboxes, gt_contours, sizes):

FILE: code/mmdet/core/bbox/assigners/point_hm_assigner.py
  class PointHMAssigner (line 9) | class PointHMAssigner(BaseAssigner):
    method __init__ (line 20) | def __init__(self, gaussian_bump=False, gaussian_iou=0.7):
    method assign (line 24) | def assign(self, points, gt_bboxes, gt_labels=None):
  function gaussian_radius (line 145) | def gaussian_radius(det_size, min_overlap):

FILE: code/mmdet/core/bbox/builder.py
  function build_assigner (line 8) | def build_assigner(cfg, **default_args):
  function build_sampler (line 13) | def build_sampler(cfg, **default_args):
  function build_bbox_coder (line 18) | def build_bbox_coder(cfg, **default_args):

FILE: code/mmdet/core/bbox/coder/base_bbox_coder.py
  class BaseBBoxCoder (line 4) | class BaseBBoxCoder(metaclass=ABCMeta):
    method __init__ (line 7) | def __init__(self, **kwargs):
    method encode (line 11) | def encode(self, bboxes, gt_bboxes):
    method decode (line 16) | def decode(self, bboxes, bboxes_pred):

FILE: code/mmdet/core/bbox/coder/delta_xywh_bbox_coder.py
  class DeltaXYWHBBoxCoder (line 9) | class DeltaXYWHBBoxCoder(BaseBBoxCoder):
    method __init__ (line 23) | def __init__(self,
    method encode (line 30) | def encode(self, bboxes, gt_bboxes):
    method decode (line 48) | def decode(self,
  function bbox2delta (line 74) | def bbox2delta(proposals, gt, means=(0., 0., 0., 0.), stds=(1., 1., 1., ...
  function delta2bbox (line 120) | def delta2bbox(rois,

FILE: code/mmdet/core/bbox/coder/legacy_delta_xywh_bbox_coder.py
  class LegacyDeltaXYWHBBoxCoder (line 9) | class LegacyDeltaXYWHBBoxCoder(BaseBBoxCoder):
    method __init__ (line 32) | def __init__(self,
    method encode (line 39) | def encode(self, bboxes, gt_bboxes):
    method decode (line 57) | def decode(self,
  function legacy_bbox2delta (line 82) | def legacy_bbox2delta(proposals,
  function legacy_delta2bbox (line 131) | def legacy_delta2bbox(rois,

FILE: code/mmdet/core/bbox/coder/pseudo_bbox_coder.py
  class PseudoBBoxCoder (line 6) | class PseudoBBoxCoder(BaseBBoxCoder):
    method __init__ (line 9) | def __init__(self, **kwargs):
    method encode (line 12) | def encode(self, bboxes, gt_bboxes):
    method decode (line 16) | def decode(self, bboxes, pred_bboxes):

FILE: code/mmdet/core/bbox/coder/tblr_bbox_coder.py
  class TBLRBBoxCoder (line 8) | class TBLRBBoxCoder(BaseBBoxCoder):
    method __init__ (line 22) | def __init__(self, normalizer=4.0):
    method encode (line 26) | def encode(self, bboxes, gt_bboxes):
    method decode (line 45) | def decode(self, bboxes, pred_bboxes, max_shape=None):
  function bboxes2tblr (line 67) | def bboxes2tblr(priors, gts, normalizer=4.0, normalize_by_wh=True):
  function tblr2bboxes (line 113) | def tblr2bboxes(priors,

FILE: code/mmdet/core/bbox/demodata.py
  function ensure_rng (line 5) | def ensure_rng(rng=None):
  function random_boxes (line 30) | def random_boxes(num=1, scale=1, rng=None):

FILE: code/mmdet/core/bbox/iou_calculators/builder.py
  function build_iou_calculator (line 6) | def build_iou_calculator(cfg, default_args=None):

FILE: code/mmdet/core/bbox/iou_calculators/iou2d_calculator.py
  class BboxOverlaps2D (line 7) | class BboxOverlaps2D(object):
    method __call__ (line 10) | def __call__(self, bboxes1, bboxes2, mode='iou', is_aligned=False):
    method __repr__ (line 33) | def __repr__(self):
  function bbox_overlaps (line 39) | def bbox_overlaps(bboxes1, bboxes2, mode='iou', is_aligned=False, eps=1e...

FILE: code/mmdet/core/bbox/samplers/base_sampler.py
  class BaseSampler (line 8) | class BaseSampler(metaclass=ABCMeta):
    method __init__ (line 11) | def __init__(self,
    method _sample_pos (line 25) | def _sample_pos(self, assign_result, num_expected, **kwargs):
    method _sample_neg (line 30) | def _sample_neg(self, assign_result, num_expected, **kwargs):
    method sample (line 34) | def sample(self,

FILE: code/mmdet/core/bbox/samplers/combined_sampler.py
  class CombinedSampler (line 6) | class CombinedSampler(BaseSampler):
    method __init__ (line 9) | def __init__(self, pos_sampler, neg_sampler, **kwargs):
    method _sample_pos (line 14) | def _sample_pos(self, **kwargs):
    method _sample_neg (line 18) | def _sample_neg(self, **kwargs):

FILE: code/mmdet/core/bbox/samplers/instance_balanced_pos_sampler.py
  class InstanceBalancedPosSampler (line 9) | class InstanceBalancedPosSampler(RandomSampler):
    method _sample_pos (line 13) | def _sample_pos(self, assign_result, num_expected, **kwargs):

FILE: code/mmdet/core/bbox/samplers/iou_balanced_neg_sampler.py
  class IoUBalancedNegSampler (line 9) | class IoUBalancedNegSampler(RandomSampler):
    method __init__ (line 29) | def __init__(self,
    method sample_via_interval (line 46) | def sample_via_interval(self, max_overlaps, full_set, num_expected):
    method _sample_neg (line 88) | def _sample_neg(self, assign_result, num_expected, **kwargs):

FILE: code/mmdet/core/bbox/samplers/ohem_sampler.py
  class OHEMSampler (line 9) | class OHEMSampler(BaseSampler):
    method __init__ (line 17) | def __init__(self,
    method hard_mining (line 34) | def hard_mining(self, inds, num_expected, bboxes, labels, feats):
    method _sample_pos (line 52) | def _sample_pos(self,
    method _sample_neg (line 80) | def _sample_neg(self,

FILE: code/mmdet/core/bbox/samplers/pseudo_sampler.py
  class PseudoSampler (line 9) | class PseudoSampler(BaseSampler):
    method __init__ (line 12) | def __init__(self, **kwargs):
    method _sample_pos (line 15) | def _sample_pos(self, **kwargs):
    method _sample_neg (line 19) | def _sample_neg(self, **kwargs):
    method sample (line 23) | def sample(self, assign_result, bboxes, gt_bboxes, **kwargs):

FILE: code/mmdet/core/bbox/samplers/random_sampler.py
  class RandomSampler (line 8) | class RandomSampler(BaseSampler):
    method __init__ (line 20) | def __init__(self,
    method random_choice (line 31) | def random_choice(self, gallery, num):
    method _sample_pos (line 57) | def _sample_pos(self, assign_result, num_expected, **kwargs):
    method _sample_neg (line 67) | def _sample_neg(self, assign_result, num_expected, **kwargs):

FILE: code/mmdet/core/bbox/samplers/sampling_result.py
  class SamplingResult (line 6) | class SamplingResult(util_mixins.NiceRepr):
    method __init__ (line 25) | def __init__(self, pos_inds, neg_inds, bboxes, gt_bboxes, assign_result,
    method bboxes (line 52) | def bboxes(self):
    method to (line 56) | def to(self, device):
    method __nice__ (line 71) | def __nice__(self):
    method info (line 80) | def info(self):
    method random (line 93) | def random(cls, rng=None, **kwargs):

FILE: code/mmdet/core/bbox/samplers/score_hlr_sampler.py
  class ScoreHLRSampler (line 11) | class ScoreHLRSampler(BaseSampler):
    method __init__ (line 35) | def __init__(self,
    method random_choice (line 65) | def random_choice(gallery, num):
    method _sample_pos (line 91) | def _sample_pos(self, assign_result, num_expected, **kwargs):
    method _sample_neg (line 99) | def _sample_neg(self,
    method sample (line 215) | def sample(self,

FILE: code/mmdet/core/bbox/transforms.py
  function bbox_flip (line 5) | def bbox_flip(bboxes, img_shape, direction='horizontal'):
  function polygon_flip (line 30) | def polygon_flip(polygons, img_shape, direction='horizontal'):
  function extreme_flip (line 48) | def extreme_flip(extremes, img_shape, direction='horizontal'):
  function kps_flip (line 69) | def kps_flip(kps, img_shape, direction='horizontal'):
  function bbox_mapping (line 91) | def bbox_mapping(bboxes,
  function bbox_mapping_back (line 103) | def bbox_mapping_back(bboxes,
  function instance_mapping_back (line 115) | def instance_mapping_back(bboxes,
  function bbox2roi (line 139) | def bbox2roi(bbox_list):
  function roi2bbox (line 161) | def roi2bbox(rois):
  function bbox2result (line 180) | def bbox2result(bboxes, labels, num_classes):
  function bbox_extreme2result (line 198) | def bbox_extreme2result(bboxes, extremes, labels, num_classes):
  function bbox_poly2result (line 209) | def bbox_poly2result(bboxes, polygons, labels, num_classes, num_contour_...
  function distance2bbox (line 221) | def distance2bbox(points, distance, max_shape=None):
  function bbox2distance (line 245) | def bbox2distance(points, bbox, max_dis=None, eps=0.1):

FILE: code/mmdet/core/evaluation/bbox_overlaps.py
  function bbox_overlaps (line 4) | def bbox_overlaps(bboxes1, bboxes2, mode='iou', eps=1e-6):

FILE: code/mmdet/core/evaluation/class_names.py
  function wider_face_classes (line 4) | def wider_face_classes():
  function voc_classes (line 8) | def voc_classes():
  function imagenet_det_classes (line 16) | def imagenet_det_classes():
  function imagenet_vid_classes (line 57) | def imagenet_vid_classes():
  function coco_classes (line 67) | def coco_classes():
  function cityscapes_classes (line 85) | def cityscapes_classes():
  function get_classes (line 102) | def get_classes(dataset):

FILE: code/mmdet/core/evaluation/eval_hooks.py
  class EvalHook (line 7) | class EvalHook(Hook):
    method __init__ (line 15) | def __init__(self, dataloader, interval=1, bbox_head=None, **eval_kwar...
    method after_train_epoch (line 24) | def after_train_epoch(self, runner):
    method evaluate (line 32) | def evaluate(self, runner, results):
  class DistEvalHook (line 40) | class DistEvalHook(EvalHook):
    method __init__ (line 52) | def __init__(self,
    method after_train_epoch (line 67) | def after_train_epoch(self, runner):

FILE: code/mmdet/core/evaluation/mean_ap.py
  function average_precision (line 12) | def average_precision(recalls, precisions, mode='area'):
  function tpfp_imagenet (line 59) | def tpfp_imagenet(det_bboxes,
  function tpfp_default (line 153) | def tpfp_default(det_bboxes,
  function get_cls_results (line 240) | def get_cls_results(det_results, annotations, class_id):
  function eval_map (line 267) | def eval_map(det_results,
  function print_map_summary (line 393) | def print_map_summary(mean_ap,

FILE: code/mmdet/core/evaluation/recall.py
  function _recalls (line 10) | def _recalls(all_ious, proposal_nums, thrs):
  function set_recall_param (line 43) | def set_recall_param(proposal_nums, iou_thrs):
  function eval_recalls (line 65) | def eval_recalls(gts,
  function print_recall_summary (line 110) | def print_recall_summary(recalls,
  function plot_num_recall (line 143) | def plot_num_recall(recalls, proposal_nums):
  function plot_iou_recall (line 168) | def plot_iou_recall(recalls, iou_thrs):

FILE: code/mmdet/core/fp16/decorators.py
  function auto_fp16 (line 9) | def auto_fp16(apply_to=None, out_fp32=False):
  function force_fp32 (line 88) | def force_fp32(apply_to=None, out_fp16=False):

FILE: code/mmdet/core/fp16/hooks.py
  class Fp16OptimizerHook (line 11) | class Fp16OptimizerHook(OptimizerHook):
    method __init__ (line 27) | def __init__(self,
    method before_run (line 39) | def before_run(self, runner):
    method copy_grads_to_fp32 (line 51) | def copy_grads_to_fp32(self, fp16_net, fp32_weights):
    method copy_params_to_fp16 (line 59) | def copy_params_to_fp16(self, fp16_net, fp32_weights):
    method after_train_iter (line 64) | def after_train_iter(self, runner):
  function wrap_fp16_model (line 99) | def wrap_fp16_model(model):
  function patch_norm_fp32 (line 118) | def patch_norm_fp32(module):
  function patch_forward_method (line 138) | def patch_forward_method(func, src_type, dst_type, convert_output=True):

FILE: code/mmdet/core/fp16/utils.py
  function cast_tensor_type (line 7) | def cast_tensor_type(inputs, src_type, dst_type):

FILE: code/mmdet/core/mask/mask_target.py
  function mask_target (line 6) | def mask_target(pos_proposals_list, pos_assigned_gt_inds_list, gt_masks_...
  function mask_target_single (line 31) | def mask_target_single(pos_proposals, pos_assigned_gt_inds, gt_masks, cfg):

FILE: code/mmdet/core/mask/structures.py
  class BaseInstanceMasks (line 11) | class BaseInstanceMasks(metaclass=ABCMeta):
    method rescale (line 14) | def rescale(self, scale, interpolation='nearest'):
    method resize (line 28) | def resize(self, out_shape, interpolation='nearest'):
    method flip (line 41) | def flip(self, flip_direction='horizontal'):
    method pad (line 53) | def pad(self, out_shape, pad_val):
    method crop (line 66) | def crop(self, bbox):
    method crop_and_resize (line 78) | def crop_and_resize(self,
    method expand (line 103) | def expand(self, expanded_h, expanded_w, top, left):
    method areas (line 109) | def areas(self):
    method to_ndarray (line 114) | def to_ndarray(self):
    method to_tensor (line 123) | def to_tensor(self, dtype, device):
  class BitmapMasks (line 136) | class BitmapMasks(BaseInstanceMasks):
    method __init__ (line 146) | def __init__(self, masks, height, width):
    method __getitem__ (line 163) | def __getitem__(self, index):
    method __iter__ (line 176) | def __iter__(self):
    method __repr__ (line 179) | def __repr__(self):
    method __len__ (line 186) | def __len__(self):
    method rescale (line 190) | def rescale(self, scale, interpolation='nearest'):
    method resize (line 203) | def resize(self, out_shape, interpolation='nearest'):
    method flip (line 214) | def flip(self, flip_direction='horizontal'):
    method pad (line 227) | def pad(self, out_shape, pad_val=0):
    method crop (line 238) | def crop(self, bbox):
    method crop_and_resize (line 257) | def crop_and_resize(self,
    method expand (line 289) | def expand(self, expanded_h, expanded_w, top, left):
    method areas (line 302) | def areas(self):
    method to_ndarray (line 306) | def to_ndarray(self):
    method to_tensor (line 310) | def to_tensor(self, dtype, device):
  class PolygonMasks (line 315) | class PolygonMasks(BaseInstanceMasks):
    method __init__ (line 330) | def __init__(self, masks, height, width):
    method __getitem__ (line 340) | def __getitem__(self, index):
    method __iter__ (line 363) | def __iter__(self):
    method __repr__ (line 366) | def __repr__(self):
    method __len__ (line 373) | def __len__(self):
    method rescale (line 377) | def rescale(self, scale, interpolation=None):
    method resize (line 386) | def resize(self, out_shape, interpolation=None):
    method flip (line 405) | def flip(self, flip_direction='horizontal', keep_cw=False):
    method crop (line 435) | def crop(self, bbox):
    method pad (line 464) | def pad(self, out_shape, pad_val=0):
    method expand (line 468) | def expand(self, *args, **kwargs):
    method crop_and_resize (line 472) | def crop_and_resize(self,
    method to_bitmap (line 508) | def to_bitmap(self):
    method areas (line 514) | def areas(self):
    method _polygon_area (line 532) | def _polygon_area(self, x, y):
    method to_ndarray (line 548) | def to_ndarray(self):
    method to_tensor (line 558) | def to_tensor(self, dtype, device):
  function polygon_to_bitmap (line 568) | def polygon_to_bitmap(polygons, height, width):

FILE: code/mmdet/core/mask/utils.py
  function split_combined_polys (line 6) | def split_combined_polys(polys, poly_lens, polys_per_mask):
  function encode_mask_results (line 36) | def encode_mask_results(mask_results):
  function get_rle (line 65) | def get_rle(cls_segm, img_h, img_w):
  function encode_poly_results (line 70) | def encode_poly_results(mask_results, img_h, img_w):

FILE: code/mmdet/core/post_processing/bbox_nms.py
  function multiclass_nms (line 7) | def multiclass_nms(multi_bboxes,
  function multiclass_nms_lsvr (line 60) | def multiclass_nms_lsvr(multi_bboxes,
  function multiclass_nms_pts (line 102) | def multiclass_nms_pts(multi_bboxes,
  function multiclass_nms_pts_refine (line 167) | def multiclass_nms_pts_refine(multi_bboxes,

FILE: code/mmdet/core/post_processing/merge_augs.py
  function merge_aug_proposals (line 8) | def merge_aug_proposals(aug_proposals, img_metas, rpn_test_cfg):
  function merge_aug_bboxes (line 48) | def merge_aug_bboxes(aug_bboxes, aug_scores, img_metas, rcnn_test_cfg):
  function merge_aug_scores (line 77) | def merge_aug_scores(aug_scores):
  function merge_aug_masks (line 85) | def merge_aug_masks(aug_masks, img_metas, rcnn_test_cfg, weights=None):

FILE: code/mmdet/core/utils/dist_utils.py
  function _allreduce_coalesced (line 10) | def _allreduce_coalesced(tensors, world_size, bucket_size_mb=-1):
  function allreduce_grads (line 32) | def allreduce_grads(params, coalesce=True, bucket_size_mb=-1):
  class DistOptimizerHook (line 54) | class DistOptimizerHook(OptimizerHook):
    method __init__ (line 57) | def __init__(self, *args, **kwargs):

FILE: code/mmdet/core/utils/misc.py
  function tensor2imgs (line 9) | def tensor2imgs(tensor, mean=(0, 0, 0), std=(1, 1, 1), to_rgb=True):
  function multi_apply (line 35) | def multi_apply(func, *args, **kwargs):
  function unmap (line 57) | def unmap(data, count, inds, fill=0):

FILE: code/mmdet/datasets/builder.py
  function _concat_dataset (line 26) | def _concat_dataset(cfg, default_args=None):
  function build_dataset (line 49) | def build_dataset(cfg, default_args=None):
  function build_dataloader (line 68) | def build_dataloader(dataset,
  function worker_init_fn (line 130) | def worker_init_fn(worker_id, num_workers, rank, seed):

FILE: code/mmdet/datasets/cityscapes.py
  class CityscapesDataset (line 19) | class CityscapesDataset(CocoDataset):
    method _filter_imgs (line 24) | def _filter_imgs(self, min_size=32):
    method _parse_ann_info (line 40) | def _parse_ann_info(self, img_info, ann_info):
    method results2txt (line 94) | def results2txt(self, results, outfile_prefix):
    method format_results (line 160) | def format_results(self, results, txtfile_prefix=None):
    method evaluate (line 193) | def evaluate(self,
    method _evaluate_cityscapes (line 260) | def _evaluate_cityscapes(self, results, txtfile_prefix, logger):

FILE: code/mmdet/datasets/coco.py
  class CocoDataset (line 19) | class CocoDataset(CustomDataset):
    method load_annotations (line 36) | def load_annotations(self, ann_file):
    method get_ann_info (line 57) | def get_ann_info(self, idx):
    method get_cat_ids (line 72) | def get_cat_ids(self, idx):
    method _filter_imgs (line 87) | def _filter_imgs(self, min_size=32):
    method get_subset_by_classes (line 98) | def get_subset_by_classes(self):
    method _parse_ann_info (line 123) | def _parse_ann_info(self, img_info, ann_info):
    method xyxy2xywh (line 188) | def xyxy2xywh(self, bbox):
    method _proposal2json (line 208) | def _proposal2json(self, results):
    method _det2json (line 223) | def _det2json(self, results):
    method _segm2json (line 240) | def _segm2json(self, results):
    method results2json (line 278) | def results2json(self, results, outfile_prefix):
    method fast_eval_recall (line 318) | def fast_eval_recall(self, results, proposal_nums, iou_thrs, logger=No...
    method format_results (line 342) | def format_results(self, results, jsonfile_prefix=None, **kwargs):
    method evaluate (line 370) | def evaluate(self,

FILE: code/mmdet/datasets/coco_pose.py
  class CocoPoseDataset (line 19) | class CocoPoseDataset(CustomDataset):
    method load_annotations (line 23) | def load_annotations(self, ann_file):
    method get_ann_info (line 44) | def get_ann_info(self, idx):
    method get_cat_ids (line 59) | def get_cat_ids(self, idx):
    method _filter_imgs (line 74) | def _filter_imgs(self, min_size=32):
    method get_subset_by_classes (line 85) | def get_subset_by_classes(self):
    method _parse_ann_info (line 110) | def _parse_ann_info(self, img_info, ann_info):
    method xyxy2xywh (line 174) | def xyxy2xywh(self, bbox):
    method _proposal2json (line 194) | def _proposal2json(self, results):
    method _det2json (line 209) | def _det2json(self, results):
    method _kps2json (line 226) | def _kps2json(self, results):
    method _segm2json (line 249) | def _segm2json(self, results):
    method results2json (line 287) | def results2json(self, results, outfile_prefix):
    method fast_eval_recall (line 331) | def fast_eval_recall(self, results, proposal_nums, iou_thrs, logger=No...
    method format_results (line 355) | def format_results(self, results, jsonfile_prefix=None, **kwargs):
    method evaluate (line 383) | def evaluate(self,

FILE: code/mmdet/datasets/custom.py
  class CustomDataset (line 13) | class CustomDataset(Dataset):
    method __init__ (line 50) | def __init__(self,
    method __len__ (line 103) | def __len__(self):
    method load_annotations (line 107) | def load_annotations(self, ann_file):
    method load_proposals (line 111) | def load_proposals(self, proposal_file):
    method get_ann_info (line 115) | def get_ann_info(self, idx):
    method get_cat_ids (line 127) | def get_cat_ids(self, idx):
    method pre_pipeline (line 139) | def pre_pipeline(self, results):
    method _filter_imgs (line 150) | def _filter_imgs(self, min_size=32):
    method _set_group_flag (line 158) | def _set_group_flag(self):
    method _rand_another (line 170) | def _rand_another(self, idx):
    method __getitem__ (line 175) | def __getitem__(self, idx):
    method prepare_train_img (line 195) | def prepare_train_img(self, idx):
    method prepare_test_img (line 214) | def prepare_test_img(self, idx):
    method get_classes (line 233) | def get_classes(cls, classes=None):
    method get_subset_by_classes (line 259) | def get_subset_by_classes(self):
    method format_results (line 262) | def format_results(self, results, **kwargs):
    method evaluate (line 266) | def evaluate(self,

FILE: code/mmdet/datasets/dataset_wrappers.py
  class ConcatDataset (line 12) | class ConcatDataset(_ConcatDataset):
    method __init__ (line 22) | def __init__(self, datasets):
    method get_cat_ids (line 31) | def get_cat_ids(self, idx):
  class RepeatDataset (line 55) | class RepeatDataset(object):
    method __init__ (line 68) | def __init__(self, dataset, times):
    method __getitem__ (line 77) | def __getitem__(self, idx):
    method get_cat_ids (line 80) | def get_cat_ids(self, idx):
    method __len__ (line 92) | def __len__(self):
  class ClassBalancedDataset (line 99) | class ClassBalancedDataset(object):
    method __init__ (line 131) | def __init__(self, dataset, oversample_thr):
    method _get_repeat_factors (line 149) | def _get_repeat_factors(self, dataset, repeat_thr):
    method __getitem__ (line 192) | def __getitem__(self, idx):
    method __len__ (line 196) | def __len__(self):

FILE: code/mmdet/datasets/deepfashion.py
  class DeepFashionDataset (line 6) | class DeepFashionDataset(CocoDataset):

FILE: code/mmdet/datasets/lvis.py
  class LVISDataset (line 15) | class LVISDataset(CocoDataset):
    method load_annotations (line 267) | def load_annotations(self, ann_file):
    method evaluate (line 301) | def evaluate(self,

FILE: code/mmdet/datasets/pipelines/auto_augment.py
  class AutoAugment (line 10) | class AutoAugment(object):
    method __init__ (line 51) | def __init__(self, policies):
    method __call__ (line 65) | def __call__(self, results):
    method __repr__ (line 69) | def __repr__(self):

FILE: code/mmdet/datasets/pipelines/compose.py
  class Compose (line 9) | class Compose(object):
    method __init__ (line 17) | def __init__(self, transforms):
    method __call__ (line 29) | def __call__(self, data):
    method __repr__ (line 45) | def __repr__(self):

FILE: code/mmdet/datasets/pipelines/formating.py
  function to_tensor (line 11) | def to_tensor(data):
  class ToTensor (line 37) | class ToTensor(object):
    method __init__ (line 44) | def __init__(self, keys):
    method __call__ (line 47) | def __call__(self, results):
    method __repr__ (line 61) | def __repr__(self):
  class ImageToTensor (line 66) | class ImageToTensor(object):
    method __init__ (line 77) | def __init__(self, keys):
    method __call__ (line 80) | def __call__(self, results):
    method __repr__ (line 98) | def __repr__(self):
  class Transpose (line 103) | class Transpose(object):
    method __init__ (line 111) | def __init__(self, keys, order):
    method __call__ (line 115) | def __call__(self, results):
    method __repr__ (line 129) | def __repr__(self):
  class ToDataContainer (line 135) | class ToDataContainer(object):
    method __init__ (line 146) | def __init__(self,
    method __call__ (line 151) | def __call__(self, results):
    method __repr__ (line 169) | def __repr__(self):
  class DefaultFormatBundle (line 174) | class DefaultFormatBundle(object):
    method __call__ (line 191) | def __call__(self, results):
    method _add_default_meta_keys (line 221) | def _add_default_meta_keys(self, results):
    method __repr__ (line 246) | def __repr__(self):
  class Collect (line 251) | class Collect(object):
    method __init__ (line 290) | def __init__(self,
    method __call__ (line 298) | def __call__(self, results):
    method __repr__ (line 320) | def __repr__(self):
  class WrapFieldsToLists (line 326) | class WrapFieldsToLists(object):
    method __call__ (line 347) | def __call__(self, results):
    method __repr__ (line 363) | def __repr__(self):

FILE: code/mmdet/datasets/pipelines/formating_reppointsv2.py
  class RPDV2FormatBundle (line 13) | class RPDV2FormatBundle(object):
    method __init__ (line 30) | def __init__(self):
    method __call__ (line 33) | def __call__(self, results):
    method _add_default_meta_keys (line 70) | def _add_default_meta_keys(self, results):
    method __repr__ (line 95) | def __repr__(self):

FILE: code/mmdet/datasets/pipelines/instaboost.py
  class InstaBoost (line 7) | class InstaBoost(object):
    method __init__ (line 14) | def __init__(self,
    method _load_anns (line 35) | def _load_anns(self, results):
    method _parse_anns (line 57) | def _parse_anns(self, results, anns, img):
    method __call__ (line 78) | def __call__(self, results):
    method __repr__ (line 94) | def __repr__(self):

FILE: code/mmdet/datasets/pipelines/loading.py
  class LoadImageFromFile (line 12) | class LoadImageFromFile(object):
    method __init__ (line 31) | def __init__(self,
    method __call__ (line 40) | def __call__(self, results):
    method __repr__ (line 72) | def __repr__(self):
  class LoadMultiChannelImageFromFiles (line 81) | class LoadMultiChannelImageFromFiles(object):
    method __init__ (line 101) | def __init__(self,
    method __call__ (line 110) | def __call__(self, results):
    method __repr__ (line 155) | def __repr__(self):
  class LoadAnnotations (line 164) | class LoadAnnotations(object):
    method __init__ (line 183) | def __init__(self,
    method _load_bboxes (line 207) | def _load_bboxes(self, results):
    method _load_extremes (line 227) | def _load_extremes(self, results):
    method _load_keypoints (line 242) | def _load_keypoints(self, results):
    method _load_labels (line 257) | def _load_labels(self, results):
    method _poly2mask (line 270) | def _poly2mask(self, mask_ann, img_h, img_w):
    method process_polygons (line 297) | def process_polygons(self, polygons):
    method uniformsample (line 314) | def uniformsample(self, pgtnp_px2, newpnum): # https://github.com/zju3...
    method _polygon_area (line 378) | def _polygon_area(self, poly):
    method filter_tiny_polys (line 396) | def filter_tiny_polys(self, polys):
    method get_cw_poly (line 405) | def get_cw_poly(self, poly):
    method unify_origin_polygon (line 408) | def unify_origin_polygon(self, poly):
    method unify_polygons (line 422) | def unify_polygons(self, polygons, gt_bbox):
    method _load_masks (line 443) | def _load_masks(self, results):
    method _load_semantic_seg (line 469) | def _load_semantic_seg(self, results):
    method __call__ (line 490) | def __call__(self, results):
    method __repr__ (line 517) | def __repr__(self):
  class LoadProposals (line 531) | class LoadProposals(object):
    method __init__ (line 541) | def __init__(self, num_max_proposals=None):
    method __call__ (line 544) | def __call__(self, results):
    method __repr__ (line 570) | def __repr__(self):

FILE: code/mmdet/datasets/pipelines/loading_reppointsv2.py
  class LoadRPDV2Annotations (line 9) | class LoadRPDV2Annotations(object):
    method __init__ (line 27) | def __init__(self, num_classes=80):
    method _load_semantic_map_from_box (line 31) | def _load_semantic_map_from_box(self, results):
    method __call__ (line 52) | def __call__(self, results):
    method __repr__ (line 66) | def __repr__(self):
  class LoadDenseRPDV2Annotations (line 73) | class LoadDenseRPDV2Annotations(object):
    method __init__ (line 91) | def __init__(self):
    method mask_to_poly (line 94) | def mask_to_poly(self, mask):
    method _load_semantic_map_from_mask (line 103) | def _load_semantic_map_from_mask(self, results):
    method _load_contours (line 120) | def _load_contours(self, results):
    method __call__ (line 143) | def __call__(self, results):
    method __repr__ (line 159) | def __repr__(self):

FILE: code/mmdet/datasets/pipelines/test_time_aug.py
  class MultiScaleFlipAug (line 10) | class MultiScaleFlipAug(object):
    method __init__ (line 52) | def __init__(self,
    method __call__ (line 83) | def __call__(self, results):
    method __repr__ (line 112) | def __repr__(self):

FILE: code/mmdet/datasets/pipelines/transforms.py
  class Resize (line 25) | class Resize(object):
    method __init__ (line 54) | def __init__(self,
    method random_select (line 80) | def random_select(img_scales):
    method random_sample (line 98) | def random_sample(img_scales):
    method random_sample_ratio (line 125) | def random_sample_ratio(img_scale, ratio_range):
    method _random_scale (line 151) | def _random_scale(self, results):
    method _resize_img (line 184) | def _resize_img(self, results):
    method _resize_bboxes (line 209) | def _resize_bboxes(self, results):
    method _resize_extremes (line 218) | def _resize_extremes(self, results):
    method _resize_keypoints (line 228) | def _resize_keypoints(self, results):
    method _resize_masks (line 241) | def _resize_masks(self, results):
    method _resize_seg (line 251) | def _resize_seg(self, results):
    method __call__ (line 262) | def __call__(self, results):
    method __repr__ (line 295) | def __repr__(self):
  class RandomFlip (line 305) | class RandomFlip(object):
    method __init__ (line 318) | def __init__(self, flip_ratio=None, direction='horizontal', keep_poly_...
    method bbox_flip (line 328) | def bbox_flip(self, bboxes, img_shape, direction):
    method extreme_flip (line 354) | def extreme_flip(self, extremes, img_shape, direction):
    method keypoint_flip (line 390) | def keypoint_flip(self, keypoints, img_shape, direction):
    method __call__ (line 409) | def __call__(self, results):
    method __repr__ (line 458) | def __repr__(self):
  class Pad (line 463) | class Pad(object):
    method __init__ (line 476) | def __init__(self, size=None, size_divisor=None, pad_val=0):
    method _pad_img (line 484) | def _pad_img(self, results):
    method _pad_masks (line 497) | def _pad_masks(self, results):
    method _pad_seg (line 503) | def _pad_seg(self, results):
    method __call__ (line 509) | def __call__(self, results):
    method __repr__ (line 524) | def __repr__(self):
  class Normalize (line 533) | class Normalize(object):
    method __init__ (line 545) | def __init__(self, mean, std, to_rgb=True):
    method __call__ (line 550) | def __call__(self, results):
    method __repr__ (line 568) | def __repr__(self):
  class RandomCrop (line 575) | class RandomCrop(object):
    method __init__ (line 591) | def __init__(self, crop_size):
    method __call__ (line 604) | def __call__(self, results):
    method __repr__ (line 670) | def __repr__(self):
  class SegRescale (line 675) | class SegRescale(object):
    method __init__ (line 682) | def __init__(self, scale_factor=1):
    method __call__ (line 685) | def __call__(self, results):
    method __repr__ (line 701) | def __repr__(self):
  class PhotoMetricDistortion (line 706) | class PhotoMetricDistortion(object):
    method __init__ (line 727) | def __init__(self,
    method __call__ (line 737) | def __call__(self, results):
    method __repr__ (line 800) | def __repr__(self):
  class Expand (line 812) | class Expand(object):
    method __init__ (line 825) | def __init__(self,
    method __call__ (line 841) | def __call__(self, results):
    method __repr__ (line 889) | def __repr__(self):
  class MinIoURandomCrop (line 898) | class MinIoURandomCrop(object):
    method __init__ (line 915) | def __init__(self, min_ious=(0.1, 0.3, 0.5, 0.7, 0.9), min_crop_size=0...
    method __call__ (line 929) | def __call__(self, results):
    method __repr__ (line 1022) | def __repr__(self):
  class Corrupt (line 1030) | class Corrupt(object):
    method __init__ (line 1041) | def __init__(self, corruption, severity=1):
    method __call__ (line 1045) | def __call__(self, results):
    method __repr__ (line 1066) | def __repr__(self):
  class Albu (line 1074) | class Albu(object):
    method __init__ (line 1116) | def __init__(self,
    method albu_builder (line 1153) | def albu_builder(self, cfg):
    method mapper (line 1186) | def mapper(d, keymap):
    method __call__ (line 1204) | def __call__(self, results):
    method __repr__ (line 1263) | def __repr__(self):
  class RandomCenterCropPad (line 1269) | class RandomCenterCropPad(object):
    method __init__ (line 1349) | def __init__(self,
    method _get_border (line 1391) | def _get_border(self, border, size):
    method _filter_boxes (line 1408) | def _filter_boxes(self, patch, boxes):
    method _crop_image_and_paste (line 1423) | def _crop_image_and_paste(self, image, center, size):
    method _train_aug (line 1472) | def _train_aug(self, results):
    method _test_aug (line 1538) | def _test_aug(self, results):
    method __call__ (line 1570) | def __call__(self, results):
    method __repr__ (line 1582) | def __repr__(self):

FILE: code/mmdet/datasets/samplers/distributed_sampler.py
  class DistributedSampler (line 5) | class DistributedSampler(_DistributedSampler):
    method __init__ (line 7) | def __init__(self, dataset, num_replicas=None, rank=None, shuffle=True):
    method __iter__ (line 11) | def __iter__(self):

FILE: code/mmdet/datasets/samplers/group_sampler.py
  class GroupSampler (line 10) | class GroupSampler(Sampler):
    method __init__ (line 12) | def __init__(self, dataset, samples_per_gpu=1):
    method __iter__ (line 23) | def __iter__(self):
    method __len__ (line 47) | def __len__(self):
  class DistributedGroupSampler (line 51) | class DistributedGroupSampler(Sampler):
    method __init__ (line 69) | def __init__(self,
    method __iter__ (line 96) | def __iter__(self):
    method __len__ (line 136) | def __len__(self):
    method set_epoch (line 139) | def set_epoch(self, epoch):

FILE: code/mmdet/datasets/voc.py
  class VOCDataset (line 7) | class VOCDataset(XMLDataset):
    method __init__ (line 14) | def __init__(self, **kwargs):
    method evaluate (line 23) | def evaluate(self,

FILE: code/mmdet/datasets/wider_face.py
  class WIDERFaceDataset (line 11) | class WIDERFaceDataset(XMLDataset):
    method __init__ (line 19) | def __init__(self, **kwargs):
    method load_annotations (line 22) | def load_annotations(self, ann_file):

FILE: code/mmdet/datasets/xml_style.py
  class XMLDataset (line 13) | class XMLDataset(CustomDataset):
    method __init__ (line 22) | def __init__(self, min_size=None, **kwargs):
    method load_annotations (line 27) | def load_annotations(self, ann_file):
    method get_subset_by_classes (line 61) | def get_subset_by_classes(self):
    method get_ann_info (line 78) | def get_ann_info(self, idx):
    method get_cat_ids (line 143) | def get_cat_ids(self, idx):

FILE: code/mmdet/models/backbones/detectors_resnet.py
  class Bottleneck (line 10) | class Bottleneck(_Bottleneck):
    method __init__ (line 28) | def __init__(self,
    method init_weights (line 61) | def init_weights(self):
    method rfp_forward (line 66) | def rfp_forward(self, x, rfp_feat):
  class ResLayer (line 113) | class ResLayer(nn.Sequential):
    method __init__ (line 139) | def __init__(self,
  class DetectoRS_ResNet (line 205) | class DetectoRS_ResNet(ResNet):
    method __init__ (line 228) | def __init__(self,
    method make_res_layer (line 277) | def make_res_layer(self, **kwargs):
    method forward (line 281) | def forward(self, x):
    method rfp_forward (line 288) | def rfp_forward(self, x, rfp_feats):

FILE: code/mmdet/models/backbones/detectors_resnext.py
  class Bottleneck (line 10) | class Bottleneck(_Bottleneck):
    method __init__ (line 13) | def __init__(self,
  class DetectoRS_ResNeXt (line 97) | class DetectoRS_ResNeXt(DetectoRS_ResNet):
    method __init__ (line 111) | def __init__(self, groups=1, base_width=4, **kwargs):
    method make_res_layer (line 116) | def make_res_layer(self, **kwargs):

FILE: code/mmdet/models/backbones/hourglass.py
  class HourglassModule (line 9) | class HourglassModule(nn.Module):
    method __init__ (line 23) | def __init__(self,
    method forward (line 70) | def forward(self, x):
  class HourglassNet (line 81) | class HourglassNet(nn.Module):
    method __init__ (line 112) | def __init__(self,
    method init_weights (line 164) | def init_weights(self, pretrained=None):
    method forward (line 174) | def forward(self, x):

FILE: code/mmdet/models/backbones/hrnet.py
  class HRModule (line 12) | class HRModule(nn.Module):
    method __init__ (line 17) | def __init__(self,
    method _check_branches (line 43) | def _check_branches(self, num_branches, num_blocks, in_channels,
    method _make_one_branch (line 60) | def _make_one_branch(self,
    method _make_branches (line 104) | def _make_branches(self, num_branches, block, num_blocks, num_channels):
    method _make_fuse_layers (line 113) | def _make_fuse_layers(self):
    method forward (line 175) | def forward(self, x):
  class HRNet (line 196) | class HRNet(nn.Module):
    method __init__ (line 257) | def __init__(self,
    method norm1 (line 346) | def norm1(self):
    method norm2 (line 351) | def norm2(self):
    method _make_transition_layer (line 355) | def _make_transition_layer(self, num_channels_pre_layer,
    method _make_layer (line 401) | def _make_layer(self, block, inplanes, planes, blocks, stride=1):
    method _make_stage (line 436) | def _make_stage(self, layer_config, in_channels, multiscale_output=True):
    method init_weights (line 465) | def init_weights(self, pretrained=None):
    method forward (line 491) | def forward(self, x):
    method train (line 527) | def train(self, mode=True):

FILE: code/mmdet/models/backbones/mobilenet.py
  class _NewEmptyTensorOp (line 22) | class _NewEmptyTensorOp(torch.autograd.Function):
    method forward (line 24) | def forward(ctx, x, new_shape):
    method backward (line 29) | def backward(ctx, grad):
  class Conv2d (line 34) | class Conv2d(torch.nn.Conv2d):
    method forward (line 35) | def forward(self, x):
  function conv_bn (line 50) | def conv_bn(inp, oup, stride, norm_cfg=dict(type='BN', requires_grad=Tru...
  function conv_1x1_bn (line 58) | def conv_1x1_bn(inp, oup, norm_cfg=dict(type='BN', requires_grad=True)):
  class InvertedResidual (line 66) | class InvertedResidual(nn.Module):
    method __init__ (line 67) | def __init__(self, inp, oup, stride, expand_ratio, norm_cfg=dict(type=...
    method forward (line 100) | def forward(self, x):
  class MobileNetV2 (line 108) | class MobileNetV2(nn.Module):
    method __init__ (line 112) | def __init__(self,
    method _freeze_backbone (line 150) | def _freeze_backbone(self, freeze_at):
    method forward (line 155) | def forward(self, x):
    method init_weights (line 163) | def init_weights(self, pretrained=None):
  function load_url_dist (line 182) | def load_url_dist(url, model_dir=None, map_location=None):
  function _load_checkpoint (line 196) | def _load_checkpoint(filename, map_location=None):
  function load_checkpoint (line 246) | def load_checkpoint(model,

FILE: code/mmdet/models/backbones/regnet.py
  class RegNet (line 11) | class RegNet(ResNet):
    method __init__ (line 83) | def __init__(self,
    method _make_stem_layer (line 204) | def _make_stem_layer(self, in_channels, base_channels):
    method generate_regnet (line 218) | def generate_regnet(self,
    method quantize_float (line 251) | def quantize_float(number, divisor):
    method adjust_width_group (line 263) | def adjust_width_group(self, widths, bottleneck_ratio, groups):
    method get_stages_from_blocks (line 288) | def get_stages_from_blocks(self, widths):
    method forward (line 310) | def forward(self, x):

FILE: code/mmdet/models/backbones/res2net.py
  class Bottle2neck (line 17) | class Bottle2neck(_Bottleneck):
    method __init__ (line 20) | def __init__(self,
    method forward (line 108) | def forward(self, x):
  class Res2Layer (line 165) | class Res2Layer(nn.Sequential):
    method __init__ (line 184) | def __init__(self,
  class Res2Net (line 245) | class Res2Net(ResNet):
    method __init__ (line 302) | def __init__(self,
    method make_res_layer (line 314) | def make_res_layer(self, **kwargs):
    method init_weights (line 321) | def init_weights(self, pretrained=None):

FILE: code/mmdet/models/backbones/resnet.py
  class BasicBlock (line 14) | class BasicBlock(nn.Module):
    method __init__ (line 17) | def __init__(self,
    method norm1 (line 57) | def norm1(self):
    method norm2 (line 62) | def norm2(self):
    method forward (line 66) | def forward(self, x):
  class Bottleneck (line 96) | class Bottleneck(nn.Module):
    method __init__ (line 99) | def __init__(self,
    method make_block_plugins (line 216) | def make_block_plugins(self, in_channels, plugins):
    method forward_plugin (line 240) | def forward_plugin(self, x, plugin_names):
    method norm1 (line 247) | def norm1(self):
    method norm2 (line 252) | def norm2(self):
    method norm3 (line 257) | def norm3(self):
    method forward (line 261) | def forward(self, x):
  class ResNet (line 305) | class ResNet(nn.Module):
    method __init__ (line 364) | def __init__(self,
    method make_stage_plugins (line 452) | def make_stage_plugins(self, plugins, stage_idx):
    method make_res_layer (line 512) | def make_res_layer(self, **kwargs):
    method norm1 (line 517) | def norm1(self):
    method _make_stem_layer (line 521) | def _make_stem_layer(self, in_channels, stem_channels):
    method _freeze_stages (line 569) | def _freeze_stages(self):
    method init_weights (line 587) | def init_weights(self, pretrained=None):
    method forward (line 619) | def forward(self, x):
    method train (line 636) | def train(self, mode=True):
  class ResNetV1d (line 649) | class ResNetV1d(ResNet):
    method __init__ (line 659) | def __init__(self, **kwargs):

FILE: code/mmdet/models/backbones/resnext.py
  class Bottleneck (line 11) | class Bottleneck(_Bottleneck):
    method __init__ (line 14) | def __init__(self,
  class ResNeXt (line 87) | class ResNeXt(ResNet):
    method __init__ (line 120) | def __init__(self, groups=1, base_width=4, **kwargs):
    method make_res_layer (line 125) | def make_res_layer(self, **kwargs):

FILE: code/mmdet/models/backbones/ssd_vgg.py
  class SSDVGG (line 12) | class SSDVGG(VGG):
    method __init__ (line 38) | def __init__(self,
    method init_weights (line 75) | def init_weights(self, pretrained=None):
    method forward (line 102) | def forward(self, x):
    method _make_extra_layers (line 119) | def _make_extra_layers(self, outplanes):
  class L2Norm (line 146) | class L2Norm(nn.Module):
    method __init__ (line 148) | def __init__(self, n_dims, scale=20., eps=1e-10):
    method forward (line 163) | def forward(self, x):

FILE: code/mmdet/models/builder.py
  function build (line 13) | def build(cfg, registry, default_args=None):
  function build_backbone (line 35) | def build_backbone(cfg):
  function build_neck (line 40) | def build_neck(cfg):
  function build_roi_extractor (line 45) | def build_roi_extractor(cfg):
  function build_shared_head (line 50) | def build_shared_head(cfg):
  function build_head (line 55) | def build_head(cfg):
  function build_loss (line 60) | def build_loss(cfg):
  function build_detector (line 65) | def build_detector(cfg, train_cfg=None, test_cfg=None):

FILE: code/mmdet/models/dense_heads/anchor_free_head.py
  class AnchorFreeHead (line 14) | class AnchorFreeHead(BaseDenseHead):
    method __init__ (line 42) | def __init__(self,
    method _init_layers (line 87) | def _init_layers(self):
    method _init_cls_convs (line 93) | def _init_cls_convs(self):
    method _init_reg_convs (line 113) | def _init_reg_convs(self):
    method _init_predictor (line 133) | def _init_predictor(self):
    method init_weights (line 139) | def init_weights(self):
    method _load_from_state_dict (line 151) | def _load_from_state_dict(self, state_dict, prefix, local_metadata, st...
    method forward (line 189) | def forward(self, feats):
    method forward_single (line 207) | def forward_single(self, x):
    method loss (line 232) | def loss(self,
    method get_bboxes (line 261) | def get_bboxes(self,
    method get_targets (line 284) | def get_targets(self, points, gt_bboxes_list, gt_labels_list):
    method _get_points_single (line 298) | def _get_points_single(self,
    method get_points (line 314) | def get_points(self, featmap_sizes, dtype, device, flatten=False):

FILE: code/mmdet/models/dense_heads/anchor_head.py
  class AnchorHead (line 14) | class AnchorHead(BaseDenseHead):
    method __init__ (line 35) | def __init__(self,
    method _init_layers (line 103) | def _init_layers(self):
    method init_weights (line 109) | def init_weights(self):
    method forward_single (line 114) | def forward_single(self, x):
    method forward (line 131) | def forward(self, feats):
    method get_anchors (line 149) | def get_anchors(self, featmap_sizes, img_metas, device='cuda'):
    method _get_targets_single (line 179) | def _get_targets_single(self,
    method get_targets (line 279) | def get_targets(self,
    method loss_single (line 378) | def loss_single(self, cls_score, bbox_pred, anchors, labels, label_wei...
    method loss (line 426) | def loss(self,
    method get_bboxes (line 496) | def get_bboxes(self,
    method _get_bboxes_single (line 574) | def _get_bboxes_single(self,

FILE: code/mmdet/models/dense_heads/atss_head.py
  function reduce_mean (line 13) | def reduce_mean(tensor):
  class ATSSHead (line 22) | class ATSSHead(AnchorHead):
    method __init__ (line 33) | def __init__(self,
    method _init_layers (line 57) | def _init_layers(self):
    method init_weights (line 94) | def init_weights(self):
    method forward (line 105) | def forward(self, feats):
    method forward_single (line 123) | def forward_single(self, x, scale):
    method loss_single (line 152) | def loss_single(self, anchors, cls_score, bbox_pred, centerness, labels,
    method loss (line 228) | def loss(self,
    method centerness_target (line 302) | def centerness_target(self, anchors, bbox_targets):
    method get_bboxes (line 321) | def get_bboxes(self,
    method _get_bboxes_single (line 380) | def _get_bboxes_single(self,
    method get_targets (line 467) | def get_targets(self,
    method _get_target_single (line 531) | def _get_target_single(self,
    method get_num_level_anchors_inside (line 635) | def get_num_level_anchors_inside(self, num_level_anchors, inside_flags):

FILE: code/mmdet/models/dense_heads/base_dense_head.py
  class BaseDenseHead (line 6) | class BaseDenseHead(nn.Module, metaclass=ABCMeta):
    method __init__ (line 9) | def __init__(self):
    method loss (line 13) | def loss(self, **kwargs):
    method get_bboxes (line 18) | def get_bboxes(self, **kwargs):
    method forward_train (line 22) | def forward_train(self,

FILE: code/mmdet/models/dense_heads/dense_reppoints_head.py
  class DenseRepPointsHead (line 18) | class DenseRepPointsHead(AnchorFreeHead):
    method __init__ (line 36) | def __init__(self,
    method _init_layers (line 108) | def _init_layers(self):
    method init_weights (line 163) | def init_weights(self):
    method points2bbox (line 183) | def points2bbox(self, pts):
    method sample_offset (line 206) | def sample_offset(self, x, flow, padding_mode):
    method compute_offset_feature (line 230) | def compute_offset_feature(self, x, offset, padding_mode):
    method sample_offset_3d (line 252) | def sample_offset_3d(self, x, flow, padding_mode):
    method compute_offset_feature_5d (line 281) | def compute_offset_feature_5d(self, x, offset, padding_mode):
    method forward (line 296) | def forward(self, feats, test=False):
    method forward_pts_head_single (line 307) | def forward_pts_head_single(self, x):
    method forward_mask_head (line 346) | def forward_mask_head(self, mask_feat_list, pts_out_list):
    method forward_mask_head_single (line 371) | def forward_mask_head_single(self, pts, mask_feat):
    method normalize_pts_within_bboxes (line 395) | def normalize_pts_within_bboxes(pts):
    method grid_position_sensitive_group_partition (line 420) | def grid_position_sensitive_group_partition(self, pts, num_group):
    method get_points (line 442) | def get_points(self, featmap_sizes, img_metas):
    method offset_to_pts (line 481) | def offset_to_pts(self, center_list, pred_list):
    method offset_to_pts_img_lvl (line 497) | def offset_to_pts_img_lvl(self, center_list, pred_list):
    method _dense_point_target_single (line 519) | def _dense_point_target_single(self,
    method get_targets (line 618) | def get_targets(self,
    method loss_single (line 715) | def loss_single(self, cls_score, pts_pred_init, pts_pred_refine, pts_s...
    method loss (line 786) | def loss(self,
    method get_bboxes (line 883) | def get_bboxes(self,
    method _get_bboxes_single (line 923) | def _get_bboxes_single(self,
    method get_num_level_proposals_inside (line 995) | def get_num_level_proposals_inside(self, num_level_proposals, inside_f...
  function mask_to_levels (line 1003) | def mask_to_levels(target, mask_index_list):
  function mask_to_poly (line 1019) | def mask_to_poly(mask):
  function distance_sample_pts (line 1029) | def distance_sample_pts(gt_bboxes, gt_masks, cfg, num_pts):

FILE: code/mmdet/models/dense_heads/dense_reppoints_v2_head.py
  class DenseRepPointsV2Head (line 18) | class DenseRepPointsV2Head(AnchorFreeHead):
    method __init__ (line 36) | def __init__(self,
    method _init_layers (line 117) | def _init_layers(self):
    method init_weights (line 198) | def init_weights(self):
    method points2bbox (line 223) | def points2bbox(self, pts):
    method sample_offset (line 246) | def sample_offset(self, x, flow, padding_mode):
    method compute_offset_feature (line 270) | def compute_offset_feature(self, x, offset, padding_mode):
    method sample_offset_3d (line 292) | def sample_offset_3d(self, x, flow, padding_mode):
    method compute_offset_feature_5d (line 321) | def compute_offset_feature_5d(self, x, offset, padding_mode):
    method forward (line 336) | def forward(self, feats, test=False):
    method forward_pts_head_single (line 350) | def forward_pts_head_single(self, x):
    method forward_mask_head (line 411) | def forward_mask_head(self, mask_feat_list, pts_out_list, sem_feat_list):
    method forward_mask_head_single (line 436) | def forward_mask_head_single(self, pts, mask_feat):
    method normalize_pts_within_bboxes (line 460) | def normalize_pts_within_bboxes(pts):
    method grid_position_sensitive_group_partition (line 485) | def grid_position_sensitive_group_partition(self, pts, num_group):
    method get_points (line 507) | def get_points(self, featmap_sizes, img_metas):
    method offset_to_pts (line 546) | def offset_to_pts(self, center_list, pred_list):
    method offset_to_pts_img_lvl (line 562) | def offset_to_pts_img_lvl(self, center_list, pred_list):
    method _dense_point_target_single (line 584) | def _dense_point_target_single(self,
    method get_targets (line 683) | def get_targets(self,
    method _cont_target_single (line 780) | def _cont_target_single(self,
    method get_cont_target (line 803) | def get_cont_target(self,
    method loss_single (line 845) | def loss_single(self, cls_score, pts_pred_init, pts_pred_refine, pts_s...
    method loss (line 930) | def loss(self,
    method get_bboxes (line 1073) | def get_bboxes(self,
    method _get_bboxes_single (line 1122) | def _get_bboxes_single(self,
    method get_num_level_proposals_inside (line 1260) | def get_num_level_proposals_inside(self, num_level_proposals, inside_f...
  function mask_to_levels (line 1268) | def mask_to_levels(target, mask_index_list):
  function mask_to_poly (line 1284) | def mask_to_poly(mask):
  function distance_sample_pts (line 1294) | def distance_sample_pts(gt_bboxes, gt_masks, cfg, num_pts):

FILE: code/mmdet/models/dense_heads/fcos_head.py
  class FCOSHead (line 14) | class FCOSHead(AnchorFreeHead):
    method __init__ (line 55) | def __init__(self,
    method _init_layers (line 91) | def _init_layers(self):
    method init_weights (line 97) | def init_weights(self):
    method forward (line 102) | def forward(self, feats):
    method forward_single (line 123) | def forward_single(self, x, scale, stride):
    method loss (line 155) | def loss(self,
    method get_bboxes (line 252) | def get_bboxes(self,
    method _get_bboxes_single (line 309) | def _get_bboxes_single(self,
    method _get_points_single (line 385) | def _get_points_single(self,
    method get_targets (line 397) | def get_targets(self, points, gt_bboxes_list, gt_labels_list):
    method _get_target_single (line 458) | def _get_target_single(self, gt_bboxes, gt_labels, points, regress_ran...
    method centerness_target (line 542) | def centerness_target(self, pos_bbox_targets):

FILE: code/mmdet/models/dense_heads/fovea_head.py
  class FeatureAlign (line 13) | class FeatureAlign(nn.Module):
    method __init__ (line 15) | def __init__(self,
    method init_weights (line 32) | def init_weights(self):
    method forward (line 36) | def forward(self, x, shape):
  class FoveaHead (line 43) | class FoveaHead(AnchorFreeHead):
    method __init__ (line 48) | def __init__(self,
    method _init_layers (line 65) | def _init_layers(self):
    method init_weights (line 105) | def init_weights(self):
    method forward_single (line 110) | def forward_single(self, x):
    method _get_points_single (line 123) | def _get_points_single(self, *args, **kwargs):
    method loss (line 127) | def loss(self,
    method get_targets (line 178) | def get_targets(self, gt_bbox_list, gt_label_list, featmap_sizes, poin...
    method _get_target_single (line 200) | def _get_target_single(self,
    method get_bboxes (line 261) | def get_bboxes(self,
    method _get_bboxes_single (line 292) | def _get_bboxes_single(self,

FILE: code/mmdet/models/dense_heads/free_anchor_retina_head.py
  class FreeAnchorRetinaHead (line 10) | class FreeAnchorRetinaHead(RetinaHead):
    method __init__ (line 31) | def __init__(self,
    method loss (line 51) | def loss(self,
    method positive_bag_loss (line 217) | def positive_bag_loss(self, matched_cls_prob, matched_box_prob):
    method negative_bag_loss (line 244) | def negative_bag_loss(self, cls_prob, box_prob):

FILE: code/mmdet/models/dense_heads/fsaf_head.py
  class FSAFHead (line 13) | class FSAFHead(RetinaHead):
    method forward_single (line 32) | def forward_single(self, x):
    method init_weights (line 49) | def init_weights(self):
    method _get_targets_single (line 56) | def _get_targets_single(self,
    method loss (line 161) | def loss(self,
    method calculate_accuracy (line 289) | def calculate_accuracy(self, cls_scores, labels_list, pos_inds):
    method collect_loss_level_single (line 320) | def collect_loss_level_single(self, cls_loss, reg_loss, assigned_gt_inds,
    method reweight_loss_single (line 351) | def reweight_loss_single(self, cls_loss, reg_loss, assigned_gt_inds,

FILE: code/mmdet/models/dense_heads/ga_retina_head.py
  class GARetinaHead (line 10) | class GARetinaHead(GuidedAnchorHead):
    method __init__ (line 13) | def __init__(self,
    method _init_layers (line 25) | def _init_layers(self):
    method init_weights (line 72) | def init_weights(self):
    method forward_single (line 88) | def forward_single(self, x):

FILE: code/mmdet/models/dense_heads/ga_rpn_head.py
  class GARPNHead (line 13) | class GARPNHead(RPNTestMixin, GuidedAnchorHead):
    method __init__ (line 16) | def __init__(self, in_channels, **kwargs):
    method _init_layers (line 20) | def _init_layers(self):
    method init_weights (line 26) | def init_weights(self):
    method forward_single (line 31) | def forward_single(self, x):
    method loss (line 40) | def loss(self,
    method _get_bboxes_single (line 63) | def _get_bboxes_single(self,

FILE: code/mmdet/models/dense_heads/gfl_head.py
  function reduce_mean (line 15) | def reduce_mean(tensor):
  class Integral (line 23) | class Integral(nn.Module):
    method __init__ (line 36) | def __init__(self, reg_max=16):
    method forward (line 42) | def forward(self, x):
  class GFLHead (line 60) | class GFLHead(AnchorHead):
    method __init__ (line 93) | def __init__(self,
    method _init_layers (line 118) | def _init_layers(self):
    method init_weights (line 151) | def init_weights(self):
    method forward (line 161) | def forward(self, feats):
    method forward_single (line 179) | def forward_single(self, x, scale):
    method anchor_center (line 205) | def anchor_center(self, anchors):
    method loss_single (line 218) | def loss_single(self, anchors, cls_score, bbox_pred, labels, label_wei...
    method loss (line 307) | def loss(self,
    method _get_bboxes_single (line 379) | def _get_bboxes_single(self,
    method get_targets (line 459) | def get_targets(self,
    method _get_target_single (line 523) | def _get_target_single(self,
    method get_num_level_anchors_inside (line 627) | def get_num_level_anchors_inside(self, num_level_anchors, inside_flags):

FILE: code/mmdet/models/dense_heads/guided_anchor_head.py
  class FeatureAdaption (line 14) | class FeatureAdaption(nn.Module):
    method __init__ (line 28) | def __init__(self,
    method init_weights (line 45) | def init_weights(self):
    method forward (line 49) | def forward(self, x, shape):
  class GuidedAnchorHead (line 56) | class GuidedAnchorHead(AnchorHead):
    method __init__ (line 89) | def __init__(
    method _init_layers (line 204) | def _init_layers(self):
    method init_weights (line 219) | def init_weights(self):
    method forward_single (line 229) | def forward_single(self, x):
    method forward (line 242) | def forward(self, feats):
    method get_sampled_approxs (line 245) | def get_sampled_approxs(self, featmap_sizes, img_metas, device='cuda'):
    method get_anchors (line 295) | def get_anchors(self,
    method _get_guided_anchors_single (line 347) | def _get_guided_anchors_single(self,
    method ga_loc_targets (line 381) | def ga_loc_targets(self, gt_bboxes_list, featmap_sizes):
    method _ga_shape_target_single (line 483) | def _ga_shape_target_single(self,
    method ga_shape_targets (line 546) | def ga_shape_targets(self,
    method loss_shape_single (line 612) | def loss_shape_single(self, shape_pred, bbox_anchors, bbox_gts,
    method loss_loc_single (line 636) | def loss_loc_single(self, loc_pred, loc_target, loc_weight,
    method loss (line 647) | def loss(self,
    method get_bboxes (line 753) | def get_bboxes(self,
    method _get_bboxes_single (line 797) | def _get_bboxes_single(self,

FILE: code/mmdet/models/dense_heads/lscpvnet_head.py
  class LSCPVHead (line 15) | class LSCPVHead(AnchorFreeHead):
    method __init__ (line 16) | def __init__(self,
    method _init_layers (line 98) | def _init_layers(self):
    method init_weights (line 181) | def init_weights(self):
    method extreme_points2bbox (line 208) | def extreme_points2bbox(self, pts, y_first=True, extreme=False):
    method get_pred_reg (line 236) | def get_pred_reg(self, raw_reg1, raw_reg2):
    method get_bbox_gt_reg (line 245) | def get_bbox_gt_reg(self, gt_pts, anchor_pts, bbox_weights):
    method forward (line 272) | def forward(self, feats):
    method forward_single1 (line 287) | def forward_single1(self, x):
    method forward_single2 (line 343) | def forward_single2(self, bbox_dcn_offset, bbox_reg_init_sp, fpn_level,
    method get_points (line 389) | def get_points(self, featmap_sizes, img_metas):
    method centers_to_bboxes (line 428) | def centers_to_bboxes(self, point_list):
    method offset_to_pts (line 442) | def offset_to_pts(self, center_list, pred_list):
    method _point_target_single (line 463) | def _point_target_single(self,
    method get_targets (line 538) | def get_targets(self,
    method _hm_target_single (line 605) | def _hm_target_single(self,
    method get_hm_targets (line 651) | def get_hm_targets(self,
    method loss_single (line 717) | def loss_single(self, cls_score, bbox_pts_pred_init, bbox_pts_pred_ref...
    method loss (line 816) | def loss(self,
    method get_bboxes (line 957) | def get_bboxes(self,
    method _get_bboxes_single (line 1001) | def _get_bboxes_single(self,
    method get_num_level_proposals_inside (line 1097) | def get_num_level_proposals_inside(self, num_level_proposals, inside_f...
  class DCNConvModule (line 1105) | class DCNConvModule(nn.Module):
    method __init__ (line 1106) | def __init__(
    method forward (line 1122) | def forward(self, x):

FILE: code/mmdet/models/dense_heads/lsnet_head.py
  class LSHead (line 17) | class LSHead(AnchorFreeHead):
    method __init__ (line 18) | def __init__(self,
    method _init_layers (line 93) | def _init_layers(self):
    method init_weights (line 259) | def init_weights(self):
    method extreme_points2bbox (line 321) | def extreme_points2bbox(self, pts, y_first=True, extreme=False):
    method vectors2bbox (line 349) | def vectors2bbox(self, pts, y_first=True, vector=False):
    method get_pred_reg (line 372) | def get_pred_reg(self, raw_reg1, raw_reg2):
    method get_bbox_gt_reg (line 402) | def get_bbox_gt_reg(self, gt_pts, anchor_pts, bbox_weights):
    method get_poly_gt_reg (line 429) | def get_poly_gt_reg(self, gt_pts, anchor_pts, bbox_weights):
    method forward_train (line 456) | def forward_train(self,
    method forward (line 479) | def forward(self, feats):
    method forward_single1 (line 502) | def forward_single1(self, x):
    method forward_single2 (line 600) | def forward_single2(self, bbox_dcn_offset, bbox_reg_init_sp, segm_dcn_...
    method get_points (line 757) | def get_points(self, featmap_sizes, img_metas):
    method _target_single (line 796) | def _target_single(self,
    method get_targets (line 919) | def get_targets(self,
    method loss_single (line 1021) | def loss_single(self,
    method loss (line 1272) | def loss(self,
    method get_bboxes (line 1439) | def get_bboxes(self,
    method _get_bboxes_single (line 1513) | def _get_bboxes_single(self,
    method get_num_level_proposals_inside (line 1670) | def get_num_level_proposals_inside(self, num_level_proposals, inside_f...
    method get_border_center (line 1677) | def get_border_center(self, gt_bboxes_list):
    method component_polygon_area (line 1699) | def component_polygon_area(self, poly):
    method process_polygons (line 1717) | def process_polygons(self, gt_masks_list, cls_scores):
    method process_keypoints_with_bbox (line 1758) | def process_keypoints_with_bbox(self, gt_bboxes_list, gt_keypoints_vs_...
    method process_keypoints_with_kbox (line 1786) | def process_keypoints_with_kbox(self, gt_keypoints_vs_list):
  class DCNConvModule (line 1830) | class DCNConvModule(nn.Module):
    method __init__ (line 1831) | def __init__(
    method forward (line 1847) | def forward(self, x):

FILE: code/mmdet/models/dense_heads/nasfcos_head.py
  class NASFCOSHead (line 12) | class NASFCOSHead(FCOSHead):
    method _init_layers (line 21) | def _init_layers(self):
    method init_weights (line 64) | def init_weights(self):

FILE: code/mmdet/models/dense_heads/pisa_retinanet_head.py
  class PISARetinaHead (line 10) | class PISARetinaHead(RetinaHead):
    method loss (line 21) | def loss(self,

FILE: code/mmdet/models/dense_heads/pisa_ssd_head.py
  class PISASSDHead (line 11) | class PISASSDHead(SSDHead):
    method loss (line 13) | def loss(self,

FILE: code/mmdet/models/dense_heads/reppoints_head.py
  class RepPointsHead (line 14) | class RepPointsHead(AnchorFreeHead):
    method __init__ (line 32) | def __init__(self,
    method _init_layers (line 97) | def _init_layers(self):
    method init_weights (line 140) | def init_weights(self):
    method points2bbox (line 154) | def points2bbox(self, pts, y_first=True):
    method gen_grid_from_reg (line 213) | def gen_grid_from_reg(self, reg, previous_boxes):
    method forward (line 247) | def forward(self, feats):
    method forward_single (line 250) | def forward_single(self, x):
    method get_points (line 292) | def get_points(self, featmap_sizes, img_metas):
    method centers_to_bboxes (line 331) | def centers_to_bboxes(self, point_list):
    method offset_to_pts (line 345) | def offset_to_pts(self, center_list, pred_list):
    method _point_target_single (line 366) | def _point_target_single(self,
    method get_targets (line 430) | def get_targets(self,
    method loss_single (line 514) | def loss_single(self, cls_score, pts_pred_init, pts_pred_refine,
    method loss (line 551) | def loss(self,
    method get_bboxes (line 634) | def get_bboxes(self,
    method _get_bboxes_single (line 667) | def _get_bboxes_single(self,
    method get_num_level_proposals_inside (line 714) | def get_num_level_proposals_inside(self, num_level_proposals, inside_f...

FILE: code/mmdet/models/dense_heads/reppoints_v2_head.py
  class RepPointsV2Head (line 15) | class RepPointsV2Head(AnchorFreeHead):
    method __init__ (line 33) | def __init__(self,
    method _init_layers (line 118) | def _init_layers(self):
    method init_weights (line 193) | def init_weights(self):
    method points2bbox (line 214) | def points2bbox(self, pts, y_first=True):
    method gen_grid_from_reg (line 273) | def gen_grid_from_reg(self, reg, previous_boxes):
    method forward (line 307) | def forward(self, feats):
    method forward_single (line 310) | def forward_single(self, x):
    method get_points (line 378) | def get_points(self, featmap_sizes, img_metas):
    method centers_to_bboxes (line 417) | def centers_to_bboxes(self, point_list):
    method offset_to_pts (line 431) | def offset_to_pts(self, center_list, pred_list):
    method _point_target_single (line 452) | def _point_target_single(self,
    method get_targets (line 516) | def get_targets(self,
    method _hm_target_single (line 600) | def _hm_target_single(self,
    method get_hm_targets (line 646) | def get_hm_targets(self,
    method loss_single (line 711) | def loss_single(self, cls_score, pts_pred_init, pts_pred_refine, hm_sc...
    method loss (line 788) | def loss(self,
    method get_bboxes (line 925) | def get_bboxes(self,
    method _get_bboxes_single (line 967) | def _get_bboxes_single(self,
    method get_num_level_proposals_inside (line 1058) | def get_num_level_proposals_inside(self, num_level_proposals, inside_f...

FILE: code/mmdet/models/dense_heads/retina_head.py
  class RetinaHead (line 9) | class RetinaHead(AnchorHead):
    method __init__ (line 28) | def __init__(self,
    method _init_layers (line 50) | def _init_layers(self):
    method init_weights (line 83) | def init_weights(self):
    method forward_single (line 93) | def forward_single(self, x):

FILE: code/mmdet/models/dense_heads/retina_sepbn_head.py
  class RetinaSepBNHead (line 9) | class RetinaSepBNHead(AnchorHead):
    method __init__ (line 17) | def __init__(self,
    method _init_layers (line 32) | def _init_layers(self):
    method init_weights (line 74) | def init_weights(self):
    method forward (line 84) | def forward(self, feats):

FILE: code/mmdet/models/dense_heads/rpn_head.py
  class RPNHead (line 13) | class RPNHead(RPNTestMixin, AnchorHead):
    method __init__ (line 20) | def __init__(self, in_channels, **kwargs):
    method _init_layers (line 24) | def _init_layers(self):
    method init_weights (line 32) | def init_weights(self):
    method forward_single (line 38) | def forward_single(self, x):
    method loss (line 46) | def loss(self,
    method _get_bboxes_single (line 79) | def _get_bboxes_single(self,

FILE: code/mmdet/models/dense_heads/rpn_test_mixin.py
  class RPNTestMixin (line 9) | class RPNTestMixin(object):
    method async_simple_test_rpn (line 14) | async def async_simple_test_rpn(self, x, img_metas):
    method simple_test_rpn (line 25) | def simple_test_rpn(self, x, img_metas):
    method aug_test_rpn (line 40) | def aug_test_rpn(self, feats, img_metas):

FILE: code/mmdet/models/dense_heads/ssd_head.py
  class SSDHead (line 15) | class SSDHead(AnchorHead):
    method __init__ (line 33) | def __init__(self,
    method init_weights (line 98) | def init_weights(self):
    method forward (line 104) | def forward(self, feats):
    method loss_single (line 128) | def loss_single(self, cls_score, bbox_pred, anchor, labels, label_weig...
    method loss (line 182) | def loss(self,

FILE: code/mmdet/models/detectors/atss.py
  class ATSS (line 6) | class ATSS(SingleStageDetector):
    method __init__ (line 8) | def __init__(self,

FILE: code/mmdet/models/detectors/base.py
  class BaseDetector (line 16) | class BaseDetector(nn.Module, metaclass=ABCMeta):
    method __init__ (line 19) | def __init__(self):
    method with_neck (line 24) | def with_neck(self):
    method with_shared_head (line 31) | def with_shared_head(self):
    method with_bbox (line 37) | def with_bbox(self):
    method with_mask (line 44) | def with_mask(self):
    method extract_feat (line 51) | def extract_feat(self, imgs):
    method extract_feats (line 55) | def extract_feats(self, imgs):
    method forward_train (line 69) | def forward_train(self, imgs, img_metas, **kwargs):
    method async_simple_test (line 83) | async def async_simple_test(self, img, img_metas, **kwargs):
    method simple_test (line 87) | def simple_test(self, img, img_metas, **kwargs):
    method aug_test (line 91) | def aug_test(self, imgs, img_metas, **kwargs):
    method init_weights (line 95) | def init_weights(self, pretrained=None):
    method aforward_test (line 106) | async def aforward_test(self, *, img, img_metas, **kwargs):
    method forward_test (line 124) | def forward_test(self, imgs, img_metas, **kwargs):
    method forward (line 162) | def forward(self, img, img_metas, return_loss=True, **kwargs):
    method _parse_losses (line 176) | def _parse_losses(self, losses):
    method train_step (line 211) | def train_step(self, data, optimizer):
    method val_step (line 245) | def val_step(self, data, optimizer):
    method show_result (line 260) | def show_result(self,

FILE: code/mmdet/models/detectors/cascade_rcnn.py
  class CascadeRCNN (line 6) | class CascadeRCNN(TwoStageDetector):
    method __init__ (line 10) | def __init__(self,
    method show_result (line 27) | def show_result(self, data, result, **kwargs):

FILE: code/mmdet/models/detectors/dense_reppoints_detector.py
  class DenseRepPointsDetector (line 12) | class DenseRepPointsDetector(SingleStageDetector):
    method __init__ (line 14) | def __init__(self,
    method with_mask (line 24) | def with_mask(self):
    method forward_train (line 27) | def forward_train(self,
    method simple_test (line 41) | def simple_test(self, img, img_meta, rescale=False):
    method get_seg_masks (line 67) | def get_seg_masks(self, pts_score, det_pts, det_bboxes, det_labels,
  function pts2result (line 130) | def pts2result(pts, labels, num_classes):

FILE: code/mmdet/models/detectors/dense_reppoints_v2_detector.py
  class DenseRepPointsV2Detector (line 12) | class DenseRepPointsV2Detector(SingleStageDetector):
    method __init__ (line 14) | def __init__(self,
    method with_mask (line 24) | def with_mask(self):
    method forward_train (line 27) | def forward_train(self,
    method simple_test (line 43) | def simple_test(self, img, img_meta, rescale=False):
    method get_seg_masks (line 69) | def get_seg_masks(self, pts_score, det_pts, det_bboxes, det_labels, de...
  function pts2result (line 142) | def pts2result(pts, labels, num_classes):

FILE: code/mmdet/models/detectors/fast_rcnn.py
  class FastRCNN (line 6) | class FastRCNN(TwoStageDetector):
    method __init__ (line 9) | def __init__(self,
    method forward_test (line 24) | def forward_test(self, imgs, img_metas, proposals, **kwargs):

FILE: code/mmdet/models/detectors/faster_rcnn.py
  class FasterRCNN (line 6) | class FasterRCNN(TwoStageDetector):
    method __init__ (line 9) | def __init__(self,

FILE: code/mmdet/models/detectors/fcos.py
  class FCOS (line 6) | class FCOS(SingleStageDetector):
    method __init__ (line 9) | def __init__(self,

FILE: code/mmdet/models/detectors/fovea.py
  class FOVEA (line 6) | class FOVEA(SingleStageDetector):
    method __init__ (line 9) | def __init__(self,

FILE: code/mmdet/models/detectors/fsaf.py
  class FSAF (line 6) | class FSAF(SingleStageDetector):
    method __init__ (line 9) | def __init__(self,

FILE: code/mmdet/models/detectors/gfl.py
  class GFL (line 6) | class GFL(SingleStageDetector):
    method __init__ (line 8) | def __init__(self,

FILE: code/mmdet/models/detectors/grid_rcnn.py
  class GridRCNN (line 6) | class GridRCNN(TwoStageDetector):
    method __init__ (line 14) | def __init__(self,

FILE: code/mmdet/models/detectors/htc.py
  class HybridTaskCascade (line 6) | class HybridTaskCascade(CascadeRCNN):
    method __init__ (line 9) | def __init__(self, **kwargs):
    method with_semantic (line 13) | def with_semantic(self):

FILE: code/mmdet/models/detectors/lscpvnet.py
  class LSCPVDetector (line 11) | class LSCPVDetector(SingleStageDetector):
    method __init__ (line 13) | def __init__(self,
    method forward_train (line 23) | def forward_train(self,
    method simple_test (line 39) | def simple_test(self, img, img_metas, rescale=False, show=False, out_d...
    method merge_aug_results (line 61) | def merge_aug_results(self, aug_bboxes, aug_scores, img_metas):
    method aug_test_simple (line 88) | def aug_test_simple(self, imgs, img_metas, rescale=False):
    method merge_aug_vote_results (line 131) | def merge_aug_vote_results(self, aug_bboxes, aug_labels, img_metas):
    method remove_boxes (line 157) | def remove_boxes(self, boxes, min_scale, max_scale):
    method bboxes_vote (line 164) | def bboxes_vote(self, boxes, scores, vote_thresh=0.66):
    method aug_test_vote (line 230) | def aug_test_vote(self, imgs, img_metas, rescale=False):
    method aug_test (line 293) | def aug_test(self, imgs, img_metas, rescale=False):

FILE: code/mmdet/models/detectors/lsnet.py
  class LSDetector (line 13) | class LSDetector(SingleStageDetector):
    method __init__ (line 14) | def __init__(self,
    method merge_aug_results (line 27) | def merge_aug_results(self, aug_bboxes, aug_scores, img_metas):
    method forward_train (line 44) | def forward_train(self,
    method simple_test (line 58) | def simple_test(self, img, img_metas, rescale=False, show=False, out_d...
    method aug_test_simple (line 102) | def aug_test_simple(self, imgs, img_metas, rescale=False):
    method merge_aug_vote_results (line 137) | def merge_aug_vote_results(self, aug_bboxes, aug_vectors, aug_labels, ...
    method remove_boxes (line 156) | def remove_boxes(self, boxes, min_scale, max_scale):
    method bboxes_vote (line 163) | def bboxes_vote(self, boxes, scores, vote_thresh=0.66):
    method instances_vote (line 229) | def instances_vote(self, boxes, vectors, scores, vote_thresh=0.66):
    method aug_test_vote (line 301) | def aug_test_vote(self, imgs, img_metas, rescale=False, show=False, ou...
    method aug_test (line 403) | def aug_test(self, imgs, img_metas, rescale=False, show=False, out_dir...
    method show_result (line 411) | def show_result(self,

FILE: code/mmdet/models/detectors/mask_rcnn.py
  class MaskRCNN (line 6) | class MaskRCNN(TwoStageDetector):
    method __init__ (line 9) | def __init__(self,

FILE: code/mmdet/models/detectors/mask_scoring_rcnn.py
  class MaskScoringRCNN (line 6) | class MaskScoringRCNN(TwoStageDetector):
    method __init__ (line 12) | def __init__(self,

FILE: code/mmdet/models/detectors/nasfcos.py
  class NASFCOS (line 6) | class NASFCOS(SingleStageDetector):
    method __init__ (line 12) | def __init__(self,

FILE: code/mmdet/models/detectors/point_rend.py
  class PointRend (line 6) | class PointRend(TwoStageDetector):
    method __init__ (line 14) | def __init__(self,

FILE: code/mmdet/models/detectors/reppoints_detector.py
  class RepPointsDetector (line 9) | class RepPointsDetector(SingleStageDetector):
    method __init__ (line 16) | def __init__(self,
    method merge_aug_results (line 27) | def merge_aug_results(self, aug_bboxes, aug_scores, img_metas):
    method aug_test (line 54) | def aug_test(self, imgs, img_metas, rescale=False):

FILE: code/mmdet/models/detectors/reppoints_v2_detector.py
  class RepPointsV2Detector (line 11) | class RepPointsV2Detector(SingleStageDetector):
    method __init__ (line 13) | def __init__(self,
    method forward_train (line 23) | def forward_train(self,
    method merge_aug_results (line 38) | def merge_aug_results(self, aug_bboxes, aug_scores, img_metas):
    method aug_test_simple (line 65) | def aug_test_simple(self, imgs, img_metas, rescale=False):
    method merge_aug_vote_results (line 108) | def merge_aug_vote_results(self, aug_bboxes, aug_labels, img_metas):
    method remove_boxes (line 134) | def remove_boxes(self, boxes, min_scale, max_scale):
    method bboxes_vote (line 140) | def bboxes_vote(self, boxes, scores, vote_thresh=0.66):
    method aug_test_vote (line 206) | def aug_test_vote(self, imgs, img_metas, rescale=False):
    method aug_test (line 267) | def aug_test(self, imgs, img_metas, rescale=False):

FILE: code/mmdet/models/detectors/retinanet.py
  class RetinaNet (line 6) | class RetinaNet(SingleStageDetector):
    method __init__ (line 9) | def __init__(self,

FILE: code/mmdet/models/detectors/rpn.py
  class RPN (line 9) | class RPN(BaseDetector):
    method __init__ (line 12) | def __init__(self,
    method init_weights (line 30) | def init_weights(self, pretrained=None):
    method extract_feat (line 43) | def extract_feat(self, img):
    method forward_dummy (line 58) | def forward_dummy(self, img):
    method forward_train (line 64) | def forward_train(self,
    method simple_test (line 94) | def simple_test(self, img, img_metas, rescale=False):
    method aug_test (line 115) | def aug_test(self, imgs, img_metas, rescale=False):
    method show_result (line 141) | def show_result(self, data, result, dataset=None, top_k=20):

FILE: code/mmdet/models/detectors/single_stage.py
  class SingleStageDetector (line 9) | class SingleStageDetector(BaseDetector):
    method __init__ (line 16) | def __init__(self,
    method init_weights (line 34) | def init_weights(self, pretrained=None):
    method extract_feat (line 51) | def extract_feat(self, img):
    method forward_dummy (line 59) | def forward_dummy(self, img):
    method forward_train (line 68) | def forward_train(self,
    method simple_test (line 97) | def simple_test(self, img, img_metas, rescale=False):
    method aug_test (line 119) | def aug_test(self, imgs, img_metas, rescale=False):

FILE: code/mmdet/models/detectors/two_stage.py
  class TwoStageDetector (line 10) | class TwoStageDetector(BaseDetector):
    method __init__ (line 17) | def __init__(self,
    method with_rpn (line 51) | def with_rpn(self):
    method with_roi_head (line 56) | def with_roi_head(self):
    method init_weights (line 60) | def init_weights(self, pretrained=None):
    method extract_feat (line 80) | def extract_feat(self, img):
    method forward_dummy (line 88) | def forward_dummy(self, img):
    method forward_train (line 106) | def forward_train(self,
    method async_simple_test (line 170) | async def async_simple_test(self,
    method simple_test (line 188) | def simple_test(self, img, img_metas, proposals=None, rescale=False):
    method aug_test (line 202) | def aug_test(self, imgs, img_metas, rescale=False):

FILE: code/mmdet/models/losses/accuracy.py
  function accuracy (line 4) | def accuracy(pred, target, topk=1):
  class Accuracy (line 40) | class Accuracy(nn.Module):
    method __init__ (line 42) | def __init__(self, topk=(1, )):
    method forward (line 52) | def forward(self, pred, target):

FILE: code/mmdet/models/losses/ae_loss.py
  function ae_loss_per_image (line 8) | def ae_loss_per_image(tl_preds, br_preds, match):
  class AssociativeEmbeddingLoss (line 70) | class AssociativeEmbeddingLoss(nn.Module):
    method __init__ (line 83) | def __init__(self, pull_weight=0.25, push_weight=0.25):
    method forward (line 88) | def forward(self, pred, target, match):

FILE: code/mmdet/models/losses/balanced_l1_loss.py
  function balanced_l1_loss (line 10) | def balanced_l1_loss(pred,
  class BalancedL1Loss (line 51) | class BalancedL1Loss(nn.Module):
    method __init__ (line 69) | def __init__(self,
    method forward (line 82) | def forward(self,

FILE: code/mmdet/models/losses/chamfer_loss.py
  class ChamferLoss2D (line 9) | class ChamferLoss2D(nn.Module):
    method __init__ (line 10) | def __init__(self, use_cuda=True, loss_weight=1.0, eps=1e-12):
    method forward (line 16) | def forward(self, point_set_1, point_set_2):
  class ChamferDistancePytorch (line 56) | class ChamferDistancePytorch(nn.Module):
    method __init__ (line 63) | def __init__(self, reduction='none'):
    method forward (line 67) | def forward(self, x, y):
    method _cost_matrix (line 87) | def _cost_matrix(x, y, p=2):

FILE: code/mmdet/models/losses/cross_entropy_loss.py
  function cross_entropy (line 9) | def cross_entropy(pred,
  function _expand_binary_labels (line 42) | def _expand_binary_labels(labels, label_weights, label_channels):
  function binary_cross_entropy (line 58) | def binary_cross_entropy(pred,
  function mask_cross_entropy (line 94) | def mask_cross_entropy(pred,
  class CrossEntropyLoss (line 129) | class CrossEntropyLoss(nn.Module):
    method __init__ (line 131) | def __init__(self,
    method forward (line 165) | def forward(self,

FILE: code/mmdet/models/losses/cross_iou_loss.py
  function get_bbox_from_extreme (line 10) | def get_bbox_from_extreme(pred, anchor_pts):
  function get_bbox_from_polygon (line 35) | def get_bbox_from_polygon(pred, anchor_pts):
  function cross_iou_loss (line 62) | def cross_iou_loss(pred, target, loss_type=None, anchor_pts=None, vs=None,
  class CrossIOULoss (line 135) | class CrossIOULoss(nn.Module):
    method __init__ (line 137) | def __init__(self, eps=1e-6, reduction='mean', loss_weight=1.0, loss_t...
    method forward (line 146) | def forward(self,

FILE: code/mmdet/models/losses/focal_loss.py
  function py_sigmoid_focal_loss (line 11) | def py_sigmoid_focal_loss(pred,
  function separate_sigmoid_focal_loss (line 45) | def separate_sigmoid_focal_loss(pred,
  function sigmoid_focal_loss (line 74) | def sigmoid_focal_loss(pred,
  class FocalLoss (line 120) | class FocalLoss(nn.Module):
    method __init__ (line 122) | def __init__(self,
    method forward (line 150) | def forward(self,
  class SEPFocalLoss (line 190) | class SEPFocalLoss(nn.Module):
    method __init__ (line 192) | def __init__(self,
    method forward (line 203) | def forward(self,

FILE: code/mmdet/models/losses/gaussian_focal_loss.py
  function gaussian_focal_loss (line 8) | def gaussian_focal_loss(pred, gaussian_target, alpha=2.0, gamma=4.0):
  class GaussianFocalLoss (line 30) | class GaussianFocalLoss(nn.Module):
    method __init__ (line 47) | def __init__(self,
    method forward (line 58) | def forward(self,

FILE: code/mmdet/models/losses/gfocal_loss.py
  function quality_focal_loss (line 9) | def quality_focal_loss(pred, target, beta=2.0):
  function distribution_focal_loss (line 54) | def distribution_focal_loss(pred, label):
  class QualityFocalLoss (line 80) | class QualityFocalLoss(nn.Module):
    method __init__ (line 95) | def __init__(self,
    method forward (line 107) | def forward(self,
  class DistributionFocalLoss (line 146) | class DistributionFocalLoss(nn.Module):
    method __init__ (line 157) | def __init__(self, reduction='mean', loss_weight=1.0):
    method forward (line 162) | def forward(self,

FILE: code/mmdet/models/losses/ghm_loss.py
  function _expand_onehot_labels (line 8) | def _expand_onehot_labels(labels, label_weights, label_channels):
  class GHMC (line 21) | class GHMC(nn.Module):
    method __init__ (line 35) | def __init__(self, bins=10, momentum=0, use_sigmoid=True, loss_weight=...
    method forward (line 50) | def forward(self, pred, target, label_weight, *args, **kwargs):
  class GHMR (line 99) | class GHMR(nn.Module):
    method __init__ (line 113) | def __init__(self, mu=0.02, bins=10, momentum=0, loss_weight=1.0):
    method forward (line 127) | def forward(self, pred, target, label_weight, avg_factor=None):

FILE: code/mmdet/models/losses/iou_loss.py
  function iou_loss (line 12) | def iou_loss(pred, target, eps=1e-6):
  function bounded_iou_loss (line 32) | def bounded_iou_loss(pred, target, beta=0.2, eps=1e-3):
  function giou_loss (line 74) | def giou_loss(pred, target, eps=1e-7):
  function diou_loss (line 119) | def diou_loss(pred, target, eps=1e-7):
  function ciou_loss (line 171) | def ciou_loss(pred, target, eps=1e-7):
  class IoULoss (line 230) | class IoULoss(nn.Module):
    method __init__ (line 241) | def __init__(self, eps=1e-6, reduction='mean', loss_weight=1.0):
    method forward (line 247) | def forward(self,
  class BoundedIoULoss (line 291) | class BoundedIoULoss(nn.Module):
    method __init__ (line 293) | def __init__(self, beta=0.2, eps=1e-3, reduction='mean', loss_weight=1...
    method forward (line 300) | def forward(self,
  class GIoULoss (line 325) | class GIoULoss(nn.Module):
    method __init__ (line 327) | def __init__(self, eps=1e-6, reduction='mean', loss_weight=1.0):
    method forward (line 333) | def forward(self,
  class DIoULoss (line 362) | class DIoULoss(nn.Module):
    method __init__ (line 364) | def __init__(self, eps=1e-6, reduction='mean', loss_weight=1.0):
    method forward (line 370) | def forward(self,
  class CIoULoss (line 400) | class CIoULoss(nn.Module):
    method __init__ (line 402) | def __init__(self, eps=1e-6, reduction='mean', loss_weight=1.0):
    method forward (line 408) | def forward(self,

FILE: code/mmdet/models/losses/mse_loss.py
  function mse_loss (line 9) | def mse_loss(pred, target):
  class MSELoss (line 15) | class MSELoss(nn.Module):
    method __init__ (line 24) | def __init__(self, reduction='mean', loss_weight=1.0):
    method forward (line 29) | def forward(self, pred, target, weight=None, avg_factor=None):

FILE: code/mmdet/models/losses/pisa_loss.py
  function isr_p (line 6) | def isr_p(cls_score,
  function carl_loss (line 119) | def carl_loss(cls_score,

FILE: code/mmdet/models/losses/smooth_l1_loss.py
  function smooth_l1_loss (line 9) | def smooth_l1_loss(pred, target, beta=1.0):
  function l1_loss (line 30) | def l1_loss(pred, target):
  class SmoothL1Loss (line 46) | class SmoothL1Loss(nn.Module):
    method __init__ (line 57) | def __init__(self, beta=1.0, reduction='mean', loss_weight=1.0):
    method forward (line 63) | def forward(self,
  class L1Loss (line 98) | class L1Loss(nn.Module):
    method __init__ (line 107) | def __init__(self, reduction='mean', loss_weight=1.0):
    method forward (line 112) | def forward(self,

FILE: code/mmdet/models/losses/utils.py
  function reduce_loss (line 6) | def reduce_loss(loss, reduction):
  function weight_reduce_loss (line 26) | def weight_reduce_loss(loss, weight=None, reduction='mean', avg_factor=N...
  function weighted_loss (line 55) | def weighted_loss(loss_func):

FILE: code/mmdet/models/necks/bfp.py
  class BFP (line 10) | class BFP(nn.Module):
    method __init__ (line 30) | def __init__(self,
    method init_weights (line 65) | def init_weights(self):
    method forward (line 71) | def forward(self, inputs):

FILE: code/mmdet/models/necks/fpn.py
  class FPN (line 10) | class FPN(nn.Module):
    method __init__ (line 65) | def __init__(self,
    method init_weights (line 159) | def init_weights(self):
    method forward (line 166) | def forward(self, inputs):

FILE: code/mmdet/models/necks/fpn_carafe.py
  class FPN_CARAFE (line 9) | class FPN_CARAFE(nn.Module):
    method __init__ (line 33) | def __init__(self,
    method init_weights (line 202) | def init_weights(self):
    method slice_as (line 211) | def slice_as(self, src, dst):
    method tensor_add (line 231) | def tensor_add(self, a, b):
    method forward (line 239) | def forward(self, inputs):

FILE: code/mmdet/models/necks/hrfpn.py
  class HRFPN (line 11) | class HRFPN(nn.Module):
    method __init__ (line 29) | def __init__(self,
    method init_weights (line 72) | def init_weights(self):
    method forward (line 78) | def forward(self, inputs):

FILE: code/mmdet/models/necks/nas_fpn.py
  class NASFPN (line 9) | class NASFPN(nn.Module):
    method __init__ (line 30) | def __init__(self,
    method init_weights (line 123) | def init_weights(self):
    method forward (line 129) | def forward(self, inputs):

FILE: code/mmdet/models/necks/nasfcos_fpn.py
  class NASFCOS_FPN (line 10) | class NASFCOS_FPN(nn.Module):
    method __init__ (line 31) | def __init__(self,
    method forward (line 115) | def forward(self, inputs):
    method init_weights (line 149) | def init_weights(self):

FILE: code/mmdet/models/necks/pafpn.py
  class PAFPN (line 11) | class PAFPN(FPN):
    method __init__ (line 39) | def __init__(self,
    method forward (line 84) | def forward(self, inputs):

FILE: code/mmdet/models/necks/rfp.py
  class ASPP (line 10) | class ASPP(nn.Module):
    method __init__ (line 23) | def __init__(self, in_channels, out_channels, dilations=(1, 3, 6, 1)):
    method init_weights (line 42) | def init_weights(self):
    method forward (line 47) | def forward(self, x):
  class RFP (line 59) | class RFP(FPN):
    method __init__ (line 75) | def __init__(self,
    method init_weights (line 97) | def init_weights(self):
    method forward (line 104) | def forward(self, inputs):

FILE: code/mmdet/models/roi_heads/base_roi_head.py
  class BaseRoIHead (line 8) | class BaseRoIHead(nn.Module, metaclass=ABCMeta):
    method __init__ (line 11) | def __init__(self,
    method with_bbox (line 34) | def with_bbox(self):
    method with_mask (line 39) | def with_mask(self):
    method with_shared_head (line 44) | def with_shared_head(self):
    method init_weights (line 49) | def init_weights(self, pretrained):
    method init_bbox_head (line 59) | def init_bbox_head(self):
    method init_mask_head (line 64) | def init_mask_head(self):
    method init_assigner_sampler (line 69) | def init_assigner_sampler(self):
    method forward_train (line 74) | def forward_train(self,
    method async_simple_test (line 86) | async def async_simple_test(self, x, img_meta, **kwargs):
    method simple_test (line 90) | def simple_test(self,
    method aug_test (line 100) | def aug_test(self, x, proposal_list, img_metas, rescale=False, **kwargs):

FILE: code/mmdet/models/roi_heads/bbox_heads/bbox_head.py
  class BBoxHead (line 13) | class BBoxHead(nn.Module):
    method __init__ (line 17) | def __init__(self,
    method init_weights (line 66) | def init_weights(self):
    method forward (line 76) | def forward(self, x):
    method _get_target_single (line 84) | def _get_target_single(self, pos_bboxes, neg_bboxes, pos_gt_bboxes,
    method get_targets (line 115) | def get_targets(self,
    method loss (line 141) | def loss(self,
    method get_bboxes (line 188) | def get_bboxes(self,
    method refine_bboxes (line 227) | def refine_bboxes(self, rois, labels, bbox_preds, pos_is_gts, img_metas):
    method regress_by_class (line 306) | def regress_by_class(self, rois, label, bbox_pred, img_meta):

FILE: code/mmdet/models/roi_heads/bbox_heads/convfc_bbox_head.py
  class ConvFCBBoxHead (line 9) | class ConvFCBBoxHead(BBoxHead):
    method __init__ (line 20) | def __init__(self,
    method _add_conv_fc_branch (line 85) | def _add_conv_fc_branch(self,
    method init_weights (line 126) | def init_weights(self):
    method forward (line 135) | def forward(self, x):
  class Shared2FCBBoxHead (line 177) | class Shared2FCBBoxHead(ConvFCBBoxHead):
    method __init__ (line 179) | def __init__(self, fc_out_channels=1024, *args, **kwargs):
  class Shared4Conv1FCBBoxHead (line 193) | class Shared4Conv1FCBBoxHead(ConvFCBBoxHead):
    method __init__ (line 195) | def __init__(self, fc_out_channels=1024, *args, **kwargs):

FILE: code/mmdet/models/roi_heads/bbox_heads/double_bbox_head.py
  class BasicResBlock (line 9) | class BasicResBlock(nn.Module):
    method __init__ (line 22) | def __init__(self,
    method forward (line 58) | def forward(self, x):
  class DoubleConvFCBBoxHead (line 72) | class DoubleConvFCBBoxHead(BBoxHead):
    method __init__ (line 86) | def __init__(self,
    method _add_conv_branch (line 121) | def _add_conv_branch(self):
    method _add_fc_branch (line 133) | def _add_fc_branch(self):
    method init_weights (line 143) | def init_weights(self):
    method forward (line 152) | def forward(self, x_cls, x_reg):

FILE: code/mmdet/models/roi_heads/cascade_roi_head.py
  class CascadeRoIHead (line 13) | class CascadeRoIHead(BaseRoIHead, BBoxTestMixin, MaskTestMixin):
    method __init__ (line 19) | def __init__(self,
    method init_bbox_head (line 44) | def init_bbox_head(self, bbox_roi_extractor, bbox_head):
    method init_mask_head (line 64) | def init_mask_head(self, mask_roi_extractor, mask_head):
    method init_assigner_sampler (line 92) | def init_assigner_sampler(self):
    method init_weights (line 102) | def init_weights(self, pretrained):
    method forward_dummy (line 120) | def forward_dummy(self, x, proposals):
    method _bbox_forward (line 138) | def _bbox_forward(self, stage, x, rois):
    method _bbox_forward_train (line 151) | def _bbox_forward_train(self, stage, x, sampling_results, gt_bboxes,
    method _mask_forward (line 166) | def _mask_forward(self, stage, x, rois):
    method _mask_forward_train (line 178) | def _mask_forward_train(self,
    method forward_train (line 202) | def forward_train(self,
    method simple_test (line 289) | def simple_test(self, x, proposal_list, img_metas, rescale=False):
    method aug_test (line 355) | def aug_test(self, features, proposal_list, img_metas, rescale=False):

FILE: code/mmdet/models/roi_heads/double_roi_head.py
  class DoubleHeadRoIHead (line 6) | class DoubleHeadRoIHead(StandardRoIHead):
    method __init__ (line 12) | def __init__(self, reg_roi_scale_factor, **kwargs):
    method _bbox_forward (line 16) | def _bbox_forward(self, x, rois):

FILE: code/mmdet/models/roi_heads/dynamic_roi_head.py
  class DynamicRoIHead (line 11) | class DynamicRoIHead(StandardRoIHead):
    method __init__ (line 14) | def __init__(self, **kwargs):
    method forward_train (line 22) | def forward_train(self,
    method _bbox_forward_train (line 107) | def _bbox_forward_train(self, x, sampling_results, gt_bboxes, gt_labels,
    method update_hyperparameters (line 132) | def update_hyperparameters(self):

FILE: code/mmdet/models/roi_heads/grid_roi_head.py
  class GridRoIHead (line 9) | class GridRoIHead(StandardRoIHead):
    method __init__ (line 15) | def __init__(self, grid_roi_extractor, grid_head, **kwargs):
    method init_weights (line 26) | def init_weights(self, pretrained):
    method _random_jitter (line 38) | def _random_jitter(self, sampling_results, img_metas, amplitude=0.15):
    method forward_dummy (line 63) | def forward_dummy(self, x, proposals):
    method _bbox_forward_train (line 89) | def _bbox_forward_train(self, x, sampling_results, gt_bboxes, gt_labels,
    method simple_test (line 127) | def simple_test(self,

FILE: code/mmdet/models/roi_heads/htc_roi_head.py
  class HybridTaskCascadeRoIHead (line 11) | class HybridTaskCascadeRoIHead(CascadeRoIHead):
    method __init__ (line 17) | def __init__(self,
    method init_weights (line 40) | def init_weights(self, pretrained):
    method with_semantic (line 52) | def with_semantic(self):
    method forward_dummy (line 59) | def forward_dummy(self, x, proposals):
    method _bbox_forward_train (line 94) | def _bbox_forward_train(self,
    method _mask_forward_train (line 121) | def _mask_forward_train(self,
    method _bbox_forward (line 165) | def _bbox_forward(self, stage, x, rois, semantic_feat=None):
    method _mask_forward_test (line 183) | def _mask_forward_test(self, stage, x, bboxes, semantic_feat=None):
    method forward_train (line 212) | def forward_train(self,
    method simple_test (line 337) | def simple_test(self, x, proposal_list, img_metas, rescale=False):
    method aug_test (line 421) | def aug_test(self, img_feats, proposal_list, img_metas, rescale=False):

FILE: code/mmdet/models/roi_heads/mask_heads/coarse_mask_head.py
  class CoarseMaskHead (line 10) | class CoarseMaskHead(FCNMaskHead):
    method __init__ (line 25) | def __init__(self,
    method init_weights (line 72) | def init_weights(self):
    method forward (line 79) | def forward(self, x):

FILE: code/mmdet/models/roi_heads/mask_heads/fcn_mask_head.py
  class FCNMaskHead (line 20) | class FCNMaskHead(nn.Module):
    method __init__ (line 22) | def __init__(self,
    method init_weights (line 106) | def init_weights(self):
    method forward (line 118) | def forward(self, x):
    method get_targets (line 128) | def get_targets(self, sampling_results, gt_masks, rcnn_train_cfg):
    method loss (line 138) | def loss(self, mask_pred, mask_targets, labels):
    method get_seg_masks (line 151) | def get_seg_masks(self, mask_pred, det_bboxes, det_labels, rcnn_test_cfg,
  function _do_paste_mask (line 240) | def _do_paste_mask(masks, boxes, img_h, img_w, skip_empty=True):

FILE: code/mmdet/models/roi_heads/mask_heads/fused_semantic_head.py
  class FusedSemanticHead (line 10) | class FusedSemanticHead(nn.Module):
    method __init__ (line 26) | def __init__(self,
    method init_weights (line 82) | def init_weights(self):
    method forward (line 86) | def forward(self, feats):
    method loss (line 103) | def loss(self, mask_pred, labels):

FILE: code/mmdet/models/roi_heads/mask_heads/grid_head.py
  class GridHead (line 11) | class GridHead(nn.Module):
    method __init__ (line 13) | def __init__(self,
    method init_weights (line 141) | def init_weights(self):
    method forward (line 151) | def forward(self, x):
    method calc_sub_regions (line 189) | def calc_sub_regions(self):
    method get_targets (line 220) | def get_targets(self, sampling_results, rcnn_train_cfg):
    method loss (line 288) | def loss(self, grid_pred, grid_targets):
    method get_bboxes (line 294) | def get_bboxes(self, det_bboxes, grid_pred, img_metas):

FILE: code/mmdet/models/roi_heads/mask_heads/htc_mask_head.py
  class HTCMaskHead (line 8) | class HTCMaskHead(FCNMaskHead):
    method __init__ (line 10) | def __init__(self, with_conv_res=True, *args, **kwargs):
    method init_weights (line 21) | def init_weights(self):
    method forward (line 26) | def forward(self, x, res_feat=None, return_logits=True, return_feat=Tr...

FILE: code/mmdet/models/roi_heads/mask_heads/mask_point_head.py
  class MaskPointHead (line 12) | class MaskPointHead(nn.Module):
    method __init__ (line 37) | def __init__(self,
    method init_weights (line 80) | def init_weights(self):
    method forward (line 85) | def forward(self, fine_grained_feats, coarse_feats):
    method get_targets (line 106) | def get_targets(self, rois, rel_roi_points, sampling_results, gt_masks,
    method _get_target_single (line 146) | def _get_target_single(self, rois, rel_roi_points, pos_assigned_gt_inds,
    method loss (line 164) | def loss(self, point_pred, point_targets, labels):
    method _get_uncertainty (line 187) | def _get_uncertainty(self, mask_pred, labels):
    method get_roi_rel_points_train (line 212) | def get_roi_rel_points_train(self, mask_pred, labels, cfg):
    method get_roi_rel_points_test (line 267) | def get_roi_rel_points_test(self, mask_pred, pred_label, cfg):

FILE: code/mmdet/models/roi_heads/mask_heads/maskiou_head.py
  class MaskIoUHead (line 13) | class MaskIoUHead(nn.Module):
    method __init__ (line 19) | def __init__(self,
    method init_weights (line 65) | def init_weights(self):
    method forward (line 77) | def forward(self, mask_feat, mask_pred):
    method loss (line 92) | def loss(self, mask_iou_pred, mask_iou_targets):
    method get_targets (line 102) | def get_targets(self, sampling_results, gt_masks, mask_pred, mask_targ...
    method _get_area_ratio (line 151) | def _get_area_ratio(self, pos_proposals, pos_assigned_gt_inds, gt_masks):
    method get_mask_scores (line 178) | def get_mask_scores(self, mask_iou_pred, det_bboxes, det_labels):

FILE: code/mmdet/models/roi_heads/mask_scoring_roi_head.py
  class MaskScoringRoIHead (line 9) | class MaskScoringRoIHead(StandardRoIHead):
    method __init__ (line 15) | def __init__(self, mask_iou_head, **kwargs):
    method init_weights (line 20) | def init_weights(self, pretrained):
    method _mask_forward_train (line 30) | def _mask_forward_train(self, x, sampling_results, bbox_feats, gt_masks,
    method simple_test_mask (line 57) | def simple_test_mask(self,

FILE: code/mmdet/models/roi_heads/pisa_roi_head.py
  class PISARoIHead (line 8) | class PISARoIHead(StandardRoIHead):
    method forward_train (line 10) | def forward_train(self,
    method _bbox_forward (line 87) | def _bbox_forward(self, x, rois):
    method _bbox_forward_train (line 100) | def _bbox_forward_train(self,

FILE: code/mmdet/models/roi_heads/point_rend_roi_head.py
  class PointRendRoIHead (line 14) | class PointRendRoIHead(StandardRoIHead):
    method __init__ (line 18) | def __init__(self, point_head, *args, **kwargs):
    method init_point_head (line 23) | def init_point_head(self, point_head):
    method init_weights (line 27) | def init_weights(self, pretrained):
    method _mask_forward_train (line 36) | def _mask_forward_train(self, x, sampling_results, bbox_feats, gt_masks,
    method _mask_point_forward_train (line 51) | def _mask_point_forward_train(self, x, sampling_results, mask_pred,
    method _get_fine_grained_point_feats (line 72) | def _get_fine_grained_point_feats(self, x, rois, rel_roi_points,
    method _mask_point_forward_test (line 97) | def _mask_point_forward_test(self, x, rois, label_pred, mask_pred,
    method simple_test_mask (line 135) | def simple_test_mask(self,
    method aug_test_mask (line 163) | def aug_test_mask(self, feats, img_metas, det_bboxes, det_labels):

FILE: code/mmdet/models/roi_heads/roi_extractors/base_roi_extractor.py
  class BaseRoIExtractor (line 9) | class BaseRoIExtractor(nn.Module, metaclass=ABCMeta):
    method __init__ (line 18) | def __init__(self, roi_layer, out_channels, featmap_strides):
    method num_inputs (line 26) | def num_inputs(self):
    method init_weights (line 30) | def init_weights(self):
    method build_roi_layers (line 33) | def build_roi_layers(self, layer_cfg, featmap_strides):
    method roi_rescale (line 58) | def roi_rescale(self, rois, scale_factor):
    method forward (line 83) | def forward(self, feats, rois, roi_scale_factor=None):

FILE: code/mmdet/models/roi_heads/roi_extractors/generic_roi_extractor.py
  class GenericRoIExtractor (line 8) | class GenericRoIExtractor(BaseRoIExtractor):
    method __init__ (line 23) | def __init__(self,
    method forward (line 42) | def forward(self, feats, rois, roi_scale_factor=None):

FILE: code/mmdet/models/roi_heads/roi_extractors/single_level_roi_extractor.py
  class SingleRoIExtractor (line 9) | class SingleRoIExtractor(BaseRoIExtractor):
    method __init__ (line 23) | def __init__(self,
    method map_roi_levels (line 32) | def map_roi_levels(self, rois, num_levels):
    method forward (line 54) | def forward(self, feats, rois, roi_scale_factor=None):

FILE: code/mmdet/models/roi_heads/shared_heads/res_layer.py
  class ResLayer (line 13) | class ResLayer(nn.Module):
    method __init__ (line 15) | def __init__(self,
    method init_weights (line 48) | def init_weights(self, pretrained=None):
    method forward (line 68) | def forward(self, x):
    method train (line 73) | def train(self, mode=True):

FILE: code/mmdet/models/roi_heads/standard_roi_head.py
  class StandardRoIHead (line 10) | class StandardRoIHead(BaseRoIHead, BBoxTestMixin, MaskTestMixin):
    method init_assigner_sampler (line 14) | def init_assigner_sampler(self):
    method init_bbox_head (line 23) | def init_bbox_head(self, bbox_roi_extractor, bbox_head):
    method init_mask_head (line 28) | def init_mask_head(self, mask_roi_extractor, mask_head):
    method init_weights (line 38) | def init_weights(self, pretrained):
    method forward_dummy (line 55) | def forward_dummy(self, x, proposals):
    method forward_train (line 71) | def forward_train(self,
    method _bbox_forward (line 136) | def _bbox_forward(self, x, rois):
    method _bbox_forward_train (line 149) | def _bbox_forward_train(self, x, sampling_results, gt_bboxes, gt_labels,
    method _mask_forward_train (line 164) | def _mask_forward_train(self, x, sampling_results, bbox_feats, gt_masks,
    method _mask_forward (line 201) | def _mask_forward(self, x, rois=None, pos_inds=None, bbox_feats=None):
    method async_simple_test (line 218) | async def async_simple_test(self,
    method simple_test (line 243) | def simple_test(self,
    method aug_test (line 264) | def aug_test(self, x, proposal_list, img_metas, rescale=False):

FILE: code/mmdet/models/roi_heads/test_mixins.py
  class BBoxTestMixin (line 15) | class BBoxTestMixin(object):
    method async_test_bboxes (line 19) | async def async_test_bboxes(self,
    method simple_test_bboxes (line 52) | def simple_test_bboxes(self,
    method aug_test_bboxes (line 73) | def aug_test_bboxes(self, feats, img_metas, proposal_list, rcnn_test_c...
  class MaskTestMixin (line 109) | class MaskTestMixin(object):
    method async_test_mask (line 113) | async def async_test_mask(self,
    method simple_test_mask (line 151) | def simple_test_mask(self,
    method aug_test_mask (line 178) | def aug_test_mask(self, feats, img_metas, det_bboxes, det_labels):

FILE: code/mmdet/models/utils/res_layer.py
  class ResLayer (line 5) | class ResLayer(nn.Sequential):
    method __init__ (line 24) | def __init__(self,

FILE: code/mmdet/ops/carafe/carafe.py
  class CARAFENaiveFunction (line 11) | class CARAFENaiveFunction(Function):
    method forward (line 14) | def forward(ctx, features, masks, kernel_size, group_size, scale_factor):
    method backward (line 40) | def backward(ctx, grad_output):
  class CARAFENaive (line 60) | class CARAFENaive(Module):
    method __init__ (line 62) | def __init__(self, kernel_size, group_size, scale_factor):
    method forward (line 71) | def forward(self, features, masks):
  class CARAFEFunction (line 76) | class CARAFEFunction(Function):
    method forward (line 79) | def forward(ctx, features, masks, kernel_size, group_size, scale_factor):
    method backward (line 108) | def backward(ctx, grad_output):
  class CARAFE (line 132) | class CARAFE(Module):
    method __init__ (line 146) | def __init__(self, kernel_size, group_size, scale_factor):
    method forward (line 155) | def forward(self, features, masks):
  class CARAFEPack (line 161) | class CARAFEPack(nn.Module):
    method __init__ (line 182) | def __init__(self,
    method init_weights (line 210) | def init_weights(self):
    method kernel_normalizer (line 216) | def kernel_normalizer(self, mask):
    method feature_reassemble (line 227) | def feature_reassemble(self, x, mask):
    method forward (line 231) | def forward(self, x):

FILE: code/mmdet/ops/carafe/src/carafe_ext.cpp
  function carafe_forward (line 21) | int carafe_forward(at::Tensor features, at::Tensor rfeatures,
  function carafe_backward (line 36) | int carafe_backward(at::Tensor top_grad, at::Tensor rfeatures,
  function PYBIND11_MODULE (line 54) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: code/mmdet/ops/carafe/src/carafe_naive_ext.cpp
  function carafe_naive_forward (line 18) | int carafe_naive_forward(at::Tensor features, at::Tensor masks,
  function carafe_naive_backward (line 32) | int carafe_naive_backward(at::Tensor top_grad, at::Tensor features,
  function PYBIND11_MODULE (line 48) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: code/mmdet/ops/carafe/src/cuda/carafe_cuda.cpp
  function carafe_forward_cuda (line 34) | int carafe_forward_cuda(at::Tensor features, at::Tensor rfeatures,
  function carafe_backward_cuda (line 68) | int carafe_backward_cuda(at::Tensor top_grad, at::Tensor rfeatures,

FILE: code/mmdet/ops/carafe/src/cuda/carafe_naive_cuda.cpp
  function carafe_naive_forward_cuda (line 28) | int carafe_naive_forward_cuda(at::Tensor features, at::Tensor masks,
  function carafe_naive_backward_cuda (line 48) | int carafe_naive_backward_cuda(at::Tensor top_grad, at::Tensor features,

FILE: code/mmdet/ops/chamfer_2d/dist_chamfer_2d.py
  class ChamferFunction2D (line 10) | class ChamferFunction2D(Function):
    method forward (line 12) | def forward(ctx, xyz1, xyz2):
    method backward (line 34) | def backward(ctx, graddist1, graddist2, gradidx1, gradidx2):
  class Chamfer2D (line 51) | class Chamfer2D(nn.Module):
    method __init__ (line 52) | def __init__(self):
    method forward (line 55) | def forward(self, input1, input2):

FILE: code/mmdet/ops/chamfer_2d/src/chamfer_cuda.cpp
  function chamfer_forward (line 17) | int chamfer_forward(at::Tensor xyz1, at::Tensor xyz2, at::Tensor dist1, ...
  function chamfer_backward (line 22) | int chamfer_backward(at::Tensor xyz1, at::Tensor xyz2, at::Tensor gradxy...
  function PYBIND11_MODULE (line 30) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: code/mmdet/ops/context_block.py
  function last_zero_init (line 6) | def last_zero_init(m):
  class ContextBlock (line 13) | class ContextBlock(nn.Module):
    method __init__ (line 27) | def __init__(self,
    method reset_parameters (line 66) | def reset_parameters(self):
    method spatial_pool (line 76) | def spatial_pool(self, x):
    method forward (line 102) | def forward(self, x):

FILE: code/mmdet/ops/conv_ws.py
  function conv_ws_2d (line 7) | def conv_ws_2d(input,
  class ConvWS2d (line 24) | class ConvWS2d(nn.Conv2d):
    method __init__ (line 26) | def __init__(self,
    method forward (line 47) | def forward(self, x):
  class ConvAWS2d (line 53) | class ConvAWS2d(nn.Conv2d):
    method __init__ (line 76) | def __init__(self,
    method _get_weight (line 99) | def _get_weight(self, weight):
    method forward (line 107) | def forward(self, x):
    method _load_from_state_dict (line 112) | def _load_from_state_dict(self, state_dict, prefix, local_metadata, st...

FILE: code/mmdet/ops/corner_pool/corner_pool.py
  class TopPoolFunction (line 10) | class TopPoolFunction(Function):
    method forward (line 13) | def forward(ctx, input):
    method backward (line 19) | def backward(ctx, grad_output):
  class BottomPoolFunction (line 25) | class BottomPoolFunction(Function):
    method forward (line 28) | def forward(ctx, input):
    method backward (line 34) | def backward(ctx, grad_output):
  class LeftPoolFunction (line 40) | class LeftPoolFunction(Function):
    method forward (line 43) | def forward(ctx, input):
    method backward (line 49) | def backward(ctx, grad_output):
  class RightPoolFunction (line 55) | class RightPoolFunction(Function):
    method forward (line 58) | def forward(ctx, input):
    method backward (line 64) | def backward(ctx, grad_output):
  class CornerPool (line 70) | class CornerPool(nn.Module):
    method __init__ (line 100) | def __init__(self, mode):
    method forward (line 106) | def forward(self, x):
  class CornerPoolPack (line 119) | class CornerPoolPack(nn.Module):
    method __init__ (line 120) | def __init__(self, dim, pool1, pool2, conv_cfg=None, norm_cfg=None, fi...
    method forward (line 158) | def forward(self, x):
  class TLPool (line 179) | class TLPool(CornerPoolPack):
    method __init__ (line 180) | def __init__(self, dim, conv_cfg=None, norm_cfg=None, first_kernel_siz...
  class BRPool (line 184) | class BRPool(CornerPoolPack):
    method __init__ (line 185) | def __init__(self, dim, conv_cfg=None, norm_cfg=None, first_kernel_siz...

FILE: code/mmdet/ops/corner_pool/src/corner_pool.cpp
  function bottom_pool_forward (line 7) | at::Tensor bottom_pool_forward(at::Tensor input) {
  function bottom_pool_backward (line 26) | at::Tensor bottom_pool_backward(at::Tensor input, at::Tensor grad_output) {
  function left_pool_forward (line 68) | at::Tensor left_pool_forward(at::Tensor input) {
  function left_pool_backward (line 87) | at::Tensor left_pool_backward(at::Tensor input, at::Tensor grad_output) {
  function right_pool_forward (line 129) | at::Tensor right_pool_forward(at::Tensor input) {
  function right_pool_backward (line 148) | at::Tensor right_pool_backward(at::Tensor input, at::Tensor grad_output) {
  function top_pool_forward (line 190) | at::Tensor top_pool_forward(at::Tensor input) {
  function top_pool_backward (line 209) | at::Tensor top_pool_backward(at::Tensor input, at::Tensor grad_output) {
  function PYBIND11_MODULE (line 251) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: code/mmdet/ops/dcn/deform_conv.py
  class DeformConvFunction (line 15) | class DeformConvFunction(Function):
    method forward (line 18) | def forward(ctx,
    method backward (line 62) | def backward(ctx, grad_output):
    method _output_size (line 99) | def _output_size(input, weight, padding, dilation, stride):
  class ModulatedDeformConvFunction (line 114) | class ModulatedDeformConvFunction(Function):
    method forward (line 117) | def forward(ctx,
    method backward (line 153) | def backward(ctx, grad_output):
    method _infer_shape (line 175) | def _infer_shape(ctx, input, weight):
  class PyramidDeformConvFunction (line 188) | class PyramidDeformConvFunction(Function):
    method forward (line 191) | def forward(ctx,
    method backward (line 237) | def backward(ctx, grad_output):
    method _output_size (line 275) | def _output_size(input, weight, padding, dilation, stride):
  class DeformConv (line 295) | class DeformConv(nn.Module):
    method __init__ (line 297) | def __init__(self,
    method reset_parameters (line 334) | def reset_parameters(self):
    method forward (line 341) | def forward(self, x, offset):
  class DeformConvPack (line 361) | class DeformConvPack(DeformConv):
    method __init__ (line 387) | def __init__(self, *args, **kwargs):
    method init_offset (line 401) | def init_offset(self):
    method forward (line 405) | def forward(self, x):
    method _load_from_state_dict (line 410) | def _load_from_state_dict(self, state_dict, prefix, local_metadata, st...
  class ModulatedDeformConv (line 438) | class ModulatedDeformConv(nn.Module):
    method __init__ (line 440) | def __init__(self,
    method init_weights (line 473) | def init_weights(self):
    method forward (line 482) | def forward(self, x, offset, mask):
  class ModulatedDeformConvPack (line 489) | class ModulatedDeformConvPack(ModulatedDeformConv):
    method __init__ (line 507) | def __init__(self, *args, **kwargs):
    method init_weights (line 521) | def init_weights(self):
    method forward (line 527) | def forward(self, x):
    method _load_from_state_dict (line 536) | def _load_from_state_dict(self, state_dict, prefix, local_metadata, st...
  class PyramidDeformConv (line 565) | class PyramidDeformConv(nn.Module):
    method __init__ (line 567) | def __init__(self,
    method reset_parameters (line 604) | def reset_parameters(self):
    method forward (line 611) | def forward(self, x, offset, scale_h, scale_w):

FILE: code/mmdet/ops/dcn/deform_pool.py
  class DeformRoIPoolingFunction (line 10) | class DeformRoIPoolingFunction(Function):
    method forward (line 13) | def forward(ctx,
    method backward (line 60) | def backward(ctx, grad_output):
  class DeformRoIPooling (line 82) | class DeformRoIPooling(nn.Module):
    method __init__ (line 84) | def __init__(self,
    method forward (line 103) | def forward(self, data, rois, offset):
  class DeformRoIPoolingPack (line 113) | class DeformRoIPoolingPack(DeformRoIPooling):
    method __init__ (line 115) | def __init__(self,
    method forward (line 149) | def forward(self, data, rois):
  class ModulatedDeformRoIPoolingPack (line 177) | class ModulatedDeformRoIPoolingPack(DeformRoIPooling):
    method __init__ (line 179) | def __init__(self,
    method forward (line 232) | def forward(self, data, rois):

FILE: code/mmdet/ops/dcn/src/cuda/deform_conv_cuda.cpp
  function shape_check (line 92) | void shape_check(at::Tensor input, at::Tensor offset, at::Tensor *gradOu...
  function pyramid_shape_check (line 182) | void pyramid_shape_check(at::Tensor input, at::Tensor offset, at::Tensor...
  function deform_conv_forward_cuda (line 274) | int deform_conv_forward_cuda(at::Tensor input, at::Tensor weight,
  function deform_conv_backward_input_cuda (line 384) | int deform_conv_backward_input_cuda(at::Tensor input, at::Tensor offset,
  function deform_conv_backward_parameters_cuda (line 498) | int deform_conv_backward_parameters_cuda(
  function modulated_deform_conv_cuda_forward (line 613) | void modulated_deform_conv_cuda_forward(
  function modulated_deform_conv_cuda_backward (line 694) | void modulated_deform_conv_cuda_backward(
  function pyramid_deform_conv_forward_cuda (line 811) | int pyramid_deform_conv_forward_cuda(at::Tensor input, at::Tensor weight,
  function pyramid_deform_conv_backward_input_cuda (line 921) | int pyramid_deform_conv_backward_input_cuda(at::Tensor input, at::Tensor...
  function pyramid_deform_conv_backward_parameters_cuda (line 1038) | int pyramid_deform_conv_backward_parameters_cuda(

FILE: code/mmdet/ops/dcn/src/cuda/deform_pool_cuda.cpp
  function deform_psroi_pooling_cuda_forward (line 31) | void deform_psroi_pooling_cuda_forward(
  function deform_psroi_pooling_cuda_backward (line 56) | void deform_psroi_pooling_cuda_backward(

FILE: code/mmdet/ops/dcn/src/deform_conv_ext.cpp
  function deform_conv_forward (line 74) | int deform_conv_forward(at::Tensor input, at::Tensor weight,
  function deform_conv_backward_input (line 92) | int deform_conv_backward_input(at::Tensor input, at::Tensor offset,
  function deform_conv_backward_parameters (line 111) | int deform_conv_backward_parameters(
  function modulated_deform_conv_forward (line 129) | void modulated_deform_conv_forward(
  function modulated_deform_conv_backward (line 149) | void modulated_deform_conv_backward(
  function pyramid_deform_conv_forward (line 171) | int pyramid_deform_conv_forward(at::Tensor input, at::Tensor weight,
  function pyramid_deform_conv_backward_input (line 190) | int pyramid_deform_conv_backward_input(at::Tensor input, at::Tensor offset,
  function pyramid_deform_conv_backward_parameters (line 209) | int pyramid_deform_conv_backward_parameters(
  function PYBIND11_MODULE (line 227) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: code/mmdet/ops/dcn/src/deform_pool_ext.cpp
  function deform_psroi_pooling_forward (line 29) | void deform_psroi_pooling_forward(
  function deform_psroi_pooling_backward (line 46) | void deform_psroi_pooling_backward(
  function PYBIND11_MODULE (line 66) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: code/mmdet/ops/generalized_attention.py
  class GeneralizedAttention (line 10) | class GeneralizedAttention(nn.Module):
    method __init__ (line 34) | def __init__(self,
    method get_position_embedding (line 153) | def get_position_embedding(self,
    method forward (line 197) | def forward(self, x_input):
    method init_weights (line 375) | def init_weights(self):

FILE: code/mmdet/ops/masked_conv/masked_conv.py
  class MaskedConv2dFunction (line 12) | class MaskedConv2dFunction(Function):
    method forward (line 15) | def forward(ctx, features, mask, weight, bias, padding=0, stride=1):
    method backward (line 57) | def backward(ctx, grad_output):
  class MaskedConv2d (line 64) | class MaskedConv2d(nn.Conv2d):
    method __init__ (line 71) | def __init__(self,
    method forward (line 84) | def forward(self, input, mask=None):

FILE: code/mmdet/ops/masked_conv/src/cuda/masked_conv2d_cuda.cpp
  function masked_im2col_forward_cuda (line 27) | int masked_im2col_forward_cuda(const at::Tensor im, const at::Tensor mas...
  function masked_col2im_forward_cuda (line 51) | int masked_col2im_forward_cuda(const at::Tensor col,

FILE: code/mmdet/ops/masked_conv/src/masked_conv2d_ext.cpp
  function masked_im2col_forward (line 18) | int masked_im2col_forward(const at::Tensor im, const at::Tensor mask_h_idx,
  function masked_col2im_forward (line 33) | int masked_col2im_forward(const at::Tensor col,
  function PYBIND11_MODULE (line 49) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: code/mmdet/ops/merge_cells.py
  class BaseMergeCell (line 9) | class BaseMergeCell(nn.Module):
    method __init__ (line 42) | def __init__(self,
    method _build_input_conv (line 77) | def _build_input_conv(self, channel, conv_cfg, norm_cfg):
    method _binary_op (line 88) | def _binary_op(self, x1, x2):
    method _resize (line 91) | def _resize(self, x, size):
    method forward (line 102) | def forward(self, x1, x2, out_size=None):
  class SumCell (line 120) | class SumCell(BaseMergeCell):
    method __init__ (line 122) | def __init__(self, in_channels, out_channels, **kwargs):
    method _binary_op (line 125) | def _binary_op(self, x1, x2):
  class ConcatCell (line 129) | class ConcatCell(BaseMergeCell):
    method __init__ (line 131) | def __init__(self, in_channels, out_channels, **kwargs):
    method _binary_op (line 135) | def _binary_op(self, x1, x2):
  class GlobalPoolingCell (line 140) | class GlobalPoolingCell(BaseMergeCell):
    method __init__ (line 142) | def __init__(self, in_channels=None, out_channels=None, **kwargs):
    method _binary_op (line 146) | def _binary_op(self, x1, x2):

FILE: code/mmdet/ops/nms/nms_wrapper.py
  function nms (line 7) | def nms(dets, iou_thr, device_id=None):
  function soft_nms (line 62) | def soft_nms(dets, iou_thr, method='linear', sigma=0.5, min_score=1e-3):
  function batched_nms (line 119) | def batched_nms(bboxes, scores, inds, nms_cfg, class_agnostic=False):
  function nms_match (line 160) | def nms_match(dets, thresh):

FILE: code/mmdet/ops/nms/src/cpu/nms_cpu.cpp
  function nms_cpu_kernel (line 8) | at::Tensor nms_cpu_kernel(const at::Tensor& dets, const float threshold) {
  function nms_cpu (line 68) | at::Tensor nms_cpu(const at::Tensor& dets, const float threshold) {
  function soft_nms_cpu_kernel (line 77) | at::Tensor soft_nms_cpu_kernel(const at::Tensor& dets, const float thres...
  function soft_nms_cpu (line 208) | at::Tensor soft_nms_cpu(const at::Tensor& dets, const float threshold,
  function nms_match_cpu_kernel (line 221) | std::vector<std::vector<int> > nms_match_cpu_kernel(const at::Tensor& dets,
  function nms_match_cpu (line 285) | std::vector<std::vector<int> > nms_match_cpu(const at::Tensor& dets,

FILE: code/mmdet/ops/nms/src/cuda/nms_cuda.cpp
  function nms_cuda (line 8) | at::Tensor nms_cuda(const at::Tensor& dets, const float threshold) {

FILE: code/mmdet/ops/nms/src/nms_ext.cpp
  function nms (line 18) | at::Tensor nms(const at::Tensor& dets, const float threshold){
  function soft_nms (line 29) | at::Tensor soft_nms(const at::Tensor& dets, const float threshold,
  function nms_match (line 38) | std::vector<std::vector<int> > nms_match(const at::Tensor& dets, const f...
  function PYBIND11_MODULE (line 45) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: code/mmdet/ops/non_local.py
  class NonLocal2D (line 6) | class NonLocal2D(nn.Module):
    method __init__ (line 22) | def __init__(self,
    method init_weights (line 55) | def init_weights(self, std=0.01, zeros_init=True):
    method embedded_gaussian (line 63) | def embedded_gaussian(self, theta_x, phi_x):
    method dot_product (line 72) | def dot_product(self, theta_x, phi_x):
    method forward (line 78) | def forward(self, x):

FILE: code/mmdet/ops/plugin.py
  function build_plugin_layer (line 16) | def build_plugin_layer(cfg, postfix='', **kwargs):

FILE: code/mmdet/ops/point_sample.py
  function normalize (line 9) | def normalize(grid):
  function denormalize (line 22) | def denormalize(grid):
  function generate_grid (line 34) | def generate_grid(num_grid, size, device):
  function rel_roi_point_to_abs_img_point (line 55) | def rel_roi_point_to_abs_img_point(rois, rel_roi_points):
  function abs_img_point_to_rel_img_point (line 86) | def abs_img_point_to_rel_img_point(abs_img_points,
  function rel_roi_point_to_rel_img_point (line 114) | def rel_roi_point_to_rel_img_point(rois,
  function point_sample (line 140) | def point_sample(input, points, align_corners=False, **kwargs):
  class SimpleRoIAlign (line 167) | class SimpleRoIAlign(nn.Module):
    method __init__ (line 169) | def __init__(self, out_size, spatial_scale, aligned=True):
    method forward (line 187) | def forward(self, features, rois):
    method __repr__ (line 214) | def __repr__(self):

FILE: code/mmdet/ops/roi_align/roi_align.py
  class RoIAlignFunction (line 9) | class RoIAlignFunction(Function):
    method forward (line 12) | def forward(ctx,
    method backward (line 46) | def backward(ctx, grad_output):
  class RoIAlign (line 79) | class RoIAlign(nn.Module):
    method __init__ (line 81) | def __init__(self,
    method forward (line 129) | def forward(self, features, rois):
    method __repr__ (line 146) | def __repr__(self):

FILE: code/mmdet/ops/roi_align/src/cpu/roi_align_v2.cpp
  type PreCalc (line 9) | struct PreCalc {
  function pre_calc_for_bilinear_interpolate (line 21) | void pre_calc_for_bilinear_interpolate(
  function ROIAlignForward (line 108) | void ROIAlignForward(const int nthreads, const T* input, const T& spatia...
  function bilinear_interpolate_gradient (line 194) | void bilinear_interpolate_gradient(const int height, const int width, T ...
  function add (line 243) | inline void add(T* address, const T& val) {
  function ROIAlignBackward (line 248) | void ROIAlignBackward(const int nthreads, const T* grad_output,
  function ROIAlignForwardV2CPULaucher (line 334) | at::Tensor ROIAlignForwardV2CPULaucher(const at::Tensor& input,
  function ROIAlignBackwardV2CPULaucher (line 369) | at::Tensor ROIAlignBackwardV2CPULaucher(

FILE: code/mmdet/ops/roi_align/src/roi_align_ext.cpp
  function ROIAlign_forwardV1 (line 56) | int ROIAlign_forwardV1(at::Tensor features, at::Tensor rois, int pooled_...
  function ROIAlign_backwardV1 (line 91) | int ROIAlign_backwardV1(at::Tensor top_grad, at::Tensor rois, int pooled...
  function ROIAlign_forwardV2 (line 126) | inline at::Tensor ROIAlign_forwardV2(const at::Tensor& input,
  function ROIAlign_backwardV2 (line 144) | inline at::Tensor ROIAlign_backwardV2(
  function PYBIND11_MODULE (line 163) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: code/mmdet/ops/roi_pool/roi_pool.py
  class RoIPoolFunction (line 10) | class RoIPoolFunction(Function):
    method forward (line 13) | def forward(ctx, features, rois, out_size, spatial_scale):
    method backward (line 33) | def backward(ctx, grad_output):
  class RoIPool (line 53) | class RoIPool(nn.Module):
    method __init__ (line 55) | def __init__(self, out_size, spatial_scale, use_torchvision=False):
    method forward (line 62) | def forward(self, features, rois):
    method __repr__ (line 70) | def __repr__(self):

FILE: code/mmdet/ops/roi_pool/src/roi_pool_ext.cpp
  function roi_pooling_forward (line 28) | int roi_pooling_forward(at::Tensor features, at::Tensor rois,
  function roi_pooling_backward (line 64) | int roi_pooling_backward(at::Tensor top_grad, at::Tensor rois,
  function PYBIND11_MODULE (line 101) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: code/mmdet/ops/saconv.py
  class SAConv2d (line 11) | class SAConv2d(ConvAWS2d):
    method __init__ (line 36) | def __init__(self,
    method init_weights (line 80) | def init_weights(self):
    method forward (line 89) | def forward(self, x):

FILE: code/mmdet/ops/sigmoid_focal_loss/sigmoid_focal_loss.py
  class SigmoidFocalLossFunction (line 8) | class SigmoidFocalLossFunction(Function):
    method forward (line 11) | def forward(ctx, input, target, gamma=2.0, alpha=0.25):
    method backward (line 24) | def backward(ctx, d_loss):
  class SigmoidFocalLoss (line 39) | class SigmoidFocalLoss(nn.Module):
    method __init__ (line 41) | def __init__(self, gamma, alpha):
    method forward (line 46) | def forward(self, logits, targets):
    method __repr__ (line 51) | def __repr__(self):

FILE: code/mmdet/ops/sigmoid_focal_loss/src/sigmoid_focal_loss_ext.cpp
  function SigmoidFocalLoss_forward (line 19) | at::Tensor SigmoidFocalLoss_forward(const at::Tensor &logits,
  function SigmoidFocalLoss_backward (line 35) | at::Tensor SigmoidFocalLoss_backward(const at::Tensor &logits,
  function PYBIND11_MODULE (line 52) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: code/mmdet/ops/utils/src/compiling_info.cpp
  function get_cudart_version (line 7) | int get_cudart_version() { return CUDART_VERSION; }
  function get_compiling_cuda_version (line 10) | std::string get_compiling_cuda_version() {
  function get_compiler_version (line 31) | std::string get_compiler_version() {
  function PYBIND11_MODULE (line 52) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: code/mmdet/ops/wrappers.py
  class NewEmptyTensorOp (line 16) | class NewEmptyTensorOp(torch.autograd.Function):
    method forward (line 19) | def forward(ctx, x, new_shape):
    method backward (line 24) | def backward(ctx, grad):
  class Conv2d (line 30) | class Conv2d(nn.Conv2d):
    method forward (line 32) | def forward(self, x):
  class ConvTranspose2d (line 50) | class ConvTranspose2d(nn.ConvTranspose2d):
    method forward (line 52) | def forward(self, x):
  class MaxPool2d (line 70) | class MaxPool2d(nn.MaxPool2d):
    method forward (line 72) | def forward(self, x):
  class Linear (line 87) | class Linear(torch.nn.Linear):
    method forward (line 89) | def forward(self, x):

FILE: code/mmdet/utils/collect_env.py
  function collect_env (line 14) | def collect_env():

FILE: code/mmdet/utils/contextmanagers.py
  function completed (line 16) | async def completed(trace_name='',
  function concurrent (line 94) | async def concurrent(streamqueue: asyncio.Queue,

FILE: code/mmdet/utils/logger.py
  function get_root_logger (line 6) | def get_root_logger(log_file=None, log_level=logging.INFO):

FILE: code/mmdet/utils/profiling.py
  function profile_time (line 10) | def profile_time(trace_name,

FILE: code/mmdet/utils/util_mixins.py
  class NiceRepr (line 43) | class NiceRepr(object):
    method __nice__ (line 78) | def __nice__(self):
    method __repr__ (line 89) | def __repr__(self):
    method __str__ (line 99) | def __str__(self):

FILE: code/setup.py
  function readme (line 12) | def readme():
  function get_git_hash (line 21) | def get_git_hash():
  function get_hash (line 47) | def get_hash():
  function write_version_py (line 62) | def write_version_py():
  function get_version (line 82) | def get_version():
  function make_cuda_ext (line 88) | def make_cuda_ext(name, module, sources, sources_cuda=[]):
  function parse_requirements (line 114) | def parse_requirements(fname='requirements.txt', with_version=True):

FILE: code/tests/async_benchmark.py
  function main (line 15) | async def main():

FILE: code/tests/test_anchor.py
  function test_standard_anchor_generator (line 10) | def test_standard_anchor_generator():
  function test_strides (line 22) | def test_strides():
  function test_ssd_anchor_generator (line 43) | def test_ssd_anchor_generator():
  function test_anchor_generator_with_tuples (line 113) | def test_anchor_generator_with_tuples():
  function test_retina_anchor (line 148) | def test_retina_anchor():
  function test_guided_anchor (line 247) | def test_guided_anchor():

FILE: code/tests/test_assigner.py
  function test_max_iou_assigner (line 18) | def test_max_iou_assigner():
  function test_max_iou_assigner_with_ignore (line 42) | def test_max_iou_assigner_with_ignore():
  function test_max_iou_assigner_with_empty_gt (line 69) | def test_max_iou_assigner_with_empty_gt():
  function test_max_iou_assigner_with_empty_boxes (line 90) | def test_max_iou_assigner_with_empty_boxes():
  function test_max_iou_assigner_with_empty_boxes_and_ignore (line 116) | def test_max_iou_assigner_with_empty_boxes_and_ignore():
  function test_max_iou_assigner_with_empty_boxes_and_gt (line 152) | def test_max_iou_assigner_with_empty_boxes_and_gt():
  function test_point_assigner (line 166) | def test_point_assigner():
  function test_point_assigner_with_empty_gt (line 183) | def test_point_assigner_with_empty_gt():
  function test_point_assigner_with_empty_boxes_and_gt (line 201) | def test_point_assigner_with_empty_boxes_and_gt():
  function test_approx_iou_assigner (line 212) | def test_approx_iou_assigner():
  function test_approx_iou_assigner_with_empty_gt (line 237) | def test_approx_iou_assigner_with_empty_gt():
  function test_approx_iou_assigner_with_empty_boxes (line 262) | def test_approx_iou_assigner_with_empty_boxes():
  function test_approx_iou_assigner_with_empty_boxes_and_gt (line 283) | def test_approx_iou_assigner_with_empty_boxes_and_gt():
  function test_random_assign_result (line 301) | def test_random_assign_result():
  function test_center_region_assigner (line 317) | def test_center_region_assigner():
  function test_center_region_assigner_with_ignore (line 343) | def test_center_region_assigner_with_ignore():
  function test_center_region_assigner_with_empty_bboxes (line 372) | def test_center_region_assigner_with_empty_bboxes():
  function test_center_region_assigner_with_empty_gts (line 388) | def test_center_region_assigner_with_empty_gts():

FILE: code/tests/test_async.py
  class AsyncTestCase (line 17) | class AsyncTestCase(asynctest.TestCase):
    method _run_test_method (line 23) | def _run_test_method(self, method):
  class MaskRCNNDetector (line 30) | class MaskRCNNDetector:
    method __init__ (line 32) | def __init__(self,
    method init (line 45) | async def init(self):
    method apredict (line 53) | async def apredict(self, img):
  class AsyncInferenceTestCase (line 61) | class AsyncInferenceTestCase(AsyncTestCase):
    method test_simple_inference (line 65) | async def test_simple_inference(self):

FILE: code/tests/test_backbone.py
  function is_block (line 15) | def is_block(modules):
  function is_norm (line 22) | def is_norm(modules):
  function all_zeros (line 29) | def all_zeros(modules):
  function check_norm_state (line 42) | def check_norm_state(modules, train_state):
  function test_resnet_basic_block (line 51) | def test_resnet_basic_block():
  function test_resnet_bottleneck (line 101) | def test_resnet_bottleneck():
  function test_resnet_res_layer (line 236) | def test_resnet_res_layer():
  function test_resnet_backbone (line 292) | def test_resnet_backbone():
  function test_renext_bottleneck (line 622) | def test_renext_bottleneck():
  function test_resnext_backbone (line 654) | def test_resnext_backbone():
  function test_regnet_backbone (line 705) | def test_regnet_backbone(arch_name, arch, out_channels):
  function test_res2net_bottle2neck (line 731) | def test_res2net_bottle2neck():
  function test_res2net_backbone (line 765) | def test_res2net_backbone():
  function test_hourglass_backbone (line 787) | def test_hourglass_backbone():

FILE: code/tests/test_config.py
  function _get_config_directory (line 9) | def _get_config_directory():
  function test_config_build_detector (line 24) | def test_config_build_detector():
  function test_config_data_pipeline (line 79) | def test_config_data_pipeline():
  function _check_roi_head (line 215) | def _check_roi_head(config, head):
  function _check_roi_extractor (line 268) | def _check_roi_extractor(config, roi_extractor, prev_roi_extractor=None):
  function _check_mask_head (line 295) | def _check_mask_head(mask_cfg, mask_head):
  function _check_bbox_head (line 318) | def _check_bbox_head(bbox_cfg, bbox_head):
  function _check_anchorhead (line 342) | def _check_anchorhead(config, head):

FILE: code/tests/test_dataset.py
  function test_custom_classes_override_default (line 15) | def test_custom_classes_override_default(dataset):
  function test_dataset_wrapper (line 89) | def test_dataset_wrapper():

FILE: code/tests/test_forward.py
  function _get_config_directory (line 12) | def _get_config_directory():
  function _get_config_module (line 27) | def _get_config_module(fname):
  function _get_detector_cfg (line 38) | def _get_detector_cfg(fname):
  function test_rpn_forward (line 51) | def test_rpn_forward():
  function test_single_stage_forward_gpu (line 93) | def test_single_stage_forward_gpu(cfg_file):
  function test_faster_rcnn_ohem_forward (line 133) | def test_faster_rcnn_ohem_forward():
  function test_two_stage_forward (line 183) | def test_two_stage_forward(cfg_file):
  function test_single_stage_forward_cpu (line 244) | def test_single_stage_forward_cpu(cfg_file):
  function _demo_mm_inputs (line 278) | def _demo_mm_inputs(input_shape=(1, 3, 300, 300),

FILE: code/tests/test_fp16.py
  function test_cast_tensor_type (line 10) | def test_cast_tensor_type():
  function test_auto_fp16 (line 52) | def test_auto_fp16():
  function test_force_fp32 (line 178) | def test_force_fp32():

FILE: code/tests/test_heads.py
  function test_fcos_head_loss (line 11) | def test_fcos_head_loss():
  function test_anchor_head_loss (line 72) | def test_anchor_head_loss():
  function test_fsaf_head_loss (line 139) | def test_fsaf_head_loss():
  function test_ga_anchor_head_loss (line 217) | def test_ga_anchor_head_loss():
  function test_bbox_head_loss (line 305) | def test_bbox_head_loss():
  function test_refine_boxes (line 365) | def test_refine_boxes():
  function _demodata_refine_boxes (line 490) | def _demodata_refine_boxes(n_roi, n_img, rng=0):
  function test_mask_head_loss (line 534) | def test_mask_head_loss():
  function _dummy_bbox_sampling (line 600) | def _dummy_bbox_sampling(proposal_list, gt_bboxes, gt_labels):

FILE: code/tests/test_losses.py
  function test_ce_loss (line 5) | def test_ce_loss():

FILE: code/tests/test_masks.py
  function dummy_raw_bitmap_masks (line 8) | def dummy_raw_bitmap_masks(size):
  function dummy_raw_polygon_masks (line 19) | def dummy_raw_polygon_masks(size):
  function dummy_bboxes (line 35) | def dummy_bboxes(num, max_height, max_width):
  function test_bitmap_mask_init (line 42) | def test_bitmap_mask_init():
  function test_bitmap_mask_rescale (line 77) | def test_bitmap_mask_rescale():
  function test_bitmap_mask_resize (line 98) | def test_bitmap_mask_resize():
  function test_bitmap_mask_flip (line 121) | def test_bitmap_mask_flip():
  function test_bitmap_mask_pad (line 151) | def test_bitmap_mask_pad():
  function test_bitmap_mask_crop (line 170) | def test_bitmap_mask_crop():
  function test_bitmap_mask_crop_and_resize (line 196) | def test_bitmap_mask_crop_and_resize():
  function test_bitmap_mask_expand (line 219) | def test_bitmap_mask_expand():
  function test_bitmap_mask_area (line 239) | def test_bitmap_mask_area():
  function test_bitmap_mask_to_ndarray (line 253) | def test_bitmap_mask_to_ndarray():
  function test_bitmap_mask_to_tensor (line 270) | def test_bitmap_mask_to_tensor():
  function test_bitmap_mask_index (line 287) | def test_bitmap_mask_index():
  function test_bitmap_mask_iter (line 294) | def test_bitmap_mask_iter():
  function test_polygon_mask_init (line 302) | def test_polygon_mask_init():
  function test_polygon_mask_rescale (line 330) | def test_polygon_mask_rescale():
  function test_polygon_mask_resize (line 358) | def test_polygon_mask_resize():
  function test_polygon_mask_flip (line 413) | def test_polygon_mask_flip():
  function test_polygon_mask_crop (line 449) | def test_polygon_mask_crop():
  function test_polygon_mask_pad (line 478) | def test_polygon_mask_pad():
  function test_polygon_mask_expand (line 499) | def test_polygon_mask_expand():
  function test_polygon_mask_crop_and_resize (line 506) | def test_polygon_mask_crop_and_resize():
  function test_polygon_mask_area (line 531) | def test_polygon_mask_area():
  function test_polygon_mask_to_bitmap (line 548) | def test_polygon_mask_to_bitmap():
  function test_polygon_mask_to_ndarray (line 556) | def test_polygon_mask_to_ndarray():
  function test_polygon_to_tensor (line 572) | def test_polygon_to_tensor():
  function test_polygon_mask_index (line 589) | def test_polygon_mask_index():
  function test_polygon_mask_iter (line 603) | def test_polygon_mask_iter():

FILE: code/tests/test_necks.py
  function test_fpn (line 8) | def test_fpn():

FILE: code/tests/test_ops/test_corner_pool.py
  function test_corner_pool_device_and_dtypes_cpu (line 11) | def test_corner_pool_device_and_dtypes_cpu():

FILE: code/tests/test_ops/test_merge_cells.py
  function test_sum_cell (line 12) | def test_sum_cell():
  function test_concat_cell (line 24) | def test_concat_cell():
  function test_global_pool_cell (line 36) | def test_global_pool_cell():
  function test_resize_methods (line 47) | def test_resize_methods():

FILE: code/tests/test_ops/test_nms.py
  function test_nms_device_and_dtypes_cpu (line 12) | def test_nms_device_and_dtypes_cpu():
  function test_nms_device_and_dtypes_gpu (line 51) | def test_nms_device_and_dtypes_gpu():
  function test_nms_match (line 86) | def test_nms_match():

FILE: code/tests/test_ops/test_soft_nms.py
  function test_soft_nms_device_and_dtypes_cpu (line 11) | def test_soft_nms_device_and_dtypes_cpu():

FILE: code/tests/test_ops/test_wrappers.py
  function test_conv2d (line 13) | def test_conv2d():
  function test_conv_transposed_2d (line 55) | def test_conv_transposed_2d():
  function test_max_pool_2d (line 108) | def test_max_pool_2d():
  function test_linear (line 132) | def test_linear():
  function test_nn_op_forward_called (line 170) | def test_nn_op_forward_called():

FILE: code/tests/test_pipelines/test_formatting.py
  function test_default_format_bundle (line 8) | def test_default_format_bundle():

FILE: code/tests/test_pipelines/test_loading.py
  class TestLoading (line 10) | class TestLoading(object):
    method setup_class (line 13) | def setup_class(cls):
    method test_load_img (line 16) | def test_load_img(self):
    method test_load_multi_channel_img (line 58) | def test_load_multi_channel_img(self):

FILE: code/tests/test_pipelines/test_models_aug_test.py
  function model_aug_test_template (line 12) | def model_aug_test_template(cfg_file):
  function test_cascade_rcnn_aug_test (line 43) | def test_cascade_rcnn_aug_test():
  function test_mask_rcnn_aug_test (line 49) | def test_mask_rcnn_aug_test():
  function test_htc_aug_test (line 57) | def test_htc_aug_test():

FILE: code/tests/test_pipelines/test_transform.py
  function test_resize (line 14) | def test_resize():
  function test_flip (line 82) | def test_flip():
  function test_random_crop (line 119) | def test_random_crop():
  function test_min_iou_random_crop (line 167) | def test_min_iou_random_crop():
  function test_pad (line 217) | def test_pad():
  function test_normalize (line 257) | def test_normalize():
  function test_albu_transform (line 286) | def test_albu_transform():
  function test_random_center_crop_pad (line 310) | def test_random_center_crop_pad():
  function test_multi_scale_flip_aug (line 456) | def test_multi_scale_flip_aug():

FILE: code/tests/test_pisa_heads.py
  function test_pisa_retinanet_head_loss (line 8) | def test_pisa_retinanet_head_loss():
  function test_pisa_ssd_head_loss (line 77) | def test_pisa_ssd_head_loss():
  function test_pisa_roi_head_loss (line 154) | def test_pisa_roi_head_loss():

FILE: code/tests/test_roi_extractor.py
  function test_groie (line 7) | def test_groie():

FILE: code/tests/test_sampler.py
  function test_random_sampler (line 8) | def test_random_sampler():
  function test_random_sampler_empty_gt (line 44) | def test_random_sampler_empty_gt():
  function test_random_sampler_empty_pred (line 70) | def test_random_sampler_empty_pred():
  function _context_for_ohem (line 94) | def _context_for_ohem():
  function test_ohem_sampler (line 113) | def test_ohem_sampler():
  function test_ohem_sampler_empty_gt (line 158) | def test_ohem_sampler_empty_gt():
  function test_ohem_sampler_empty_pred (line 199) | def test_ohem_sampler_empty_pred():
  function test_random_sample_result (line 239) | def test_random_sample_result():
  function test_score_hlr_sampler_empty_pred (line 253) | def test_score_hlr_sampler_empty_pred():

FILE: code/tools/analyze_logs.py
  function cal_train_time (line 10) | def cal_train_time(log_dicts, args):
  function plot_curve (line 33) | def plot_curve(log_dicts, args):
  function add_plot_parser (line 92) | def add_plot_parser(subparsers):
  function add_time_parser (line 120) | def add_time_parser(subparsers):
  function parse_args (line 136) | def parse_args():
  function load_json_logs (line 146) | def load_json_logs(json_logs):
  function main (line 166) | def main():

FILE: code/tools/benchmark.py
  function parse_args (line 15) | def parse_args():
  function main (line 30) | def main():

FILE: code/tools/browse_dataset.py
  function parse_args (line 11) | def parse_args():
  function retrieve_data_cfg (line 35) | def retrieve_data_cfg(config_path, skip_type):
  function main (line 45) | def main():

FILE: code/tools/coco_error_analysis.py
  function makeplot (line 12) | def makeplot(rs, ps, outDir, class_name, iou_type):
  function analyze_individual_category (line 52) | def analyze_individual_category(k, cocoDt, cocoGt, catId, iou_type):
  function analyze_results (line 103) | def analyze_results(res_file, ann_file, res_types, out_dir):
  function main (line 156) | def main():

FILE: code/tools/convert_datasets/cityscapes.py
  function collect_files (line 11) | def collect_files(img_dir, gt_dir):
  function collect_annotations (line 28) | def collect_annotations(files, nproc=1):
  function load_img_info (line 39) | def load_img_info(files):
  function cvt_annotations (line 84) | def cvt_annotations(image_infos, out_json_name):
  function parse_args (line 113) | def parse_args():
  function main (line 126) | def main():

FILE: code/tools/convert_datasets/pascal_voc.py
  function parse_xml (line 13) | def parse_xml(args):
  function cvt_annotations (line 67) | def cvt_annotations(devkit_path, years, split, out_file):
  function parse_args (line 93) | def parse_args():
  function main (line 102) | def main():

FILE: code/tools/detectron2pytorch.py
  function convert_bn (line 10) | def convert_bn(blobs, state_dict, caffe_name, torch_name, converted_names):
  function convert_conv_fc (line 23) | def convert_conv_fc(blobs, state_dict, caffe_name, torch_name,
  function convert (line 34) | def convert(src, dst, depth):
  function main (line 72) | def main():

FILE: code/tools/fuse_conv_bn.py
  function fuse_conv_bn (line 10) | def fuse_conv_bn(conv, bn):
  function fuse_module (line 27) | def fuse_module(m):
  function parse_args (line 48) | def parse_args():
  function main (line 58) | def main():

FILE: code/tools/gen_coco_lsvr.py
  function _coco_box_to_bbox (line 17) | def _coco_box_to_bbox(box):
  function _get_extreme_points (line 21) | def _get_extreme_points(pts):

FILE: code/tools/get_flops.py
  function parse_args (line 14) | def parse_args():
  function main (line 27) | def main():

FILE: code/tools/print_config.py
  function parse_args (line 6) | def parse_args():
  function main (line 16) | def main():

FILE: code/tools/publish_model.py
  function parse_args (line 7) | def parse_args():
  function process_checkpoint (line 16) | def process_checkpoint(in_file, out_file):
  function main (line 31) | def main():

FILE: code/tools/pytorch2onnx.py
  function export_onnx_model (line 15) | def export_onnx_model(model, inputs, passes):
  function parse_args (line 59) | def parse_args():
  function main (line 78) | def main():

FILE: code/tools/regnet2mmdet.py
  function convert_stem (line 7) | def convert_stem(model_key, model_weight, state_dict, converted_names):
  function convert_head (line 15) | def convert_head(model_key, model_weight, state_dict, converted_names):
  function convert_reslayer (line 22) | def convert_reslayer(model_key, model_weight, state_dict, converted_names):
  function convert (line 54) | def convert(src, dst):
  function main (line 80) | def main():

FILE: code/tools/robustness_eval.py
  function print_coco_results (line 8) | def print_coco_results(results):
  function get_coco_style_results (line 34) | def get_coco_style_results(filename,
  function get_voc_style_results (line 111) | def get_voc_style_results(filename, prints='mPC', aggregate='benchmark'):
  function get_results (line 155) | def get_results(filename,
  function get_distortions_from_file (line 183) | def get_distortions_from_file(filename):
  function get_distortions_from_results (line 190) | def get_distortions_from_results(eval_output):
  function main (line 197) | def main():

FILE: code/tools/test.py
  function parse_args (line 17) | def parse_args():
  function main (line 70) | def main():

FILE: code/tools/test_robustness.py
  function coco_eval_with_return (line 24) | def coco_eval_with_return(result_files,
  function voc_eval_with_return (line 66) | def voc_eval_with_return(result_file,
  function single_gpu_test (line 93) | def single_gpu_test(model, data_loader, show=False):
  function multi_gpu_test (line 118) | def multi_gpu_test(model, data_loader, tmpdir=None):
  function collect_results (line 148) | def collect_results(result_part, size, tmpdir=None):
  function parse_args (line 190) | def parse_args():
  function main (line 261) | def main():

FILE: code/tools/train.py
  function parse_args (line 20) | def parse_args():
  function main (line 64) | def main():

FILE: code/tools/upgrade_model_version.py
  function is_head (line 10) | def is_head(key):
  function parse_config (line 18) | def parse_config(config_strings):
  function reorder_cls_channel (line 45) | def reorder_cls_channel(val, num_classes=81):
  function truncate_cls_channel (line 67) | def truncate_cls_channel(val, num_classes=81):
  function truncate_reg_channel (line 89) | def truncate_reg_channel(val, num_classes=81):
  function convert (line 114) | def convert(in_file, out_file, num_classes):
  function main (line 179) | def main():