SYMBOL INDEX (4271 symbols across 633 files)

FILE: .dev_scripts/benchmark_filter.py
  function parse_args (line 7) | def parse_args():
  function main (line 132) | def main():

FILE: .dev_scripts/benchmark_inference_fps.py
  function parse_args (line 15) | def parse_args():
  function results2markdown (line 63) | def results2markdown(result_dict):

FILE: .dev_scripts/benchmark_test.py
  function parse_args (line 16) | def parse_args():
  function fast_test_model (line 46) | def fast_test_model(config_name, checkpoint, args, logger=None):
  function main (line 86) | def main(args):

FILE: .dev_scripts/benchmark_test_image.py
  function parse_args (line 16) | def parse_args():
  function inference_model (line 43) | def inference_model(config_name, checkpoint, visualizer, args, logger=No...
  function main (line 82) | def main(args):

FILE: .dev_scripts/benchmark_train.py
  function parse_args (line 16) | def parse_args():
  function fast_train_model (line 59) | def fast_train_model(config_name, args, logger=None):
  function main (line 147) | def main(args):

FILE: .dev_scripts/benchmark_valid_flops.py
  function parse_args (line 32) | def parse_args():
  function inference (line 76) | def inference(config_file, checkpoint, work_dir, args, exp_name):
  function show_summary (line 177) | def show_summary(summary_data, args):
  function main (line 208) | def main(args):

FILE: .dev_scripts/check_links.py
  function parse_args (line 17) | def parse_args():
  class MatchTuple (line 47) | class MatchTuple(NamedTuple):
  function check_link (line 53) | def check_link(
  function check_url (line 69) | def check_url(match_tuple: MatchTuple,
  function check_path (line 83) | def check_path(match_tuple: MatchTuple) -> bool:
  function main (line 91) | def main():

FILE: .dev_scripts/convert_test_benchmark_script.py
  function parse_args (line 9) | def parse_args():
  function process_model_info (line 23) | def process_model_info(model_info, work_dir):
  function create_test_bash_info (line 36) | def create_test_bash_info(commands, model_test_dict, port, script_name,
  function main (line 62) | def main():

FILE: .dev_scripts/convert_train_benchmark_script.py
  function parse_args (line 7) | def parse_args():
  function determine_gpus (line 21) | def determine_gpus(cfg_name):
  function main (line 37) | def main():

FILE: .dev_scripts/download_checkpoints.py
  function download (line 14) | def download(url, out_file, min_bytes=math.pow(1024, 2), progress=True):
  function parse_args (line 38) | def parse_args():

FILE: .dev_scripts/gather_models.py
  function ordered_yaml_dump (line 17) | def ordered_yaml_dump(data, stream=None, Dumper=yaml.SafeDumper, **kwds):
  function process_checkpoint (line 30) | def process_checkpoint(in_file, out_file):
  function is_by_epoch (line 53) | def is_by_epoch(config):
  function get_final_epoch_or_iter (line 58) | def get_final_epoch_or_iter(config):
  function get_best_epoch_or_iter (line 66) | def get_best_epoch_or_iter(exp_dir):
  function get_real_epoch_or_iter (line 75) | def get_real_epoch_or_iter(config):
  function get_final_results (line 86) | def get_final_results(log_json_path,
  function get_dataset_name (line 134) | def get_dataset_name(config):
  function convert_model_info_to_pwc (line 153) | def convert_model_info_to_pwc(model_infos):
  function parse_args (line 212) | def parse_args():
  function main (line 229) | def main():

FILE: .dev_scripts/gather_test_benchmark_metric.py
  function parse_args (line 11) | def parse_args():

FILE: .dev_scripts/gather_train_benchmark_metric.py
  function parse_args (line 22) | def parse_args():

FILE: .dev_scripts/test_init_backbone.py
  function _get_config_directory (line 15) | def _get_config_directory():
  function _get_config_module (line 30) | def _get_config_module(fname):
  function _get_detector_cfg (line 38) | def _get_detector_cfg(fname):
  function _traversed_config_file (line 49) | def _traversed_config_file():
  function _check_backbone (line 90) | def _check_backbone(config, print_cfg=True):
  function test_load_pretrained (line 149) | def test_load_pretrained(config):
  function _test_load_pretrained (line 158) | def _test_load_pretrained():

FILE: demo/create_result_gif.py
  function parse_args (line 19) | def parse_args():
  function _generate_batch_data (line 34) | def _generate_batch_data(sampler, batch_size):
  function create_gif (line 45) | def create_gif(frames, gif_name, duration=2):
  function create_frame_by_matplotlib (line 60) | def create_frame_by_matplotlib(image_dir,
  function main (line 158) | def main():

FILE: demo/image_demo.py
  function parse_args (line 32) | def parse_args():
  function main (line 99) | def main():

FILE: demo/video_demo.py
  function parse_args (line 13) | def parse_args():
  function main (line 33) | def main():

FILE: demo/video_gpuaccel_demo.py
  function parse_args (line 24) | def parse_args():
  function prefetch_batch_input_shape (line 47) | def prefetch_batch_input_shape(model: nn.Module, ori_wh: Tuple[int,
  function pack_data (line 60) | def pack_data(frame_resize: np.ndarray, batch_input_shape: Tuple[int, int],
  function main (line 77) | def main():

FILE: demo/webcam_demo.py
  function parse_args (line 12) | def parse_args():
  function main (line 26) | def main():

FILE: mmdet/apis/det_inferencer.py
  class DetInferencer (line 44) | class DetInferencer(BaseInferencer):
    method __init__ (line 83) | def __init__(self,
    method _load_weights_to_model (line 99) | def _load_weights_to_model(self, model: nn.Module,
    method _init_pipeline (line 154) | def _init_pipeline(self, cfg: ConfigType) -> Compose:
    method _get_transform_idx (line 172) | def _get_transform_idx(self, pipeline_cfg: ConfigType, name: str) -> int:
    method _init_visualizer (line 182) | def _init_visualizer(self, cfg: ConfigType) -> Optional[Visualizer]:
    method _inputs_to_list (line 195) | def _inputs_to_list(self, inputs: InputsType) -> list:
    method preprocess (line 230) | def preprocess(self, inputs: InputsType, batch_size: int = 1, **kwargs):
    method _get_chunk_data (line 257) | def _get_chunk_data(self, inputs: Iterable, chunk_size: int):
    method __call__ (line 283) | def __call__(self,
    method visualize (line 368) | def visualize(self,
    method postprocess (line 447) | def postprocess(
    method pred2dict (line 513) | def pred2dict(self,

FILE: mmdet/apis/inference.py
  function init_detector (line 24) | def init_detector(
  function inference_detector (line 117) | def inference_detector(
  function async_inference_detector (line 188) | async def async_inference_detector(model, imgs):

FILE: mmdet/datasets/api_wrappers/coco_api.py
  class COCO (line 13) | class COCO(_COCO):
    method __init__ (line 20) | def __init__(self, annotation_file=None):
    method get_ann_ids (line 29) | def get_ann_ids(self, img_ids=[], cat_ids=[], area_rng=[], iscrowd=None):
    method get_cat_ids (line 32) | def get_cat_ids(self, cat_names=[], sup_names=[], cat_ids=[]):
    method get_img_ids (line 35) | def get_img_ids(self, img_ids=[], cat_ids=[]):
    method load_anns (line 38) | def load_anns(self, ids):
    method load_cats (line 41) | def load_cats(self, ids):
    method load_imgs (line 44) | def load_imgs(self, ids):
  class COCOPanoptic (line 52) | class COCOPanoptic(COCO):
    method __init__ (line 62) | def __init__(self, annotation_file: Optional[str] = None) -> None:
    method createIndex (line 65) | def createIndex(self) -> None:
    method load_anns (line 115) | def load_anns(self,

FILE: mmdet/datasets/base_det_dataset.py
  class BaseDetDataset (line 13) | class BaseDetDataset(BaseDataset):
    method __init__ (line 23) | def __init__(self,
    method full_init (line 35) | def full_init(self) -> None:
    method load_proposals (line 75) | def load_proposals(self) -> None:
    method get_cat_ids (line 103) | def get_cat_ids(self, idx: int) -> List[int]:

FILE: mmdet/datasets/cityscapes.py
  class CityscapesDataset (line 12) | class CityscapesDataset(CocoDataset):
    method filter_data (line 22) | def filter_data(self) -> List[dict]:

FILE: mmdet/datasets/coco.py
  class CocoDataset (line 12) | class CocoDataset(BaseDetDataset):
    method load_data_list (line 57) | def load_data_list(self) -> List[dict]:
    method parse_data_info (line 99) | def parse_data_info(self, raw_data_info: dict) -> Union[dict, List[dic...
    method filter_data (line 158) | def filter_data(self) -> List[dict]:

FILE: mmdet/datasets/coco_panoptic.py
  class CocoPanopticDataset (line 11) | class CocoPanopticDataset(CocoDataset):
    method __init__ (line 160) | def __init__(self,
    method parse_data_info (line 185) | def parse_data_info(self, raw_data_info: dict) -> dict:
    method filter_data (line 250) | def filter_data(self) -> List[dict]:

FILE: mmdet/datasets/crowdhuman.py
  class CrowdHumanDataset (line 19) | class CrowdHumanDataset(BaseDetDataset):
    method __init__ (line 38) | def __init__(self, data_root, ann_file, extra_ann_file=None, **kwargs):
    method load_data_list (line 63) | def load_data_list(self) -> List[dict]:
    method parse_data_info (line 97) | def parse_data_info(self, raw_data_info: dict) -> Union[dict, List[dic...

FILE: mmdet/datasets/dataset_wrappers.py
  class MultiImageMixDataset (line 12) | class MultiImageMixDataset:
    method __init__ (line 36) | def __init__(self,
    method metainfo (line 81) | def metainfo(self) -> dict:
    method full_init (line 89) | def full_init(self):
    method get_data_info (line 99) | def get_data_info(self, idx: int) -> dict:
    method __len__ (line 111) | def __len__(self):
    method __getitem__ (line 114) | def __getitem__(self, idx):
    method update_skip_type_keys (line 159) | def update_skip_type_keys(self, skip_type_keys):

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

FILE: mmdet/datasets/lvis.py
  class LVISV05Dataset (line 11) | class LVISV05Dataset(CocoDataset):
    method load_data_list (line 271) | def load_data_list(self) -> List[dict]:
  class LVISV1Dataset (line 332) | class LVISV1Dataset(LVISDataset):
    method load_data_list (line 583) | def load_data_list(self) -> List[dict]:

FILE: mmdet/datasets/objects365.py
  class Objects365V1Dataset (line 19) | class Objects365V1Dataset(CocoDataset):
    method load_data_list (line 99) | def load_data_list(self) -> List[dict]:
  class Objects365V2Dataset (line 152) | class Objects365V2Dataset(CocoDataset):
    method load_data_list (line 231) | def load_data_list(self) -> List[dict]:

FILE: mmdet/datasets/openimages.py
  class OpenImagesDataset (line 16) | class OpenImagesDataset(BaseDetDataset):
    method __init__ (line 35) | def __init__(self,
    method load_data_list (line 47) | def load_data_list(self) -> List[dict]:
    method _parse_label_file (line 156) | def _parse_label_file(self, label_file: str) -> tuple:
    method _parse_img_level_ann (line 180) | def _parse_img_level_ann(self,
    method _get_relation_matrix (line 218) | def _get_relation_matrix(self, hierarchy_file: str) -> np.ndarray:
    method _convert_hierarchy_tree (line 242) | def _convert_hierarchy_tree(self,
    method _join_prefix (line 286) | def _join_prefix(self):
  class OpenImagesChallengeDataset (line 301) | class OpenImagesChallengeDataset(OpenImagesDataset):
    method __init__ (line 310) | def __init__(self, ann_file: str, **kwargs) -> None:
    method load_data_list (line 317) | def load_data_list(self) -> List[dict]:
    method _parse_label_file (line 402) | def _parse_label_file(self, label_file: str) -> tuple:
    method _parse_img_level_ann (line 431) | def _parse_img_level_ann(self, image_level_ann_file):
    method _get_relation_matrix (line 470) | def _get_relation_matrix(self, hierarchy_file: str) -> np.ndarray:

FILE: mmdet/datasets/samplers/batch_sampler.py
  class AspectRatioBatchSampler (line 11) | class AspectRatioBatchSampler(BatchSampler):
    method __init__ (line 23) | def __init__(self,
    method __iter__ (line 39) | def __iter__(self) -> Sequence[int]:
    method __len__ (line 64) | def __len__(self) -> int:

FILE: mmdet/datasets/samplers/class_aware_sampler.py
  class ClassAwareSampler (line 15) | class ClassAwareSampler(Sampler):
    method __init__ (line 36) | def __init__(self,
    method get_cat2imgs (line 70) | def get_cat2imgs(self) -> Dict[int, list]:
    method __iter__ (line 89) | def __iter__(self) -> Iterator[int]:
    method __len__ (line 135) | def __len__(self) -> int:
    method set_epoch (line 139) | def set_epoch(self, epoch: int) -> None:
  class RandomCycleIter (line 152) | class RandomCycleIter:
    method __init__ (line 170) | def __init__(self,
    method __iter__ (line 179) | def __iter__(self) -> Iterator:
    method __len__ (line 182) | def __len__(self) -> int:
    method __next__ (line 185) | def __next__(self):

FILE: mmdet/datasets/samplers/multi_source_sampler.py
  class MultiSourceSampler (line 15) | class MultiSourceSampler(Sampler):
    method __init__ (line 64) | def __init__(self,
    method _infinite_indices (line 107) | def _infinite_indices(self, sample_size: int) -> Iterator[int]:
    method _indices_of_rank (line 117) | def _indices_of_rank(self, sample_size: int) -> Iterator[int]:
    method __iter__ (line 123) | def __iter__(self) -> Iterator[int]:
    method __len__ (line 137) | def __len__(self) -> int:
    method set_epoch (line 140) | def set_epoch(self, epoch: int) -> None:
  class GroupMultiSourceSampler (line 146) | class GroupMultiSourceSampler(MultiSourceSampler):
    method __init__ (line 162) | def __init__(self,
    method _get_source_group_info (line 182) | def _get_source_group_info(self) -> None:
    method __iter__ (line 199) | def __iter__(self) -> Iterator[int]:

FILE: mmdet/datasets/transforms/augment_wrappers.py
  function policies_v0 (line 55) | def policies_v0():
  function level_to_mag (line 76) | def level_to_mag(level: Optional[int], min_mag: float,
  class AutoAugment (line 86) | class AutoAugment(RandomChoice):
    method __init__ (line 147) | def __init__(self,
    method __repr__ (line 162) | def __repr__(self) -> str:
  class RandAugment (line 168) | class RandAugment(RandomChoice):
    method __init__ (line 224) | def __init__(self,
    method random_pipeline_index (line 242) | def random_pipeline_index(self):
    method transform (line 247) | def transform(self, results: dict) -> dict:
    method __repr__ (line 260) | def __repr__(self) -> str:

FILE: mmdet/datasets/transforms/colorspace.py
  class ColorTransform (line 15) | class ColorTransform(BaseTransform):
    method __init__ (line 43) | def __init__(self,
    method _transform_img (line 66) | def _transform_img(self, results: dict, mag: float) -> None:
    method _random_disable (line 71) | def _random_disable(self):
    method _get_mag (line 76) | def _get_mag(self):
    method transform (line 80) | def transform(self, results: dict) -> dict:
    method __repr__ (line 96) | def __repr__(self) -> str:
  class Color (line 106) | class Color(ColorTransform):
    method __init__ (line 132) | def __init__(self,
    method _transform_img (line 144) | def _transform_img(self, results: dict, mag: float) -> None:
  class Brightness (line 152) | class Brightness(ColorTransform):
    method __init__ (line 177) | def __init__(self,
    method _transform_img (line 189) | def _transform_img(self, results: dict, mag: float) -> None:
  class Contrast (line 196) | class Contrast(ColorTransform):
    method __init__ (line 221) | def __init__(self,
    method _transform_img (line 233) | def _transform_img(self, results: dict, mag: float) -> None:
  class Sharpness (line 240) | class Sharpness(ColorTransform):
    method __init__ (line 265) | def __init__(self,
    method _transform_img (line 277) | def _transform_img(self, results: dict, mag: float) -> None:
  class Solarize (line 284) | class Solarize(ColorTransform):
    method __init__ (line 308) | def __init__(self,
    method _transform_img (line 320) | def _transform_img(self, results: dict, mag: float) -> None:
  class SolarizeAdd (line 327) | class SolarizeAdd(ColorTransform):
    method __init__ (line 351) | def __init__(self,
    method _transform_img (line 363) | def _transform_img(self, results: dict, mag: float) -> None:
  class Posterize (line 371) | class Posterize(ColorTransform):
    method __init__ (line 394) | def __init__(self,
    method _transform_img (line 406) | def _transform_img(self, results: dict, mag: float) -> None:
  class Equalize (line 413) | class Equalize(ColorTransform):
    method _transform_img (line 434) | def _transform_img(self, results: dict, mag: float) -> None:
  class AutoContrast (line 441) | class AutoContrast(ColorTransform):
    method _transform_img (line 463) | def _transform_img(self, results: dict, mag: float) -> None:
  class Invert (line 470) | class Invert(ColorTransform):
    method _transform_img (line 490) | def _transform_img(self, results: dict, mag: float) -> None:

FILE: mmdet/datasets/transforms/formatting.py
  class PackDetInputs (line 13) | class PackDetInputs(BaseTransform):
    method __init__ (line 48) | def __init__(self,
    method transform (line 53) | def transform(self, results: dict) -> dict:
    method __repr__ (line 139) | def __repr__(self) -> str:
  class ToTensor (line 146) | class ToTensor:
    method __init__ (line 153) | def __init__(self, keys):
    method __call__ (line 156) | def __call__(self, results):
    method __repr__ (line 170) | def __repr__(self):
  class ImageToTensor (line 175) | class ImageToTensor:
    method __init__ (line 186) | def __init__(self, keys):
    method __call__ (line 189) | def __call__(self, results):
    method __repr__ (line 208) | def __repr__(self):
  class Transpose (line 213) | class Transpose:
    method __init__ (line 221) | def __init__(self, keys, order):
    method __call__ (line 225) | def __call__(self, results):
    method __repr__ (line 239) | def __repr__(self):
  class WrapFieldsToLists (line 245) | class WrapFieldsToLists:
    method __call__ (line 265) | def __call__(self, results):
    method __repr__ (line 281) | def __repr__(self):

FILE: mmdet/datasets/transforms/geometric.py
  class GeomTransform (line 17) | class GeomTransform(BaseTransform):
    method __init__ (line 69) | def __init__(self,
    method _transform_img (line 120) | def _transform_img(self, results: dict, mag: float) -> None:
    method _transform_masks (line 124) | def _transform_masks(self, results: dict, mag: float) -> None:
    method _transform_seg (line 128) | def _transform_seg(self, results: dict, mag: float) -> None:
    method _get_homography_matrix (line 132) | def _get_homography_matrix(self, results: dict, mag: float) -> np.ndar...
    method _transform_bboxes (line 136) | def _transform_bboxes(self, results: dict, mag: float) -> None:
    method _record_homography_matrix (line 141) | def _record_homography_matrix(self, results: dict) -> None:
    method _random_disable (line 150) | def _random_disable(self):
    method _get_mag (line 155) | def _get_mag(self):
    method transform (line 161) | def transform(self, results: dict) -> dict:
    method __repr__ (line 186) | def __repr__(self) -> str:
  class ShearX (line 201) | class ShearX(GeomTransform):
    method __init__ (line 248) | def __init__(self,
    method _get_mag (line 276) | def _get_mag(self):
    method _get_homography_matrix (line 282) | def _get_homography_matrix(self, results: dict, mag: float) -> np.ndar...
    method _transform_img (line 286) | def _transform_img(self, results: dict, mag: float) -> None:
    method _transform_masks (line 295) | def _transform_masks(self, results: dict, mag: float) -> None:
    method _transform_seg (line 304) | def _transform_seg(self, results: dict, mag: float) -> None:
  class ShearY (line 315) | class ShearY(GeomTransform):
    method __init__ (line 362) | def __init__(self,
    method _get_mag (line 390) | def _get_mag(self):
    method _get_homography_matrix (line 396) | def _get_homography_matrix(self, results: dict, mag: float) -> np.ndar...
    method _transform_img (line 400) | def _transform_img(self, results: dict, mag: float) -> None:
    method _transform_masks (line 409) | def _transform_masks(self, results: dict, mag: float) -> None:
    method _transform_seg (line 418) | def _transform_seg(self, results: dict, mag: float) -> None:
  class Rotate (line 429) | class Rotate(GeomTransform):
    method __init__ (line 476) | def __init__(self,
    method _get_homography_matrix (line 501) | def _get_homography_matrix(self, results: dict, mag: float) -> np.ndar...
    method _transform_img (line 510) | def _transform_img(self, results: dict, mag: float) -> None:
    method _transform_masks (line 518) | def _transform_masks(self, results: dict, mag: float) -> None:
    method _transform_seg (line 526) | def _transform_seg(self, results: dict, mag: float) -> None:
  class TranslateX (line 536) | class TranslateX(GeomTransform):
    method __init__ (line 583) | def __init__(self,
    method _get_homography_matrix (line 610) | def _get_homography_matrix(self, results: dict, mag: float) -> np.ndar...
    method _transform_img (line 615) | def _transform_img(self, results: dict, mag: float) -> None:
    method _transform_masks (line 625) | def _transform_masks(self, results: dict, mag: float) -> None:
    method _transform_seg (line 635) | def _transform_seg(self, results: dict, mag: float) -> None:
  class TranslateY (line 647) | class TranslateY(GeomTransform):
    method __init__ (line 694) | def __init__(self,
    method _get_homography_matrix (line 721) | def _get_homography_matrix(self, results: dict, mag: float) -> np.ndar...
    method _transform_img (line 726) | def _transform_img(self, results: dict, mag: float) -> None:
    method _transform_masks (line 736) | def _transform_masks(self, results: dict, mag: float) -> None:
    method _transform_seg (line 746) | def _transform_seg(self, results: dict, mag: float) -> None:

FILE: mmdet/datasets/transforms/instaboost.py
  class InstaBoost (line 11) | class InstaBoost(BaseTransform):
    method __init__ (line 49) | def __init__(self,
    method _load_anns (line 80) | def _load_anns(self, results: dict) -> Tuple[list, list]:
    method _parse_anns (line 103) | def _parse_anns(self, results: dict, anns: list, ignore_anns: list,
    method transform (line 126) | def transform(self, results) -> dict:
    method __repr__ (line 147) | def __repr__(self) -> str:

FILE: mmdet/datasets/transforms/loading.py
  class LoadImageFromNDArray (line 21) | class LoadImageFromNDArray(LoadImageFromFile):
    method transform (line 45) | def transform(self, results: dict) -> dict:
  class LoadMultiChannelImageFromFiles (line 68) | class LoadMultiChannelImageFromFiles(BaseTransform):
    method __init__ (line 96) | def __init__(
    method transform (line 109) | def transform(self, results: dict) -> dict:
    method __repr__ (line 138) | def __repr__(self):
  class LoadAnnotations (line 148) | class LoadAnnotations(MMCV_LoadAnnotations):
    method __init__ (line 244) | def __init__(self,
    method _load_bboxes (line 254) | def _load_bboxes(self, results: dict) -> None:
    method _load_labels (line 275) | def _load_labels(self, results: dict) -> None:
    method _poly2mask (line 291) | def _poly2mask(self, mask_ann: Union[list, dict], img_h: int,
    method _process_masks (line 319) | def _process_masks(self, results: dict) -> list:
    method _load_masks (line 362) | def _load_masks(self, results: dict) -> None:
    method transform (line 378) | def transform(self, results: dict) -> dict:
    method __repr__ (line 399) | def __repr__(self) -> str:
  class LoadPanopticAnnotations (line 412) | class LoadPanopticAnnotations(LoadAnnotations):
    method __init__ (line 509) | def __init__(
    method _load_masks_and_semantic_segs (line 539) | def _load_masks_and_semantic_segs(self, results: dict) -> None:
    method transform (line 577) | def transform(self, results: dict) -> dict:
  class LoadProposals (line 601) | class LoadProposals(BaseTransform):
    method __init__ (line 617) | def __init__(self, num_max_proposals: Optional[int] = None) -> None:
    method transform (line 620) | def transform(self, results: dict) -> dict:
    method __repr__ (line 657) | def __repr__(self):
  class FilterAnnotations (line 663) | class FilterAnnotations(BaseTransform):
    method __init__ (line 693) | def __init__(self,
    method transform (line 708) | def transform(self, results: dict) -> Union[dict, None]:
    method __repr__ (line 747) | def __repr__(self):
  class LoadEmptyAnnotations (line 754) | class LoadEmptyAnnotations(BaseTransform):
    method __init__ (line 778) | def __init__(self,
    method transform (line 790) | def transform(self, results: dict) -> dict:
    method __repr__ (line 814) | def __repr__(self) -> str:
  class InferencerLoader (line 825) | class InferencerLoader(BaseTransform):
    method __init__ (line 849) | def __init__(self, **kwargs) -> None:
    method transform (line 856) | def transform(self, results: Union[str, np.ndarray, dict]) -> dict:

FILE: mmdet/datasets/transforms/transforms.py
  class Resize (line 41) | class Resize(MMCV_Resize):
    method _resize_masks (line 92) | def _resize_masks(self, results: dict) -> None:
    method _resize_bboxes (line 102) | def _resize_bboxes(self, results: dict) -> None:
    method _resize_seg (line 109) | def _resize_seg(self, results: dict) -> None:
    method _record_homography_matrix (line 126) | def _record_homography_matrix(self, results: dict) -> None:
    method transform (line 138) | def transform(self, results: dict) -> dict:
    method __repr__ (line 161) | def __repr__(self) -> str:
  class FixShapeResize (line 173) | class FixShapeResize(Resize):
    method __init__ (line 231) | def __init__(self,
    method transform (line 257) | def transform(self, results: dict) -> dict:
    method __repr__ (line 299) | def __repr__(self) -> str:
  class RandomFlip (line 310) | class RandomFlip(MMCV_RandomFlip):
    method _record_homography_matrix (line 363) | def _record_homography_matrix(self, results: dict) -> None:
    method _flip (line 387) | def _flip(self, results: dict) -> None:
  class RandomShift (line 414) | class RandomShift(BaseTransform):
    method __init__ (line 439) | def __init__(self,
    method _random_prob (line 450) | def _random_prob(self) -> float:
    method transform (line 454) | def transform(self, results: dict) -> dict:
    method __repr__ (line 510) | def __repr__(self):
  class Pad (line 519) | class Pad(MMCV_Pad):
    method _pad_masks (line 578) | def _pad_masks(self, results: dict) -> None:
    method transform (line 586) | def transform(self, results: dict) -> dict:
  class RandomCrop (line 602) | class RandomCrop(BaseTransform):
    method __init__ (line 662) | def __init__(self,
    method _crop_data (line 686) | def _crop_data(self, results: dict, crop_size: Tuple[int, int],
    method _rand_offset (line 765) | def _rand_offset(self, margin: Tuple[int, int]) -> Tuple[int, int]:
    method _get_crop_size (line 782) | def _get_crop_size(self, image_size: Tuple[int, int]) -> Tuple[int, int]:
    method transform (line 813) | def transform(self, results: dict) -> Union[dict, None]:
    method __repr__ (line 830) | def __repr__(self) -> str:
  class SegRescale (line 841) | class SegRescale(BaseTransform):
    method __init__ (line 862) | def __init__(self, scale_factor: float = 1, backend: str = 'cv2') -> N...
    method transform (line 866) | def transform(self, results: dict) -> dict:
    method __repr__ (line 884) | def __repr__(self) -> str:
  class PhotoMetricDistortion (line 892) | class PhotoMetricDistortion(BaseTransform):
    method __init__ (line 921) | def __init__(self,
    method _random_flags (line 932) | def _random_flags(self) -> Sequence[Number]:
    method transform (line 951) | def transform(self, results: dict) -> dict:
    method __repr__ (line 1010) | def __repr__(self) -> str:
  class Expand (line 1022) | class Expand(BaseTransform):
    method __init__ (line 1053) | def __init__(self,
    method _random_prob (line 1070) | def _random_prob(self) -> float:
    method _random_ratio (line 1074) | def _random_ratio(self) -> float:
    method _random_left_top (line 1078) | def _random_left_top(self, ratio: float, h: int,
    method transform (line 1085) | def transform(self, results: dict) -> dict:
    method __repr__ (line 1136) | def __repr__(self) -> str:
  class MinIoURandomCrop (line 1146) | class MinIoURandomCrop(BaseTransform):
    method __init__ (line 1183) | def __init__(self,
    method _random_mode (line 1194) | def _random_mode(self) -> Number:
    method transform (line 1198) | def transform(self, results: dict) -> dict:
    method __repr__ (line 1293) | def __repr__(self) -> str:
  class Corrupt (line 1302) | class Corrupt(BaseTransform):
    method __init__ (line 1323) | def __init__(self, corruption: str, severity: int = 1) -> None:
    method transform (line 1327) | def transform(self, results: dict) -> dict:
    method __repr__ (line 1345) | def __repr__(self) -> str:
  class Albu (line 1354) | class Albu(BaseTransform):
    method __init__ (line 1410) | def __init__(self,
    method albu_builder (line 1451) | def albu_builder(self, cfg: dict) -> albumentations:
    method mapper (line 1485) | def mapper(d: dict, keymap: dict) -> dict:
    method transform (line 1501) | def transform(self, results: dict) -> Union[dict, None]:
    method _preprocess_results (line 1516) | def _preprocess_results(self, results: dict) -> tuple:
    method _postprocess_results (line 1543) | def _postprocess_results(
    method __repr__ (line 1590) | def __repr__(self) -> str:
  class RandomCenterCropPad (line 1597) | class RandomCenterCropPad(BaseTransform):
    method __init__ (line 1705) | def __init__(self,
    method _get_border (line 1751) | def _get_border(self, border, size):
    method _filter_boxes (line 1770) | def _filter_boxes(self, patch, boxes):
    method _crop_image_and_paste (line 1786) | def _crop_image_and_paste(self, image, center, size):
    method _train_aug (line 1837) | def _train_aug(self, results):
    method _test_aug (line 1911) | def _test_aug(self, results):
    method transform (line 1945) | def transform(self, results: dict) -> dict:
    method __repr__ (line 1957) | def __repr__(self):
  class CutOut (line 1972) | class CutOut(BaseTransform):
    method __init__ (line 2006) | def __init__(
    method transform (line 2033) | def transform(self, results: dict) -> dict:
    method __repr__ (line 2053) | def __repr__(self):
  class Mosaic (line 2063) | class Mosaic(BaseTransform):
    method __init__ (line 2127) | def __init__(self,
    method get_indexes (line 2145) | def get_indexes(self, dataset: BaseDataset) -> int:
    method transform (line 2159) | def transform(self, results: dict) -> dict:
    method _mosaic_combine (line 2250) | def _mosaic_combine(
    method __repr__ (line 2313) | def __repr__(self):
  class MixUp (line 2323) | class MixUp(BaseTransform):
    method __init__ (line 2384) | def __init__(self,
    method get_indexes (line 2401) | def get_indexes(self, dataset: BaseDataset) -> int:
    method transform (line 2420) | def transform(self, results: dict) -> dict:
    method __repr__ (line 2533) | def __repr__(self):
  class RandomAffine (line 2545) | class RandomAffine(BaseTransform):
    method __init__ (line 2586) | def __init__(self,
    method _get_random_homography_matrix (line 2606) | def _get_random_homography_matrix(self, height, width):
    method transform (line 2636) | def transform(self, results: dict) -> dict:
    method __repr__ (line 2669) | def __repr__(self):
    method _get_rotation_matrix (line 2681) | def _get_rotation_matrix(rotate_degrees: float) -> np.ndarray:
    method _get_scaling_matrix (line 2690) | def _get_scaling_matrix(scale_ratio: float) -> np.ndarray:
    method _get_shear_matrix (line 2697) | def _get_shear_matrix(x_shear_degrees: float,
    method _get_translation_matrix (line 2707) | def _get_translation_matrix(x: float, y: float) -> np.ndarray:
  class YOLOXHSVRandomAug (line 2714) | class YOLOXHSVRandomAug(BaseTransform):
    method __init__ (line 2733) | def __init__(self,
    method _get_hsv_gains (line 2742) | def _get_hsv_gains(self):
    method transform (line 2752) | def transform(self, results: dict) -> dict:
    method __repr__ (line 2765) | def __repr__(self):
  class CopyPaste (line 2774) | class CopyPaste(BaseTransform):
    method __init__ (line 2822) | def __init__(
    method get_indexes (line 2835) | def get_indexes(self, dataset: BaseDataset) -> int:
    method transform (line 2846) | def transform(self, results: dict) -> dict:
    method _get_selected_inds (line 2866) | def _get_selected_inds(self, num_bboxes: int) -> np.ndarray:
    method _select_object (line 2871) | def _select_object(self, results: dict) -> dict:
    method _copy_paste (line 2891) | def _copy_paste(self, dst_results: dict, src_results: dict) -> dict:
    method _get_updated_masks (line 2948) | def _get_updated_masks(self, masks: BitmapMasks,
    method __repr__ (line 2956) | def __repr__(self):
  class RandomErasing (line 2966) | class RandomErasing(BaseTransform):
    method __init__ (line 3011) | def __init__(
    method _get_patches (line 3039) | def _get_patches(self, img_shape: Tuple[int, int]) -> List[list]:
    method _transform_img (line 3060) | def _transform_img(self, results: dict, patches: List[list]) -> None:
    method _transform_bboxes (line 3066) | def _transform_bboxes(self, results: dict, patches: List[list]) -> None:
    method _transform_masks (line 3086) | def _transform_masks(self, results: dict, patches: List[list]) -> None:
    method _transform_seg (line 3093) | def _transform_seg(self, results: dict, patches: List[list]) -> None:
    method transform (line 3100) | def transform(self, results: dict) -> dict:
    method __repr__ (line 3112) | def __repr__(self):
  class CachedMosaic (line 3125) | class CachedMosaic(Mosaic):
    method __init__ (line 3195) | def __init__(self,
    method get_indexes (line 3208) | def get_indexes(self, cache: list) -> list:
    method transform (line 3222) | def transform(self, results: dict) -> dict:
    method __repr__ (line 3348) | def __repr__(self):
  class CachedMixUp (line 3360) | class CachedMixUp(BaseTransform):
    method __init__ (line 3431) | def __init__(self,
    method get_indexes (line 3459) | def get_indexes(self, cache: list) -> int:
    method transform (line 3477) | def transform(self, results: dict) -> dict:
    method __repr__ (line 3626) | def __repr__(self):

FILE: mmdet/datasets/transforms/wrappers.py
  class MultiBranch (line 13) | class MultiBranch(BaseTransform):
    method __init__ (line 92) | def __init__(self, branch_field: List[str],
    method transform (line 100) | def transform(self, results: dict) -> dict:
    method __repr__ (line 135) | def __repr__(self) -> str:
  class RandomOrder (line 142) | class RandomOrder(Compose):
    method _random_permutation (line 146) | def _random_permutation(self):
    method transform (line 149) | def transform(self, results: Dict) -> Optional[Dict]:
    method __repr__ (line 166) | def __repr__(self):
  class ProposalBroadcaster (line 176) | class ProposalBroadcaster(BaseTransform):
    method __init__ (line 213) | def __init__(self, transforms: List[Union[dict, Callable]] = []) -> None:
    method transform (line 216) | def transform(self, results: dict) -> dict:
    method _process_input (line 236) | def _process_input(self, data: dict) -> list:
    method _apply_transforms (line 251) | def _apply_transforms(self, inputs: list) -> list:
    method _process_output (line 266) | def _process_output(self, output_scatters: list) -> dict:

FILE: mmdet/datasets/utils.py
  function get_loading_pipeline (line 9) | def get_loading_pipeline(pipeline):

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

FILE: mmdet/datasets/wider_face.py
  class WIDERFaceDataset (line 12) | class WIDERFaceDataset(XMLDataset):
    method __init__ (line 20) | def __init__(self, **kwargs):
    method load_annotations (line 23) | def load_annotations(self, ann_file):

FILE: mmdet/datasets/xml_style.py
  class XMLDataset (line 14) | class XMLDataset(BaseDetDataset):
    method __init__ (line 25) | def __init__(self,
    method sub_data_root (line 34) | def sub_data_root(self) -> str:
    method load_data_list (line 38) | def load_data_list(self) -> List[dict]:
    method bbox_min_size (line 69) | def bbox_min_size(self) -> Optional[str]:
    method parse_data_info (line 76) | def parse_data_info(self, img_info: dict) -> Union[dict, List[dict]]:
    method filter_data (line 142) | def filter_data(self) -> List[dict]:

FILE: mmdet/engine/hooks/checkloss_hook.py
  class CheckInvalidLossHook (line 12) | class CheckInvalidLossHook(Hook):
    method __init__ (line 23) | def __init__(self, interval: int = 50) -> None:
    method after_train_iter (line 26) | def after_train_iter(self,

FILE: mmdet/engine/hooks/mean_teacher_hook.py
  class MeanTeacherHook (line 13) | class MeanTeacherHook(Hook):
    method __init__ (line 38) | def __init__(self,
    method before_train (line 47) | def before_train(self, runner: Runner) -> None:
    method after_train_iter (line 58) | def after_train_iter(self,
    method momentum_update (line 71) | def momentum_update(self, model: nn.Module, momentum: float) -> None:

FILE: mmdet/engine/hooks/memory_profiler_hook.py
  class MemoryProfilerHook (line 12) | class MemoryProfilerHook(Hook):
    method __init__ (line 21) | def __init__(self, interval: int = 50) -> None:
    method _record_memory_information (line 40) | def _record_memory_information(self, runner: Runner) -> None:
    method after_train_iter (line 68) | def after_train_iter(self,
    method after_val_iter (line 85) | def after_val_iter(
    method after_test_iter (line 104) | def after_test_iter(

FILE: mmdet/engine/hooks/num_class_check_hook.py
  class NumClassCheckHook (line 10) | class NumClassCheckHook(Hook):
    method _check_head (line 14) | def _check_head(self, runner: Runner, mode: str) -> None:
    method before_train_epoch (line 52) | def before_train_epoch(self, runner: Runner) -> None:
    method before_val_epoch (line 61) | def before_val_epoch(self, runner: Runner) -> None:

FILE: mmdet/engine/hooks/pipeline_switch_hook.py
  class PipelineSwitchHook (line 9) | class PipelineSwitchHook(Hook):
    method __init__ (line 17) | def __init__(self, switch_epoch, switch_pipeline):
    method before_train_epoch (line 22) | def before_train_epoch(self, runner):

FILE: mmdet/engine/hooks/set_epoch_info_hook.py
  class SetEpochInfoHook (line 9) | class SetEpochInfoHook(Hook):
    method before_train_epoch (line 12) | def before_train_epoch(self, runner):

FILE: mmdet/engine/hooks/sync_norm_hook.py
  function get_norm_states (line 12) | def get_norm_states(module: nn.Module) -> OrderedDict:
  class SyncNormHook (line 23) | class SyncNormHook(Hook):
    method before_val_epoch (line 26) | def before_val_epoch(self, runner):

FILE: mmdet/engine/hooks/utils.py
  function trigger_visualization_hook (line 2) | def trigger_visualization_hook(cfg, args):

FILE: mmdet/engine/hooks/visualization_hook.py
  class DetVisualizationHook (line 18) | class DetVisualizationHook(Hook):
    method __init__ (line 50) | def __init__(self,
    method after_val_iter (line 77) | def after_val_iter(self, runner: Runner, batch_idx: int, data_batch: d...
    method after_test_iter (line 113) | def after_test_iter(self, runner: Runner, batch_idx: int, data_batch: ...

FILE: mmdet/engine/hooks/yolox_mode_switch_hook.py
  class YOLOXModeSwitchHook (line 11) | class YOLOXModeSwitchHook(Hook):
    method __init__ (line 25) | def __init__(
    method before_train_epoch (line 34) | def before_train_epoch(self, runner) -> None:

FILE: mmdet/engine/optimizers/layer_decay_optimizer_constructor.py
  function get_layer_id_for_convnext (line 13) | def get_layer_id_for_convnext(var_name, max_layer_id):
  function get_stage_id_for_convnext (line 56) | def get_stage_id_for_convnext(var_name, max_stage_id):
  class LearningRateDecayOptimizerConstructor (line 82) | class LearningRateDecayOptimizerConstructor(DefaultOptimWrapperConstruct...
    method add_params (line 86) | def add_params(self, params: List[dict], module: nn.Module,

FILE: mmdet/engine/runner/loops.py
  class TeacherStudentValLoop (line 10) | class TeacherStudentValLoop(ValLoop):
    method run (line 13) | def run(self):

FILE: mmdet/engine/schedulers/quadratic_warmup.py
  class QuadraticWarmupParamScheduler (line 11) | class QuadraticWarmupParamScheduler(_ParamScheduler):
    method __init__ (line 35) | def __init__(self,
    method build_iter_from_epoch (line 59) | def build_iter_from_epoch(cls,
    method _get_value (line 79) | def _get_value(self):
  class QuadraticWarmupLR (line 96) | class QuadraticWarmupLR(LRSchedulerMixin, QuadraticWarmupParamScheduler):
  class QuadraticWarmupMomentum (line 115) | class QuadraticWarmupMomentum(MomentumSchedulerMixin,

FILE: mmdet/evaluation/functional/bbox_overlaps.py
  function bbox_overlaps (line 5) | def bbox_overlaps(bboxes1,

FILE: mmdet/evaluation/functional/class_names.py
  function wider_face_classes (line 5) | def wider_face_classes() -> list:
  function voc_classes (line 10) | def voc_classes() -> list:
  function imagenet_det_classes (line 19) | def imagenet_det_classes() -> list:
  function imagenet_vid_classes (line 61) | def imagenet_vid_classes() -> list:
  function coco_classes (line 72) | def coco_classes() -> list:
  function coco_panoptic_classes (line 91) | def coco_panoptic_classes() -> list:
  function cityscapes_classes (line 121) | def cityscapes_classes() -> list:
  function oid_challenge_classes (line 129) | def oid_challenge_classes() -> list:
  function oid_v6_classes (line 225) | def oid_v6_classes() -> list:
  function objects365v1_classes (line 344) | def objects365v1_classes() -> list:
  function objects365v2_classes (line 415) | def objects365v2_classes() -> list:
  function get_classes (line 503) | def get_classes(dataset) -> list:

FILE: mmdet/evaluation/functional/mean_ap.py
  function average_precision (line 13) | def average_precision(recalls, precisions, mode='area'):
  function tpfp_imagenet (line 60) | def tpfp_imagenet(det_bboxes,
  function tpfp_default (line 169) | def tpfp_default(det_bboxes,
  function tpfp_openimages (line 272) | def tpfp_openimages(det_bboxes,
  function get_cls_results (line 477) | def get_cls_results(det_results, annotations, class_id):
  function get_cls_group_ofs (line 504) | def get_cls_group_ofs(annotations, class_id):
  function eval_map (line 525) | def eval_map(det_results,
  function print_map_summary (line 726) | def print_map_summary(mean_ap,

FILE: mmdet/evaluation/functional/panoptic_utils.py
  function pq_compute_single_core (line 30) | def pq_compute_single_core(proc_id,
  function pq_compute_multi_core (line 180) | def pq_compute_multi_core(matched_annotations_list,

FILE: mmdet/evaluation/functional/recall.py
  function _recalls (line 11) | def _recalls(all_ious, proposal_nums, thrs):
  function set_recall_param (line 44) | def set_recall_param(proposal_nums, iou_thrs):
  function eval_recalls (line 65) | def eval_recalls(gts,
  function print_recall_summary (line 118) | def print_recall_summary(recalls,
  function plot_num_recall (line 152) | def plot_num_recall(recalls, proposal_nums):
  function plot_iou_recall (line 177) | def plot_iou_recall(recalls, iou_thrs):

FILE: mmdet/evaluation/metrics/cityscapes_metric.py
  class CityScapesMetric (line 28) | class CityScapesMetric(BaseMetric):
    method __init__ (line 55) | def __init__(self,
    method __del__ (line 82) | def __del__(self) -> None:
    method process (line 89) | def process(self, data_batch: dict, data_samples: Sequence[dict]) -> N...
    method compute_metrics (line 135) | def compute_metrics(self, results: list) -> Dict[str, float]:

FILE: mmdet/evaluation/metrics/coco_metric.py
  class CocoMetric (line 23) | class CocoMetric(BaseMetric):
    method __init__ (line 68) | def __init__(self,
    method fast_eval_recall (line 137) | def fast_eval_recall(self,
    method xyxy2xywh (line 178) | def xyxy2xywh(self, bbox: np.ndarray) -> list:
    method results2json (line 198) | def results2json(self, results: Sequence[dict],
    method gt_to_coco_json (line 262) | def gt_to_coco_json(self, gt_dicts: Sequence[dict],
    method process (line 334) | def process(self, data_batch: dict, data_samples: Sequence[dict]) -> N...
    method compute_metrics (line 374) | def compute_metrics(self, results: list) -> Dict[str, float]:

FILE: mmdet/evaluation/metrics/coco_occluded_metric.py
  class CocoOccludedSeparatedMetric (line 18) | class CocoOccludedSeparatedMetric(CocoMetric):
    method __init__ (line 59) | def __init__(
    method compute_metrics (line 81) | def compute_metrics(self, results: list) -> Dict[str, float]:
    method evaluate_occluded_separated (line 96) | def evaluate_occluded_separated(self, results: List[tuple]) -> dict:
    method compute_recall (line 154) | def compute_recall(self,
    method mask_iou (line 205) | def mask_iou(self, mask1: np.ndarray, mask2: np.ndarray) -> np.ndarray:

FILE: mmdet/evaluation/metrics/coco_panoptic_metric.py
  class CocoPanopticMetric (line 33) | class CocoPanopticMetric(BaseMetric):
    method __init__ (line 72) | def __init__(self,
    method __del__ (line 124) | def __del__(self) -> None:
    method gt_to_coco_json (line 129) | def gt_to_coco_json(self, gt_dicts: Sequence[dict],
    method result2json (line 210) | def result2json(self, results: Sequence[dict],
    method _parse_predictions (line 244) | def _parse_predictions(self,
    method _compute_batch_pq_stats (line 297) | def _compute_batch_pq_stats(self, data_samples: Sequence[dict]):
    method _process_gt_and_predictions (line 377) | def _process_gt_and_predictions(self, data_samples: Sequence[dict]):
    method process (line 407) | def process(self, data_batch: dict, data_samples: Sequence[dict]) -> N...
    method compute_metrics (line 424) | def compute_metrics(self, results: list) -> Dict[str, float]:
  function parse_pq_results (line 544) | def parse_pq_results(pq_results: dict) -> dict:
  function print_panoptic_table (line 566) | def print_panoptic_table(

FILE: mmdet/evaluation/metrics/crowdhuman_metric.py
  class CrowdHumanMetric (line 24) | class CrowdHumanMetric(BaseMetric):
    method __init__ (line 66) | def __init__(self,
    method results2json (line 114) | def results2json(results: Sequence[dict], outfile_prefix: str) -> str:
    method process (line 138) | def process(self, data_batch: Sequence[dict],
    method compute_metrics (line 162) | def compute_metrics(self, results: list) -> Dict[str, float]:
    method load_eval_samples (line 215) | def load_eval_samples(self, result_file):
    method compare (line 240) | def compare(self, samples):
    method eval_ap (line 263) | def eval_ap(score_list, gt_num, img_num):
    method eval_mr (line 312) | def eval_mr(self, score_list, gt_num, img_num):
    method eval_ji (line 372) | def eval_ji(self, samples):
    method compute_ji_with_ignore (line 411) | def compute_ji_with_ignore(self, result_queue, dt_result, score_thr):
    method gather (line 462) | def gather(results):
    method compute_ji_matching (line 477) | def compute_ji_matching(self, dt_boxes, gt_boxes):
    method get_ignores (line 502) | def get_ignores(self, dt_boxes, gt_boxes):
  class Image (line 513) | class Image(object):
    method __init__ (line 526) | def __init__(self, mode):
    method load (line 538) | def load(self, record, body_key, head_key, class_names, gt_flag):
    method load_gt_boxes (line 622) | def load_gt_boxes(dict_input, key_name, class_names):
    method load_det_boxes (line 654) | def load_det_boxes(dict_input, key_name, key_box, key_score, key_tag=N...
    method clip_all_boader (line 688) | def clip_all_boader(self):
    method compare_voc (line 717) | def compare_voc(self, thres):
    method compare_caltech (line 758) | def compare_caltech(self, thres):

FILE: mmdet/evaluation/metrics/dump_det_results.py
  class DumpDetResults (line 13) | class DumpDetResults(DumpResults):
    method process (line 27) | def process(self, data_batch: dict, data_samples: Sequence[dict]) -> N...

FILE: mmdet/evaluation/metrics/dump_proposals_metric.py
  class DumpProposals (line 16) | class DumpProposals(BaseMetric):
    method __init__ (line 39) | def __init__(self,
    method process (line 58) | def process(self, data_batch: Sequence[dict],
    method compute_metrics (line 93) | def compute_metrics(self, results: list) -> dict:

FILE: mmdet/evaluation/metrics/lvis_metric.py
  class LVISMetric (line 32) | class LVISMetric(CocoMetric):
    method __init__ (line 69) | def __init__(self,
    method fast_eval_recall (line 122) | def fast_eval_recall(self,
    method process (line 163) | def process(self, data_batch: dict, data_samples: Sequence[dict]) -> N...
    method compute_metrics (line 202) | def compute_metrics(self, results: list) -> Dict[str, float]:

FILE: mmdet/evaluation/metrics/openimages_metric.py
  class OpenImagesMetric (line 15) | class OpenImagesMetric(BaseMetric):
    method __init__ (line 44) | def __init__(self,
    method _get_supercategory_ann (line 66) | def _get_supercategory_ann(self, instances: List[dict]) -> List[dict]:
    method _process_predictions (line 87) | def _process_predictions(self, pred_bboxes: np.ndarray,
    method process (line 147) | def process(self, data_batch: dict, data_samples: Sequence[dict]) -> N...
    method compute_metrics (line 195) | def compute_metrics(self, results: list) -> dict:

FILE: mmdet/evaluation/metrics/voc_metric.py
  class VOCMetric (line 16) | class VOCMetric(BaseMetric):
    method __init__ (line 46) | def __init__(self,
    method process (line 74) | def process(self, data_batch: dict, data_samples: Sequence[dict]) -> N...
    method compute_metrics (line 109) | def compute_metrics(self, results: list) -> dict:

FILE: mmdet/models/backbones/csp_darknet.py
  class Focus (line 14) | class Focus(nn.Module):
    method __init__ (line 30) | def __init__(self,
    method forward (line 49) | def forward(self, x):
  class SPPBottleneck (line 67) | class SPPBottleneck(BaseModule):
    method __init__ (line 85) | def __init__(self,
    method forward (line 116) | def forward(self, x):
  class CSPDarknet (line 126) | class CSPDarknet(BaseModule):
    method __init__ (line 179) | def __init__(self,
    method _freeze_stages (line 263) | def _freeze_stages(self):
    method train (line 271) | def train(self, mode=True):
    method forward (line 279) | def forward(self, x):

FILE: mmdet/models/backbones/cspnext.py
  class CSPNeXt (line 18) | class CSPNeXt(BaseModule):
    method __init__ (line 64) | def __init__(
    method _freeze_stages (line 172) | def _freeze_stages(self) -> None:
    method train (line 180) | def train(self, mode=True) -> None:
    method forward (line 188) | def forward(self, x: Tuple[Tensor, ...]) -> Tuple[Tensor, ...]:

FILE: mmdet/models/backbones/darknet.py
  class ResBlock (line 14) | class ResBlock(BaseModule):
    method __init__ (line 33) | def __init__(self,
    method forward (line 50) | def forward(self, x):
  class Darknet (line 60) | class Darknet(BaseModule):
    method __init__ (line 101) | def __init__(self,
    method forward (line 153) | def forward(self, x):
    method _freeze_stages (line 163) | def _freeze_stages(self):
    method train (line 171) | def train(self, mode=True):
    method make_conv_res_block (line 180) | def make_conv_res_block(in_channels,

FILE: mmdet/models/backbones/detectors_resnet.py
  class Bottleneck (line 16) | class Bottleneck(_Bottleneck):
    method __init__ (line 36) | def __init__(self,
    method rfp_forward (line 73) | def rfp_forward(self, x, rfp_feat):
  class ResLayer (line 120) | class ResLayer(Sequential):
    method __init__ (line 146) | def __init__(self,
  class DetectoRS_ResNet (line 212) | class DetectoRS_ResNet(ResNet):
    method __init__ (line 234) | def __init__(self,
    method init_weights (line 296) | def init_weights(self):
    method make_res_layer (line 325) | def make_res_layer(self, **kwargs):
    method forward (line 329) | def forward(self, x):
    method rfp_forward (line 336) | def rfp_forward(self, x, rfp_feats):

FILE: mmdet/models/backbones/detectors_resnext.py
  class Bottleneck (line 11) | class Bottleneck(_Bottleneck):
    method __init__ (line 14) | def __init__(self,
  class DetectoRS_ResNeXt (line 99) | class DetectoRS_ResNeXt(DetectoRS_ResNet):
    method __init__ (line 113) | def __init__(self, groups=1, base_width=4, **kwargs):
    method make_res_layer (line 118) | def make_res_layer(self, **kwargs):

FILE: mmdet/models/backbones/efficientnet.py
  class EdgeResidual (line 17) | class EdgeResidual(BaseModule):
    method __init__ (line 42) | def __init__(self,
    method forward (line 92) | def forward(self, x):
  function model_scaling (line 116) | def model_scaling(layer_setting, arch_setting):
  class EfficientNet (line 160) | class EfficientNet(BaseModule):
    method __init__ (line 255) | def __init__(self,
    method make_layer (line 328) | def make_layer(self):
    method forward (line 396) | def forward(self, x):
    method _freeze_stages (line 405) | def _freeze_stages(self):
    method train (line 412) | def train(self, mode=True):

FILE: mmdet/models/backbones/hourglass.py
  class HourglassModule (line 16) | class HourglassModule(BaseModule):
    method __init__ (line 35) | def __init__(self,
    method forward (line 85) | def forward(self, x: torch.Tensor) -> nn.Module:
  class HourglassNet (line 102) | class HourglassNet(BaseModule):
    method __init__ (line 135) | def __init__(self,
    method init_weights (line 198) | def init_weights(self) -> None:
    method forward (line 206) | def forward(self, x: torch.Tensor) -> List[torch.Tensor]:

FILE: mmdet/models/backbones/hrnet.py
  class HRModule (line 13) | class HRModule(BaseModule):
    method __init__ (line 20) | def __init__(self,
    method _check_branches (line 49) | def _check_branches(self, num_branches, num_blocks, in_channels,
    method _make_one_branch (line 66) | def _make_one_branch(self,
    method _make_branches (line 112) | def _make_branches(self, num_branches, block, num_blocks, num_channels):
    method _make_fuse_layers (line 121) | def _make_fuse_layers(self):
    method forward (line 183) | def forward(self, x):
  class HRNet (line 204) | class HRNet(BaseModule):
    method __init__ (line 281) | def __init__(self,
    method norm1 (line 403) | def norm1(self):
    method norm2 (line 408) | def norm2(self):
    method _make_transition_layer (line 412) | def _make_transition_layer(self, num_channels_pre_layer,
    method _make_layer (line 458) | def _make_layer(self, block, inplanes, planes, blocks, stride=1):
    method _make_stage (line 505) | def _make_stage(self, layer_config, in_channels, multiscale_output=True):
    method forward (line 545) | def forward(self, x):
    method train (line 581) | def train(self, mode=True):

FILE: mmdet/models/backbones/mobilenet_v2.py
  class MobileNetV2 (line 15) | class MobileNetV2(BaseModule):
    method __init__ (line 47) | def __init__(self,
    method make_layer (line 139) | def make_layer(self, out_channels, num_blocks, stride, expand_ratio):
    method _freeze_stages (line 168) | def _freeze_stages(self):
    method forward (line 178) | def forward(self, x):
    method train (line 189) | def train(self, mode=True):

FILE: mmdet/models/backbones/pvt.py
  class MixFFN (line 24) | class MixFFN(BaseModule):
    method __init__ (line 48) | def __init__(self,
    method forward (line 94) | def forward(self, x, hw_shape, identity=None):
  class SpatialReductionAttention (line 103) | class SpatialReductionAttention(MultiheadAttention):
    method __init__ (line 130) | def __init__(self,
    method forward (line 170) | def forward(self, x, hw_shape, identity=None):
    method legacy_forward (line 201) | def legacy_forward(self, x, hw_shape, identity=None):
  class PVTEncoderLayer (line 220) | class PVTEncoderLayer(BaseModule):
    method __init__ (line 246) | def __init__(self,
    method forward (line 285) | def forward(self, x, hw_shape):
  class AbsolutePositionEmbedding (line 292) | class AbsolutePositionEmbedding(BaseModule):
    method __init__ (line 302) | def __init__(self, pos_shape, pos_dim, drop_rate=0., init_cfg=None):
    method init_weights (line 320) | def init_weights(self):
    method resize_pos_embed (line 323) | def resize_pos_embed(self, pos_embed, input_shape, mode='bilinear'):
    method forward (line 352) | def forward(self, x, hw_shape, mode='bilinear'):
  class PyramidVisionTransformer (line 358) | class PyramidVisionTransformer(BaseModule):
    method __init__ (line 411) | def __init__(self,
    method init_weights (line 524) | def init_weights(self):
    method forward (line 564) | def forward(self, x):
  class PyramidVisionTransformerV2 (line 581) | class PyramidVisionTransformerV2(PyramidVisionTransformer):
    method __init__ (line 585) | def __init__(self, **kwargs):
  function pvt_convert (line 595) | def pvt_convert(ckpt):

FILE: mmdet/models/backbones/regnet.py
  class RegNet (line 14) | class RegNet(ResNet):
    method __init__ (line 90) | def __init__(self,
    method _make_stem_layer (line 238) | def _make_stem_layer(self, in_channels, base_channels):
    method generate_regnet (line 252) | def generate_regnet(self,
    method quantize_float (line 285) | def quantize_float(number, divisor):
    method adjust_width_group (line 297) | def adjust_width_group(self, widths, bottleneck_ratio, groups):
    method get_stages_from_blocks (line 322) | def get_stages_from_blocks(self, widths):
    method forward (line 344) | def forward(self, x):

FILE: mmdet/models/backbones/res2net.py
  class Bottle2neck (line 15) | class Bottle2neck(_Bottleneck):
    method __init__ (line 18) | def __init__(self,
    method forward (line 106) | def forward(self, x):
  class Res2Layer (line 163) | class Res2Layer(Sequential):
    method __init__ (line 182) | def __init__(self,
  class Res2Net (line 243) | class Res2Net(ResNet):
    method __init__ (line 303) | def __init__(self,
    method make_res_layer (line 322) | def make_res_layer(self, **kwargs):

FILE: mmdet/models/backbones/resnest.py
  class RSoftmax (line 17) | class RSoftmax(nn.Module):
    method __init__ (line 25) | def __init__(self, radix, groups):
    method forward (line 30) | def forward(self, x):
  class SplitAttentionConv2d (line 41) | class SplitAttentionConv2d(BaseModule):
    method __init__ (line 64) | def __init__(self,
    method norm0 (line 116) | def norm0(self):
    method norm1 (line 121) | def norm1(self):
    method forward (line 125) | def forward(self, x):
  class Bottleneck (line 154) | class Bottleneck(_Bottleneck):
    method __init__ (line 173) | def __init__(self,
    method forward (line 234) | def forward(self, x):
  class ResNeSt (line 278) | class ResNeSt(ResNetV1d):
    method __init__ (line 299) | def __init__(self,
    method make_res_layer (line 313) | def make_res_layer(self, **kwargs):

FILE: mmdet/models/backbones/resnet.py
  class BasicBlock (line 14) | class BasicBlock(BaseModule):
    method __init__ (line 17) | def __init__(self,
    method norm1 (line 58) | def norm1(self):
    method norm2 (line 63) | def norm2(self):
    method forward (line 67) | def forward(self, x):
  class Bottleneck (line 97) | class Bottleneck(BaseModule):
    method __init__ (line 100) | def __init__(self,
    method make_block_plugins (line 219) | def make_block_plugins(self, in_channels, plugins):
    method forward_plugin (line 242) | def forward_plugin(self, x, plugin_names):
    method norm1 (line 249) | def norm1(self):
    method norm2 (line 254) | def norm2(self):
    method norm3 (line 259) | def norm3(self):
    method forward (line 263) | def forward(self, x):
  class ResNet (line 306) | class ResNet(BaseModule):
    method __init__ (line 369) | def __init__(self,
    method make_stage_plugins (line 494) | def make_stage_plugins(self, plugins, stage_idx):
    method make_res_layer (line 556) | def make_res_layer(self, **kwargs):
    method norm1 (line 561) | def norm1(self):
    method _make_stem_layer (line 565) | def _make_stem_layer(self, in_channels, stem_channels):
    method _freeze_stages (line 613) | def _freeze_stages(self):
    method forward (line 631) | def forward(self, x):
    method train (line 648) | def train(self, mode=True):
  class ResNetV1d (line 661) | class ResNetV1d(ResNet):
    method __init__ (line 670) | def __init__(self, **kwargs):

FILE: mmdet/models/backbones/resnext.py
  class Bottleneck (line 12) | class Bottleneck(_Bottleneck):
    method __init__ (line 15) | def __init__(self,
    method _del_block_plugins (line 98) | def _del_block_plugins(self, plugin_names):
  class ResNeXt (line 110) | class ResNeXt(ResNet):
    method __init__ (line 143) | def __init__(self, groups=1, base_width=4, **kwargs):
    method make_res_layer (line 148) | def make_res_layer(self, **kwargs):

FILE: mmdet/models/backbones/ssd_vgg.py
  class SSDVGG (line 13) | class SSDVGG(VGG, BaseModule):
    method __init__ (line 50) | def __init__(self,
    method init_weights (line 105) | def init_weights(self, pretrained=None):
    method forward (line 108) | def forward(self, x):
  class L2Norm (line 122) | class L2Norm(ssd_neck.L2Norm):
    method __init__ (line 124) | def __init__(self, **kwargs):

FILE: mmdet/models/backbones/swin.py
  class WindowMSA (line 23) | class WindowMSA(BaseModule):
    method __init__ (line 42) | def __init__(self,
    method init_weights (line 79) | def init_weights(self):
    method forward (line 82) | def forward(self, x, mask=None):
    method double_step_seq (line 123) | def double_step_seq(step1, len1, step2, len2):
  class ShiftWindowMSA (line 129) | class ShiftWindowMSA(BaseModule):
    method __init__ (line 152) | def __init__(self,
    method forward (line 181) | def forward(self, query, hw_shape):
    method window_reverse (line 257) | def window_reverse(self, windows, H, W):
    method window_partition (line 273) | def window_partition(self, x):
  class SwinBlock (line 289) | class SwinBlock(BaseModule):
    method __init__ (line 314) | def __init__(self,
    method forward (line 359) | def forward(self, x, hw_shape):
  class SwinBlockSequence (line 382) | class SwinBlockSequence(BaseModule):
    method __init__ (line 411) | def __init__(self,
    method forward (line 456) | def forward(self, x, hw_shape):
  class SwinTransformer (line 468) | class SwinTransformer(BaseModule):
    method __init__ (line 525) | def __init__(self,
    method train (line 644) | def train(self, mode=True):
    method _freeze_stages (line 649) | def _freeze_stages(self):
    method init_weights (line 671) | def init_weights(self):
    method forward (line 746) | def forward(self, x):
  function swin_converter (line 767) | def swin_converter(ckpt):

FILE: mmdet/models/backbones/trident_resnet.py
  class TridentConv (line 14) | class TridentConv(BaseModule):
    method __init__ (line 33) | def __init__(self,
    method extra_repr (line 61) | def extra_repr(self):
    method forward (line 73) | def forward(self, inputs):
  class TridentBottleneck (line 93) | class TridentBottleneck(Bottleneck):
    method __init__ (line 106) | def __init__(self, trident_dilations, test_branch_idx, concat_output,
    method forward (line 128) | def forward(self, x):
  function make_trident_res_layer (line 182) | def make_trident_res_layer(block,
  class TridentResNet (line 235) | class TridentResNet(ResNet):
    method __init__ (line 256) | def __init__(self, depth, num_branch, test_branch_idx, trident_dilations,

FILE: mmdet/models/data_preprocessors/data_preprocessor.py
  class DetDataPreprocessor (line 31) | class DetDataPreprocessor(ImgDataPreprocessor):
    method __init__ (line 77) | def __init__(self,
    method forward (line 110) | def forward(self, data: dict, training: bool = False) -> dict:
    method _get_pad_shape (line 151) | def _get_pad_shape(self, data: dict) -> List[tuple]:
    method pad_gt_masks (line 185) | def pad_gt_masks(self,
    method pad_gt_sem_seg (line 195) | def pad_gt_sem_seg(self,
  class BatchSyncRandomResize (line 212) | class BatchSyncRandomResize(nn.Module):
    method __init__ (line 224) | def __init__(self,
    method forward (line 236) | def forward(
    method _get_random_size (line 282) | def _get_random_size(self, aspect_ratio: float,
  class BatchFixedSizePad (line 300) | class BatchFixedSizePad(nn.Module):
    method __init__ (line 317) | def __init__(self,
    method forward (line 332) | def forward(
  class MultiBranchDataPreprocessor (line 379) | class MultiBranchDataPreprocessor(BaseDataPreprocessor):
    method __init__ (line 472) | def __init__(self, data_preprocessor: ConfigType) -> None:
    method forward (line 476) | def forward(self, data: dict, training: bool = False) -> dict:
    method device (line 532) | def device(self):
    method to (line 535) | def to(self, device: Optional[Union[int, torch.device]], *args,
    method cuda (line 549) | def cuda(self, *args, **kwargs) -> nn.Module:
    method cpu (line 558) | def cpu(self, *args, **kwargs) -> nn.Module:
  class BatchResize (line 569) | class BatchResize(nn.Module):
    method __init__ (line 587) | def __init__(
    method forward (line 599) | def forward(
    method get_target_size (line 634) | def get_target_size(self, height: int,
    method get_padded_tensor (line 646) | def get_padded_tensor(self, tensor: Tensor, pad_value: int) -> Tensor:
  class BoxInstDataPreprocessor (line 662) | class BoxInstDataPreprocessor(DetDataPreprocessor):
    method __init__ (line 683) | def __init__(self,
    method get_images_color_similarity (line 702) | def get_images_color_similarity(self, inputs: Tensor,
    method forward (line 723) | def forward(self, data: dict, training: bool = False) -> dict:

FILE: mmdet/models/dense_heads/anchor_free_head.py
  class AnchorFreeHead (line 21) | class AnchorFreeHead(BaseDenseHead):
    method __init__ (line 55) | def __init__(
    method _init_layers (line 115) | def _init_layers(self) -> None:
    method _init_cls_convs (line 121) | def _init_cls_convs(self) -> None:
    method _init_reg_convs (line 141) | def _init_reg_convs(self) -> None:
    method _init_predictor (line 161) | def _init_predictor(self) -> None:
    method _load_from_state_dict (line 167) | def _load_from_state_dict(self, state_dict: dict, prefix: str,
    method forward (line 209) | def forward(self, x: Tuple[Tensor]) -> Tuple[List[Tensor], List[Tensor]]:
    method forward_single (line 227) | def forward_single(self, x: Tensor) -> Tuple[Tensor, ...]:
    method loss_by_feat (line 251) | def loss_by_feat(
    method get_targets (line 282) | def get_targets(self, points: List[Tensor],
    method aug_test (line 297) | def aug_test(self,

FILE: mmdet/models/dense_heads/anchor_head.py
  class AnchorHead (line 22) | class AnchorHead(BaseDenseHead):
    method __init__ (line 44) | def __init__(
    method num_anchors (line 107) | def num_anchors(self) -> int:
    method anchor_generator (line 114) | def anchor_generator(self) -> AnchorGenerator:
    method _init_layers (line 119) | def _init_layers(self) -> None:
    method forward_single (line 128) | def forward_single(self, x: Tensor) -> Tuple[Tensor, Tensor]:
    method forward (line 145) | def forward(self, x: Tuple[Tensor]) -> Tuple[List[Tensor]]:
    method get_anchors (line 164) | def get_anchors(self,
    method _get_targets_single (line 201) | def _get_targets_single(self,
    method get_targets (line 308) | def get_targets(self,
    method loss_by_feat_single (line 415) | def loss_by_feat_single(self, cls_score: Tensor, bbox_pred: Tensor,
    method loss_by_feat (line 467) | def loss_by_feat(

FILE: mmdet/models/dense_heads/atss_head.py
  class ATSSHead (line 19) | class ATSSHead(AnchorHead):
    method __init__ (line 48) | def __init__(self,
    method _init_layers (line 85) | def _init_layers(self) -> None:
    method forward (line 129) | def forward(self, x: Tuple[Tensor]) -> Tuple[List[Tensor]]:
    method forward_single (line 147) | def forward_single(self, x: Tensor, scale: Scale) -> Sequence[Tensor]:
    method loss_by_feat_single (line 176) | def loss_by_feat_single(self, anchors: Tensor, cls_score: Tensor,
    method loss_by_feat (line 253) | def loss_by_feat(
    method centerness_target (line 323) | def centerness_target(self, anchors: Tensor, gts: Tensor) -> Tensor:
    method get_targets (line 350) | def get_targets(self,
    method _get_targets_single (line 408) | def _get_targets_single(self,
    method get_num_level_anchors_inside (line 517) | def get_num_level_anchors_inside(self, num_level_anchors, inside_flags):

FILE: mmdet/models/dense_heads/autoassign_head.py
  class CenterPrior (line 22) | class CenterPrior(nn.Module):
    method __init__ (line 38) | def __init__(
    method forward (line 52) | def forward(self, anchor_points_list: List[Tensor],
  class AutoAssignHead (line 134) | class AutoAssignHead(FCOSHead):
    method __init__ (line 154) | def __init__(self,
    method init_weights (line 173) | def init_weights(self) -> None:
    method forward_single (line 185) | def forward_single(self, x: Tensor, scale: Scale,
    method get_pos_loss_single (line 214) | def get_pos_loss_single(self, cls_score: Tensor, objectness: Tensor,
    method get_neg_loss_single (line 261) | def get_neg_loss_single(self, cls_score: Tensor, objectness: Tensor,
    method loss_by_feat (line 319) | def loss_by_feat(
    method get_targets (line 456) | def get_targets(
    method _get_targets_single (line 485) | def _get_targets_single(self, gt_instances: InstanceData,

FILE: mmdet/models/dense_heads/base_dense_head.py
  class BaseDenseHead (line 23) | class BaseDenseHead(BaseModule, metaclass=ABCMeta):
    method __init__ (line 60) | def __init__(self, init_cfg: OptMultiConfig = None) -> None:
    method init_weights (line 66) | def init_weights(self) -> None:
    method get_positive_infos (line 75) | def get_positive_infos(self) -> InstanceList:
    method loss (line 101) | def loss(self, x: Tuple[Tensor], batch_data_samples: SampleList) -> dict:
    method loss_by_feat (line 127) | def loss_by_feat(self, **kwargs) -> dict:
    method loss_and_predict (line 132) | def loss_and_predict(
    method predict (line 171) | def predict(self,
    method predict_by_feat (line 201) | def predict_by_feat(self,
    method _predict_by_feat_single (line 291) | def _predict_by_feat_single(self,
    method _bbox_post_process (line 424) | def _bbox_post_process(self,
    method aug_test (line 488) | def aug_test(self,

FILE: mmdet/models/dense_heads/base_mask_head.py
  class BaseMaskHead (line 13) | class BaseMaskHead(BaseModule, metaclass=ABCMeta):
    method __init__ (line 16) | def __init__(self, init_cfg: OptMultiConfig = None) -> None:
    method loss_by_feat (line 20) | def loss_by_feat(self, *args, **kwargs):
    method predict_by_feat (line 26) | def predict_by_feat(self, *args, **kwargs):
    method loss (line 31) | def loss(self,
    method predict (line 82) | def predict(self,

FILE: mmdet/models/dense_heads/boxinst_head.py
  class BoxInstBboxHead (line 17) | class BoxInstBboxHead(CondInstBboxHead):
    method __init__ (line 20) | def __init__(self, *args, **kwargs) -> None:
  class BoxInstMaskHead (line 25) | class BoxInstMaskHead(CondInstMaskHead):
    method __init__ (line 39) | def __init__(self,
    method get_pairwise_affinity (line 50) | def get_pairwise_affinity(self, mask_logits: Tensor) -> Tensor:
    method loss_by_feat (line 79) | def loss_by_feat(self, mask_preds: List[Tensor],
    method _get_targets_single (line 155) | def _get_targets_single(self, mask_preds: Tensor,

FILE: mmdet/models/dense_heads/cascade_rpn_head.py
  class AdaptiveConv (line 26) | class AdaptiveConv(BaseModule):
    method __init__ (line 50) | def __init__(
    method forward (line 89) | def forward(self, x: Tensor, offset: Tensor) -> Tensor:
  class StageCascadeRPNHead (line 106) | class StageCascadeRPNHead(RPNHead):
    method __init__ (line 120) | def __init__(self,
    method _init_layers (line 159) | def _init_layers(self) -> None:
    method forward_single (line 172) | def forward_single(self, x: Tensor, offset: Tensor) -> Tuple[Tensor]:
    method forward (line 182) | def forward(
    method _region_targets_single (line 191) | def _region_targets_single(self, flat_anchors: Tensor, valid_flags: Te...
    method region_targets (line 270) | def region_targets(
    method get_targets (line 360) | def get_targets(
    method anchor_offset (line 423) | def anchor_offset(self, anchor_list: List[List[Tensor]],
    method loss_by_feat_single (line 503) | def loss_by_feat_single(self, cls_score: Tensor, bbox_pred: Tensor,
    method loss_by_feat (line 532) | def loss_by_feat(
    method predict_by_feat (line 605) | def predict_by_feat(self,
    method _predict_by_feat_single (line 657) | def _predict_by_feat_single(self,
    method refine_bboxes (line 751) | def refine_bboxes(self, anchor_list: List[List[Tensor]],
    method loss (line 769) | def loss(self, x: Tuple[Tensor], batch_data_samples: SampleList) -> dict:
    method loss_and_predict (line 804) | def loss_and_predict(
    method predict (line 856) | def predict(self,
  class CascadeRPNHead (line 902) | class CascadeRPNHead(BaseDenseHead):
    method __init__ (line 921) | def __init__(self,
    method loss_by_feat (line 943) | def loss_by_feat(self):
    method predict_by_feat (line 947) | def predict_by_feat(self):
    method loss (line 951) | def loss(self, x: Tuple[Tensor], batch_data_samples: SampleList) -> dict:
    method loss_and_predict (line 998) | def loss_and_predict(
    method predict (line 1062) | def predict(self,

FILE: mmdet/models/dense_heads/centernet_head.py
  class CenterNetHead (line 22) | class CenterNetHead(BaseDenseHead):
    method __init__ (line 48) | def __init__(self,
    method _build_head (line 75) | def _build_head(self, in_channels: int, feat_channels: int,
    method init_weights (line 84) | def init_weights(self) -> None:
    method forward (line 93) | def forward(self, x: Tuple[Tensor, ...]) -> Tuple[List[Tensor]]:
    method forward_single (line 110) | def forward_single(self, x: Tensor) -> Tuple[Tensor, ...]:
    method loss_by_feat (line 127) | def loss_by_feat(
    method get_targets (line 201) | def get_targets(self, gt_bboxes: List[Tensor], gt_labels: List[Tensor],
    method predict_by_feat (line 272) | def predict_by_feat(self,
    method _predict_by_feat_single (line 321) | def _predict_by_feat_single(self,
    method _decode_heatmap (line 384) | def _decode_heatmap(self,
    method _bboxes_nms (line 435) | def _bboxes_nms(self, bboxes: Tensor, labels: Tensor,

FILE: mmdet/models/dense_heads/centernet_update_head.py
  function _transpose (line 21) | def _transpose(tensor_list: List[Tensor],
  class CenterNetUpdateHead (line 36) | class CenterNetUpdateHead(AnchorFreeHead):
    method __init__ (line 71) | def __init__(self,
    method _init_predictor (line 116) | def _init_predictor(self) -> None:
    method forward (line 122) | def forward(self, x: Tuple[Tensor]) -> Tuple[List[Tensor], List[Tensor]]:
    method forward_single (line 139) | def forward_single(self, x: Tensor, scale: Scale,
    method loss_by_feat (line 165) | def loss_by_feat(
    method get_targets (line 276) | def get_targets(
    method _get_targets_single (line 331) | def _get_targets_single(self, gt_instances: InstanceData, points: Tensor,
    method add_cls_pos_inds (line 406) | def add_cls_pos_inds(
    method _create_heatmaps_from_dist (line 482) | def _create_heatmaps_from_dist(self, weighted_dist: Tensor,
    method _get_center3x3_region_index_targets (line 497) | def _get_center3x3_region_index_targets(self,

FILE: mmdet/models/dense_heads/centripetal_head.py
  class CentripetalHead (line 18) | class CentripetalHead(CornerHead):
    method __init__ (line 55) | def __init__(self,
    method _init_centripetal_layers (line 79) | def _init_centripetal_layers(self) -> None:
    method _init_layers (line 139) | def _init_layers(self) -> None:
    method init_weights (line 147) | def init_weights(self) -> None:
    method forward_single (line 163) | def forward_single(self, x: Tensor, lvl_ind: int) -> List[Tensor]:
    method loss_by_feat (line 213) | def loss_by_feat(
    method loss_by_feat_single (line 298) | def loss_by_feat_single(self, tl_hmp: Tensor, br_hmp: Tensor,
    method predict_by_feat (line 383) | def predict_by_feat(self,

FILE: mmdet/models/dense_heads/condinst_head.py
  class CondInstBboxHead (line 29) | class CondInstBboxHead(FCOSHead):
    method __init__ (line 42) | def __init__(self, *args, num_params: int = 169, **kwargs) -> None:
    method _init_layers (line 46) | def _init_layers(self) -> None:
    method forward_single (line 52) | def forward_single(self, x: Tensor, scale: Scale,
    method loss_by_feat (line 89) | def loss_by_feat(
    method get_targets (line 210) | def get_targets(
    method _get_targets_single (line 276) | def _get_targets_single(
    method get_positive_infos (line 394) | def get_positive_infos(self) -> InstanceList:
    method predict_by_feat (line 457) | def predict_by_feat(self,
    method _predict_by_feat_single (line 558) | def _predict_by_feat_single(self,
  class MaskFeatModule (line 715) | class MaskFeatModule(BaseModule):
    method __init__ (line 739) | def __init__(self,
    method _init_layers (line 766) | def _init_layers(self) -> None:
    method init_weights (line 800) | def init_weights(self) -> None:
    method forward (line 807) | def forward(self, x: Tuple[Tensor]) -> Tensor:
  class CondInstMaskHead (line 838) | class CondInstMaskHead(BaseMaskHead):
    method __init__ (line 859) | def __init__(self,
    method _init_layers (line 887) | def _init_layers(self) -> None:
    method parse_dynamic_params (line 905) | def parse_dynamic_params(
    method dynamic_conv_forward (line 928) | def dynamic_conv_forward(self, features: Tensor, weights: List[Tensor],
    method forward (line 939) | def forward(self, x: tuple, positive_infos: InstanceList) -> tuple:
    method forward_single (line 956) | def forward_single(self, mask_feat: Tensor,
    method loss_by_feat (line 989) | def loss_by_feat(self, mask_preds: List[Tensor],
    method _get_targets_single (line 1038) | def _get_targets_single(self, mask_preds: Tensor,
    method predict_by_feat (line 1127) | def predict_by_feat(self,
    method _predict_by_feat_single (line 1177) | def _predict_by_feat_single(self,

FILE: mmdet/models/dense_heads/conditional_detr_head.py
  class ConditionalDETRHead (line 17) | class ConditionalDETRHead(DETRHead):
    method init_weights (line 24) | def init_weights(self):
    method forward (line 33) | def forward(self, hidden_states: Tensor,
    method loss (line 69) | def loss(self, hidden_states: Tensor, references: Tensor,
    method loss_and_predict (line 97) | def loss_and_predict(
    method predict (line 134) | def predict(self,

FILE: mmdet/models/dense_heads/corner_head.py
  class BiCornerPool (line 24) | class BiCornerPool(BaseModule):
    method __init__ (line 38) | def __init__(self,
    method forward (line 68) | def forward(self, x: Tensor) -> Tensor:
  class CornerHead (line 89) | class CornerHead(BaseDenseHead):
    method __init__ (line 124) | def __init__(self,
    method _make_layers (line 163) | def _make_layers(self,
    method _init_corner_kpt_layers (line 173) | def _init_corner_kpt_layers(self) -> None:
    method _init_corner_emb_layers (line 211) | def _init_corner_emb_layers(self) -> None:
    method _init_layers (line 229) | def _init_layers(self) -> None:
    method init_weights (line 238) | def init_weights(self) -> None:
    method forward (line 256) | def forward(self, feats: Tuple[Tensor]) -> tuple:
    method forward_single (line 288) | def forward_single(self,
    method get_targets (line 337) | def get_targets(self,
    method loss_by_feat (line 525) | def loss_by_feat(
    method loss_by_feat_single (line 596) | def loss_by_feat_single(self, tl_hmp: Tensor, br_hmp: Tensor,
    method predict_by_feat (line 677) | def predict_by_feat(self,
    method _predict_by_feat_single (line 739) | def _predict_by_feat_single(self,
    method _bboxes_nms (line 830) | def _bboxes_nms(self, bboxes: Tensor, labels: Tensor,
    method _decode_heatmap (line 850) | def _decode_heatmap(self,

FILE: mmdet/models/dense_heads/dab_detr_head.py
  class DABDETRHead (line 17) | class DABDETRHead(ConditionalDETRHead):
    method _init_layers (line 25) | def _init_layers(self) -> None:
    method init_weights (line 32) | def init_weights(self) -> None:
    method forward (line 39) | def forward(self, hidden_states: Tensor,
    method predict (line 72) | def predict(self,

FILE: mmdet/models/dense_heads/ddod_head.py
  class DDODHead (line 23) | class DDODHead(AnchorHead):
    method __init__ (line 44) | def __init__(self,
    method _init_layers (line 69) | def _init_layers(self) -> None:
    method init_weights (line 116) | def init_weights(self) -> None:
    method forward (line 127) | def forward(self, x: Tuple[Tensor]) -> Tuple[List[Tensor]]:
    method forward_single (line 149) | def forward_single(self, x: Tensor, scale: Scale) -> Sequence[Tensor]:
    method loss_cls_by_feat_single (line 179) | def loss_cls_by_feat_single(self, cls_score: Tensor, labels: Tensor,
    method loss_reg_by_feat_single (line 211) | def loss_reg_by_feat_single(self, anchors: Tensor, bbox_pred: Tensor,
    method calc_reweight_factor (line 292) | def calc_reweight_factor(self, labels_list: List[Tensor]) -> List[float]:
    method loss_by_feat (line 311) | def loss_by_feat(
    method process_predictions_and_anchors (line 421) | def process_predictions_and_anchors(
    method get_cls_targets (line 498) | def get_cls_targets(self,
    method get_reg_targets (line 573) | def get_reg_targets(self,
    method _get_targets_single (line 648) | def _get_targets_single(self,
    method get_num_level_anchors_inside (line 776) | def get_num_level_anchors_inside(self, num_level_anchors: List[int],

FILE: mmdet/models/dense_heads/deformable_detr_head.py
  class DeformableDETRHead (line 19) | class DeformableDETRHead(DETRHead):
    method __init__ (line 38) | def __init__(self,
    method _init_layers (line 50) | def _init_layers(self) -> None:
    method init_weights (line 72) | def init_weights(self) -> None:
    method forward (line 85) | def forward(self, hidden_states: Tensor,
    method loss (line 143) | def loss(self, hidden_states: Tensor, references: List[Tensor],
    method loss_by_feat (line 189) | def loss_by_feat(
    method predict (line 252) | def predict(self,
    method predict_by_feat (line 293) | def predict_by_feat(self,

FILE: mmdet/models/dense_heads/dense_test_mixins.py
  class BBoxTestMixin (line 17) | class BBoxTestMixin(object):
    method simple_test_bboxes (line 20) | def simple_test_bboxes(self, feats, img_metas, rescale=False):
    method aug_test_bboxes (line 53) | def aug_test_bboxes(self, feats, img_metas, rescale=False):
    method aug_test_rpn (line 135) | def aug_test_rpn(self, feats, img_metas):
    method async_simple_test_rpn (line 178) | async def async_simple_test_rpn(self, x, img_metas):
    method merge_aug_bboxes (line 188) | def merge_aug_bboxes(self, aug_bboxes, aug_scores, img_metas):

FILE: mmdet/models/dense_heads/detr_head.py
  class DETRHead (line 22) | class DETRHead(BaseModule):
    method __init__ (line 51) | def __init__(
    method _init_layers (line 120) | def _init_layers(self) -> None:
    method forward (line 138) | def forward(self, hidden_states: Tensor) -> Tuple[Tensor]:
    method loss (line 162) | def loss(self, hidden_states: Tensor,
    method loss_by_feat (line 189) | def loss_by_feat(
    method loss_by_feat_single (line 249) | def loss_by_feat_single(self, cls_scores: Tensor, bbox_preds: Tensor,
    method get_targets (line 327) | def get_targets(self, cls_scores_list: List[Tensor],
    method _get_targets_single (line 368) | def _get_targets_single(self, cls_score: Tensor, bbox_pred: Tensor,
    method loss_and_predict (line 441) | def loss_and_predict(
    method predict (line 476) | def predict(self,
    method predict_by_feat (line 509) | def predict_by_feat(self,
    method _predict_by_feat_single (line 554) | def _predict_by_feat_single(self,

FILE: mmdet/models/dense_heads/dino_head.py
  class DINOHead (line 17) | class DINOHead(DeformableDETRHead):
    method loss (line 28) | def loss(self, hidden_states: Tensor, references: List[Tensor],
    method loss_by_feat (line 75) | def loss_by_feat(
    method loss_dn (line 166) | def loss_dn(self, all_layers_denoising_cls_scores: Tensor,
    method _loss_dn_single (line 203) | def _loss_dn_single(self, dn_cls_scores: Tensor, dn_bbox_preds: Tensor,
    method get_dn_targets (line 288) | def get_dn_targets(self, batch_gt_instances: InstanceList,
    method _get_dn_targets_single (line 325) | def _get_dn_targets_single(self, gt_instances: InstanceData,
    method split_outputs (line 397) | def split_outputs(all_layers_cls_scores: Tensor,

FILE: mmdet/models/dense_heads/embedding_rpn_head.py
  class EmbeddingRPNHead (line 17) | class EmbeddingRPNHead(BaseModule):
    method __init__ (line 32) | def __init__(self,
    method _init_layers (line 45) | def _init_layers(self) -> None:
    method init_weights (line 51) | def init_weights(self) -> None:
    method _decode_init_proposals (line 61) | def _decode_init_proposals(self, x: List[Tensor],
    method loss (line 109) | def loss(self, *args, **kwargs):
    method predict (line 116) | def predict(self, x: List[Tensor], batch_data_samples: SampleList,
    method loss_and_predict (line 124) | def loss_and_predict(self, x: List[Tensor], batch_data_samples: Sample...

FILE: mmdet/models/dense_heads/fcos_head.py
  class FCOSHead (line 20) | class FCOSHead(AnchorFreeHead):
    method __init__ (line 68) | def __init__(self,
    method _init_layers (line 115) | def _init_layers(self) -> None:
    method forward (line 121) | def forward(
    method forward_single (line 144) | def forward_single(self, x: Tensor, scale: Scale,
    method loss_by_feat (line 179) | def loss_by_feat(
    method get_targets (line 285) | def get_targets(
    method _get_targets_single (line 347) | def _get_targets_single(
    method centerness_target (line 436) | def centerness_target(self, pos_bbox_targets: Tensor) -> Tensor:

FILE: mmdet/models/dense_heads/fovea_head.py
  class FeatureAlign (line 21) | class FeatureAlign(BaseModule):
    method __init__ (line 39) | def __init__(
    method forward (line 63) | def forward(self, x: Tensor, shape: Tensor) -> Tensor:
  class FoveaHead (line 79) | class FoveaHead(AnchorFreeHead):
    method __init__ (line 97) | def __init__(self,
    method _init_layers (line 127) | def _init_layers(self) -> None:
    method forward_single (line 168) | def forward_single(self, x: Tensor) -> Tuple[Tensor, Tensor]:
    method loss_by_feat (line 190) | def loss_by_feat(
    method get_targets (line 265) | def get_targets(
    method _get_targets_single (line 305) | def _get_targets_single(self,
    method _predict_by_feat_single (line 386) | def _predict_by_feat_single(self,
    method _bbox_decode (line 480) | def _bbox_decode(self, priors: Tensor, bbox_pred: Tensor, base_len: int,

FILE: mmdet/models/dense_heads/free_anchor_retina_head.py
  class FreeAnchorRetinaHead (line 19) | class FreeAnchorRetinaHead(RetinaHead):
    method __init__ (line 42) | def __init__(self,
    method loss_by_feat (line 66) | def loss_by_feat(
    method positive_loss_single (line 145) | def positive_loss_single(self, cls_prob: Tensor, bbox_pred: Tensor,
    method positive_bag_loss (line 259) | def positive_bag_loss(self, matched_cls_prob: Tensor,
    method negative_bag_loss (line 287) | def negative_bag_loss(self, cls_prob: Tensor, box_prob: Tensor) -> Ten...

FILE: mmdet/models/dense_heads/fsaf_head.py
  class FSAFHead (line 19) | class FSAFHead(RetinaHead):
    method __init__ (line 47) | def __init__(self,
    method forward_single (line 71) | def forward_single(self, x: Tensor) -> Tuple[Tensor, Tensor]:
    method _get_targets_single (line 89) | def _get_targets_single(self,
    method loss_by_feat (line 209) | def loss_by_feat(
    method calculate_pos_recall (line 337) | def calculate_pos_recall(self, cls_scores: List[Tensor],
    method collect_loss_level_single (line 373) | def collect_loss_level_single(self, cls_loss: Tensor, reg_loss: Tensor,
    method reweight_loss_single (line 405) | def reweight_loss_single(self, cls_loss: Tensor, reg_loss: Tensor,

FILE: mmdet/models/dense_heads/ga_retina_head.py
  class GARetinaHead (line 15) | class GARetinaHead(GuidedAnchorHead):
    method __init__ (line 18) | def __init__(self,
    method _init_layers (line 52) | def _init_layers(self) -> None:
    method forward_single (line 99) | def forward_single(self, x: Tensor) -> Tuple[Tensor]:

FILE: mmdet/models/dense_heads/ga_rpn_head.py
  class GARPNHead (line 18) | class GARPNHead(GuidedAnchorHead):
    method __init__ (line 21) | def __init__(self,
    method _init_layers (line 40) | def _init_layers(self) -> None:
    method forward_single (line 46) | def forward_single(self, x: Tensor) -> Tuple[Tensor]:
    method loss_by_feat (line 55) | def loss_by_feat(
    method _predict_by_feat_single (line 103) | def _predict_by_feat_single(self,

FILE: mmdet/models/dense_heads/gfl_head.py
  class Integral (line 23) | class Integral(nn.Module):
    method __init__ (line 36) | def __init__(self, reg_max: int = 16) -> None:
    method forward (line 42) | def forward(self, x: Tensor) -> Tensor:
  class GFLHead (line 60) | class GFLHead(AnchorHead):
    method __init__ (line 98) | def __init__(self,
    method _init_layers (line 141) | def _init_layers(self) -> None:
    method forward (line 174) | def forward(self, x: Tuple[Tensor]) -> Tuple[List[Tensor]]:
    method forward_single (line 193) | def forward_single(self, x: Tensor, scale: Scale) -> Sequence[Tensor]:
    method anchor_center (line 220) | def anchor_center(self, anchors: Tensor) -> Tensor:
    method loss_by_feat_single (line 233) | def loss_by_feat_single(self, anchors: Tensor, cls_score: Tensor,
    method loss_by_feat (line 327) | def loss_by_feat(
    method _predict_by_feat_single (line 396) | def _predict_by_feat_single(self,
    method get_targets (line 492) | def get_targets(self,
    method _get_targets_single (line 550) | def _get_targets_single(self,
    method get_num_level_anchors_inside (line 659) | def get_num_level_anchors_inside(self, num_level_anchors: List[int],

FILE: mmdet/models/dense_heads/guided_anchor_head.py
  class FeatureAdaption (line 21) | class FeatureAdaption(BaseModule):
    method __init__ (line 37) | def __init__(
    method forward (line 61) | def forward(self, x: Tensor, shape: Tensor) -> Tensor:
  class GuidedAnchorHead (line 68) | class GuidedAnchorHead(AnchorHead):
    method __init__ (line 108) | def __init__(
    method _init_layers (line 219) | def _init_layers(self) -> None:
    method forward_single (line 236) | def forward_single(self, x: Tensor) -> Tuple[Tensor]:
    method forward (line 250) | def forward(self, x: List[Tensor]) -> Tuple[List[Tensor]]:
    method get_sampled_approxs (line 254) | def get_sampled_approxs(self,
    method get_anchors (line 307) | def get_anchors(self,
    method _get_guided_anchors_single (line 359) | def _get_guided_anchors_single(
    method ga_loc_targets (line 395) | def ga_loc_targets(self, batch_gt_instances: InstanceList,
    method _ga_shape_target_single (line 500) | def _ga_shape_target_single(self,
    method ga_shape_targets (line 577) | def ga_shape_targets(self,
    method loss_shape_single (line 648) | def loss_shape_single(self, shape_pred: Tensor, bbox_anchors: Tensor,
    method loss_loc_single (line 671) | def loss_loc_single(self, loc_pred: Tensor, loc_target: Tensor,
    method loss_by_feat (line 681) | def loss_by_feat(
    method predict_by_feat (line 803) | def predict_by_feat(self,
    method _predict_by_feat_single (line 881) | def _predict_by_feat_single(self,

FILE: mmdet/models/dense_heads/lad_head.py
  class LADHead (line 16) | class LADHead(PAAHead):
    method get_label_assignment (line 20) | def get_label_assignment(
    method loss (line 124) | def loss(self, x: List[Tensor], label_assignment_results: tuple,
    method loss_by_feat (line 152) | def loss_by_feat(self,

FILE: mmdet/models/dense_heads/ld_head.py
  class LDHead (line 16) | class LDHead(GFLHead):
    method __init__ (line 31) | def __init__(self,
    method loss_by_feat_single (line 44) | def loss_by_feat_single(self, anchors: Tensor, cls_score: Tensor,
    method loss (line 156) | def loss(self, x: List[Tensor], out_teacher: Tuple[Tensor],
    method loss_by_feat (line 185) | def loss_by_feat(

FILE: mmdet/models/dense_heads/mask2former_head.py
  class Mask2FormerHead (line 24) | class Mask2FormerHead(MaskFormerHead):
    method __init__ (line 62) | def __init__(self,
    method init_weights (line 158) | def init_weights(self) -> None:
    method _get_targets_single (line 169) | def _get_targets_single(self, cls_score: Tensor, mask_pred: Tensor,
    method _loss_by_feat_single (line 249) | def _loss_by_feat_single(self, cls_scores: Tensor, mask_preds: Tensor,
    method _forward_head (line 337) | def _forward_head(self, decoder_out: Tensor, mask_feature: Tensor,
    method forward (line 379) | def forward(self, x: List[Tensor],

FILE: mmdet/models/dense_heads/maskformer_head.py
  class MaskFormerHead (line 23) | class MaskFormerHead(AnchorFreeHead):
    method __init__ (line 59) | def __init__(self,
    method init_weights (line 134) | def init_weights(self) -> None:
    method preprocess_gt (line 144) | def preprocess_gt(
    method get_targets (line 192) | def get_targets(
    method _get_targets_single (line 254) | def _get_targets_single(self, cls_score: Tensor, mask_pred: Tensor,
    method loss_by_feat (line 324) | def loss_by_feat(self, all_cls_scores: Tensor, all_mask_preds: Tensor,
    method _loss_by_feat_single (line 367) | def _loss_by_feat_single(self, cls_scores: Tensor, mask_preds: Tensor,
    method forward (line 455) | def forward(self, x: Tuple[Tensor],
    method loss (line 524) | def loss(
    method predict (line 566) | def predict(self, x: Tuple[Tensor],

FILE: mmdet/models/dense_heads/nasfcos_head.py
  class NASFCOSHead (line 13) | class NASFCOSHead(FCOSHead):
    method __init__ (line 51) | def __init__(self,
    method _init_layers (line 73) | def _init_layers(self) -> None:

FILE: mmdet/models/dense_heads/paa_head.py
  class PAAHead (line 25) | class PAAHead(ATSSHead):
    method __init__ (line 53) | def __init__(self,
    method loss_by_feat (line 65) | def loss_by_feat(
    method get_pos_loss (line 180) | def get_pos_loss(self, anchors: List[Tensor], cls_score: Tensor,
    method paa_reassign (line 238) | def paa_reassign(self, pos_losses: Tensor, label: Tensor,
    method gmm_separation_scheme (line 349) | def gmm_separation_scheme(self, gmm_assignment: Tensor, scores: Tensor,
    method get_targets (line 385) | def get_targets(self,
    method _get_targets_single (line 472) | def _get_targets_single(self,
    method predict_by_feat (line 494) | def predict_by_feat(self,
    method _predict_by_feat_single (line 519) | def _predict_by_feat_single(self,
    method _bbox_post_process (line 604) | def _bbox_post_process(self,
    method score_voting (line 666) | def score_voting(self, det_bboxes: Tensor, det_labels: Tensor,

FILE: mmdet/models/dense_heads/pisa_retinanet_head.py
  class PISARetinaHead (line 15) | class PISARetinaHead(RetinaHead):
    method loss_by_feat (line 25) | def loss_by_feat(

FILE: mmdet/models/dense_heads/pisa_ssd_head.py
  class PISASSDHead (line 16) | class PISASSDHead(SSDHead):
    method loss_by_feat (line 52) | def loss_by_feat(

FILE: mmdet/models/dense_heads/reppoints_head.py
  class RepPointsHead (line 23) | class RepPointsHead(AnchorFreeHead):
    method __init__ (line 49) | def __init__(self,
    method _init_layers (line 140) | def _init_layers(self) -> None:
    method points2bbox (line 184) | def points2bbox(self, pts: Tensor, y_first: bool = True) -> Tensor:
    method gen_grid_from_reg (line 239) | def gen_grid_from_reg(self, reg: Tensor,
    method forward (line 277) | def forward(self, feats: Tuple[Tensor]) -> Tuple[Tensor]:
    method forward_single (line 280) | def forward_single(self, x: Tensor) -> Tuple[Tensor]:
    method get_points (line 326) | def get_points(self, featmap_sizes: List[Tuple[int]],
    method centers_to_bboxes (line 355) | def centers_to_bboxes(self, point_list: List[Tensor]) -> List[Tensor]:
    method offset_to_pts (line 373) | def offset_to_pts(self, center_list: List[Tensor],
    method _get_targets_single (line 395) | def _get_targets_single(self,
    method get_targets (line 493) | def get_targets(self,
    method loss_by_feat_single (line 587) | def loss_by_feat_single(self, cls_score: Tensor, pts_pred_init: Tensor,
    method loss_by_feat (line 656) | def loss_by_feat(
    method _predict_by_feat_single (line 768) | def _predict_by_feat_single(self,
    method _bbox_decode (line 865) | def _bbox_decode(self, points: Tensor, bbox_pred: Tensor, stride: int,

FILE: mmdet/models/dense_heads/retina_head.py
  class RetinaHead (line 10) | class RetinaHead(AnchorHead):
    method __init__ (line 29) | def __init__(self,
    method _init_layers (line 64) | def _init_layers(self):
    method forward_single (line 99) | def forward_single(self, x):

FILE: mmdet/models/dense_heads/retina_sepbn_head.py
  class RetinaSepBNHead (line 15) | class RetinaSepBNHead(AnchorHead):
    method __init__ (line 23) | def __init__(self,
    method _init_layers (line 44) | def _init_layers(self) -> None:
    method init_weights (line 86) | def init_weights(self) -> None:
    method forward (line 97) | def forward(self, feats: Tuple[Tensor]) -> tuple:

FILE: mmdet/models/dense_heads/rpn_head.py
  class RPNHead (line 22) | class RPNHead(AnchorHead):
    method __init__ (line 35) | def __init__(self,
    method _init_layers (line 50) | def _init_layers(self) -> None:
    method forward_single (line 80) | def forward_single(self, x: Tensor) -> Tuple[Tensor, Tensor]:
    method loss_by_feat (line 99) | def loss_by_feat(self,
    method _predict_by_feat_single (line 134) | def _predict_by_feat_single(self,
    method _bbox_post_process (line 236) | def _bbox_post_process(self,

FILE: mmdet/models/dense_heads/rtmdet_head.py
  class RTMDetHead (line 22) | class RTMDetHead(ATSSHead):
    method __init__ (line 35) | def __init__(self,
    method _init_layers (line 47) | def _init_layers(self):
    method init_weights (line 94) | def init_weights(self) -> None:
    method forward (line 107) | def forward(self, feats: Tuple[Tensor, ...]) -> tuple:
    method loss_by_feat_single (line 149) | def loss_by_feat_single(self, cls_score: Tensor, bbox_pred: Tensor,
    method loss_by_feat (line 212) | def loss_by_feat(self,
    method get_targets (line 290) | def get_targets(self,
    method _get_targets_single (line 383) | def _get_targets_single(self,
    method get_anchors (line 492) | def get_anchors(self,
  class RTMDetSepBNHead (line 530) | class RTMDetSepBNHead(RTMDetHead):
    method __init__ (line 548) | def __init__(self,
    method _init_layers (line 570) | def _init_layers(self) -> None:
    method init_weights (line 635) | def init_weights(self) -> None:
    method forward (line 650) | def forward(self, feats: Tuple[Tensor, ...]) -> tuple:

FILE: mmdet/models/dense_heads/rtmdet_ins_head.py
  class RTMDetInsHead (line 27) | class RTMDetInsHead(RTMDetHead):
    method __init__ (line 42) | def __init__(self,
    method _init_layers (line 61) | def _init_layers(self) -> None:
    method forward (line 111) | def forward(self, feats: Tuple[Tensor, ...]) -> tuple:
    method predict_by_feat (line 167) | def predict_by_feat(self,
    method _predict_by_feat_single (line 270) | def _predict_by_feat_single(self,
    method _bbox_mask_post_process (line 425) | def _bbox_mask_post_process(
    method parse_dynamic_params (line 521) | def parse_dynamic_params(self, flatten_kernels: Tensor) -> tuple:
    method _mask_predict_by_feat_single (line 542) | def _mask_predict_by_feat_single(self, mask_feat: Tensor, kernels: Ten...
    method loss_mask_by_feat (line 591) | def loss_mask_by_feat(self, mask_feats: Tensor, flatten_kernels: Tensor,
    method loss_by_feat (line 661) | def loss_by_feat(self,
  class MaskFeatModule (line 756) | class MaskFeatModule(BaseModule):
    method __init__ (line 775) | def __init__(
    method forward (line 803) | def forward(self, features: Tuple[Tensor, ...]) -> Tensor:
  class RTMDetInsSepBNHead (line 819) | class RTMDetInsSepBNHead(RTMDetInsHead):
    method __init__ (line 835) | def __init__(self,
    method _init_layers (line 854) | def _init_layers(self) -> None:
    method init_weights (line 964) | def init_weights(self) -> None:
    method forward (line 980) | def forward(self, feats: Tuple[Tensor, ...]) -> tuple:

FILE: mmdet/models/dense_heads/sabl_retina_head.py
  class SABLRetinaHead (line 23) | class SABLRetinaHead(BaseDenseHead):
    method __init__ (line 64) | def __init__(
    method _init_layers (line 158) | def _init_layers(self) -> None:
    method forward_single (line 189) | def forward_single(self, x: Tensor) -> Tuple[Tensor, Tensor]:
    method forward (line 202) | def forward(self, feats: List[Tensor]) -> Tuple[List[Tensor]]:
    method get_anchors (line 205) | def get_anchors(
    method get_targets (line 231) | def get_targets(self,
    method _get_targets_single (line 325) | def _get_targets_single(self,
    method loss_by_feat_single (line 440) | def loss_by_feat_single(self, cls_score: Tensor, bbox_pred: Tensor,
    method loss_by_feat (line 493) | def loss_by_feat(
    method predict_by_feat (line 560) | def predict_by_feat(self,
    method _predict_by_feat_single (line 631) | def _predict_by_feat_single(self,

FILE: mmdet/models/dense_heads/solo_head.py
  class SOLOHead (line 22) | class SOLOHead(BaseMaskHead):
    method __init__ (line 55) | def __init__(
    method _init_layers (line 116) | def _init_layers(self) -> None:
    method resize_feats (line 147) | def resize_feats(self, x: Tuple[Tensor]) -> List[Tensor]:
    method forward (line 170) | def forward(self, x: Tuple[Tensor]) -> tuple:
    method loss_by_feat (line 232) | def loss_by_feat(self, mlvl_mask_preds: List[Tensor],
    method _get_targets_single (line 311) | def _get_targets_single(self,
    method predict_by_feat (line 460) | def predict_by_feat(self, mlvl_mask_preds: List[Tensor],
    method _predict_by_feat_single (line 512) | def _predict_by_feat_single(self,
  class DecoupledSOLOHead (line 624) | class DecoupledSOLOHead(SOLOHead):
    method __init__ (line 633) | def __init__(self,
    method _init_layers (line 656) | def _init_layers(self) -> None:
    method forward (line 700) | def forward(self, x: Tuple[Tensor]) -> Tuple:
    method loss_by_feat (line 780) | def loss_by_feat(self, mlvl_mask_preds_x: List[Tensor],
    method _get_targets_single (line 874) | def _get_targets_single(self,
    method predict_by_feat (line 911) | def predict_by_feat(self, mlvl_mask_preds_x: List[Tensor],
    method _predict_by_feat_single (line 974) | def _predict_by_feat_single(self,
  class DecoupledSOLOLightHead (line 1111) | class DecoupledSOLOLightHead(DecoupledSOLOHead):
    method __init__ (line 1121) | def __init__(self,
    method _init_layers (line 1147) | def _init_layers(self) -> None:
    method forward (line 1190) | def forward(self, x: Tuple[Tensor]) -> Tuple:

FILE: mmdet/models/dense_heads/solov2_head.py
  class MaskFeatModule (line 23) | class MaskFeatModule(BaseModule):
    method __init__ (line 46) | def __init__(
    method _init_layers (line 73) | def _init_layers(self) -> None:
    method forward (line 141) | def forward(self, x: Tuple[Tensor]) -> Tensor:
  class SOLOV2Head (line 169) | class SOLOV2Head(SOLOHead):
    method __init__ (line 185) | def __init__(self,
    method _init_layers (line 226) | def _init_layers(self) -> None:
    method forward (line 269) | def forward(self, x):
    method _get_targets_single (line 331) | def _get_targets_single(self,
    method loss_by_feat (line 496) | def loss_by_feat(self, mlvl_kernel_preds: List[Tensor],
    method predict_by_feat (line 609) | def predict_by_feat(self, mlvl_kernel_preds: List[Tensor],
    method _predict_by_feat_single (line 672) | def _predict_by_feat_single(self,

FILE: mmdet/models/dense_heads/ssd_head.py
  class SSDHead (line 20) | class SSDHead(AnchorHead):
    method __init__ (line 56) | def __init__(
    method _init_layers (line 119) | def _init_layers(self) -> None:
    method forward (line 190) | def forward(self, x: Tuple[Tensor]) -> Tuple[List[Tensor], List[Tensor]]:
    method loss_by_feat_single (line 215) | def loss_by_feat_single(self, cls_score: Tensor, bbox_pred: Tensor,
    method loss_by_feat (line 279) | def loss_by_feat(

FILE: mmdet/models/dense_heads/tood_head.py
  class TaskDecomposition (line 25) | class TaskDecomposition(nn.Module):
    method __init__ (line 39) | def __init__(self,
    method init_weights (line 69) | def init_weights(self) -> None:
    method forward (line 76) | def forward(self,
  class TOODHead (line 105) | class TOODHead(ATSSHead):
    method __init__ (line 131) | def __init__(self,
    method _init_layers (line 161) | def _init_layers(self) -> None:
    method init_weights (line 210) | def init_weights(self) -> None:
    method forward (line 229) | def forward(self, feats: Tuple[Tensor]) -> Tuple[List[Tensor]]:
    method deform_sampling (line 303) | def deform_sampling(self, feat: Tensor, offset: Tensor) -> Tensor:
    method anchor_center (line 316) | def anchor_center(self, anchors: Tensor) -> Tensor:
    method loss_by_feat_single (line 329) | def loss_by_feat_single(self, anchors: Tensor, cls_score: Tensor,
    method loss_by_feat (line 405) | def loss_by_feat(
    method _predict_by_feat_single (line 484) | def _predict_by_feat_single(self,
    method get_targets (line 578) | def get_targets(self,
    method _get_targets_single (line 691) | def _get_targets_single(self,

FILE: mmdet/models/dense_heads/vfnet_head.py
  class VFNetHead (line 25) | class VFNetHead(ATSSHead, FCOSHead):
    method __init__ (line 75) | def __init__(self,
    method _init_layers (line 187) | def _init_layers(self) -> None:
    method forward (line 222) | def forward(self, x: Tuple[Tensor]) -> Tuple[List[Tensor]]:
    method forward_single (line 245) | def forward_single(self, x: Tensor, scale: Scale, scale_refine: Scale,
    method star_dcn_offset (line 307) | def star_dcn_offset(self, bbox_pred: Tensor, gradient_mul: float,
    method loss_by_feat (line 349) | def loss_by_feat(
    method get_targets (line 502) | def get_targets(
    method _get_targets_single (line 544) | def _get_targets_single(self, *args, **kwargs):
    method get_fcos_targets (line 551) | def get_fcos_targets(self, points: List[Tensor],
    method get_anchors (line 577) | def get_anchors(self,
    method get_atss_targets (line 611) | def get_atss_targets(
    method transform_bbox_targets (line 687) | def transform_bbox_targets(self, decoded_bboxes: List[Tensor],
    method _load_from_state_dict (line 715) | def _load_from_state_dict(self, state_dict: dict, prefix: str,

FILE: mmdet/models/dense_heads/yolact_head.py
  class YOLACTHead (line 25) | class YOLACTHead(AnchorHead):
    method __init__ (line 57) | def __init__(self,
    method _init_layers (line 98) | def _init_layers(self) -> None:
    method forward_single (line 126) | def forward_single(self, x: Tensor) -> tuple:
    method loss_by_feat (line 149) | def loss_by_feat(
    method OHEMloss_by_feat_single (line 264) | def OHEMloss_by_feat_single(self, cls_score: Tensor, bbox_pred: Tensor,
    method get_positive_infos (line 327) | def get_positive_infos(self) -> InstanceList:
    method predict_by_feat (line 359) | def predict_by_feat(self,
    method _predict_by_feat_single (line 421) | def _predict_by_feat_single(self,
    method _bbox_post_process (line 526) | def _bbox_post_process(self,
  class YOLACTProtonet (line 589) | class YOLACTProtonet(BaseMaskHead):
    method __init__ (line 618) | def __init__(
    method _init_layers (line 659) | def _init_layers(self) -> None:
    method forward (line 695) | def forward(self, x: tuple, positive_infos: InstanceList) -> tuple:
    method loss_by_feat (line 736) | def loss_by_feat(self, mask_preds: List[Tensor], segm_preds: List[Tens...
    method _get_targets_single (line 824) | def _get_targets_single(self, mask_preds: Tensor, segm_pred: Tensor,
    method crop_mask_preds (line 913) | def crop_mask_preds(self, mask_preds: List[Tensor],
    method crop_single (line 941) | def crop_single(self,
    method sanitize_coordinates (line 979) | def sanitize_coordinates(self,
    method predict_by_feat (line 1016) | def predict_by_feat(self,
    method _predict_by_feat_single (line 1070) | def _predict_by_feat_single(self,
  class SegmentationModule (line 1125) | class SegmentationModule(BaseModule):
    method __init__ (line 1139) | def __init__(
    method _init_layers (line 1153) | def _init_layers(self) -> None:
    method forward (line 1158) | def forward(self, x: Tensor) -> Tensor:
  class InterpolateModule (line 1172) | class InterpolateModule(BaseModule):
    method __init__ (line 1178) | def __init__(self, *args, init_cfg=None, **kwargs) -> None:
    method forward (line 1183) | def forward(self, x: Tensor) -> Tensor:

FILE: mmdet/models/dense_heads/yolo_head.py
  class YOLOV3Head (line 25) | class YOLOV3Head(BaseDenseHead):
    method __init__ (line 56) | def __init__(self,
    method num_levels (line 127) | def num_levels(self) -> int:
    method num_attrib (line 132) | def num_attrib(self) -> int:
    method _init_layers (line 138) | def _init_layers(self) -> None:
    method init_weights (line 157) | def init_weights(self) -> None:
    method forward (line 174) | def forward(self, x: Tuple[Tensor, ...]) -> tuple:
    method predict_by_feat (line 196) | def predict_by_feat(self,
    method loss_by_feat (line 289) | def loss_by_feat(
    method loss_by_feat_single (line 344) | def loss_by_feat_single(self, pred_map: Tensor, target_map: Tensor,
    method get_targets (line 391) | def get_targets(self, anchor_list: List[List[Tensor]],
    method _get_targets_single (line 428) | def _get_targets_single(self, anchors: List[Tensor],
    method responsible_flags (line 493) | def responsible_flags(self, featmap_sizes: List[tuple], gt_bboxes: Ten...

FILE: mmdet/models/dense_heads/yolof_head.py
  class YOLOFHead (line 21) | class YOLOFHead(AnchorHead):
    method __init__ (line 35) | def __init__(self,
    method _init_layers (line 48) | def _init_layers(self) -> None:
    method init_weights (line 88) | def init_weights(self) -> None:
    method forward_single (line 99) | def forward_single(self, x: Tensor) -> Tuple[Tensor, Tensor]:
    method loss_by_feat (line 129) | def loss_by_feat(
    method get_targets (line 213) | def get_targets(self,
    method _get_targets_single (line 297) | def _get_targets_single(self,

FILE: mmdet/models/dense_heads/yolox_head.py
  class YOLOXHead (line 26) | class YOLOXHead(BaseDenseHead):
    method __init__ (line 65) | def __init__(
    method _init_layers (line 143) | def _init_layers(self) -> None:
    method _build_stacked_convs (line 158) | def _build_stacked_convs(self) -> nn.Sequential:
    method _build_predictor (line 182) | def _build_predictor(self) -> Tuple[nn.Module, nn.Module, nn.Module]:
    method init_weights (line 189) | def init_weights(self) -> None:
    method forward_single (line 199) | def forward_single(self, x: Tensor, cls_convs: nn.Module,
    method forward (line 214) | def forward(self, x: Tuple[Tensor]) -> Tuple[List]:
    method predict_by_feat (line 231) | def predict_by_feat(self,
    method _bbox_decode (line 326) | def _bbox_decode(self, priors: Tensor, bbox_preds: Tensor) -> Tensor:
    method _bbox_post_process (line 351) | def _bbox_post_process(self,
    method loss_by_feat (line 399) | def loss_by_feat(
    method _get_targets_single (line 522) | def _get_targets_single(
    method _get_l1_target (line 609) | def _get_l1_target(self,

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

FILE: mmdet/models/detectors/autoassign.py
  class AutoAssign (line 8) | class AutoAssign(SingleStageDetector):
    method __init__ (line 28) | def __init__(self,

FILE: mmdet/models/detectors/base.py
  class BaseDetector (line 17) | class BaseDetector(BaseModel, metaclass=ABCMeta):
    method __init__ (line 28) | def __init__(self,
    method with_neck (line 35) | def with_neck(self) -> bool:
    method with_shared_head (line 42) | def with_shared_head(self) -> bool:
    method with_bbox (line 47) | def with_bbox(self) -> bool:
    method with_mask (line 53) | def with_mask(self) -> bool:
    method forward (line 58) | def forward(self,
    method loss (line 102) | def loss(self, batch_inputs: Tensor,
    method predict (line 108) | def predict(self, batch_inputs: Tensor,
    method _forward (line 115) | def _forward(self,
    method extract_feat (line 126) | def extract_feat(self, batch_inputs: Tensor):
    method add_pred_to_datasample (line 130) | def add_pred_to_datasample(self, data_samples: SampleList,

FILE: mmdet/models/detectors/base_detr.py
  class DetectionTransformer (line 14) | class DetectionTransformer(BaseDetector, metaclass=ABCMeta):
    method __init__ (line 48) | def __init__(self,
    method _init_layers (line 80) | def _init_layers(self) -> None:
    method loss (line 84) | def loss(self, batch_inputs: Tensor,
    method predict (line 106) | def predict(self,
    method _forward (line 144) | def _forward(
    method forward_transformer (line 167) | def forward_transformer(self,
    method extract_feat (line 227) | def extract_feat(self, batch_inputs: Tensor) -> Tuple[Tensor]:
    method pre_transformer (line 243) | def pre_transformer(
    method forward_encoder (line 271) | def forward_encoder(self, feat: Tensor, feat_mask: Tensor,
    method pre_decoder (line 291) | def pre_decoder(self, memory: Tensor, **kwargs) -> Tuple[Dict, Dict]:
    method forward_decoder (line 314) | def forward_decoder(self, query: Tensor, query_pos: Tensor, memory: Te...

FILE: mmdet/models/detectors/boxinst.py
  class BoxInst (line 8) | class BoxInst(SingleStageInstanceSegmentor):
    method __init__ (line 11) | def __init__(self,

FILE: mmdet/models/detectors/cascade_rcnn.py
  class CascadeRCNN (line 8) | class CascadeRCNN(TwoStageDetector):
    method __init__ (line 12) | def __init__(self,

FILE: mmdet/models/detectors/centernet.py
  class CenterNet (line 8) | class CenterNet(SingleStageDetector):
    method __init__ (line 14) | def __init__(self,

FILE: mmdet/models/detectors/condinst.py
  class CondInst (line 8) | class CondInst(SingleStageInstanceSegmentor):
    method __init__ (line 11) | def __init__(self,

FILE: mmdet/models/detectors/conditional_detr.py
  class ConditionalDETR (line 14) | class ConditionalDETR(DETR):
    method _init_layers (line 23) | def _init_layers(self) -> None:
    method forward_decoder (line 40) | def forward_decoder(self, query: Tensor, query_pos: Tensor, memory: Te...

FILE: mmdet/models/detectors/cornernet.py
  class CornerNet (line 8) | class CornerNet(SingleStageDetector):
    method __init__ (line 15) | def __init__(self,

FILE: mmdet/models/detectors/crosskd_atss.py
  class CrossKDATSS (line 16) | class CrossKDATSS(CrossKDSingleStageDetector):
    method __init__ (line 18) | def __init__(self,
    method loss (line 26) | def loss(self, batch_inputs: Tensor,
    method forward_hkd_single (line 82) | def forward_hkd_single(self, x, scale, module):
    method reuse_teacher_head (line 100) | def reuse_teacher_head(self, tea_cls_feat, tea_reg_feat, stu_cls_feat,
    method align_scale (line 117) | def align_scale(self, stu_feat, tea_feat):
    method loss_by_feat (line 131) | def loss_by_feat(
    method pred_imitation_loss_single (line 230) | def pred_imitation_loss_single(self,

FILE: mmdet/models/detectors/crosskd_fcos.py
  class CrossKDFCOS (line 17) | class CrossKDFCOS(CrossKDSingleStageDetector):
    method loss (line 19) | def loss(self, batch_inputs: Tensor,
    method forward_hkd_single (line 75) | def forward_hkd_single(self, x, scale, stride, module):
    method reuse_teacher_head (line 105) | def reuse_teacher_head(self, tea_cls_feat, tea_reg_feat, stu_cls_feat,...
    method align_scale (line 133) | def align_scale(self, stu_feat, tea_feat):
    method loss_by_feat (line 147) | def loss_by_feat(

FILE: mmdet/models/detectors/crosskd_gfl.py
  class CrossKDGFL (line 17) | class CrossKDGFL(CrossKDSingleStageDetector):
    method loss (line 19) | def loss(self, batch_inputs: Tensor,
    method forward_crosskd_single (line 55) | def forward_crosskd_single(self, x, scale, module):
    method reuse_teacher_head (line 72) | def reuse_teacher_head(self, tea_cls_feat, tea_reg_feat, stu_cls_feat,
    method align_scale (line 88) | def align_scale(self, stu_feat, tea_feat):
    method loss_by_feat (line 102) | def loss_by_feat(
    method pred_mimicking_loss_single (line 198) | def pred_mimicking_loss_single(self, tea_cls_score, tea_bbox_pred,

FILE: mmdet/models/detectors/crosskd_retinanet.py
  class CrossKDRetinaNet (line 17) | class CrossKDRetinaNet(CrossKDSingleStageDetector):
    method loss (line 19) | def loss(self, batch_inputs: Tensor,
    method forward_crosskd_single (line 53) | def forward_crosskd_single(self, x, module):
    method reuse_teacher_head (line 70) | def reuse_teacher_head(self, tea_cls_feat, tea_reg_feat, stu_cls_feat,
    method align_scale (line 86) | def align_scale(self, stu_feat, tea_feat):
    method loss_by_feat (line 100) | def loss_by_feat(
    method pred_mimicking_loss_single (line 192) | def pred_mimicking_loss_single(self, tea_cls_score, tea_bbox_pred,

FILE: mmdet/models/detectors/crosskd_single_stage.py
  class CrossKDSingleStageDetector (line 22) | class CrossKDSingleStageDetector(SingleStageDetector):
    method __init__ (line 46) | def __init__(
    method freeze (line 83) | def freeze(model: nn.Module):
    method cuda (line 89) | def cuda(self, device: Optional[str] = None) -> nn.Module:
    method to (line 95) | def to(self, device: Optional[str] = None) -> nn.Module:
    method train (line 101) | def train(self, mode: bool = True) -> None:
    method __setattr__ (line 106) | def __setattr__(self, name: str, value: Any) -> None:

FILE: mmdet/models/detectors/crowddet.py
  class CrowdDet (line 8) | class CrowdDet(TwoStageDetector):
    method __init__ (line 28) | def __init__(self,

FILE: mmdet/models/detectors/d2_wrapper.py
  function _to_cfgnode_list (line 26) | def _to_cfgnode_list(cfg: ConfigType,
  function convert_d2_pred_to_datasample (line 57) | def convert_d2_pred_to_datasample(data_samples: SampleList,
  class Detectron2Wrapper (line 97) | class Detectron2Wrapper(BaseDetector):
    method __init__ (line 111) | def __init__(self,
    method init_weights (line 127) | def init_weights(self) -> None:
    method loss (line 138) | def loss(self, batch_inputs: Tensor,
    method predict (line 166) | def predict(self, batch_inputs: Tensor,
    method _forward (line 206) | def _forward(self, *args, **kwargs):
    method extract_feat (line 215) | def extract_feat(self, *args, **kwargs):
    method _convert_to_d2_inputs (line 222) | def _convert_to_d2_inputs(self,

FILE: mmdet/models/detectors/dab_detr.py
  class DABDETR (line 15) | class DABDETR(DETR):
    method __init__ (line 31) | def __init__(self,
    method _init_layers (line 43) | def _init_layers(self) -> None:
    method init_weights (line 60) | def init_weights(self) -> None:
    method pre_decoder (line 69) | def pre_decoder(self, memory: Tensor) -> Tuple[Dict, Dict]:
    method forward_decoder (line 107) | def forward_decoder(self, query: Tensor, query_pos: Tensor, memory: Te...

FILE: mmdet/models/detectors/ddod.py
  class DDOD (line 8) | class DDOD(SingleStageDetector):
    method __init__ (line 26) | def __init__(self,

FILE: mmdet/models/detectors/deformable_detr.py
  class DeformableDETR (line 21) | class DeformableDETR(DetectionTransformer):
    method __init__ (line 41) | def __init__(self,
    method _init_layers (line 71) | def _init_layers(self) -> None:
    method init_weights (line 101) | def init_weights(self) -> None:
    method pre_transformer (line 119) | def pre_transformer(
    method forward_encoder (line 221) | def forward_encoder(self, feat: Tensor, feat_mask: Tensor,
    method pre_decoder (line 265) | def pre_decoder(self, memory: Tensor, memory_mask: Tensor,
    method forward_decoder (line 347) | def forward_decoder(self, query: Tensor, query_pos: Tensor, memory: Te...
    method get_valid_ratio (line 403) | def get_valid_ratio(mask: Tensor) -> Tensor:
    method gen_encoder_output_proposals (line 441) | def gen_encoder_output_proposals(
    method get_proposal_pos_embed (line 509) | def get_proposal_pos_embed(proposals: Tensor,

FILE: mmdet/models/detectors/detr.py
  class DETR (line 16) | class DETR(DetectionTransformer):
    method _init_layers (line 25) | def _init_layers(self) -> None:
    method init_weights (line 42) | def init_weights(self) -> None:
    method pre_transformer (line 50) | def pre_transformer(
    method forward_encoder (line 114) | def forward_encoder(self, feat: Tensor, feat_mask: Tensor,
    method pre_decoder (line 141) | def pre_decoder(self, memory: Tensor) -> Tuple[Dict, Dict]:
    method forward_decoder (line 178) | def forward_decoder(self, query: Tensor, query_pos: Tensor, memory: Te...

FILE: mmdet/models/detectors/dino.py
  class DINO (line 17) | class DINO(DeformableDETR):
    method __init__ (line 29) | def __init__(self, *args, dn_cfg: OptConfigType = None, **kwargs) -> N...
    method _init_layers (line 46) | def _init_layers(self) -> None:
    method init_weights (line 69) | def init_weights(self) -> None:
    method forward_transformer (line 83) | def forward_transformer(
    method pre_decoder (line 126) | def pre_decoder(
    method forward_decoder (line 216) | def forward_decoder(self,

FILE: mmdet/models/detectors/fast_rcnn.py
  class FastRCNN (line 8) | class FastRCNN(TwoStageDetector):
    method __init__ (line 11) | def __init__(self,

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

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

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

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

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

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

FILE: mmdet/models/detectors/htc.py
  class HybridTaskCascade (line 7) | class HybridTaskCascade(CascadeRCNN):
    method __init__ (line 10) | def __init__(self, **kwargs) -> None:
    method with_semantic (line 14) | def with_semantic(self) -> bool:

FILE: mmdet/models/detectors/kd_one_stage.py
  class KnowledgeDistillationSingleStageDetector (line 18) | class KnowledgeDistillationSingleStageDetector(SingleStageDetector):
    method __init__ (line 42) | def __init__(
    method loss (line 70) | def loss(self, batch_inputs: Tensor,
    method cuda (line 90) | def cuda(self, device: Optional[str] = None) -> nn.Module:
    method to (line 96) | def to(self, device: Optional[str] = None) -> nn.Module:
    method train (line 103) | def train(self, mode: bool = True) -> None:
    method __setattr__ (line 111) | def __setattr__(self, name: str, value: Any) -> None:

FILE: mmdet/models/detectors/lad.py
  class LAD (line 17) | class LAD(KnowledgeDistillationSingleStageDetector):
    method __init__ (line 20) | def __init__(self,
    method with_teacher_neck (line 52) | def with_teacher_neck(self) -> bool:
    method extract_teacher_feat (line 57) | def extract_teacher_feat(self, batch_inputs: Tensor) -> Tensor:
    method loss (line 64) | def loss(self, batch_inputs: Tensor,

FILE: mmdet/models/detectors/mask2former.py
  class Mask2Former (line 8) | class Mask2Former(MaskFormer):
    method __init__ (line 13) | def __init__(self,

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

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

FILE: mmdet/models/detectors/maskformer.py
  class MaskFormer (line 13) | class MaskFormer(SingleStageDetector):
    method __init__ (line 18) | def __init__(self,
    method loss (line 49) | def loss(self, batch_inputs: Tensor,
    method predict (line 66) | def predict(self,
    method add_pred_to_datasample (line 112) | def add_pred_to_datasample(self, data_samples: SampleList,
    method _forward (line 153) | def _forward(self, batch_inputs: Tensor,

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

FILE: mmdet/models/detectors/paa.py
  class PAA (line 8) | class PAA(SingleStageDetector):
    method __init__ (line 26) | def __init__(self,

FILE: mmdet/models/detectors/panoptic_fpn.py
  class PanopticFPN (line 8) | class PanopticFPN(TwoStagePanopticSegmentor):
    method __init__ (line 12) | def __init__(

FILE: mmdet/models/detectors/panoptic_two_stage_segmentor.py
  class TwoStagePanopticSegmentor (line 16) | class TwoStagePanopticSegmentor(TwoStageDetector):
    method __init__ (line 23) | def __init__(
    method with_semantic_head (line 62) | def with_semantic_head(self) -> bool:
    method with_panoptic_fusion_head (line 68) | def with_panoptic_fusion_head(self) -> bool:
    method loss (line 73) | def loss(self, batch_inputs: Tensor,
    method predict (line 126) | def predict(self,
    method _forward (line 175) | def _forward(self, batch_inputs: Tensor,
    method add_pred_to_datasample (line 215) | def add_pred_to_datasample(self, data_samples: SampleList,

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

FILE: mmdet/models/detectors/queryinst.py
  class QueryInst (line 8) | class QueryInst(SparseRCNN):
    method __init__ (line 12) | def __init__(self,

FILE: mmdet/models/detectors/reppoints_detector.py
  class RepPointsDetector (line 8) | class RepPointsDetector(SingleStageDetector):
    method __init__ (line 15) | def __init__(self,

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

FILE: mmdet/models/detectors/rpn.py
  class RPN (line 15) | class RPN(SingleStageDetector):
    method __init__ (line 32) | def __init__(self,
    method loss (line 58) | def loss(self, batch_inputs: Tensor,

FILE: mmdet/models/detectors/rtmdet.py
  class RTMDet (line 12) | class RTMDet(SingleStageDetector):
    method __init__ (line 31) | def __init__(self,

FILE: mmdet/models/detectors/scnet.py
  class SCNet (line 7) | class SCNet(CascadeRCNN):
    method __init__ (line 10) | def __init__(self, **kwargs) -> None:

FILE: mmdet/models/detectors/semi_base.py
  class SemiBaseDetector (line 19) | class SemiBaseDetector(BaseDetector):
    method __init__ (line 40) | def __init__(self,
    method freeze (line 56) | def freeze(model: nn.Module):
    method loss (line 62) | def loss(self, multi_batch_inputs: Dict[str, Tensor],
    method loss_by_gt_instances (line 92) | def loss_by_gt_instances(self, batch_inputs: Tensor,
    method loss_by_pseudo_instances (line 112) | def loss_by_pseudo_instances(self,
    method get_pseudo_instances (line 145) | def get_pseudo_instances(
    method project_pseudo_instances (line 161) | def project_pseudo_instances(self, batch_pseudo_instances: SampleList,
    method predict (line 175) | def predict(self, batch_inputs: Tensor,
    method _forward (line 209) | def _forward(self, batch_inputs: Tensor,
    method extract_feat (line 228) | def extract_feat(self, batch_inputs: Tensor) -> Tuple[Tensor]:
    method _load_from_state_dict (line 243) | def _load_from_state_dict(self, state_dict: dict, prefix: str,

FILE: mmdet/models/detectors/single_stage.py
  class SingleStageDetector (line 13) | class SingleStageDetector(BaseDetector):
    method __init__ (line 20) | def __init__(self,
    method _load_from_state_dict (line 39) | def _load_from_state_dict(self, state_dict: dict, prefix: str,
    method loss (line 63) | def loss(self, batch_inputs: Tensor,
    method predict (line 81) | def predict(self,
    method _forward (line 116) | def _forward(
    method extract_feat (line 136) | def extract_feat(self, batch_inputs: Tensor) -> Tuple[Tensor]:

FILE: mmdet/models/detectors/single_stage_instance_seg.py
  class SingleStageInstanceSegmentor (line 16) | class SingleStageInstanceSegmentor(BaseDetector):
    method __init__ (line 19) | def __init__(self,
    method extract_feat (line 51) | def extract_feat(self, batch_inputs: Tensor) -> Tuple[Tensor]:
    method _forward (line 66) | def _forward(self,
    method loss (line 101) | def loss(self, batch_inputs: Tensor, batch_data_samples: SampleList,
    method predict (line 134) | def predict(self,

FILE: mmdet/models/detectors/soft_teacher.py
  class SoftTeacher (line 20) | class SoftTeacher(SemiBaseDetector):
    method __init__ (line 38) | def __init__(self,
    method loss_by_pseudo_instances (line 51) | def loss_by_pseudo_instances(self,
    method get_pseudo_instances (line 87) | def get_pseudo_instances(
    method rpn_loss_by_pseudo_instances (line 137) | def rpn_loss_by_pseudo_instances(self, x: Tuple[Tensor],
    method rcnn_cls_loss_by_pseudo_instances (line 169) | def rcnn_cls_loss_by_pseudo_instances(self, x: Tuple[Tensor],
    method rcnn_reg_loss_by_pseudo_instances (line 259) | def rcnn_reg_loss_by_pseudo_instances(
    method compute_uncertainty_with_aug (line 290) | def compute_uncertainty_with_aug(
    method aug_box (line 358) | def aug_box(batch_data_samples, times, frac):

FILE: mmdet/models/detectors/solo.py
  class SOLO (line 8) | class SOLO(SingleStageInstanceSegmentor):
    method __init__ (line 14) | def __init__(self,

FILE: mmdet/models/detectors/solov2.py
  class SOLOv2 (line 8) | class SOLOv2(SingleStageInstanceSegmentor):
    method __init__ (line 14) | def __init__(self,

FILE: mmdet/models/detectors/sparse_rcnn.py
  class SparseRCNN (line 8) | class SparseRCNN(TwoStageDetector):
    method __init__ (line 12) | def __init__(self,

FILE: mmdet/models/detectors/tood.py
  class TOOD (line 8) | class TOOD(SingleStageDetector):
    method __init__ (line 27) | def __init__(self,

FILE: mmdet/models/detectors/trident_faster_rcnn.py
  class TridentFasterRCNN (line 11) | class TridentFasterRCNN(FasterRCNN):
    method __init__ (line 14) | def __init__(self,
    method _forward (line 38) | def _forward(self, batch_inputs: Tensor,
    method loss (line 47) | def loss(self, batch_inputs: Tensor,
    method predict (line 56) | def predict(self,
    method aug_test (line 70) | def aug_test(self, imgs, img_metas, rescale=False):

FILE: mmdet/models/detectors/two_stage.py
  class TwoStageDetector (line 16) | class TwoStageDetector(BaseDetector):
    method __init__ (line 23) | def __init__(self,
    method _load_from_state_dict (line 66) | def _load_from_state_dict(self, state_dict: dict, prefix: str,
    method with_rpn (line 91) | def with_rpn(self) -> bool:
    method with_roi_head (line 96) | def with_roi_head(self) -> bool:
    method extract_feat (line 100) | def extract_feat(self, batch_inputs: Tensor) -> Tuple[Tensor]:
    method _forward (line 115) | def _forward(self, batch_inputs: Tensor,
    method loss (line 146) | def loss(self, batch_inputs: Tensor,
    method predict (line 196) | def predict(self,

FILE: mmdet/models/detectors/vfnet.py
  class VFNet (line 8) | class VFNet(SingleStageDetector):
    method __init__ (line 27) | def __init__(self,

FILE: mmdet/models/detectors/yolact.py
  class YOLACT (line 8) | class YOLACT(SingleStageInstanceSegmentor):
    method __init__ (line 11) | def __init__(self,

FILE: mmdet/models/detectors/yolo.py
  class YOLOV3 (line 10) | class YOLOV3(SingleStageDetector):
    method __init__ (line 30) | def __init__(self,

FILE: mmdet/models/detectors/yolof.py
  class YOLOF (line 8) | class YOLOF(SingleStageDetector):
    method __init__ (line 28) | def __init__(self,

FILE: mmdet/models/detectors/yolox.py
  class YOLOX (line 8) | class YOLOX(SingleStageDetector):
    method __init__ (line 28) | def __init__(self,

FILE: mmdet/models/layers/activations.py
  class SiLU (line 12) | class SiLU(nn.Module):
    method __init__ (line 15) | def __init__(self, inplace=True):
    method forward (line 18) | def forward(self, inputs) -> torch.Tensor:

FILE: mmdet/models/layers/bbox_nms.py
  function multiclass_nms (line 12) | def multiclass_nms(
  function fast_nms (line 108) | def fast_nms(

FILE: mmdet/models/layers/brick_wrappers.py
  function adaptive_avg_pool2d (line 15) | def adaptive_avg_pool2d(input, output_size):
  class AdaptiveAvgPool2d (line 32) | class AdaptiveAvgPool2d(nn.AdaptiveAvgPool2d):
    method forward (line 35) | def forward(self, x):

FILE: mmdet/models/layers/conv_upsample.py
  class ConvUpsample (line 7) | class ConvUpsample(BaseModule):
    method __init__ (line 28) | def __init__(self,
    method forward (line 59) | def forward(self, x):

FILE: mmdet/models/layers/csp_layer.py
  class DarknetBottleneck (line 12) | class DarknetBottleneck(BaseModule):
    method __init__ (line 37) | def __init__(self,
    method forward (line 70) | def forward(self, x: Tensor) -> Tensor:
  class CSPNeXtBlock (line 82) | class CSPNeXtBlock(BaseModule):
    method __init__ (line 106) | def __init__(self,
    method forward (line 141) | def forward(self, x: Tensor) -> Tensor:
  class CSPLayer (line 153) | class CSPLayer(BaseModule):
    method __init__ (line 181) | def __init__(self,
    method forward (line 235) | def forward(self, x: Tensor) -> Tensor:

FILE: mmdet/models/layers/dropblock.py
  class DropBlock (line 12) | class DropBlock(nn.Module):
    method __init__ (line 26) | def __init__(self, drop_prob, block_size, warmup_iters=2000, **kwargs):
    method forward (line 36) | def forward(self, x):
    method _compute_gamma (line 63) | def _compute_gamma(self, feat_size):
    method extra_repr (line 84) | def extra_repr(self):

FILE: mmdet/models/layers/ema.py
  class ExpMomentumEMA (line 14) | class ExpMomentumEMA(ExponentialMovingAverage):
    method __init__ (line 37) | def __init__(self,
    method avg_func (line 53) | def avg_func(self, averaged_param: Tensor, source_param: Tensor,

FILE: mmdet/models/layers/inverted_residual.py
  class InvertedResidual (line 11) | class InvertedResidual(BaseModule):
    method __init__ (line 42) | def __init__(self,
    method forward (line 105) | def forward(self, x):

FILE: mmdet/models/layers/matrix_nms.py
  function mask_matrix_nms (line 5) | def mask_matrix_nms(masks,

FILE: mmdet/models/layers/msdeformattn_pixel_decoder.py
  class MSDeformAttnPixelDecoder (line 21) | class MSDeformAttnPixelDecoder(BaseModule):
    method __init__ (line 45) | def __init__(self,
    method init_weights (line 119) | def init_weights(self) -> None:
    method forward (line 144) | def forward(self, feats: List[Tensor]) -> Tuple[Tensor, Tensor]:

FILE: mmdet/models/layers/normed_predictor.py
  class NormedLinear (line 13) | class NormedLinear(nn.Linear):
    method __init__ (line 23) | def __init__(self,
    method init_weights (line 35) | def init_weights(self) -> None:
    method forward (line 41) | def forward(self, x: Tensor) -> Tensor:
  class NormedConv2d (line 52) | class NormedConv2d(nn.Conv2d):
    method __init__ (line 64) | def __init__(self,
    method forward (line 77) | def forward(self, x: Tensor) -> Tensor:

FILE: mmdet/models/layers/pixel_decoder.py
  class PixelDecoder (line 18) | class PixelDecoder(BaseModule):
    method __init__ (line 40) | def __init__(self,
    method init_weights (line 85) | def init_weights(self) -> None:
    method forward (line 94) | def forward(self, feats: List[Tensor],
  class TransformerEncoderPixelDecoder (line 125) | class TransformerEncoderPixelDecoder(PixelDecoder):
    method __init__ (line 146) | def __init__(self,
    method init_weights (line 184) | def init_weights(self) -> None:
    method forward (line 198) | def forward(self, feats: List[Tensor],

FILE: mmdet/models/layers/positional_encoding.py
  class SinePositionalEncoding (line 14) | class SinePositionalEncoding(BaseModule):
    method __init__ (line 39) | def __init__(self,
    method forward (line 59) | def forward(self, mask: Tensor) -> Tensor:
    method __repr__ (line 98) | def __repr__(self) -> str:
  class LearnedPositionalEncoding (line 110) | class LearnedPositionalEncoding(BaseModule):
    method __init__ (line 124) | def __init__(
    method forward (line 138) | def forward(self, mask: Tensor) -> Tensor:
    method __repr__ (line 162) | def __repr__(self) -> str:

FILE: mmdet/models/layers/res_layer.py
  class ResLayer (line 12) | class ResLayer(Sequential):
    method __init__ (line 31) | def __init__(self,
  class SimplifiedBasicBlock (line 112) | class SimplifiedBasicBlock(BaseModule):
    method __init__ (line 121) | def __init__(self,
    method norm1 (line 167) | def norm1(self) -> Optional[BaseModule]:
    method norm2 (line 172) | def norm2(self) -> Optional[BaseModule]:
    method forward (line 176) | def forward(self, x: Tensor) -> Tensor:

FILE: mmdet/models/layers/se_layer.py
  class SELayer (line 12) | class SELayer(BaseModule):
    method __init__ (line 31) | def __init__(self,
    method forward (line 59) | def forward(self, x: Tensor) -> Tensor:
  class DyReLU (line 67) | class DyReLU(BaseModule):
    method __init__ (line 93) | def __init__(self,
    method forward (line 126) | def forward(self, x: Tensor) -> Tensor:
  class ChannelAttention (line 138) | class ChannelAttention(BaseModule):
    method __init__ (line 147) | def __init__(self, channels: int, init_cfg: OptMultiConfig = None) -> ...
    method forward (line 156) | def forward(self, x: Tensor) -> Tensor:

FILE: mmdet/models/layers/transformer/conditional_detr_layers.py
  class ConditionalDetrTransformerDecoder (line 12) | class ConditionalDetrTransformerDecoder(DetrTransformerDecoder):
    method _init_layers (line 15) | def _init_layers(self) -> None:
    method forward (line 34) | def forward(self,
  class ConditionalDetrTransformerDecoderLayer (line 95) | class ConditionalDetrTransformerDecoderLayer(DetrTransformerDecoderLayer):
    method _init_layers (line 98) | def _init_layers(self):
    method forward (line 111) | def forward(self,

FILE: mmdet/models/layers/transformer/dab_detr_layers.py
  class DABDetrTransformerDecoderLayer (line 17) | class DABDetrTransformerDecoderLayer(DetrTransformerDecoderLayer):
    method _init_layers (line 20) | def _init_layers(self):
    method forward (line 34) | def forward(self,
  class DABDetrTransformerDecoder (line 100) | class DABDetrTransformerDecoder(DetrTransformerDecoder):
    method __init__ (line 113) | def __init__(self,
    method _init_layers (line 126) | def _init_layers(self):
    method forward (line 164) | def forward(self,
  class DABDetrTransformerEncoder (line 261) | class DABDetrTransformerEncoder(DetrTransformerEncoder):
    method _init_layers (line 264) | def _init_layers(self):
    method forward (line 274) | def forward(self, query: Tensor, query_pos: Tensor,

FILE: mmdet/models/layers/transformer/deformable_detr_layers.py
  class DeformableDetrTransformerEncoder (line 16) | class DeformableDetrTransformerEncoder(DetrTransformerEncoder):
    method _init_layers (line 19) | def _init_layers(self) -> None:
    method forward (line 27) | def forward(self, query: Tensor, query_pos: Tensor,
    method get_encoder_reference_points (line 68) | def get_encoder_reference_points(
  class DeformableDetrTransformerDecoder (line 106) | class DeformableDetrTransformerDecoder(DetrTransformerDecoder):
    method _init_layers (line 109) | def _init_layers(self) -> None:
    method forward (line 120) | def forward(self,
  class DeformableDetrTransformerEncoderLayer (line 222) | class DeformableDetrTransformerEncoderLayer(DetrTransformerEncoderLayer):
    method _init_layers (line 225) | def _init_layers(self) -> None:
  class DeformableDetrTransformerDecoderLayer (line 237) | class DeformableDetrTransformerDecoderLayer(DetrTransformerDecoderLayer):
    method _init_layers (line 240) | def _init_layers(self) -> None:

FILE: mmdet/models/layers/transformer/detr_layers.py
  class DetrTransformerEncoder (line 14) | class DetrTransformerEncoder(BaseModule):
    method __init__ (line 25) | def __init__(self,
    method _init_layers (line 35) | def _init_layers(self) -> None:
    method forward (line 43) | def forward(self, query: Tensor, query_pos: Tensor,
  class DetrTransformerDecoder (line 64) | class DetrTransformerDecoder(BaseModule):
    method __init__ (line 79) | def __init__(self,
    method _init_layers (line 92) | def _init_layers(self) -> None:
    method forward (line 102) | def forward(self, query: Tensor, key: Tensor, value: Tensor,
  class DetrTransformerEncoderLayer (line 142) | class DetrTransformerEncoderLayer(BaseModule):
    method __init__ (line 156) | def __init__(self,
    method _init_layers (line 182) | def _init_layers(self) -> None:
    method forward (line 193) | def forward(self, query: Tensor, query_pos: Tensor,
  class DetrTransformerDecoderLayer (line 221) | class DetrTransformerDecoderLayer(BaseModule):
    method __init__ (line 237) | def __init__(self,
    method _init_layers (line 280) | def _init_layers(self) -> None:
    method forward (line 292) | def forward(self,

FILE: mmdet/models/layers/transformer/dino_layers.py
  class DinoTransformerDecoder (line 16) | class DinoTransformerDecoder(DeformableDetrTransformerDecoder):
    method _init_layers (line 19) | def _init_layers(self) -> None:
    method forward (line 26) | def forward(self, query: Tensor, value: Tensor, key_padding_mask: Tensor,
  class CdnQueryGenerator (line 110) | class CdnQueryGenerator(BaseModule):
    method __init__ (line 137) | def __init__(self,
    method __call__ (line 177) | def __call__(self, batch_data_samples: SampleList) -> tuple:
    method get_num_groups (line 259) | def get_num_groups(self, max_num_target: int = None) -> int:
    method generate_dn_label_query (line 295) | def generate_dn_label_query(self, gt_labels: Tensor,
    method generate_dn_bbox_query (line 333) | def generate_dn_bbox_query(self, gt_bboxes: Tensor,
    method collate_dn_queries (line 425) | def collate_dn_queries(self, input_label_query: Tensor,
    method generate_dn_mask (line 494) | def generate_dn_mask(self, max_num_target: int, num_groups: int,

FILE: mmdet/models/layers/transformer/mask2former_layers.py
  class Mask2FormerTransformerEncoder (line 10) | class Mask2FormerTransformerEncoder(DeformableDetrTransformerEncoder):
    method forward (line 13) | def forward(self, query: Tensor, query_pos: Tensor,
  class Mask2FormerTransformerDecoder (line 56) | class Mask2FormerTransformerDecoder(DetrTransformerDecoder):
    method _init_layers (line 59) | def _init_layers(self) -> None:
  class Mask2FormerTransformerDecoderLayer (line 70) | class Mask2FormerTransformerDecoderLayer(DetrTransformerDecoderLayer):
    method forward (line 73) | def forward(self,

FILE: mmdet/models/layers/transformer/utils.py
  function nlc_to_nchw (line 19) | def nlc_to_nchw(x: Tensor, hw_shape: Sequence[int]) -> Tensor:
  function nchw_to_nlc (line 36) | def nchw_to_nlc(x):
  function coordinate_to_encoding (line 49) | def coordinate_to_encoding(coord_tensor: Tensor,
  function inverse_sigmoid (line 100) | def inverse_sigmoid(x: Tensor, eps: float = 1e-5) -> Tensor:
  class AdaptivePadding (line 116) | class AdaptivePadding(nn.Module):
    method __init__ (line 147) | def __init__(self, kernel_size=1, stride=1, dilation=1, padding='corne...
    method get_pad_shape (line 163) | def get_pad_shape(self, input_shape):
    method forward (line 175) | def forward(self, x):
  class PatchEmbed (line 188) | class PatchEmbed(BaseModule):
    method __init__ (line 216) | def __init__(self,
    method forward (line 288) | def forward(self, x: Tensor) -> Tuple[Tensor, Tuple[int]]:
  class PatchMerging (line 312) | class PatchMerging(BaseModule):
    method __init__ (line 343) | def __init__(self,
    method forward (line 392) | def forward(self, x: Tensor,
  class ConditionalAttention (line 441) | class ConditionalAttention(BaseModule):
    method __init__ (line 463) | def __init__(self,
    method _init_layers (line 488) | def _init_layers(self):
    method forward_attn (line 502) | def forward_attn(self,
    method forward (line 644) | def forward(self,
  class MLP (line 736) | class MLP(BaseModule):
    method __init__ (line 748) | def __init__(self, input_dim: int, hidden_dim: int, output_dim: int,
    method forward (line 756) | def forward(self, x: Tensor) -> Tensor:
  class DynamicConv (line 772) | class DynamicConv(BaseModule):
    method __init__ (line 799) | def __init__(self,
    method forward (line 833) | def forward(self, param_feature: Tensor, input_feature: Tensor) -> Ten...

FILE: mmdet/models/losses/accuracy.py
  function accuracy (line 5) | def accuracy(pred, target, topk=1, thresh=None):
  class Accuracy (line 52) | class Accuracy(nn.Module):
    method __init__ (line 54) | def __init__(self, topk=(1, ), thresh=None):
    method forward (line 67) | def forward(self, pred, target):

FILE: mmdet/models/losses/ae_loss.py
  function ae_loss_per_image (line 9) | def ae_loss_per_image(tl_preds, br_preds, match):
  class AssociativeEmbeddingLoss (line 73) | class AssociativeEmbeddingLoss(nn.Module):
    method __init__ (line 86) | def __init__(self, pull_weight=0.25, push_weight=0.25):
    method forward (line 91) | def forward(self, pred, target, match):

FILE: mmdet/models/losses/balanced_l1_loss.py
  function balanced_l1_loss (line 11) | def balanced_l1_loss(pred,
  class BalancedL1Loss (line 55) | class BalancedL1Loss(nn.Module):
    method __init__ (line 72) | def __init__(self,
    method forward (line 85) | def forward(self,

FILE: mmdet/models/losses/cross_entropy_loss.py
  function cross_entropy (line 12) | def cross_entropy(pred,
  function _expand_onehot_labels (line 64) | def _expand_onehot_labels(labels, label_weights, label_channels, ignore_...
  function binary_cross_entropy (line 85) | def binary_cross_entropy(pred,
  function mask_cross_entropy (line 148) | def mask_cross_entropy(pred,
  class CrossEntropyLoss (line 201) | class CrossEntropyLoss(nn.Module):
    method __init__ (line 203) | def __init__(self,
    method extra_repr (line 252) | def extra_repr(self):
    method forward (line 257) | def forward(self,

FILE: mmdet/models/losses/dice_loss.py
  function dice_loss (line 9) | def dice_loss(pred,
  class DiceLoss (line 66) | class DiceLoss(nn.Module):
    method __init__ (line 68) | def __init__(self,
    method forward (line 103) | def forward(self,

FILE: mmdet/models/losses/focal_loss.py
  function py_sigmoid_focal_loss (line 12) | def py_sigmoid_focal_loss(pred,
  function py_focal_loss_with_prob (line 60) | def py_focal_loss_with_prob(pred,
  function sigmoid_focal_loss (line 115) | def sigmoid_focal_loss(pred,
  class FocalLoss (line 162) | class FocalLoss(nn.Module):
    method __init__ (line 164) | def __init__(self,
    method forward (line 198) | def forward(self,

FILE: mmdet/models/losses/gaussian_focal_loss.py
  function gaussian_focal_loss (line 12) | def gaussian_focal_loss(pred: Tensor,
  function gaussian_focal_loss_with_pos_inds (line 40) | def gaussian_focal_loss_with_pos_inds(
  class GaussianFocalLoss (line 93) | class GaussianFocalLoss(nn.Module):
    method __init__ (line 112) | def __init__(self,
    method forward (line 127) | def forward(self,

FILE: mmdet/models/losses/gfocal_loss.py
  function quality_focal_loss (line 13) | def quality_focal_loss(pred, target, beta=2.0):
  function quality_focal_loss_tensor_target (line 57) | def quality_focal_loss_tensor_target(pred, target, beta=2.0, activated=F...
  function quality_focal_loss_with_prob (line 98) | def quality_focal_loss_with_prob(pred, target, beta=2.0):
  function distribution_focal_loss (line 144) | def distribution_focal_loss(pred, label):
  class QualityFocalLoss (line 169) | class QualityFocalLoss(nn.Module):
    method __init__ (line 187) | def __init__(self,
    method forward (line 201) | def forward(self,
  class DistributionFocalLoss (line 253) | class DistributionFocalLoss(nn.Module):
    method __init__ (line 263) | def __init__(self, reduction='mean', loss_weight=1.0):
    method forward (line 268) | def forward(self,

FILE: mmdet/models/losses/ghm_loss.py
  function _expand_onehot_labels (line 10) | def _expand_onehot_labels(labels, label_weights, label_channels):
  class GHMC (line 23) | class GHMC(nn.Module):
    method __init__ (line 39) | def __init__(self,
    method forward (line 60) | def forward(self,
  class GHMR (line 122) | class GHMR(nn.Module):
    method __init__ (line 138) | def __init__(self,
    method forward (line 158) | def forward(self,

FILE: mmdet/models/losses/iou_loss.py
  function iou_loss (line 16) | def iou_loss(pred: Tensor,
  function bounded_iou_loss (line 58) | def bounded_iou_loss(pred: Tensor,
  function giou_loss (line 111) | def giou_loss(pred: Tensor, target: Tensor, eps: float = 1e-7) -> Tensor:
  function diou_loss (line 130) | def diou_loss(pred: Tensor, target: Tensor, eps: float = 1e-7) -> Tensor:
  function ciou_loss (line 185) | def ciou_loss(pred: Tensor, target: Tensor, eps: float = 1e-7) -> Tensor:
  function eiou_loss (line 250) | def eiou_loss(pred: Tensor,
  class IoULoss (line 307) | class IoULoss(nn.Module):
    method __init__ (line 322) | def __init__(self,
    method forward (line 341) | def forward(self,
  class BoundedIoULoss (line 393) | class BoundedIoULoss(nn.Module):
    method __init__ (line 407) | def __init__(self,
    method forward (line 418) | def forward(self,
  class GIoULoss (line 463) | class GIoULoss(nn.Module):
    method __init__ (line 473) | def __init__(self,
    method forward (line 482) | def forward(self,
  class DIoULoss (line 532) | class DIoULoss(nn.Module):
    method __init__ (line 544) | def __init__(self,
    method forward (line 553) | def forward(self,
  class CIoULoss (line 603) | class CIoULoss(nn.Module):
    method __init__ (line 616) | def __init__(self,
    method forward (line 625) | def forward(self,
  class EIoULoss (line 675) | class EIoULoss(nn.Module):
    method __init__ (line 689) | def __init__(self,
    method forward (line 700) | def forward(self,

FILE: mmdet/models/losses/kd_loss.py
  function knowledge_distillation_kl_div_loss (line 11) | def knowledge_distillation_kl_div_loss(pred,
  function kd_quality_focal_loss (line 44) | def kd_quality_focal_loss(pred,
  class KnowledgeDistillationKLDivLoss (line 63) | class KnowledgeDistillationKLDivLoss(nn.Module):
    method __init__ (line 72) | def __init__(self,
    method forward (line 84) | def forward(self,
  class KDQualityFocalLoss (line 121) | class KDQualityFocalLoss(nn.Module):
    method __init__ (line 123) | def __init__(self,
    method forward (line 135) | def forward(self,

FILE: mmdet/models/losses/mse_loss.py
  function mse_loss (line 13) | def mse_loss(pred: Tensor, target: Tensor) -> Tensor:
  class MSELoss (line 26) | class MSELoss(nn.Module):
    method __init__ (line 35) | def __init__(self,
    method forward (line 42) | def forward(self,

FILE: mmdet/models/losses/pisa_loss.py
  function isr_p (line 13) | def isr_p(cls_score: Tensor,
  function carl_loss (line 126) | def carl_loss(cls_score: Tensor,

FILE: mmdet/models/losses/pkd_loss.py
  function norm (line 10) | def norm(feat: torch.Tensor) -> torch.Tensor:
  function pkd_loss (line 27) | def pkd_loss(pred, target):
  class PKDLoss (line 34) | class PKDLoss(nn.Module):
    method __init__ (line 36) | def __init__(self, reduction='mean', loss_weight=1.0):
    method forward (line 41) | def forward(self,

FILE: mmdet/models/losses/seesaw_loss.py
  function seesaw_ce_loss (line 15) | def seesaw_ce_loss(cls_score: Tensor,
  class SeesawLoss (line 83) | class SeesawLoss(nn.Module):
    method __init__ (line 106) | def __init__(self,
    method _split_cls_score (line 141) | def _split_cls_score(self, cls_score: Tensor) -> Tuple[Tensor, Tensor]:
    method get_cls_channels (line 157) | def get_cls_channels(self, num_classes: int) -> int:
    method get_activation (line 169) | def get_activation(self, cls_score: Tensor) -> Tensor:
    method get_accuracy (line 189) | def get_accuracy(self, cls_score: Tensor,
    method forward (line 212) | def forward(

FILE: mmdet/models/losses/smooth_l1_loss.py
  function smooth_l1_loss (line 13) | def smooth_l1_loss(pred: Tensor, target: Tensor, beta: float = 1.0) -> T...
  function l1_loss (line 37) | def l1_loss(pred: Tensor, target: Tensor) -> Tensor:
  class SmoothL1Loss (line 56) | class SmoothL1Loss(nn.Module):
    method __init__ (line 67) | def __init__(self,
    method forward (line 76) | def forward(self,
  class L1Loss (line 114) | class L1Loss(nn.Module):
    method __init__ (line 123) | def __init__(self,
    method forward (line 130) | def forward(self,

FILE: mmdet/models/losses/utils.py
  function reduce_loss (line 10) | def reduce_loss(loss: Tensor, reduction: str) -> Tensor:
  function weight_reduce_loss (line 30) | def weight_reduce_loss(loss: Tensor,
  function weighted_loss (line 68) | def weighted_loss(loss_func: Callable) -> Callable:

FILE: mmdet/models/losses/varifocal_loss.py
  function varifocal_loss (line 12) | def varifocal_loss(pred: Tensor,
  class VarifocalLoss (line 64) | class VarifocalLoss(nn.Module):
    method __init__ (line 66) | def __init__(self,
    method forward (line 101) | def forward(self,

FILE: mmdet/models/necks/bfp.py
  class BFP (line 15) | class BFP(BaseModule):
    method __init__ (line 40) | def __init__(
    method forward (line 79) | def forward(self, inputs: Tuple[Tensor]) -> Tuple[Tensor]:

FILE: mmdet/models/necks/channel_mapper.py
  class ChannelMapper (line 14) | class ChannelMapper(BaseModule):
    method __init__ (line 50) | def __init__(
    method forward (line 96) | def forward(self, inputs: Tuple[Tensor]) -> Tuple[Tensor]:

FILE: mmdet/models/necks/cspnext_pafpn.py
  class CSPNeXtPAFPN (line 17) | class CSPNeXtPAFPN(BaseModule):
    method __init__ (line 41) | def __init__(
    method forward (line 131) | def forward(self, inputs: Tuple[Tensor, ...]) -> Tuple[Tensor, ...]:

FILE: mmdet/models/necks/ct_resnet_neck.py
  class CTResNetNeck (line 15) | class CTResNetNeck(BaseModule):
    method __init__ (line 29) | def __init__(self,
    method _make_deconv_layer (line 43) | def _make_deconv_layer(
    method init_weights (line 71) | def init_weights(self) -> None:
    method forward (line 98) | def forward(self, x: Sequence[torch.Tensor]) -> Tuple[torch.Tensor]:

FILE: mmdet/models/necks/dilated_encoder.py
  class Bottleneck (line 10) | class Bottleneck(nn.Module):
    method __init__ (line 24) | def __init__(self,
    method forward (line 42) | def forward(self, x):
  class DilatedEncoder (line 52) | class DilatedEncoder(nn.Module):
    method __init__ (line 68) | def __init__(self, in_channels, out_channels, block_mid_channels,
    method _init_layers (line 78) | def _init_layers(self):
    method init_weights (line 95) | def init_weights(self):
    method forward (line 106) | def forward(self, feature):

FILE: mmdet/models/necks/dyhead.py
  class DyDCNv2 (line 16) | class DyDCNv2(nn.Module):
    method __init__ (line 31) | def __init__(self,
    method forward (line 44) | def forward(self, x, offset, mask):
  class DyHeadBlock (line 52) | class DyHeadBlock(nn.Module):
    method __init__ (line 68) | def __init__(self,
    method _init_weights (line 90) | def _init_weights(self):
    method forward (line 97) | def forward(self, x):
  class DyHead (line 129) | class DyHead(BaseModule):
    method __init__ (line 145) | def __init__(self,
    method forward (line 169) | def forward(self, inputs):

FILE: mmdet/models/necks/fpg.py
  class Transition (line 10) | class Transition(BaseModule):
    method __init__ (line 18) | def __init__(self, in_channels, out_channels, init_cfg=None):
    method forward (line 23) | def forward(x):
  class UpInterpolationConv (line 27) | class UpInterpolationConv(Transition):
    method __init__ (line 43) | def __init__(self,
    method forward (line 63) | def forward(self, x):
  class LastConv (line 73) | class LastConv(Transition):
    method __init__ (line 83) | def __init__(self,
    method forward (line 99) | def forward(self, inputs):
  class FPG (line 105) | class FPG(BaseModule):
    method __init__ (line 150) | def __init__(self,
    method build_trans (line 317) | def build_trans(self, cfg, in_channels, out_channels, **extra_args):
    method fuse (line 323) | def fuse(self, fuse_dict):
    method forward (line 333) | def forward(self, inputs):

FILE: mmdet/models/necks/fpn.py
  class FPN (line 15) | class FPN(BaseModule):
    method __init__ (line 70) | def __init__(
    method forward (line 161) | def forward(self, inputs: Tuple[Tensor]) -> tuple:

FILE: mmdet/models/necks/fpn_carafe.py
  class FPN_CARAFE (line 11) | class FPN_CARAFE(BaseModule):
    method __init__ (line 37) | def __init__(self,
    method init_weights (line 209) | def init_weights(self):
    method slice_as (line 219) | def slice_as(self, src, dst):
    method tensor_add (line 239) | def tensor_add(self, a, b):
    method forward (line 247) | def forward(self, inputs):

FILE: mmdet/models/necks/hrfpn.py
  class HRFPN (line 13) | class HRFPN(BaseModule):
    method __init__ (line 33) | def __init__(self,
    method forward (line 77) | def forward(self, inputs):

FILE: mmdet/models/necks/nas_fpn.py
  class NASFPN (line 15) | class NASFPN(BaseModule):
    method __init__ (line 38) | def __init__(
    method forward (line 132) | def forward(self, inputs: Tuple[Tensor]) -> tuple:

FILE: mmdet/models/necks/nasfcos_fpn.py
  class NASFCOS_FPN (line 12) | class NASFCOS_FPN(BaseModule):
    method __init__ (line 35) | def __init__(self,
    method forward (line 123) | def forward(self, inputs):
    method init_weights (line 157) | def init_weights(self):

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

FILE: mmdet/models/necks/rfp.py
  class ASPP (line 11) | class ASPP(BaseModule):
    method __init__ (line 25) | def __init__(self,
    method forward (line 47) | def forward(self, x):
  class RFP (line 59) | class RFP(FPN):
    method __init__ (line 77) | def __init__(self,
    method init_weights (line 104) | def init_weights(self):
    method forward (line 116) | def forward(self, inputs):

FILE: mmdet/models/necks/ssd_neck.py
  class SSDNeck (line 11) | class SSDNeck(BaseModule):
    method __init__ (line 33) | def __init__(self,
    method forward (line 93) | def forward(self, inputs):
  class L2Norm (line 106) | class L2Norm(nn.Module):
    method __init__ (line 108) | def __init__(self, n_dims, scale=20., eps=1e-10):
    method forward (line 123) | def forward(self, x):

FILE: mmdet/models/necks/ssh.py
  class SSHContextModule (line 13) | class SSHContextModule(BaseModule):
    method __init__ (line 31) | def __init__(self,
    method forward (line 84) | def forward(self, x: torch.Tensor) -> tuple:
  class SSHDetModule (line 93) | class SSHDetModule(BaseModule):
    method __init__ (line 111) | def __init__(self,
    method forward (line 139) | def forward(self, x: torch.Tensor) -> torch.Tensor:
  class SSH (line 149) | class SSH(BaseModule):
    method __init__ (line 183) | def __init__(self,
    method forward (line 207) | def forward(self, inputs: Tuple[torch.Tensor]) -> tuple:

FILE: mmdet/models/necks/yolo_neck.py
  class DetectionBlock (line 15) | class DetectionBlock(BaseModule):
    method __init__ (line 38) | def __init__(self,
    method forward (line 59) | def forward(self, x: Tensor) -> Tensor:
  class YOLOV3Neck (line 69) | class YOLOV3Neck(BaseModule):
    method __init__ (line 96) | def __init__(self,
    method forward (line 125) | def forward(self, feats=Tuple[Tensor]) -> Tuple[Tensor]:

FILE: mmdet/models/necks/yolox_pafpn.py
  class YOLOXPAFPN (line 14) | class YOLOXPAFPN(BaseModule):
    method __init__ (line 35) | def __init__(self,
    method forward (line 117) | def forward(self, inputs):

FILE: mmdet/models/roi_heads/base_roi_head.py
  class BaseRoIHead (line 13) | class BaseRoIHead(BaseModule, metaclass=ABCMeta):
    method __init__ (line 16) | def __init__(self,
    method with_bbox (line 40) | def with_bbox(self) -> bool:
    method with_mask (line 45) | def with_mask(self) -> bool:
    method with_shared_head (line 50) | def with_shared_head(self) -> bool:
    method init_bbox_head (line 55) | def init_bbox_head(self, *args, **kwargs):
    method init_mask_head (line 60) | def init_mask_head(self, *args, **kwargs):
    method init_assigner_sampler (line 65) | def init_assigner_sampler(self, *args, **kwargs):
    method loss (line 70) | def loss(self, x: Tuple[Tensor], rpn_results_list: InstanceList,
    method predict (line 75) | def predict(self,

FILE: mmdet/models/roi_heads/bbox_heads/bbox_head.py
  class BBoxHead (line 23) | class BBoxHead(BaseModule):
    method __init__ (line 27) | def __init__(self,
    method custom_cls_channels (line 110) | def custom_cls_channels(self) -> bool:
    method custom_activation (line 116) | def custom_activation(self) -> bool:
    method custom_accuracy (line 122) | def custom_accuracy(self) -> bool:
    method forward (line 126) | def forward(self, x: Tuple[Tensor]) -> tuple:
    method _get_targets_single (line 155) | def _get_targets_single(self, pos_priors: Tensor, neg_priors: Tensor,
    method get_targets (line 225) | def get_targets(self,
    method loss_and_target (line 285) | def loss_and_target(self,
    method loss (line 333) | def loss(self,
    method predict_by_feat (line 425) | def predict_by_feat(self,
    method _predict_by_feat_single (line 476) | def _predict_by_feat_single(
    method refine_bboxes (line 573) | def refine_bboxes(self, sampling_results: Union[List[SamplingResult],
    method regress_by_class (line 680) | def regress_by_class(self, priors: Tensor, label: Tensor,

FILE: mmdet/models/roi_heads/bbox_heads/convfc_bbox_head.py
  class ConvFCBBoxHead (line 14) | class ConvFCBBoxHead(BBoxHead):
    method __init__ (line 25) | def __init__(self,
    method _add_conv_fc_branch (line 122) | def _add_conv_fc_branch(self,
    method forward (line 163) | def forward(self, x: Tuple[Tensor]) -> tuple:
  class Shared2FCBBoxHead (line 221) | class Shared2FCBBoxHead(ConvFCBBoxHead):
    method __init__ (line 223) | def __init__(self, fc_out_channels: int = 1024, *args, **kwargs) -> None:
  class Shared4Conv1FCBBoxHead (line 237) | class Shared4Conv1FCBBoxHead(ConvFCBBoxHead):
    method __init__ (line 239) | def __init__(self, fc_out_channels: int = 1024, *args, **kwargs) -> None:

FILE: mmdet/models/roi_heads/bbox_heads/dii_head.py
  class DIIHead (line 21) | class DIIHead(BBoxHead):
    method __init__ (line 52) | def __init__(self,
    method init_weights (line 131) | def init_weights(self) -> None:
    method forward (line 146) | def forward(self, roi_feat: Tensor, proposal_feat: Tensor) -> tuple:
    method loss_and_target (line 206) | def loss_and_target(self,
    method _get_targets_single (line 286) | def _get_targets_single(self, pos_inds: Tensor, neg_inds: Tensor,
    method get_targets (line 362) | def get_targets(self,

FILE: mmdet/models/roi_heads/bbox_heads/double_bbox_head.py
  class BasicResBlock (line 15) | class BasicResBlock(BaseModule):
    method __init__ (line 32) | def __init__(self,
    method forward (line 69) | def forward(self, x: Tensor) -> Tensor:
  class DoubleConvFCBBoxHead (line 84) | class DoubleConvFCBBoxHead(BBoxHead):
    method __init__ (line 98) | def __init__(self,
    method _add_conv_branch (line 143) | def _add_conv_branch(self) -> None:
    method _add_fc_branch (line 155) | def _add_fc_branch(self) -> None:
    method forward (line 165) | def forward(self, x_cls: Tensor, x_reg: Tensor) -> Tuple[Tensor]:

FILE: mmdet/models/roi_heads/bbox_heads/multi_instance_bbox_head.py
  class MultiInstanceBBoxHead (line 20) | class MultiInstanceBBoxHead(BBoxHead):
    method __init__ (line 57) | def __init__(self,
    method _add_conv_fc_branch (line 182) | def _add_conv_fc_branch(self,
    method forward (line 219) | def forward(self, x: Tuple[Tensor]) -> tuple:
    method get_targets (line 303) | def get_targets(self,
    method loss (line 382) | def loss(self, cls_score: Tensor, bbox_pred: Tensor, rois: Tensor,
    method emd_loss (line 430) | def emd_loss(self, bbox_pred_0: Tensor, cls_score_0: Tensor,
    method _predict_by_feat_single (line 491) | def _predict_by_feat_single(
    method set_nms (line 573) | def set_nms(bboxes: Tensor,

FILE: mmdet/models/roi_heads/bbox_heads/sabl_head.py
  class SABLHead (line 23) | class SABLHead(BBoxHead):
    method __init__ (line 66) | def __init__(self,
    method _add_fc_branch (line 217) | def _add_fc_branch(self, num_branch_fcs: int, in_channels: int,
    method cls_forward (line 228) | def cls_forward(self, cls_x: Tensor) -> Tensor:
    method attention_pool (line 236) | def attention_pool(self, reg_x: Tensor) -> tuple:
    method side_aware_feature_extractor (line 249) | def side_aware_feature_extractor(self, reg_x: Tensor) -> tuple:
    method reg_pred (line 270) | def reg_pred(self, x: Tensor, offset_fcs: nn.ModuleList,
    method side_aware_split (line 289) | def side_aware_split(self, feat: Tensor) -> Tensor:
    method bbox_pred_split (line 301) | def bbox_pred_split(self, bbox_pred: tuple,
    method reg_forward (line 311) | def reg_forward(self, reg_x: Tensor) -> tuple:
    method forward (line 331) | def forward(self, x: Tensor) -> tuple:
    method get_targets (line 338) | def get_targets(self,
    method bucket_target (line 361) | def bucket_target(self,
    method _bucket_target_single (line 389) | def _bucket_target_single(self, pos_proposals: Tensor,
    method loss (line 452) | def loss(self,
    method _predict_by_feat_single (line 525) | def _predict_by_feat_single(
    method refine_bboxes (line 597) | def refine_bboxes(self, sampling_results: List[SamplingResult],
    method regress_by_class (line 660) | def regress_by_class(self, rois: Tensor, label: Tensor, bbox_pred: tuple,

FILE: mmdet/models/roi_heads/bbox_heads/scnet_bbox_head.py
  class SCNetBBoxHead (line 11) | class SCNetBBoxHead(ConvFCBBoxHead):
    method _forward_shared (line 18) | def _forward_shared(self, x: Tensor) -> Tensor:
    method _forward_cls_reg (line 42) | def _forward_cls_reg(self, x: Tensor) -> Tuple[Tensor]:
    method forward (line 80) | def forward(

FILE: mmdet/models/roi_heads/cascade_roi_head.py
  class CascadeRoIHead (line 22) | class CascadeRoIHead(BaseRoIHead):
    method __init__ (line 28) | def __init__(self,
    method init_bbox_head (line 56) | def init_bbox_head(self, bbox_roi_extractor: MultiConfig,
    method init_mask_head (line 79) | def init_mask_head(self, mask_roi_extractor: MultiConfig,
    method init_assigner_sampler (line 108) | def init_assigner_sampler(self) -> None:
    method _bbox_forward (line 122) | def _bbox_forward(self, stage: int, x: Tuple[Tensor],
    method bbox_loss (line 150) | def bbox_loss(self, stage: int, x: Tuple[Tensor],
    method _mask_forward (line 187) | def _mask_forward(self, stage: int, x: Tuple[Tensor],
    method mask_loss (line 212) | def mask_loss(self, stage: int, x: Tuple[Tensor],
    method loss (line 245) | def loss(self, x: Tuple[Tensor], rpn_results_list: InstanceList,
    method predict_bbox (line 323) | def predict_bbox(self,
    method predict_mask (line 383) | def predict_mask(self,
    method _refine_roi (line 446) | def _refine_roi(self, x: Tuple[Tensor], rois: Tensor,
    method forward (line 522) | def forward(self, x: Tuple[Tensor], rpn_results_list: InstanceList,

FILE: mmdet/models/roi_heads/double_roi_head.py
  class DoubleHeadRoIHead (line 11) | class DoubleHeadRoIHead(StandardRoIHead):
    method __init__ (line 19) | def __init__(self, reg_roi_scale_factor: float, **kwargs):
    method _bbox_forward (line 23) | def _bbox_forward(self, x: Tuple[Tensor], rois: Tensor) -> dict:

FILE: mmdet/models/roi_heads/dynamic_roi_head.py
  class DynamicRoIHead (line 21) | class DynamicRoIHead(StandardRoIHead):
    method __init__ (line 24) | def __init__(self, **kwargs) -> None:
    method loss (line 32) | def loss(self, x: Tuple[Tensor], rpn_results_list: InstanceList,
    method bbox_loss (line 98) | def bbox_loss(self, x: Tuple[Tensor],
    method update_hyperparameters (line 142) | def update_hyperparameters(self):

FILE: mmdet/models/roi_heads/grid_roi_head.py
  class GridRoIHead (line 17) | class GridRoIHead(StandardRoIHead):
    method __init__ (line 26) | def __init__(self, grid_roi_extractor: ConfigType, grid_head: ConfigType,
    method _random_jitter (line 38) | def _random_jitter(self,
    method forward (line 78) | def forward(self,
    method loss (line 125) | def loss(self, x: Tuple[Tensor], rpn_results_list: InstanceList,
    method bbox_loss (line 179) | def bbox_loss(self,
    method predict_bbox (line 230) | def predict_bbox(self,

FILE: mmdet/models/roi_heads/htc_roi_head.py
  class HybridTaskCascadeRoIHead (line 20) | class HybridTaskCascadeRoIHead(CascadeRoIHead):
    method __init__ (line 40) | def __init__(self,
    method with_semantic (line 66) | def with_semantic(self) -> bool:
    method _bbox_forward (line 71) | def _bbox_forward(
    method bbox_loss (line 110) | def bbox_loss(self,
    method _mask_forward (line 152) | def _mask_forward(self,
    method mask_loss (line 221) | def mask_loss(self,
    method loss (line 263) | def loss(self, x: Tuple[Tensor], rpn_results_list: InstanceList,
    method predict (line 382) | def predict(self,
    method predict_mask (line 448) | def predict_mask(self,
    method forward (line 520) | def forward(self, x: Tuple[Tensor], rpn_results_list: InstanceList,

FILE: mmdet/models/roi_heads/mask_heads/coarse_mask_head.py
  class CoarseMaskHead (line 12) | class CoarseMaskHead(FCNMaskHead):
    method __init__ (line 28) | def __init__(self,
    method init_weights (line 86) | def init_weights(self) -> None:
    method forward (line 90) | def forward(self, x: Tensor) -> Tensor:

FILE: mmdet/models/roi_heads/mask_heads/dynamic_mask_head.py
  class DynamicMaskHead (line 16) | class DynamicMaskHead(FCNMaskHead):
    method __init__ (line 47) | def __init__(self,
    method init_weights (line 90) | def init_weights(self) -> None:
    method forward (line 98) | def forward(self, roi_feat: Tensor, proposal_feat: Tensor) -> Tensor:
    method loss_and_target (line 129) | def loss_and_target(self, mask_preds: Tensor,

FILE: mmdet/models/roi_heads/mask_heads/fcn_mask_head.py
  class FCNMaskHead (line 29) | class FCNMaskHead(BaseModule):
    method __init__ (line 31) | def __init__(self,
    method init_weights (line 121) | def init_weights(self) -> None:
    method forward (line 134) | def forward(self, x: Tensor) -> Tensor:
    method get_targets (line 152) | def get_targets(self, sampling_results: List[SamplingResult],
    method loss_and_target (line 178) | def loss_and_target(self, mask_preds: Tensor,
    method predict_by_feat (line 218) | def predict_by_feat(self,
    method _predict_by_feat_single (line 278) | def _predict_by_feat_single(self,
  function _do_paste_mask (line 400) | def _do_paste_mask(masks: Tensor,

FILE: mmdet/models/roi_heads/mask_heads/feature_relay_head.py
  class FeatureRelayHead (line 13) | class FeatureRelayHead(BaseModule):
    method __init__ (line 28) | def __init__(
    method forward (line 50) | def forward(self, x: Tensor) -> Optional[Tensor]:

FILE: mmdet/models/roi_heads/mask_heads/fused_semantic_head.py
  class FusedSemanticHead (line 17) | class FusedSemanticHead(BaseModule):
    method __init__ (line 33) | def __init__(
    method forward (line 102) | def forward(self, feats: Tuple[Tensor]) -> Tuple[Tensor]:
    method loss (line 130) | def loss(self, mask_preds: Tensor, labels: Tensor) -> Tensor:

FILE: mmdet/models/roi_heads/mask_heads/global_context_head.py
  class GlobalContextHead (line 15) | class GlobalContextHead(BaseModule):
    method __init__ (line 37) | def __init__(
    method forward (line 89) | def forward(self, feats: Tuple[Tensor]) -> Tuple[Tensor]:
    method loss (line 112) | def loss(self, pred: Tensor, labels: List[Tensor]) -> Tensor:

FILE: mmdet/models/roi_heads/mask_heads/grid_head.py
  class GridHead (line 20) | class GridHead(BaseModule):
    method __init__ (line 44) | def __init__(
    method forward (line 185) | def forward(self, x: Tensor) -> Dict[str, Tensor]:
    method calc_sub_regions (line 233) | def calc_sub_regions(self) -> List[Tuple[float]]:
    method get_targets (line 264) | def get_targets(self, sampling_results: List[SamplingResult],
    method loss (line 344) | def loss(self, grid_pred: Tensor, sample_idx: Tensor,
    method predict_by_feat (line 367) | def predict_by_feat(self,
    method _predict_by_feat_single (line 409) | def _predict_by_feat_single(self,

FILE: mmdet/models/roi_heads/mask_heads/htc_mask_head.py
  class HTCMaskHead (line 12) | class HTCMaskHead(FCNMaskHead):
    method __init__ (line 20) | def __init__(self, with_conv_res: bool = True, *args, **kwargs) -> None:
    method forward (line 31) | def forward(self,

FILE: mmdet/models/roi_heads/mask_heads/mask_point_head.py
  class MaskPointHead (line 23) | class MaskPointHead(BaseModule):
    method __init__ (line 50) | def __init__(
    method forward (line 97) | def forward(self, fine_grained_feats: Tensor,
    method get_targets (line 119) | def get_targets(self, rois: Tensor, rel_roi_points: Tensor,
    method _get_targets_single (line 162) | def _get_targets_single(self, rois: Tensor, rel_roi_points: Tensor,
    method loss_and_target (line 183) | def loss_and_target(self, point_pred: Tensor, rel_roi_points: Tensor,
    method get_roi_rel_points_train (line 217) | def get_roi_rel_points_train(self, mask_preds: Tensor, labels: Tensor,
    method get_roi_rel_points_test (line 243) | def get_roi_rel_points_test(self, mask_preds: Tensor, label_preds: Ten...

FILE: mmdet/models/roi_heads/mask_heads/maskiou_head.py
  class MaskIoUHead (line 20) | class MaskIoUHead(BaseModule):
    method __init__ (line 42) | def __init__(
    method forward (line 94) | def forward(self, mask_feat: Tensor, mask_preds: Tensor) -> Tensor:
    method loss_and_target (line 117) | def loss_and_target(self, mask_iou_pred: Tensor, mask_preds: Tensor,
    method get_targets (line 157) | def get_targets(self, sampling_results: List[SamplingResult],
    method _get_area_ratio (line 209) | def _get_area_ratio(self, pos_proposals: Tensor,
    method predict_by_feat (line 249) | def predict_by_feat(self, mask_iou_preds: Tuple[Tensor],

FILE: mmdet/models/roi_heads/mask_heads/scnet_mask_head.py
  class SCNetMaskHead (line 8) | class SCNetMaskHead(FCNMaskHead):
    method __init__ (line 16) | def __init__(self, conv_to_res: bool = True, **kwargs) -> None:

FILE: mmdet/models/roi_heads/mask_heads/scnet_semantic_head.py
  class SCNetSemanticHead (line 8) | class SCNetSemanticHead(FusedSemanticHead):
    method __init__ (line 16) | def __init__(self, conv_to_res: bool = True, **kwargs) -> None:

FILE: mmdet/models/roi_heads/mask_scoring_roi_head.py
  class MaskScoringRoIHead (line 17) | class MaskScoringRoIHead(StandardRoIHead):
    method __init__ (line 26) | def __init__(self, mask_iou_head: ConfigType, **kwargs):
    method forward (line 31) | def forward(self,
    method mask_loss (line 76) | def mask_loss(self, x: Tuple[Tensor],
    method predict_mask (line 147) | def predict_mask(self,

FILE: mmdet/models/roi_heads/multi_instance_roi_head.py
  class MultiInstanceRoIHead (line 16) | class MultiInstanceRoIHead(StandardRoIHead):
    method __init__ (line 19) | def __init__(self, num_instance: int = 2, *args, **kwargs) -> None:
    method init_bbox_head (line 23) | def init_bbox_head(self, bbox_roi_extractor: ConfigType,
    method _bbox_forward (line 35) | def _bbox_forward(self, x: Tuple[Tensor], rois: Tensor) -> dict:
    method bbox_loss (line 72) | def bbox_loss(self, x: Tuple[Tensor],
    method loss (line 120) | def loss(self, x: Tuple[Tensor], rpn_results_list: InstanceList,
    method predict_bbox (line 164) | def predict_bbox(self,

FILE: mmdet/models/roi_heads/pisa_roi_head.py
  class PISARoIHead (line 17) | class PISARoIHead(StandardRoIHead):
    method loss (line 21) | def loss(self, x: Tuple[Tensor], rpn_results_list: InstanceList,
    method bbox_loss (line 79) | def bbox_loss(self,

FILE: mmdet/models/roi_heads/point_rend_roi_head.py
  class PointRendRoIHead (line 19) | class PointRendRoIHead(StandardRoIHead):
    method __init__ (line 22) | def __init__(self, point_head: ConfigType, *args, **kwargs) -> None:
    method init_point_head (line 27) | def init_point_head(self, point_head: ConfigType) -> None:
    method mask_loss (line 31) | def mask_loss(self, x: Tuple[Tensor],
    method _mask_point_loss (line 52) | def _mask_point_loss(self, x: Tuple[Tensor],
    method _mask_point_forward_test (line 78) | def _mask_point_forward_test(self, x: Tuple[Tensor], rois: Tensor,
    method _get_fine_grained_point_feats (line 130) | def _get_fine_grained_point_feats(self, x: Tuple[Tensor], rois: Tensor,
    method predict_mask (line 170) | def predict_mask(self,

FILE: mmdet/models/roi_heads/roi_extractors/base_roi_extractor.py
  class BaseRoIExtractor (line 14) | class BaseRoIExtractor(BaseModule, metaclass=ABCMeta):
    method __init__ (line 26) | def __init__(self,
    method num_inputs (line 37) | def num_inputs(self) -> int:
    method build_roi_layers (line 41) | def build_roi_layers(self, layer_cfg: ConfigType,
    method roi_rescale (line 67) | def roi_rescale(self, rois: Tensor, scale_factor: float) -> Tensor:
    method forward (line 92) | def forward(self,

FILE: mmdet/models/roi_heads/roi_extractors/generic_roi_extractor.py
  class GenericRoIExtractor (line 13) | class GenericRoIExtractor(BaseRoIExtractor):
    method __init__ (line 30) | def __init__(self,
    method forward (line 48) | def forward(self,

FILE: mmdet/models/roi_heads/roi_extractors/single_level_roi_extractor.py
  class SingleRoIExtractor (line 13) | class SingleRoIExtractor(BaseRoIExtractor):
    method __init__ (line 31) | def __init__(self,
    method map_roi_levels (line 44) | def map_roi_levels(self, rois: Tensor, num_levels: int) -> Tensor:
    method forward (line 65) | def forward(self,

FILE: mmdet/models/roi_heads/scnet_roi_head.py
  class SCNetRoIHead (line 20) | class SCNetRoIHead(CascadeRoIHead):
    method __init__ (line 32) | def __init__(self,
    method init_mask_head (line 57) | def init_mask_head(self, mask_roi_extractor: ConfigType,
    method with_semantic (line 66) | def with_semantic(self) -> bool:
    method with_feat_relay (line 72) | def with_feat_relay(self) -> bool:
    method with_glbctx (line 78) | def with_glbctx(self) -> bool:
    method _fuse_glbctx (line 82) | def _fuse_glbctx(self, roi_feats: Tensor, glbctx_feat: Tensor,
    method _slice_pos_feats (line 106) | def _slice_pos_feats(self, feats: Tensor,
    method _bbox_forward (line 128) | def _bbox_forward(self,
    method _mask_forward (line 173) | def _mask_forward(self,
    method bbox_loss (line 213) | def bbox_loss(self,
    method mask_loss (line 261) | def mask_loss(self,
    method semantic_loss (line 303) | def semantic_loss(self, x: Tuple[Tensor],
    method global_context_loss (line 331) | def global_context_loss(self, x: Tuple[Tensor],
    method loss (line 357) | def loss(self, x: Tensor, rpn_results_list: InstanceList,
    method predict (line 464) | def predict(self,
    method predict_mask (line 537) | def predict_mask(self,
    method forward (line 611) | def forward(self, x: Tuple[Tensor], rpn_results_list: InstanceList,

FILE: mmdet/models/roi_heads/shared_heads/res_layer.py
  class ResLayer (line 13) | class ResLayer(BaseModule):
    method __init__ (line 15) | def __init__(self,
    method forward (line 69) | def forward(self, x):
    method train (line 74) | def train(self, mode=True):

FILE: mmdet/models/roi_heads/sparse_roi_head.py
  class SparseRoIHead (line 19) | class SparseRoIHead(CascadeRoIHead):
    method __init__ (line 44) | def __init__(self,
    method bbox_loss (line 93) | def bbox_loss(self, stage: int, x: Tuple[Tensor],
    method _bbox_forward (line 173) | def _bbox_forward(self, stage: int, x: Tuple[Tensor], rois: Tensor,
    method _mask_forward (line 248) | def _mask_forward(self, stage: int, x: Tuple[Tensor], rois: Tensor,
    method mask_loss (line 276) | def mask_loss(self, stage: int, x: Tuple[Tensor], bbox_results: dict,
    method loss (line 316) | def loss(self, x: Tuple[Tensor], rpn_results_list: InstanceList,
    method predict_bbox (line 372) | def predict_bbox(self,
    method predict_mask (line 460) | def predict_mask(self,
    method forward (line 545) | def forward(self, x: Tuple[Tensor], rpn_results_list: InstanceList,

FILE: mmdet/models/roi_heads/standard_roi_head.py
  class StandardRoIHead (line 17) | class StandardRoIHead(BaseRoIHead):
    method init_assigner_sampler (line 20) | def init_assigner_sampler(self) -> None:
    method init_bbox_head (line 29) | def init_bbox_head(self, bbox_roi_extractor: ConfigType,
    method init_mask_head (line 41) | def init_mask_head(self, mask_roi_extractor: ConfigType,
    method forward (line 59) | def forward(self,
    method loss (line 94) | def loss(self, x: Tuple[Tensor], rpn_results_list: InstanceList,
    method _bbox_forward (line 147) | def _bbox_forward(self, x: Tuple[Tensor], rois: Tensor) -> dict:
    method bbox_loss (line 173) | def bbox_loss(self, x: Tuple[Tensor],
    method mask_loss (line 203) | def mask_loss(self, x: Tuple[Tensor],
    method _mask_forward (line 257) | def _mask_forward(self,
    method predict_bbox (line 293) | def predict_bbox(self,
    method predict_mask (line 365) | def predict_mask(self,

FILE: mmdet/models/roi_heads/test_mixins.py
  class BBoxTestMixin (line 15) | class BBoxTestMixin:
    method async_test_bboxes (line 19) | async def async_test_bboxes(self,
    method aug_test_bboxes (line 52) | def aug_test_bboxes(self, feats, img_metas, rpn_results_list,
  class MaskTestMixin (line 94) | class MaskTestMixin:
    method async_test_mask (line 98) | async def async_test_mask(self,
    method aug_test_mask (line 141) | def aug_test_mask(self, feats, img_metas, det_bboxes, det_labels):

FILE: mmdet/models/roi_heads/trident_roi_head.py
  class TridentRoIHead (line 16) | class TridentRoIHead(StandardRoIHead):
    method __init__ (line 26) | def __init__(self, num_branch: int, test_branch_idx: int,
    method merge_trident_bboxes (line 32) | def merge_trident_bboxes(self,
    method predict (line 63) | def predict(self,

FILE: mmdet/models/seg_heads/base_semantic_head.py
  class BaseSemanticHead (line 15) | class BaseSemanticHead(BaseModule, metaclass=ABCMeta):
    method __init__ (line 29) | def __init__(self,
    method forward (line 43) | def forward(self, x: Union[Tensor, Tuple[Tensor]]) -> Dict[str, Tensor]:
    method loss (line 57) | def loss(self, x: Union[Tensor, Tuple[Tensor]],
    method predict (line 74) | def predict(self,

FILE: mmdet/models/seg_heads/panoptic_fpn_head.py
  class PanopticFPNHead (line 19) | class PanopticFPNHead(BaseSemanticHead):
    method __init__ (line 46) | def __init__(self,
    method _set_things_to_void (line 87) | def _set_things_to_void(self, gt_semantic_seg: Tensor) -> Tensor:
    method loss (line 108) | def loss(self, x: Union[Tensor, Tuple[Tensor]],
    method init_weights (line 146) | def init_weights(self) -> None:
    method forward (line 152) | def forward(self, x: Tuple[Tensor]) -> Dict[str, Tensor]:

FILE: mmdet/models/seg_heads/panoptic_fusion_heads/base_panoptic_fusion_head.py
  class BasePanopticFusionHead (line 11) | class BasePanopticFusionHead(BaseModule, metaclass=ABCMeta):
    method __init__ (line 14) | def __init__(self,
    method with_loss (line 33) | def with_loss(self) -> bool:
    method loss (line 38) | def loss(self, **kwargs):
    method predict (line 42) | def predict(self, **kwargs):

FILE: mmdet/models/seg_heads/panoptic_fusion_heads/heuristic_fusion_head.py
  class HeuristicFusionHead (line 15) | class HeuristicFusionHead(BasePanopticFusionHead):
    method __init__ (line 18) | def __init__(self,
    method loss (line 32) | def loss(self, **kwargs) -> dict:
    method _lay_masks (line 36) | def _lay_masks(self,
    method _predict_single (line 95) | def _predict_single(self, mask_results: InstanceData, seg_preds: Tensor,
    method predict (line 140) | def predict(self, mask_results_list: InstanceList,

FILE: mmdet/models/seg_heads/panoptic_fusion_heads/maskformer_fusion_head.py
  class MaskFormerFusionHead (line 18) | class MaskFormerFusionHead(BasePanopticFusionHead):
    method __init__ (line 22) | def __init__(self,
    method loss (line 37) | def loss(self, **kwargs):
    method panoptic_postprocess (line 41) | def panoptic_postprocess(self, mask_cls: Tensor,
    method semantic_postprocess (line 108) | def semantic_postprocess(self, mask_cls: Tensor,
    method instance_postprocess (line 126) | def instance_postprocess(self, mask_cls: Tensor,
    method predict (line 184) | def predict(self,

FILE: mmdet/models/task_modules/assigners/approx_max_iou_assigner.py
  class ApproxMaxIoUAssigner (line 14) | class ApproxMaxIoUAssigner(MaxIoUAssigner):
    method __init__ (line 46) | def __init__(
    method assign (line 68) | def assign(self,

FILE: mmdet/models/task_modules/assigners/assign_result.py
  class AssignResult (line 8) | class AssignResult(util_mixins.NiceRepr):
    method __init__ (line 41) | def __init__(self, num_gts: int, gt_inds: Tensor, max_overlaps: Tensor,
    method num_preds (line 51) | def num_preds(self):
    method set_extra_property (line 55) | def set_extra_property(self, key, value):
    method get_extra_property (line 60) | def get_extra_property(self, key):
    method info (line 65) | def info(self):
    method __nice__ (line 77) | def __nice__(self):
    method random (line 97) | def random(cls, **kwargs):
    method add_gt_ (line 185) | def add_gt_(self, gt_labels):

FILE: mmdet/models/task_modules/assigners/atss_assigner.py
  function bbox_center_distance (line 15) | def bbox_center_distance(bboxes: Tensor, priors: Tensor) -> Tensor:
  class ATSSAssigner (line 40) | class ATSSAssigner(BaseAssigner):
    method __init__ (line 63) | def __init__(self,
    method assign (line 74) | def assign(

FILE: mmdet/models/task_modules/assigners/base_assigner.py
  class BaseAssigner (line 8) | class BaseAssigner(metaclass=ABCMeta):
    method assign (line 12) | def assign(self,

FILE: mmdet/models/task_modules/assigners/center_region_assigner.py
  function scale_boxes (line 14) | def scale_boxes(bboxes: Tensor, scale: float) -> Tensor:
  function is_located_in (line 41) | def is_located_in(points: Tensor, bboxes: Tensor) -> Tensor:
  function bboxes_area (line 60) | def bboxes_area(bboxes: Tensor) -> Tensor:
  class CenterRegionAssigner (line 77) | class CenterRegionAssigner(BaseAssigner):
    method __init__ (line 101) | def __init__(
    method get_gt_priorities (line 117) | def get_gt_priorities(self, gt_bboxes: Tensor) -> Tensor:
    method assign (line 135) | def assign(self,
    method assign_one_hot_gt_indices (line 286) | def assign_one_hot_gt_indices(

FILE: mmdet/models/task_modules/assigners/dynamic_soft_label_assigner.py
  function center_of_mass (line 19) | def center_of_mass(masks: Tensor, eps: float = 1e-7) -> Tensor:
  class DynamicSoftLabelAssigner (line 40) | class DynamicSoftLabelAssigner(BaseAssigner):
    method __init__ (line 54) | def __init__(
    method assign (line 66) | def assign(self,
    method dynamic_k_matching (line 186) | def dynamic_k_matching(self, cost: Tensor, pairwise_ious: Tensor,

FILE: mmdet/models/task_modules/assigners/grid_assigner.py
  class GridAssigner (line 14) | class GridAssigner(BaseAssigner):
    method __init__ (line 38) | def __init__(
    method assign (line 52) | def assign(self,

FILE: mmdet/models/task_modules/assigners/hungarian_assigner.py
  class HungarianAssigner (line 16) | class HungarianAssigner(BaseAssigner):
    method __init__ (line 36) | def __init__(
    method assign (line 51) | def assign(self,

FILE: mmdet/models/task_modules/assigners/iou2d_calculator.py
  function cast_tensor_type (line 8) | def cast_tensor_type(x, scale=1., dtype=None):
  class BboxOverlaps2D (line 16) | class BboxOverlaps2D:
    method __init__ (line 19) | def __init__(self, scale=1., dtype=None):
    method __call__ (line 23) | def __call__(self, bboxes1, bboxes2, mode='iou', is_aligned=False):
    method __repr__ (line 64) | def __repr__(self):

FILE: mmdet/models/task_modules/assigners/match_cost.py
  class BaseMatchCost (line 14) | class BaseMatchCost:
    method __init__ (line 21) | def __init__(self, weight: Union[float, int] = 1.) -> None:
    method __call__ (line 25) | def __call__(self,
  class BBoxL1Cost (line 52) | class BBoxL1Cost(BaseMatchCost):
    method __init__ (line 75) | def __init__(self,
    method __call__ (line 82) | def __call__(self,
  class IoUCost (line 120) | class IoUCost(BaseMatchCost):
    method __init__ (line 142) | def __init__(self, iou_mode: str = 'giou', weight: Union[float, int] =...
    method __call__ (line 146) | def __call__(self,
  class ClassificationCost (line 175) | class ClassificationCost(BaseMatchCost):
    method __init__ (line 196) | def __init__(self, weight: Union[float, int] = 1) -> None:
    method __call__ (line 199) | def __call__(self,
  class FocalLossCost (line 227) | class FocalLossCost(BaseMatchCost):
    method __init__ (line 240) | def __init__(self,
    method _focal_loss_cost (line 252) | def _focal_loss_cost(self, cls_pred: Tensor, gt_labels: Tensor) -> Ten...
    method _mask_focal_loss_cost (line 271) | def _mask_focal_loss_cost(self, cls_pred, gt_labels) -> Tensor:
    method __call__ (line 296) | def __call__(self,
  class DiceCost (line 324) | class DiceCost(BaseMatchCost):
    method __init__ (line 338) | def __init__(self,
    method _binary_mask_dice_loss (line 348) | def _binary_mask_dice_loss(self, mask_preds: Tensor,
    method __call__ (line 372) | def __call__(self,
  class CrossEntropyLossCost (line 399) | class CrossEntropyLossCost(BaseMatchCost):
    method __init__ (line 408) | def __init__(self,
    method _binary_cross_entropy (line 414) | def _binary_cross_entropy(self, cls_pred: Tensor,
    method __call__ (line 439) | def __call__(self,

FILE: mmdet/models/task_modules/assigners/max_iou_assigner.py
  class MaxIoUAssigner (line 14) | class MaxIoUAssigner(BaseAssigner):
    method __init__ (line 50) | def __init__(self,
    method assign (line 70) | def assign(self,
    method assign_wrt_overlaps (line 162) | def assign_wrt_overlaps(self, overlaps: Tensor,

FILE: mmdet/models/task_modules/assigners/multi_instance_assigner.py
  class MultiInstanceAssigner (line 13) | class MultiInstanceAssigner(MaxIoUAssigner):
    method __init__ (line 22) | def __init__(self, num_instance: int = 2, **kwargs):
    method assign (line 26) | def assign(self,

FILE: mmdet/models/task_modules/assigners/point_assigner.py
  class PointAssigner (line 13) | class PointAssigner(BaseAssigner):
    method __init__ (line 23) | def __init__(self, scale: int = 4, pos_num: int = 3) -> None:
    method assign (line 27) | def assign(self,

FILE: mmdet/models/task_modules/assigners/region_assigner.py
  function calc_region (line 14) | def calc_region(
  function anchor_ctr_inside_region_flags (line 35) | def anchor_ctr_inside_region_flags(anchors: Tensor, stride: int,
  class RegionAssigner (line 47) | class RegionAssigner(BaseAssigner):
    method __init__ (line 63) | def __init__(self,
    method assign (line 69) | def assign(self,

FILE: mmdet/models/task_modules/assigners/sim_ota_assigner.py
  class SimOTAAssigner (line 19) | class SimOTAAssigner(BaseAssigner):
    method __init__ (line 35) | def __init__(self,
    method assign (line 47) | def assign(self,
    method get_in_gt_and_in_center_info (line 145) | def get_in_gt_and_in_center_info(
    method dynamic_k_matching (line 192) | def dynamic_k_matching(self, cost: Tensor, pairwise_ious: Tensor,

FILE: mmdet/models/task_modules/assigners/task_aligned_assigner.py
  class TaskAlignedAssigner (line 16) | class TaskAlignedAssigner(BaseAssigner):
    method __init__ (line 34) | def __init__(self,
    method assign (line 41) | def assign(self,

FILE: mmdet/models/task_modules/assigners/uniform_assigner.py
  class UniformAssigner (line 15) | class UniformAssigner(BaseAssigner):
    method __init__ (line 29) | def __init__(self,
    method assign (line 39) | def assign(

FILE: mmdet/models/task_modules/builder.py
  function build_bbox_coder (line 15) | def build_bbox_coder(cfg, **default_args):
  function build_iou_calculator (line 22) | def build_iou_calculator(cfg, default_args=None):
  function build_match_cost (line 30) | def build_match_cost(cfg, default_args=None):
  function build_assigner (line 37) | def build_assigner(cfg, **default_args):
  function build_sampler (line 44) | def build_sampler(cfg, **default_args):
  function build_prior_generator (line 51) | def build_prior_generator(cfg, default_args=None):
  function build_anchor_generator (line 58) | def build_anchor_generator(cfg, default_args=None):

FILE: mmdet/models/task_modules/coders/base_bbox_coder.py
  class BaseBBoxCoder (line 5) | class BaseBBoxCoder(metaclass=ABCMeta):
    method __init__ (line 16) | def __init__(self, use_box_type: bool = False, **kwargs):
    method encode (line 20) | def encode(self, bboxes, gt_bboxes):
    method decode (line 24) | def decode(self, bboxes, bboxes_pred):

FILE: mmdet/models/task_modules/coders/bucketing_bbox_coder.py
  class BucketingBBoxCoder (line 12) | class BucketingBBoxCoder(BaseBBoxCoder):
    method __init__ (line 34) | def __init__(self,
    method encode (line 50) | def encode(self, bboxes, gt_bboxes):
    method decode (line 74) | def decode(self, bboxes, pred_bboxes, max_shape=None):
  function generat_buckets (line 100) | def generat_buckets(proposals, num_buckets, scale_factor=1.0):
  function bbox2bucket (line 148) | def bbox2bucket(proposals,
  function bucket2bbox (line 271) | def bucket2bbox(proposals,

FILE: mmdet/models/task_modules/coders/delta_xywh_bbox_coder.py
  class DeltaXYWHBBoxCoder (line 13) | class DeltaXYWHBBoxCoder(BaseBBoxCoder):
    method __init__ (line 34) | def __init__(self,
    method encode (line 48) | def encode(self, bboxes, gt_bboxes):
    method decode (line 68) | def decode(self,
  function bbox2delta (line 126) | def bbox2delta(proposals, gt, means=(0., 0., 0., 0.), stds=(1., 1., 1., ...
  function delta2bbox (line 171) | def delta2bbox(rois,
  function onnx_delta2bbox (line 270) | def onnx_delta2bbox(rois,

FILE: mmdet/models/task_modules/coders/distance_point_bbox_coder.py
  class DistancePointBBoxCoder (line 9) | class DistancePointBBoxCoder(BaseBBoxCoder):
    method __init__ (line 20) | def __init__(self, clip_border=True, **kwargs):
    method encode (line 24) | def encode(self, points, gt_bboxes, max_dis=None, eps=0.1):
    method decode (line 44) | def decode(self, points, pred_bboxes, max_shape=None):

FILE: mmdet/models/task_modules/coders/legacy_delta_xywh_bbox_coder.py
  class LegacyDeltaXYWHBBoxCoder (line 11) | class LegacyDeltaXYWHBBoxCoder(BaseBBoxCoder):
    method __init__ (line 34) | def __init__(self,
    method encode (line 42) | def encode(self, bboxes, gt_bboxes):
    method decode (line 63) | def decode(self,
  function legacy_bbox2delta (line 94) | def legacy_bbox2delta(proposals,
  function legacy_delta2bbox (line 142) | def legacy_delta2bbox(rois,

FILE: mmdet/models/task_modules/coders/pseudo_bbox_coder.py
  class PseudoBBoxCoder (line 8) | class PseudoBBoxCoder(BaseBBoxCoder):
    method __init__ (line 11) | def __init__(self, **kwargs):
    method encode (line 14) | def encode(self, bboxes, gt_bboxes):
    method decode (line 19) | def decode(self, bboxes, pred_bboxes):

FILE: mmdet/models/task_modules/coders/tblr_bbox_coder.py
  class TBLRBBoxCoder (line 10) | class TBLRBBoxCoder(BaseBBoxCoder):
    method __init__ (line 26) | def __init__(self, normalizer=4.0, clip_border=True, **kwargs):
    method encode (line 31) | def encode(self, bboxes, gt_bboxes):
    method decode (line 53) | def decode(self, bboxes, pred_bboxes, max_shape=None):
  function bboxes2tblr (line 83) | def bboxes2tblr(priors, gts, normalizer=4.0, normalize_by_wh=True):
  function tblr2bboxes (line 129) | def tblr2bboxes(priors,

FILE: mmdet/models/task_modules/coders/yolo_bbox_coder.py
  class YOLOBBoxCoder (line 10) | class YOLOBBoxCoder(BaseBBoxCoder):
    method __init__ (line 22) | def __init__(self, eps=1e-6, **kwargs):
    method encode (line 26) | def encode(self, bboxes, gt_bboxes, stride):
    method decode (line 62) | def decode(self, bboxes, pred_bboxes, stride):

FILE: mmdet/models/task_modules/prior_generators/anchor_generator.py
  class AnchorGenerator (line 18) | class AnchorGenerator:
    method __init__ (line 69) | def __init__(self,
    method num_base_anchors (line 126) | def num_base_anchors(self) -> List[int]:
    method num_base_priors (line 131) | def num_base_priors(self) -> List[int]:
    method num_levels (line 137) | def num_levels(self) -> int:
    method gen_base_anchors (line 141) | def gen_base_anchors(self) -> List[Tensor]:
    method gen_single_level_base_anchors (line 161) | def gen_single_level_base_anchors(self,
    method _meshgrid (line 207) | def _meshgrid(self,
    method grid_priors (line 230) | def grid_priors(self,
    method single_level_grid_priors (line 259) | def single_level_grid_priors(self,
    method sparse_priors (line 303) | def sparse_priors(self,
    method grid_anchors (line 338) | def grid_anchors(self,
    method single_level_grid_anchors (line 370) | def single_level_grid_anchors(self,
    method valid_flags (line 415) | def valid_flags(self,
    method single_level_valid_flags (line 446) | def single_level_valid_flags(self,
    method __repr__ (line 478) | def __repr__(self) -> str:
  class SSDAnchorGenerator (line 498) | class SSDAnchorGenerator(AnchorGenerator):
    method __init__ (line 521) | def __init__(self,
    method gen_base_anchors (line 602) | def gen_base_anchors(self) -> List[Tensor]:
    method __repr__ (line 623) | def __repr__(self) -> str:
  class LegacyAnchorGenerator (line 641) | class LegacyAnchorGenerator(AnchorGenerator):
    method gen_single_level_base_anchors (line 692) | def gen_single_level_base_anchors(self,
  class LegacySSDAnchorGenerator (line 744) | class LegacySSDAnchorGenerator(SSDAnchorGenerator, LegacyAnchorGenerator):
    method __init__ (line 751) | def __init__(self,
  class YOLOAnchorGenerator (line 771) | class YOLOAnchorGenerator(AnchorGenerator):
    method __init__ (line 781) | def __init__(self,
    method num_levels (line 798) | def num_levels(self) -> int:
    method gen_base_anchors (line 802) | def gen_base_anchors(self) -> List[Tensor]:
    method gen_single_level_base_anchors (line 819) | def gen_single_level_base_anchors(self,

FILE: mmdet/models/task_modules/prior_generators/point_generator.py
  class PointGenerator (line 15) | class PointGenerator:
    method _meshgrid (line 17) | def _meshgrid(self,
    method grid_points (line 39) | def grid_points(self,
    method valid_flags (line 63) | def valid_flags(self,
  class MlvlPointGenerator (line 92) | class MlvlPointGenerator:
    method __init__ (line 103) | def __init__(self,
    method num_levels (line 110) | def num_levels(self) -> int:
    method num_base_priors (line 115) | def num_base_priors(self) -> List[int]:
    method _meshgrid (line 120) | def _meshgrid(self,
    method grid_priors (line 133) | def grid_priors(self,
    method single_level_grid_priors (line 173) | def single_level_grid_priors(self,
    method valid_flags (line 231) | def valid_flags(self,
    method single_level_valid_flags (line 263) | def single_level_valid_flags(self,
    method sparse_priors (line 292) | def sparse_priors(self,

FILE: mmdet/models/task_modules/prior_generators/utils.py
  function anchor_inside_flags (line 10) | def anchor_inside_flags(flat_anchors: Tensor,
  function calc_region (line 45) | def calc_region(bbox: Tensor,

FILE: mmdet/models/task_modules/samplers/base_sampler.py
  class BaseSampler (line 12) | class BaseSampler(metaclass=ABCMeta):
    method __init__ (line 24) | def __init__(self,
    method _sample_pos (line 38) | def _sample_pos(self, assign_result: AssignResult, num_expected: int,
    method _sample_neg (line 44) | def _sample_neg(self, assign_result: AssignResult, num_expected: int,
    method sample (line 49) | def sample(self, assign_result: AssignResult, pred_instances: Instance...

FILE: mmdet/models/task_modules/samplers/combined_sampler.py
  class CombinedSampler (line 7) | class CombinedSampler(BaseSampler):
    method __init__ (line 10) | def __init__(self, pos_sampler, neg_sampler, **kwargs):
    method _sample_pos (line 15) | def _sample_pos(self, **kwargs):
    method _sample_neg (line 19) | def _sample_neg(self, **kwargs):

FILE: mmdet/models/task_modules/samplers/instance_balanced_pos_sampler.py
  class InstanceBalancedPosSampler (line 10) | class InstanceBalancedPosSampler(RandomSampler):
    method _sample_pos (line 14) | def _sample_pos(self, assign_result, num_expected, **kwargs):

FILE: mmdet/models/task_modules/samplers/iou_balanced_neg_sampler.py
  class IoUBalancedNegSampler (line 10) | class IoUBalancedNegSampler(RandomSampler):
    method __init__ (line 30) | def __init__(self,
    method sample_via_interval (line 47) | def sample_via_interval(self, max_overlaps, full_set, num_expected):
    method _sample_neg (line 89) | def _sample_neg(self, assign_result, num_expected, **kwargs):

FILE: mmdet/models/task_modules/samplers/mask_pseudo_sampler.py
  class MaskPseudoSampler (line 15) | class MaskPseudoSampler(BaseSampler):
    method __init__ (line 18) | def __init__(self, **kwargs):
    method _sample_pos (line 21) | def _sample_pos(self, **kwargs):
    method _sample_neg (line 25) | def _sample_neg(self, **kwargs):
    method sample (line 29) | def sample(self, assign_result: AssignResult, pred_instances: Instance...

FILE: mmdet/models/task_modules/samplers/mask_sampling_result.py
  class MaskSamplingResult (line 12) | class MaskSamplingResult(SamplingResult):
    method __init__ (line 15) | def __init__(self,
    method masks (line 45) | def masks(self) -> Tensor:
    method __nice__ (line 49) | def __nice__(self) -> str:
    method info (line 58) | def info(self) -> dict:

FILE: mmdet/models/task_modules/samplers/multi_instance_random_sampler.py
  class MultiInsRandomSampler (line 16) | class MultiInsRandomSampler(RandomSampler):
    method _sample_pos (line 26) | def _sample_pos(self, assign_result: AssignResult, num_expected: int,
    method _sample_neg (line 46) | def _sample_neg(self, assign_result: AssignResult, num_expected: int,
    method sample (line 66) | def sample(self, assign_result: AssignResult, pred_instances: Instance...

FILE: mmdet/models/task_modules/samplers/multi_instance_sampling_result.py
  class MultiInstanceSamplingResult (line 9) | class MultiInstanceSamplingResult(SamplingResult):
    method __init__ (line 27) | def __init__(self,

FILE: mmdet/models/task_modules/samplers/ohem_sampler.py
  class OHEMSampler (line 10) | class OHEMSampler(BaseSampler):
    method __init__ (line 16) | def __init__(self,
    method hard_mining (line 34) | def hard_mining(self, inds, num_expected, bboxes, labels, feats):
    method _sample_pos (line 55) | def _sample_pos(self,
    method _sample_neg (line 83) | def _sample_neg(self,

FILE: mmdet/models/task_modules/samplers/pseudo_sampler.py
  class PseudoSampler (line 12) | class PseudoSampler(BaseSampler):
    method __init__ (line 15) | def __init__(self, **kwargs):
    method _sample_pos (line 18) | def _sample_pos(self, **kwargs):
    method _sample_neg (line 22) | def _sample_neg(self, **kwargs):
    method sample (line 26) | def sample(self, assign_result: AssignResult, pred_instances: Instance...

FILE: mmdet/models/task_modules/samplers/random_sampler.py
  class RandomSampler (line 14) | class RandomSampler(BaseSampler):
    method __init__ (line 26) | def __init__(self,
    method random_choice (line 40) | def random_choice(self, gallery: Union[Tensor, ndarray, list],
    method _sample_pos (line 73) | def _sample_pos(self, assign_result: AssignResult, num_expected: int,
    method _sample_neg (line 92) | def _sample_neg(self, assign_result: AssignResult, num_expected: int,

FILE: mmdet/models/task_modules/samplers/sampling_result.py
  function random_boxes (line 14) | def random_boxes(num=1, scale=1, rng=None):
  class SamplingResult (line 51) | class SamplingResult(util_mixins.NiceRepr):
    method __init__ (line 86) | def __init__(self,
    method priors (line 119) | def priors(self):
    method bboxes (line 124) | def bboxes(self):
    method pos_bboxes (line 131) | def pos_bboxes(self):
    method neg_bboxes (line 137) | def neg_bboxes(self):
    method to (line 142) | def to(self, device):
    method __nice__ (line 157) | def __nice__(self):
    method info (line 166) | def info(self):
    method random (line 182) | def random(cls, rng=None, **kwargs):

FILE: mmdet/models/task_modules/samplers/score_hlr_sampler.py
  class ScoreHLRSampler (line 18) | class ScoreHLRSampler(BaseSampler):
    method __init__ (line 41) | def __init__(self,
    method random_choice (line 75) | def random_choice(gallery: Union[Tensor, ndarray, list],
    method _sample_pos (line 105) | def _sample_pos(self, assign_result: AssignResult, num_expected: int,
    method _sample_neg (line 122) | def _sample_neg(self, assign_result: AssignResult, num_expected: int,
    method sample (line 236) | def sample(self, assign_result: AssignResult, pred_instances: Instance...

FILE: mmdet/models/test_time_augs/det_tta.py
  class DetTTAModel (line 16) | class DetTTAModel(BaseTTAModel):
    method __init__ (line 49) | def __init__(self, tta_cfg=None, **kwargs):
    method merge_aug_bboxes (line 53) | def merge_aug_bboxes(self, aug_bboxes: List[Tensor],
    method merge_preds (line 84) | def merge_preds(self, data_samples_list: List[List[DetDataSample]]):
    method _merge_single_sample (line 100) | def _merge_single_sample(

FILE: mmdet/models/test_time_augs/merge_augs.py
  function merge_aug_proposals (line 16) | def merge_aug_proposals(aug_proposals, img_metas, cfg):
  function merge_aug_bboxes (line 88) | def merge_aug_bboxes(aug_bboxes, aug_scores, img_metas, rcnn_test_cfg):
  function merge_aug_results (line 117) | def merge_aug_results(aug_batch_results, aug_batch_img_metas):
  function merge_aug_scores (line 171) | def merge_aug_scores(aug_scores):
  function merge_aug_masks (line 179) | def merge_aug_masks(aug_masks: List[Tensor],

FILE: mmdet/models/utils/gaussian_target.py
  function gaussian2D (line 8) | def gaussian2D(radius, sigma=1, dtype=torch.float32, device='cpu'):
  function gen_gaussian_target (line 32) | def gen_gaussian_target(heatmap, center, radius, k=1):
  function gaussian_radius (line 68) | def gaussian_radius(det_size, min_overlap):
  function get_local_maximum (line 190) | def get_local_maximum(heat, kernel=3):
  function get_topk_from_heatmap (line 207) | def get_topk_from_heatmap(scores, k=20):
  function gather_feat (line 234) | def gather_feat(feat, ind, mask=None):
  function transpose_and_gather_feat (line 255) | def transpose_and_gather_feat(feat, ind):

FILE: mmdet/models/utils/make_divisible.py
  function make_divisible (line 2) | def make_divisible(value, divisor, min_value=None, min_ratio=0.9):

FILE: mmdet/models/utils/misc.py
  class SigmoidGeometricMean (line 20) | class SigmoidGeometricMean(Function):
    method forward (line 31) | def forward(ctx, x, y):
    method backward (line 39) | def backward(ctx, grad_output):
  function interpolate_as (line 49) | def interpolate_as(source, target, mode='bilinear', align_corners=False):
  function unpack_gt_instances (line 89) | def unpack_gt_instances(batch_data_samples: SampleList) -> tuple:
  function empty_instances (line 125) | def empty_instances(batch_img_metas: List[dict],
  function multi_apply (line 200) | def multi_apply(func, *args, **kwargs):
  function unmap (line 222) | def unmap(data, count, inds, fill=0):
  function mask2ndarray (line 235) | def mask2ndarray(mask):
  function flip_tensor (line 254) | def flip_tensor(src_tensor, flip_direction):
  function select_single_mlvl (line 277) | def select_single_mlvl(mlvl_tensors, batch_id, detach=True):
  function filter_scores_and_topk (line 308) | def filter_scores_and_topk(scores, score_thr, topk, results=None):
  function center_of_mass (line 357) | def center_of_mass(mask, esp=1e-6):
  function generate_coordinate (line 379) | def generate_coordinate(featmap_sizes, device='cuda'):
  function levels_to_images (line 400) | def levels_to_images(mlvl_tensor: List[torch.Tensor]) -> List[torch.Tens...
  function images_to_levels (line 427) | def images_to_levels(target, num_levels):
  function samplelist_boxtype2tensor (line 443) | def samplelist_boxtype2tensor(batch_data_samples: SampleList) -> SampleL...
  function floordiv (line 464) | def floordiv(dividend, divisor, rounding_mode='trunc'):
  function _filter_gt_instances_by_score (line 471) | def _filter_gt_instances_by_score(batch_data_samples: SampleList,
  function _filter_gt_instances_by_size (line 493) | def _filter_gt_instances_by_size(batch_data_samples: SampleList,
  function filter_gt_instances (line 516) | def filter_gt_instances(batch_data_samples: SampleList,
  function rename_loss_dict (line 541) | def rename_loss_dict(prefix: str, losses: dict) -> dict:
  function reweight_loss_dict (line 554) | def reweight_loss_dict(losses: dict, weight: float) -> dict:
  function relative_coordinate_maps (line 573) | def relative_coordinate_maps(
  function aligned_bilinear (line 604) | def aligned_bilinear(tensor: Tensor, factor: int) -> Tensor:
  function unfold_wo_center (line 630) | def unfold_wo_center(x, kernel_size: int, dilation: int) -> Tensor:

FILE: mmdet/models/utils/panoptic_gt_processing.py
  function preprocess_panoptic_gt (line 8) | def preprocess_panoptic_gt(gt_labels: Tensor, gt_masks: Tensor,

FILE: mmdet/models/utils/point_sample.py
  function get_uncertainty (line 7) | def get_uncertainty(mask_preds: Tensor, labels: Tensor) -> Tensor:
  function get_uncertain_point_coords_with_randomness (line 33) | def get_uncertain_point_coords_with_randomness(

FILE: mmdet/structures/bbox/base_boxes.py
  class BaseBoxes (line 18) | class BaseBoxes(metaclass=ABCMeta):
    method __init__ (line 56) | def __init__(self,
    method convert_to (line 82) | def convert_to(self, dst_type: Union[str, type]) -> 'BaseBoxes':
    method empty_boxes (line 94) | def empty_boxes(self: T,
    method fake_boxes (line 110) | def fake_boxes(self: T,
    method __getitem__ (line 131) | def __getitem__(self: T, index: IndexType) -> T:
    method __setitem__ (line 150) | def __setitem__(self: T, index: IndexType, values: Union[Tensor, T]) -...
    method __len__ (line 169) | def __len__(self) -> int:
    method __deepcopy__ (line 173) | def __deepcopy__(self, memo):
    method __repr__ (line 181) | def __repr__(self) -> str:
    method new_tensor (line 185) | def new_tensor(self, *args, **kwargs) -> Tensor:
    method new_full (line 189) | def new_full(self, *args, **kwargs) -> Tensor:
    method new_empty (line 193) | def new_empty(self, *args, **kwargs) -> Tensor:
    method new_ones (line 197) | def new_ones(self, *args, **kwargs) -> Tensor:
    method new_zeros (line 201) | def new_zeros(self, *args, **kwargs) -> Tensor:
    method size (line 205) | def size(self, dim: Optional[int] = None) -> Union[int, torch.Size]:
    method dim (line 210) | def dim(self) -> int:
    method device (line 215) | def device(self) -> torch.device:
    method dtype (line 220) | def dtype(self) -> torch.dtype:
    method shape (line 225) | def shape(self) -> torch.Size:
    method numel (line 228) | def numel(self) -> int:
    method numpy (line 232) | def numpy(self) -> np.ndarray:
    method to (line 236) | def to(self: T, *args, **kwargs) -> T:
    method cpu (line 240) | def cpu(self: T) -> T:
    method cuda (line 244) | def cuda(self: T, *args, **kwargs) -> T:
    method clone (line 248) | def clone(self: T) -> T:
    method detach (line 252) | def detach(self: T) -> T:
    method view (line 256) | def view(self: T, *shape: Tuple[int]) -> T:
    method reshape (line 260) | def reshape(self: T, *shape: Tuple[int]) -> T:
    method expand (line 264) | def expand(self: T, *sizes: Tuple[int]) -> T:
    method repeat (line 268) | def repeat(self: T, *sizes: Tuple[int]) -> T:
    method transpose (line 272) | def transpose(self: T, dim0: int, dim1: int) -> T:
    method permute (line 279) | def permute(self: T, *dims: Tuple[int]) -> T:
    method split (line 284) | def split(self: T,
    method chunk (line 292) | def chunk(self: T, chunks: int, dim: int = 0) -> List[T]:
    method unbind (line 298) | def unbind(self: T, dim: int = 0) -> T:
    method flatten (line 304) | def flatten(self: T, start_dim: int = 0, end_dim: int = -2) -> T:
    method squeeze (line 309) | def squeeze(self: T, dim: Optional[int] = None) -> T:
    method unsqueeze (line 315) | def unsqueeze(self: T, dim: int) -> T:
    method cat (line 321) | def cat(cls: Type[T], box_list: Sequence[T], dim: int = 0) -> T:
    method stack (line 344) | def stack(cls: Type[T], box_list: Sequence[T], dim: int = 0) -> T:
    method centers (line 366) | def centers(self) -> Tensor:
    method areas (line 371) | def areas(self) -> Tensor:
    method widths (line 376) | def widths(self) -> Tensor:
    method heights (line 381) | def heights(self) -> Tensor:
    method flip_ (line 386) | def flip_(self,
    method translate_ (line 399) | def translate_(self, distances: Tuple[float, float]) -> None:
    method clip_ (line 409) | def clip_(self, img_shape: Tuple[int, int]) -> None:
    method rotate_ (line 418) | def rotate_(self, center: Tuple[float, float], angle: float) -> None:
    method project_ (line 429) | def project_(self, homography_matrix: Union[Tensor, np.ndarray]) -> None:
    method rescale_ (line 439) | def rescale_(self, scale_factor: Tuple[float, float]) -> None:
    method resize_ (line 455) | def resize_(self, scale_factor: Tuple[float, float]) -> None:
    method is_inside (line 471) | def is_inside(self,
    method find_inside_points (line 492) | def find_inside_points(self,
    method overlaps (line 513) | def overlaps(boxes1: 'BaseBoxes',
    method from_instance_masks (line 539) | def from_instance_masks(masks: MaskType) -> 'BaseBoxes':

FILE: mmdet/structures/bbox/bbox_overlaps.py
  function fp16_clamp (line 5) | def fp16_clamp(x, min=None, max=None):
  function bbox_overlaps (line 13) | def bbox_overlaps(bboxes1, bboxes2, mode='iou', is_aligned=False, eps=1e...

FILE: mmdet/structures/bbox/box_type.py
  function _register_box (line 17) | def _register_box(name: str, box_type: Type, force: bool = False) -> None:
  function register_box (line 42) | def register_box(name: str,
  function _register_box_converter (line 89) | def _register_box_converter(src_type: Union[str, type],
  function register_box_converter (line 114) | def register_box_converter(src_type: Union[str, type],
  function get_box_type (line 165) | def get_box_type(box_type: Union[str, type]) -> Tuple[str, type]:
  function convert_box_type (line 190) | def convert_box_type(boxes: BoxType,
  function autocast_box_type (line 245) | def autocast_box_type(dst_box_type='hbox') -> Callable:

FILE: mmdet/structures/bbox/horizontal_boxes.py
  class HorizontalBoxes (line 20) | class HorizontalBoxes(BaseBoxes):
    method __init__ (line 49) | def __init__(self,
    method cxcywh_to_xyxy (line 63) | def cxcywh_to_xyxy(boxes: Tensor) -> Tensor:
    method xyxy_to_cxcywh (line 76) | def xyxy_to_cxcywh(boxes: Tensor) -> Tensor:
    method cxcywh (line 89) | def cxcywh(self) -> Tensor:
    method centers (line 94) | def centers(self) -> Tensor:
    method areas (line 100) | def areas(self) -> Tensor:
    method widths (line 107) | def widths(self) -> Tensor:
    method heights (line 113) | def heights(self) -> Tensor:
    method flip_ (line 118) | def flip_(self,
    method translate_ (line 143) | def translate_(self, distances: Tuple[float, float]) -> None:
    method clip_ (line 154) | def clip_(self, img_shape: Tuple[int, int]) -> None:
    method rotate_ (line 164) | def rotate_(self, center: Tuple[float, float], angle: float) -> None:
    method project_ (line 184) | def project_(self, homography_matrix: Union[Tensor, np.ndarray]) -> None:
    method hbox2corner (line 205) | def hbox2corner(boxes: Tensor) -> Tensor:
    method corner2hbox (line 220) | def corner2hbox(corners: Tensor) -> Tensor:
    method rescale_ (line 236) | def rescale_(self, scale_factor: Tuple[float, float]) -> None:
    method resize_ (line 254) | def resize_(self, scale_factor: Tuple[float, float]) -> None:
    method is_inside (line 277) | def is_inside(self,
    method find_inside_points (line 308) | def find_inside_points(self,
    method overlaps (line 339) | def overlaps(boxes1: BaseBoxes,
    method from_instance_masks (line 372) | def from_instance_masks(masks: MaskType) -> 'HorizontalBoxes':

FILE: mmdet/structures/bbox/transforms.py
  function find_inside_bboxes (line 11) | def find_inside_bboxes(bboxes: Tensor, img_h: int, img_w: int) -> Tensor:
  function bbox_flip (line 27) | def bbox_flip(bboxes: Tensor,
  function bbox_mapping (line 58) | def bbox_mapping(bboxes: Tensor,
  function bbox_mapping_back (line 70) | def bbox_mapping_back(bboxes: Tensor,
  function bbox2roi (line 82) | def bbox2roi(bbox_list: List[Union[Tensor, BaseBoxes]]) -> Tensor:
  function roi2bbox (line 105) | def roi2bbox(rois: Tensor) -> List[Tensor]:
  function bbox2result (line 125) | def bbox2result(bboxes: Union[Tensor, np.ndarray], labels: Union[Tensor,
  function distance2bbox (line 147) | def distance2bbox(
  function bbox2distance (line 206) | def bbox2distance(points: Tensor,
  function bbox_rescale (line 233) | def bbox_rescale(bboxes: Tensor, scale_factor: float = 1.0) -> Tensor:
  function bbox_cxcywh_to_xyxy (line 265) | def bbox_cxcywh_to_xyxy(bbox: Tensor) -> Tensor:
  function bbox_xyxy_to_cxcywh (line 279) | def bbox_xyxy_to_cxcywh(bbox: Tensor) -> Tensor:
  function bbox2corner (line 293) | def bbox2corner(bboxes: torch.Tensor) -> torch.Tensor:
  function corner2bbox (line 306) | def corner2bbox(corners: torch.Tensor) -> torch.Tensor:
  function bbox_project (line 321) | def bbox_project(
  function cat_boxes (line 356) | def cat_boxes(data_list: List[Union[Tensor, BaseBoxes]],
  function stack_boxes (line 375) | def stack_boxes(data_list: List[Union[Tensor, BaseBoxes]],
  function scale_boxes (line 394) | def scale_boxes(boxes: Union[Tensor, BaseBoxes],
  function get_box_wh (line 417) | def get_box_wh(boxes: Union[Tensor, BaseBoxes]) -> Tuple[Tensor, Tensor]:
  function get_box_tensor (line 437) | def get_box_tensor(boxes: Union[Tensor, BaseBoxes]) -> Tensor:
  function empty_box_as (line 453) | def empty_box_as(boxes: Union[Tensor, BaseBoxes]) -> Union[Tensor, BaseB...

FILE: mmdet/structures/det_data_sample.py
  class DetDataSample (line 7) | class DetDataSample(BaseDataElement):
    method proposals (line 116) | def proposals(self) -> InstanceData:
    method proposals (line 120) | def proposals(self, value: InstanceData):
    method proposals (line 124) | def proposals(self):
    method gt_instances (line 128) | def gt_instances(self) -> InstanceData:
    method gt_instances (line 132) | def gt_instances(self, value: InstanceData):
    method gt_instances (line 136) | def gt_instances(self):
    method pred_instances (line 140) | def pred_instances(self) -> InstanceData:
    method pred_instances (line 144) | def pred_instances(self, value: InstanceData):
    method pred_instances (line 148) | def pred_instances(self):
    method ignored_instances (line 152) | def ignored_instances(self) -> InstanceData:
    method ignored_instances (line 156) | def ignored_instances(self, value: InstanceData):
    method ignored_instances (line 160) | def ignored_instances(self):
    method gt_panoptic_seg (line 164) | def gt_panoptic_seg(self) -> PixelData:
    method gt_panoptic_seg (line 168) | def gt_panoptic_seg(self, value: PixelData):
    method gt_panoptic_seg (line 172) | def gt_panoptic_seg(self):
    method pred_panoptic_seg (line 176) | def pred_panoptic_seg(self) -> PixelData:
    method pred_panoptic_seg (line 180) | def pred_panoptic_seg(self, value: PixelData):
    method pred_panoptic_seg (line 184) | def pred_panoptic_seg(self):
    method gt_sem_seg (line 188) | def gt_sem_seg(self) -> PixelData:
    method gt_sem_seg (line 192) | def gt_sem_seg(self, value: PixelData):
    method gt_sem_seg (line 196) | def gt_sem_seg(self):
    method pred_sem_seg (line 200) | def pred_sem_seg(self) -> PixelData:
    method pred_sem_seg (line 204) | def pred_sem_seg(self, value: PixelData):
    method pred_sem_seg (line 208) | def pred_sem_seg(self):

FILE: mmdet/structures/mask/mask_target.py
  function mask_target (line 7) | def mask_target(pos_proposals_list, pos_assigned_gt_inds_list, gt_masks_...
  function mask_target_single (line 67) | def mask_target_single(pos_proposals, pos_assigned_gt_inds, gt_masks, cfg):

FILE: mmdet/structures/mask/structures.py
  class BaseInstanceMasks (line 16) | class BaseInstanceMasks(metaclass=ABCMeta):
    method rescale (line 20) | def rescale(self, scale, interpolation='nearest'):
    method resize (line 33) | def resize(self, out_shape, interpolation='nearest'):
    method flip (line 45) | def flip(self, flip_direction='horizontal'):
    method pad (line 56) | def pad(self, out_shape, pad_val):
    method crop (line 68) | def crop(self, bbox):
    method crop_and_resize (line 79) | def crop_and_resize(self,
    method expand (line 108) | def expand(self, expanded_h, expanded_w, top, left):
    method areas (line 113) | def areas(self):
    method to_ndarray (line 117) | def to_ndarray(self):
    method to_tensor (line 125) | def to_tensor(self, dtype, device):
    method translate (line 137) | def translate(self,
    method shear (line 157) | def shear(self,
    method rotate (line 179) | def rotate(self, out_shape, angle, center=None, scale=1.0, border_valu...
    method get_bboxes (line 196) | def get_bboxes(self, dst_type='hbb'):
    method cat (line 214) | def cat(cls: Type[T], masks: Sequence[T]) -> T:
  class BitmapMasks (line 225) | class BitmapMasks(BaseInstanceMasks):
    method __init__ (line 254) | def __init__(self, masks, height, width):
    method __getitem__ (line 271) | def __getitem__(self, index):
    method __iter__ (line 283) | def __iter__(self):
    method __repr__ (line 286) | def __repr__(self):
    method __len__ (line 293) | def __len__(self):
    method rescale (line 297) | def rescale(self, scale, interpolation='nearest'):
    method resize (line 310) | def resize(self, out_shape, interpolation='nearest'):
    method flip (line 322) | def flip(self, flip_direction='horizontal'):
    method pad (line 335) | def pad(self, out_shape, pad_val=0):
    method crop (line 346) | def crop(self, bbox):
    method crop_and_resize (line 365) | def crop_and_resize(self,
    method expand (line 401) | def expand(self, expanded_h, expanded_w, top, left):
    method translate (line 413) | def translate(self,
    method shear (line 470) | def shear(self,
    method rotate (line 505) | def rotate(self,
    method areas (line 546) | def areas(self):
    method to_ndarray (line 550) | def to_ndarray(self):
    method to_tensor (line 554) | def to_tensor(self, dtype, device):
    method random (line 559) | def random(cls,
    method cat (line 580) | def cat(cls: Type[T], masks: Sequence[T]) -> T:
  class PolygonMasks (line 598) | class PolygonMasks(BaseInstanceMasks):
    method __init__ (line 638) | def __init__(self, masks, height, width):
    method __getitem__ (line 648) | def __getitem__(self, index):
    method __iter__ (line 674) | def __iter__(self):
    method __repr__ (line 677) | def __repr__(self):
    method __len__ (line 684) | def __len__(self):
    method rescale (line 688) | def rescale(self, scale, interpolation=None):
    method resize (line 697) | def resize(self, out_shape, interpolation=None):
    method flip (line 716) | def flip(self, flip_direction='horizontal'):
    method crop (line 740) | def crop(self, bbox):
    method pad (line 769) | def pad(self, out_shape, pad_val=0):
    method expand (line 773) | def expand(self, *args, **kwargs):
    method crop_and_resize (line 777) | def crop_and_resize(self,
    method translate (line 818) | def translate(self,
    method shear (line 853) | def shear(self,
    method rotate (line 885) | def rotate(self,
    method to_bitmap (line 920) | def to_bitmap(self):
    method areas (line 926) | def areas(self):
    method _polygon_area (line 944) | def _polygon_area(self, x, y):
    method to_ndarray (line 960) | def to_ndarray(self):
    method to_tensor (line 970) | def to_tensor(self, dtype, device):
    method random (line 980) | def random(cls,
    method cat (line 1100) | def cat(cls: Type[T], masks: Sequence[T]) -> T:
  function polygon_to_bitmap (line 1118) | def polygon_to_bitmap(polygons, height, width):
  function bitmap_to_polygon (line 1135) | def bitmap_to_polygon(bitmap):

FILE: mmdet/structures/mask/utils.py
  function split_combined_polys (line 8) | def split_combined_polys(polys, poly_lens, polys_per_mask):
  function encode_mask_results (line 38) | def encode_mask_results(mask_results):
  function mask2bbox (line 56) | def mask2bbox(masks):

FILE: mmdet/testing/_fast_stop_training_hook.py
  class FastStopTrainingHook (line 8) | class FastStopTrainingHook(Hook):
    method __init__ (line 11) | def __init__(self, by_epoch, save_ckpt=False, stop_iter_or_epoch=5):
    method after_train_iter (line 16) | def after_train_iter(self, runner, batch_idx: int, data_batch: None,
    method after_train_epoch (line 25) | def after_train_epoch(self, runner) -> None:

FILE: mmdet/testing/_utils.py
  function _get_config_directory (line 16) | def _get_config_directory():
  function _get_config_module (line 31) | def _get_config_module(fname):
  function get_detector_cfg (line 39) | def get_detector_cfg(fname):
  function get_roi_head_cfg (line 50) | def get_roi_head_cfg(fname):
  function _rand_bboxes (line 66) | def _rand_bboxes(rng, num_boxes, w, h):
  function _rand_masks (line 78) | def _rand_masks(rng, num_boxes, bboxes, img_w, img_h):
  function demo_mm_inputs (line 89) | def demo_mm_inputs(batch_size=2,
  function demo_mm_proposals (line 205) | def demo_mm_proposals(image_shapes, num_proposals, device='cpu'):
  function demo_mm_sampling_results (line 226) | def demo_mm_sampling_results(proposals_list,
  function replace_to_ceph (line 276) | def replace_to_ceph(cfg):

FILE: mmdet/utils/benchmark.py
  function custom_round (line 29) | def custom_round(value: Union[int, float],
  function print_log (line 39) | def print_log(msg: str, logger: Optional[MMLogger] = None) -> None:
  function print_process_memory (line 47) | def print_process_memory(p: psutil.Process,
  class BaseBenchmark (line 64) | class BaseBenchmark:
    method __init__ (line 79) | def __init__(self,
    method run (line 89) | def run(self, repeat_num: int = 1) -> dict:
    method run_once (line 105) | def run_once(self) -> dict:
    method average_multiple_runs (line 109) | def average_multiple_runs(self, results: List[dict]) -> dict:
  class InferenceBenchmark (line 114) | class InferenceBenchmark(BaseBenchmark):
    method __init__ (line 131) | def __init__(self,
    method _init_model (line 178) | def _init_model(self, checkpoint: str, is_fuse_conv_bn: bool) -> nn.Mo...
    method run_once (line 202) | def run_once(self) -> dict:
    method average_multiple_runs (line 240) | def average_multiple_runs(self, results: List[dict]) -> dict:
  class DataLoaderBenchmark (line 272) | class DataLoaderBenchmark(BaseBenchmark):
    method __init__ (line 287) | def __init__(self,
    method run_once (line 333) | def run_once(self) -> dict:
    method average_multiple_runs (line 367) | def average_multiple_runs(self, results: List[dict]) -> dict:
  class DatasetBenchmark (line 400) | class DatasetBenchmark(BaseBenchmark):
    method __init__ (line 414) | def __init__(self,
    method run_once (line 442) | def run_once(self) -> dict:
    method average_multiple_runs (line 497) | def average_multiple_runs(self, results: List[dict]) -> dict:

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

FILE: mmdet/utils/compat_config.py
  function compat_cfg (line 8) | def compat_cfg(cfg):
  function compat_runner_args (line 22) | def compat_runner_args(cfg):
  function compat_imgs_per_gpu (line 37) | def compat_imgs_per_gpu(cfg):
  function compat_loader_args (line 54) | def compat_loader_args(cfg):

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

FILE: mmdet/utils/dist_utils.py
  function _allreduce_coalesced (line 15) | def _allreduce_coalesced(tensors, world_size, bucket_size_mb=-1):
  function allreduce_grads (line 37) | def allreduce_grads(params, coalesce=True, bucket_size_mb=-1):
  function reduce_mean (line 59) | def reduce_mean(tensor):
  function obj2tensor (line 68) | def obj2tensor(pyobj, device='cuda'):
  function tensor2obj (line 74) | def tensor2obj(tensor):
  function _get_global_gloo_group (line 80) | def _get_global_gloo_group():
  function all_reduce_dict (line 89) | def all_reduce_dict(py_dict, op='sum', group=None, to_float=True):
  function sync_random_seed (line 148) | def sync_random_seed(seed=None, device='cuda'):

FILE: mmdet/utils/logger.py
  function get_caller_name (line 7) | def get_caller_name():
  function log_img_scale (line 20) | def log_img_scale(img_scale, shape_order='hw', skip_square=False):

FILE: mmdet/utils/memory.py
  function cast_tensor_type (line 11) | def cast_tensor_type(inputs, src_type=None, dst_type=None):
  function _ignore_torch_cuda_oom (line 62) | def _ignore_torch_cuda_oom():
  class AvoidOOM (line 78) | class AvoidOOM:
    method __init__ (line 119) | def __init__(self, to_cpu=True, test=False):
    method retry_if_cuda_oom (line 123) | def retry_if_cuda_oom(self, func):

FILE: mmdet/utils/misc.py
  function find_latest_checkpoint (line 12) | def find_latest_checkpoint(path, suffix='pth'):
  function update_data_root (line 46) | def update_data_root(cfg, logger=None):
  function get_test_pipeline_cfg (line 80) | def get_test_pipeline_cfg(cfg: Union[str, ConfigDict]) -> ConfigDict:

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

FILE: mmdet/utils/replace_cfg_vals.py
  function replace_cfg_vals (line 7) | def replace_cfg_vals(ori_cfg):

FILE: mmdet/utils/setup_env.py
  function setup_multi_processes (line 12) | def setup_multi_processes(cfg):
  function register_all_modules (line 58) | def register_all_modules(init_default_scope: bool = True) -> None:

FILE: mmdet/utils/split_batch.py
  function split_batch (line 5) | def split_batch(img, img_metas, kwargs):

FILE: mmdet/utils/util_mixins.py
  class NiceRepr (line 42) | class NiceRepr:
    method __nice__ (line 76) | def __nice__(self):
    method __repr__ (line 87) | def __repr__(self):
    method __str__ (line 97) | def __str__(self):

FILE: mmdet/utils/util_random.py
  function ensure_rng (line 6) | def ensure_rng(rng=None):

FILE: mmdet/version.py
  function parse_version_info (line 7) | def parse_version_info(version_str):

FILE: mmdet/visualization/local_visualizer.py
  class DetLocalVisualizer (line 20) | class DetLocalVisualizer(Visualizer):
    method __init__ (line 77) | def __init__(self,
    method _draw_instances (line 103) | def _draw_instances(self, image: np.ndarray, instances: ['InstanceData'],
    method _draw_panoptic_seg (line 226) | def _draw_panoptic_seg(self, image: np.ndarray,
    method add_datasample (line 298) | def add_datasample(

FILE: mmdet/visualization/palette.py
  function palette_val (line 9) | def palette_val(palette: List[tuple]) -> List[tuple]:
  function get_palette (line 25) | def get_palette(palette: Union[List[tuple], str, tuple],
  function _get_adaptive_scales (line 70) | def _get_adaptive_scales(areas: np.ndarray,
  function jitter_color (line 95) | def jitter_color(color: tuple) -> tuple:

FILE: projects/Detic/demo.py
  function get_file_list (line 19) | def get_file_list(source_root: str) -> [list, dict]:
  function parse_args (line 57) | def parse_args():
  function main (line 79) | def main():

FILE: projects/Detic/detic/centernet_rpn_head.py
  class CenterNetRPNHead (line 21) | class CenterNetRPNHead(CenterNetUpdateHead):
    method _init_layers (line 27) | def _init_layers(self) -> None:
    method _init_predictor (line 32) | def _init_predictor(self) -> None:
    method forward (line 38) | def forward(self, x: Tuple[Tensor]) -> Tuple[List[Tensor], List[Tensor]]:
    method forward_single (line 56) | def forward_single(self, x: Tensor, scale: Scale,
    method _predict_by_feat_single (line 85) | def _predict_by_feat_single(self,

FILE: projects/Detic/detic/detic_bbox_head.py
  class DeticBBoxHead (line 16) | class DeticBBoxHead(Shared2FCBBoxHead):
    method __init__ (line 18) | def __init__(self,
    method _predict_by_feat_single (line 31) | def _predict_by_feat_single(

FILE: projects/Detic/detic/detic_roi_head.py
  class DeticRoIHead (line 19) | class DeticRoIHead(CascadeRoIHead):
    method init_mask_head (line 21) | def init_mask_head(self, mask_roi_extractor: MultiConfig,
    method _refine_roi (line 39) | def _refine_roi(self, x: Tuple[Tensor], rois: Tensor,
    method _bbox_forward (line 99) | def _bbox_forward(self, stage: int, x: Tuple[Tensor],
    method predict_bbox (line 127) | def predict_bbox(self,
    method _mask_forward (line 197) | def _mask_forward(self, x: Tuple[Tensor], rois: Tensor) -> dict:
    method mask_loss (line 219) | def mask_loss(self, x, sampling_results: List[SamplingResult],
    method loss (line 248) | def loss(self, x: Tuple[Tensor], rpn_results_list: InstanceList,
    method predict_mask (line 266) | def predict_mask(self,

FILE: projects/Detic/detic/text_encoder.py
  class CLIPTextEncoder (line 8) | class CLIPTextEncoder(nn.Module):
    method __init__ (line 10) | def __init__(self, model_name='ViT-B/32'):
    method device (line 19) | def device(self):
    method dtype (line 23) | def dtype(self):
    method tokenize (line 26) | def tokenize(self,
    method forward (line 47) | def forward(self, text):

FILE: projects/Detic/detic/utils.py
  function get_text_embeddings (line 19) | def get_text_embeddings(dataset=None,
  function get_class_names (line 39) | def get_class_names(dataset):
  function reset_cls_layer_weight (line 60) | def reset_cls_layer_weight(model, weight):

FILE: projects/Detic/detic/zero_shot_classifier.py
  class ZeroShotClassifier (line 11) | class ZeroShotClassifier(nn.Module):
    method __init__ (line 13) | def __init__(
    method forward (line 55) | def forward(self, x, classifier=None):

FILE: projects/DiffusionDet/diffusiondet/diffusiondet.py
  class DiffusionDet (line 8) | class DiffusionDet(SingleStageDetector):
    method __init__ (line 11) | def __init__(self,

FILE: projects/DiffusionDet/diffusiondet/head.py
  function cosine_beta_schedule (line 35) | def cosine_beta_schedule(timesteps, s=0.008):
  function extract (line 47) | def extract(a, t, x_shape):
  class SinusoidalPositionEmbeddings (line 54) | class SinusoidalPositionEmbeddings(nn.Module):
    method __init__ (line 56) | def __init__(self, dim):
    method forward (line 60) | def forward(self, time):
  class DynamicDiffusionDetHead (line 72) | class DynamicDiffusionDetHead(nn.Module):
    method __init__ (line 74) | def __init__(self,
    method _init_weights (line 221) | def _init_weights(self):
    method _build_diffusion (line 234) | def _build_diffusion(self):
    method forward (line 272) | def forward(self, features, init_bboxes, init_t, init_features=None):
    method loss (line 301) | def loss(self, x: Tuple[Tensor], batch_data_samples: SampleList) -> dict:
    method prepare_training_targets (line 341) | def prepare_training_targets(self, batch_data_samples):
    method prepare_diffusion (line 379) | def prepare_diffusion(self, gt_boxes, image_size):
    method q_sample (line 419) | def q_sample(self, x_start, time, noise=None):
    method predict (line 433) | def predict(self,
    method predict_by_feat (line 479) | def predict_by_feat(self,
    method do_results_post_process (line 644) | def do_results_post_process(results_list, cfg, batch_img_metas=None):
    method prepare_testing_targets (line 667) | def prepare_testing_targets(self, batch_img_metas, device):
    method predict_noise_from_start (line 700) | def predict_noise_from_start(self, x_t, t, x0):
    method inference (line 706) | def inference(self, box_cls, box_pred, cfg, device):
  class SingleDiffusionDetHead (line 794) | class SingleDiffusionDetHead(nn.Module):
    method __init__ (line 796) | def __init__(
    method forward (line 869) | def forward(self, features, bboxes, pro_features, pooler, time_emb):
    method apply_deltas (line 937) | def apply_deltas(self, deltas, boxes):
  class DynamicConv (line 978) | class DynamicConv(nn.Module):
    method __init__ (line 980) | def __init__(self,
    method forward (line 1003) | def forward(self, pro_features: Tensor, roi_features: Tensor) -> Tensor:

FILE: projects/DiffusionDet/diffusiondet/loss.py
  class DiffusionDetCriterion (line 24) | class DiffusionDetCriterion(nn.Module):
    method __init__ (line 26) | def __init__(
    method forward (line 56) | def forward(self, outputs, batch_gt_instances, batch_img_metas):
    method loss_classification (line 87) | def loss_classification(self, outputs, batch_gt_instances, indices):
    method loss_boxes (line 111) | def loss_boxes(self, outputs, batch_gt_instances, indices):
  class DiffusionDetMatcher (line 151) | class DiffusionDetMatcher(nn.Module):
    method __init__ (line 161) | def __init__(self,
    method forward (line 192) | def forward(self, outputs, batch_gt_instances, batch_img_metas):
    method single_assigner (line 212) | def single_assigner(self, pred_instances, gt_instances, img_meta):
    method get_in_gt_and_in_center_info (line 250) | def get_in_gt_and_in_center_info(
    method dynamic_k_matching (line 300) | def dynamic_k_matching(self, cost: Tensor, pairwise_ious: Tensor,

FILE: projects/DiffusionDet/model_converters/diffusiondet_resnet_to_mmdet.py
  function convert (line 10) | def convert(src, dst):
  function main (line 79) | def main():

FILE: projects/EfficientDet/convert_tf_to_pt.py
  function tf2pth (line 10) | def tf2pth(v):
  function convert_key (line 18) | def convert_key(model_name, bifpn_repeats, weights):
  function parse_args (line 578) | def parse_args():
  function main (line 597) | def main():

FILE: projects/EfficientDet/efficientdet/anchor_generator.py
  class YXYXAnchorGenerator (line 16) | class YXYXAnchorGenerator(AnchorGenerator):
    method gen_single_level_base_anchors (line 18) | def gen_single_level_base_anchors(self,
    method single_level_grid_priors (line 67) | def single_level_grid_priors(self,

FILE: projects/EfficientDet/efficientdet/api_wrappers/coco_api.py
  class COCO (line 13) | class COCO(_COCO):
    method __init__ (line 20) | def __init__(self, annotation_file=None):
    method get_ann_ids (line 29) | def get_ann_ids(self, img_ids=[], cat_ids=[], area_rng=[], iscrowd=None):
    method get_cat_ids (line 32) | def get_cat_ids(self, cat_names=[], sup_names=[], cat_ids=[]):
    method get_img_ids (line 44) | def get_img_ids(self, img_ids=[], cat_ids=[]):
    method load_anns (line 47) | def load_anns(self, ids):
    method load_cats (line 50) | def load_cats(self, ids):
    method load_imgs (line 53) | def load_imgs(self, ids):
  class COCOPanoptic (line 61) | class COCOPanoptic(COCO):
    method __init__ (line 71) | def __init__(self, annotation_file: Optional[str] = None) -> None:
    method createIndex (line 74) | def createIndex(self) -> None:
    method load_anns (line 124) | def load_anns(self,

FILE: projects/EfficientDet/efficientdet/bifpn.py
  class BiFPNStage (line 16) | class BiFPNStage(nn.Module):
    method __init__ (line 28) | def __init__(self,
    method combine (line 178) | def combine(self, x):
    method forward (line 184) | def forward(self, x):
  class BiFPN (line 270) | class BiFPN(BaseModule):
    method __init__ (line 285) | def __init__(self,
    method forward (line 312) | def forward(self, x):

FILE: projects/EfficientDet/efficientdet/coco_90class.py
  class Coco90Dataset (line 12) | class Coco90Dataset(BaseDetDataset):
    method load_data_list (line 59) | def load_data_list(self) -> List[dict]:
    method parse_data_info (line 101) | def parse_data_info(self, raw_data_info: dict) -> Union[dict, List[dic...
    method filter_data (line 160) | def filter_data(self) -> List[dict]:

FILE: projects/EfficientDet/efficientdet/coco_90metric.py
  class Coco90Metric (line 22) | class Coco90Metric(BaseMetric):
    method __init__ (line 65) | def __init__(self,
    method fast_eval_recall (line 122) | def fast_eval_recall(self,
    method xyxy2xywh (line 163) | def xyxy2xywh(self, bbox: np.ndarray) -> list:
    method results2json (line 183) | def results2json(self, results: Sequence[dict],
    method gt_to_coco_json (line 247) | def gt_to_coco_json(self, gt_dicts: Sequence[dict],
    method process (line 319) | def process(self, data_batch: dict, data_samples: Sequence[dict]) -> N...
    method compute_metrics (line 358) | def compute_metrics(self, results: list) -> Dict[str, float]:

FILE: projects/EfficientDet/efficientdet/efficientdet.py
  class EfficientDet (line 8) | class EfficientDet(SingleStageDetector):
    method __init__ (line 10) | def __init__(self,

FILE: projects/EfficientDet/efficientdet/efficientdet_head.py
  class EfficientDetSepBNHead (line 16) | class EfficientDetSepBNHead(AnchorHead):
    method __init__ (line 31) | def __init__(self,
    method _init_layers (line 51) | def _init_layers(self) -> None:
    method init_weights (line 88) | def init_weights(self) -> None:
    method forward_single_bbox (line 98) | def forward_single_bbox(self, feat: Tensor, level_id: int,
    method forward_single_cls (line 109) | def forward_single_cls(self, feat: Tensor, level_id: int,
    method forward (line 120) | def forward(self, feats: Tuple[Tensor]) -> tuple:

FILE: projects/EfficientDet/efficientdet/trans_max_iou_assigner.py
  class TransMaxIoUAssigner (line 13) | class TransMaxIoUAssigner(MaxIoUAssigner):
    method assign (line 15) | def assign(self,

FILE: projects/EfficientDet/efficientdet/utils.py
  class SwishImplementation (line 13) | class SwishImplementation(torch.autograd.Function):
    method forward (line 16) | def forward(ctx, i):
    method backward (line 22) | def backward(ctx, grad_output):
  class MemoryEfficientSwish (line 28) | class MemoryEfficientSwish(nn.Module):
    method forward (line 30) | def forward(self, x):
  class Conv2dSamePadding (line 34) | class Conv2dSamePadding(nn.Module):
    method __init__ (line 36) | def __init__(self,
    method forward (line 54) | def forward(self, x):
  class MaxPool2dSamePadding (line 72) | class MaxPool2dSamePadding(nn.Module):
    method __init__ (line 74) | def __init__(self,
    method forward (line 88) | def forward(self, x):
  class DepthWiseConvBlock (line 107) | class DepthWiseConvBlock(nn.Module):
    method __init__ (line 109) | def __init__(
    method forward (line 137) | def forward(self, x):
  class DownChannelBlock (line 148) | class DownChannelBlock(nn.Module):
    method __init__ (line 150) | def __init__(
    method forward (line 168) | def forward(self, x):

FILE: projects/EfficientDet/efficientdet/yxyx_bbox_coder.py
  class YXYXDeltaXYWHBBoxCoder (line 14) | class YXYXDeltaXYWHBBoxCoder(DeltaXYWHBBoxCoder):
    method encode (line 16) | def encode(self, bboxes, gt_bboxes):
    method decode (line 36) | def decode(self,
  function YXdelta2bbox (line 94) | def YXdelta2bbox(rois,
  function YXbbox2delta (line 195) | def YXbbox2delta(proposals, gt, means=(0., 0., 0., 0.), stds=(1., 1., 1....
  function YXonnx_delta2bbox (line 240) | def YXonnx_delta2bbox(rois,

FILE: projects/SparseInst/sparseinst/decoder.py
  function _make_stack_3x3_convs (line 14) | def _make_stack_3x3_convs(num_convs,
  class InstanceBranch (line 26) | class InstanceBranch(nn.Module):
    method __init__ (line 28) | def __init__(self,
    method _init_weights (line 53) | def _init_weights(self):
    method forward (line 66) | def forward(self, features):
  class MaskBranch (line 89) | class MaskBranch(nn.Module):
    method __init__ (line 91) | def __init__(self,
    method _init_weights (line 103) | def _init_weights(self):
    method forward (line 109) | def forward(self, features):
  class BaseIAMDecoder (line 116) | class BaseIAMDecoder(nn.Module):
    method __init__ (line 118) | def __init__(self,
    method compute_coordinates_linspace (line 153) | def compute_coordinates_linspace(self, x):
    method compute_coordinates (line 165) | def compute_coordinates(self, x):
    method forward (line 175) | def forward(self, features):
  class GroupInstanceBranch (line 211) | class GroupInstanceBranch(nn.Module):
    method __init__ (line 213) | def __init__(self,
    method _init_weights (line 246) | def _init_weights(self):
    method forward (line 260) | def forward(self, features):
  class GroupIAMDecoder (line 291) | class GroupIAMDecoder(BaseIAMDecoder):
    method __init__ (line 293) | def __init__(self,
  class GroupInstanceSoftBranch (line 329) | class GroupInstanceSoftBranch(GroupInstanceBranch):
    method __init__ (line 331) | def __init__(self, *args, **kwargs):
    method forward (line 337) | def forward(self, features):
  class GroupIAMSoftDecoder (line 365) | class GroupIAMSoftDecoder(BaseIAMDecoder):
    method __init__ (line 367) | def __init__(self,

FILE: projects/SparseInst/sparseinst/encoder.py
  class PyramidPoolingModule (line 11) | class PyramidPoolingModule(nn.Module):
    method __init__ (line 13) | def __init__(self,
    method _make_stage (line 26) | def _make_stage(self, features, out_features, size):
    method forward (line 31) | def forward(self, feats):
  class InstanceContextEncoder (line 45) | class InstanceContextEncoder(nn.Module):
    method __init__ (line 53) | def __init__(self,
    method forward (line 82) | def forward(self, features):

FILE: projects/SparseInst/sparseinst/loss.py
  function compute_mask_iou (line 13) | def compute_mask_iou(inputs, targets):
  function dice_score (line 24) | def dice_score(inputs, targets):
  class SparseInstCriterion (line 34) | class SparseInstCriterion(nn.Module):
    method __init__ (line 40) | def __init__(
    method _get_src_permutation_idx (line 76) | def _get_src_permutation_idx(self, indices):
    method _get_tgt_permutation_idx (line 83) | def _get_tgt_permutation_idx(self, indices):
    method loss_classification (line 90) | def loss_classification(self, outputs, batch_gt_instances, indices,
    method loss_masks_with_iou_objectness (line 113) | def loss_masks_with_iou_objectness(self, outputs, batch_gt_instances,
    method forward (line 170) | def forward(self, outputs, batch_gt_instances, batch_img_metas,
  class SparseInstMatcher (line 197) | class SparseInstMatcher(nn.Module):
    method __init__ (line 199) | def __init__(self, alpha=0.8, beta=0.2):
    method forward (line 205) | def forward(self, outputs, batch_gt_instances):

FILE: projects/SparseInst/sparseinst/sparseinst.py
  function rescoring_mask (line 17) | def rescoring_mask(scores, mask_pred, masks):
  class SparseInst (line 24) | class SparseInst(BaseDetector):
    method __init__ (line 42) | def __init__(self,
    method _forward (line 66) | def _forward(
    method predict (line 84) | def predict(self,
    method loss (line 172) | def loss(self, batch_inputs: Tensor,
    method extract_feat (line 194) | def extract_feat(self, batch_inputs: Tensor) -> Tuple[Tensor]:

FILE: projects/example_project/dummy/dummy_resnet.py
  class DummyResNet (line 7) | class DummyResNet(ResNet):
    method __init__ (line 13) | def __init__(self, **kwargs) -> None:

FILE: setup.py
  function readme (line 16) | def readme():
  function get_version (line 25) | def get_version():
  function make_cuda_ext (line 31) | def make_cuda_ext(name, module, sources, sources_cuda=[]):
  function parse_requirements (line 56) | def parse_requirements(fname='requirements.txt', with_version=True):
  function add_mim_extension (line 134) | def add_mim_extension():

FILE: tests/test_apis/test_det_inferencer.py
  class TestDetInferencer (line 20) | class TestDetInferencer(TestCase):
    method test_init (line 23) | def test_init(self, mock):
    method assert_predictions_equal (line 29) | def assert_predictions_equal(self, preds1, preds2):
    method test_call (line 46) | def test_call(self, model):
    method test_visualize (line 99) | def test_visualize(self, model):
    method test_postprocess (line 122) | def test_postprocess(self, model):
    method test_pred2dict (line 148) | def test_pred2dict(self, mock):
    method assertListAlmostEqual (line 160) | def assertListAlmostEqual(self, list1, list2, places=7):

FILE: tests/test_apis/test_inference.py
  function test_init_detector (line 19) | def test_init_detector(config, devices):
  function test_inference_detector (line 55) | def test_inference_detector(config, devices):

FILE: tests/test_datasets/test_cityscapes.py
  class TestCityscapesDataset (line 10) | class TestCityscapesDataset(unittest.TestCase):
    method setUp (line 12) | def setUp(self) -> None:
    method tearDown (line 151) | def tearDown(self):
    method test_cityscapes_dataset (line 154) | def test_cityscapes_dataset(self):
    method test_cityscapes_dataset_without_filter_cfg (line 181) | def test_cityscapes_dataset_without_filter_cfg(self):

FILE: tests/test_datasets/test_coco.py
  class TestCocoDataset (line 7) | class TestCocoDataset(unittest.TestCase):
    method test_coco_dataset (line 9) | def test_coco_dataset(self):
    method test_coco_dataset_without_filter_cfg (line 24) | def test_coco_dataset_without_filter_cfg(self):
    method test_coco_annotation_ids_unique (line 40) | def test_coco_annotation_ids_unique(self):

FILE: tests/test_datasets/test_coco_api_wrapper.py
  class TestCOCOPanoptic (line 10) | class TestCOCOPanoptic(unittest.TestCase):
    method setUp (line 12) | def setUp(self):
    method tearDown (line 15) | def tearDown(self):
    method test_create_index (line 18) | def test_create_index(self):
    method test_load_anns (line 24) | def test_load_anns(self):

FILE: tests/test_datasets/test_coco_panoptic.py
  class TestCocoPanopticDataset (line 10) | class TestCocoPanopticDataset(unittest.TestCase):
    method setUp (line 12) | def setUp(self):
    method tearDown (line 171) | def tearDown(self):
    method test_coco_panoptic_dataset (line 174) | def test_coco_panoptic_dataset(self):
    method test_coco_panoptic_dataset_without_filter_cfg (line 212) | def test_coco_panoptic_dataset_without_filter_cfg(self):

FILE: tests/test_datasets/test_crowdhuman.py
  class TestCrowdHumanDataset (line 7) | class TestCrowdHumanDataset(unittest.TestCase):
    method test_crowdhuman_init (line 9) | def test_crowdhuman_init(self):

FILE: tests/test_datasets/test_lvis.py
  class TestLVISDataset (line 15) | class TestLVISDataset(unittest.TestCase):
    method setUp (line 17) | def setUp(self) -> None:
    method tearDown (line 146) | def tearDown(self):
    method test_lvis05_dataset (line 150) | def test_lvis05_dataset(self):
    method test_lvis1_dataset (line 178) | def test_lvis1_dataset(self):
    method test_lvis1_dataset_without_filter_cfg (line 206) | def test_lvis1_dataset_without_filter_cfg(self):

FILE: tests/test_datasets/test_objects365.py
  class TestObjects365V1Dataset (line 7) | class TestObjects365V1Dataset(unittest.TestCase):
    method test_obj365v1_dataset (line 9) | def test_obj365v1_dataset(self):
    method test_obj365v1_with_unsorted_annotation (line 25) | def test_obj365v1_with_unsorted_annotation(self):
    method test_obj365v1_annotation_ids_unique (line 42) | def test_obj365v1_annotation_ids_unique(self):
  class TestObjects365V2Dataset (line 53) | class TestObjects365V2Dataset(unittest.TestCase):
    method test_obj365v2_dataset (line 55) | def test_obj365v2_dataset(self):
    method test_obj365v1_annotation_ids_unique (line 71) | def test_obj365v1_annotation_ids_unique(self):

FILE: tests/test_datasets/test_openimages.py
  class TestOpenImagesDataset (line 7) | class TestOpenImagesDataset(unittest.TestCase):
    method test_init (line 9) | def test_init(self):
  class TestOpenImagesChallengeDataset (line 23) | class TestOpenImagesChallengeDataset(unittest.TestCase):
    method test_init (line 25) | def test_init(self):

FILE: tests/test_datasets/test_pascal_voc.py
  class TestVOCDataset (line 7) | class TestVOCDataset(unittest.TestCase):
    method test_voc2007_init (line 9) | def test_voc2007_init(self):
    method test_voc2012_init (line 25) | def test_voc2012_init(self):

FILE: tests/test_datasets/test_samplers/test_batch_sampler.py
  class DummyDataset (line 13) | class DummyDataset(Dataset):
    method __init__ (line 15) | def __init__(self, length):
    method __len__ (line 19) | def __len__(self):
    method __getitem__ (line 22) | def __getitem__(self, idx):
    method get_data_info (line 25) | def get_data_info(self, idx):
  class TestAspectRatioBatchSampler (line 29) | class TestAspectRatioBatchSampler(TestCase):
    method setUp (line 32) | def setUp(self, mock):
    method test_invalid_inputs (line 37) | def test_invalid_inputs(self):
    method test_divisible_batch (line 46) | def test_divisible_batch(self):
    method test_indivisible_batch (line 58) | def test_indivisible_batch(self):

FILE: tests/test_datasets/test_samplers/test_multi_source_sampler.py
  class DummyDataset (line 13) | class DummyDataset(Dataset):
    method __init__ (line 15) | def __init__(self, length, flag):
    method __len__ (line 20) | def __len__(self):
    method __getitem__ (line 23) | def __getitem__(self, idx):
    method get_data_info (line 26) | def get_data_info(self, idx):
  class DummyConcatDataset (line 33) | class DummyConcatDataset(ConcatDataset):
    method _get_ori_dataset_idx (line 35) | def _get_ori_dataset_idx(self, idx):
    method get_data_info (line 41) | def get_data_info(self, idx: int):
  class TestMultiSourceSampler (line 46) | class TestMultiSourceSampler(TestCase):
    method setUp (line 49) | def setUp(self, mock):
    method test_multi_source_sampler (line 56) | def test_multi_source_sampler(self):
  class TestGroupMultiSourceSampler (line 80) | class TestGroupMultiSourceSampler(TestCase):
    method setUp (line 83) | def setUp(self, mock):
    method test_group_multi_source_sampler (line 90) | def test_group_multi_source_sampler(self):

FILE: tests/test_datasets/test_transforms/test_augment_wrappers.py
  class TestAutoAugment (line 16) | class TestAutoAugment(unittest.TestCase):
    method setUp (line 18) | def setUp(self):
    method test_autoaugment (line 31) | def test_autoaugment(self):
    method test_repr (line 192) | def test_repr(self):
  class TestRandAugment (line 207) | class TestRandAugment(unittest.TestCase):
    method setUp (line 209) | def setUp(self):
    method test_randaugment (line 222) | def test_randaugment(self):
    method test_repr (line 237) | def test_repr(self):

FILE: tests/test_datasets/test_transforms/test_colorspace.py
  class TestColorTransform (line 12) | class TestColorTransform(unittest.TestCase):
    method setUp (line 14) | def setUp(self):
    method test_colortransform (line 24) | def test_colortransform(self):
    method test_repr (line 38) | def test_repr(self):
  class TestColor (line 47) | class TestColor(unittest.TestCase):
    method setUp (line 49) | def setUp(self):
    method test_color (line 59) | def test_color(self):
    method test_repr (line 71) | def test_repr(self):
  class TestBrightness (line 80) | class TestBrightness(unittest.TestCase):
    method setUp (line 82) | def setUp(self):
    method test_brightness (line 92) | def test_brightness(self):
    method test_repr (line 105) | def test_repr(self):
  class TestContrast (line 114) | class TestContrast(unittest.TestCase):
    method setUp (line 116) | def setUp(self):
    method test_contrast (line 126) | def test_contrast(self):
    method test_repr (line 139) | def test_repr(self):
  class TestSharpness (line 148) | class TestSharpness(unittest.TestCase):
    method setUp (line 150) | def setUp(self):
    method test_sharpness (line 160) | def test_sharpness(self):
    method test_repr (line 173) | def test_repr(self):
  class TestSolarize (line 182) | class TestSolarize(unittest.TestCase):
    method setUp (line 184) | def setUp(self):
    method test_solarize (line 194) | def test_solarize(self):
    method test_repr (line 204) | def test_repr(self):
  class TestSolarizeAdd (line 213) | class TestSolarizeAdd(unittest.TestCase):
    method setUp (line 215) | def setUp(self):
    method test_solarize (line 225) | def test_solarize(self):
    method test_repr (line 235) | def test_repr(self):
  class TestPosterize (line 244) | class TestPosterize(unittest.TestCase):
    method setUp (line 246) | def setUp(self):
    method test_posterize (line 256) | def test_posterize(self):
    method test_repr (line 266) | def test_repr(self):
  class TestEqualize (line 275) | class TestEqualize(unittest.TestCase):
    method setUp (line 277) | def setUp(self):
    method test_equalize (line 287) | def test_equalize(self):
    method test_repr (line 297) | def test_repr(self):
  class TestAutoContrast (line 306) | class TestAutoContrast(unittest.TestCase):
    method setUp (line 308) | def setUp(self):
    method test_autocontrast (line 318) | def test_autocontrast(self):
    method test_repr (line 328) | def test_repr(self):
  class TestInvert (line 337) | class TestInvert(unittest.TestCase):
    method setUp (line 339) | def setUp(self):
    method test_invert (line 349) | def test_invert(self):
    method test_repr (line 359) | def test_repr(self):

FILE: tests/test_datasets/test_transforms/test_formatting.py
  class TestPackDetInputs (line 15) | class TestPackDetInputs(unittest.TestCase):
    method setUp (line 17) | def setUp(self):
    method test_transform (line 60) | def test_transform(self):
    method test_transform_without_ignore (line 79) | def test_transform_without_ignore(self):
    method test_repr (line 98) | def test_repr(self):

FILE: tests/test_datasets/test_transforms/test_geometric.py
  class TestGeomTransform (line 14) | class TestGeomTransform(unittest.TestCase):
    method setUp (line 16) | def setUp(self):
    method test_geomtransform (line 28) | def test_geomtransform(self):
    method test_repr (line 80) | def test_repr(self):
  class TestShearX (line 99) | class TestShearX(unittest.TestCase):
    method setUp (line 101) | def setUp(self):
    method test_shearx (line 116) | def test_shearx(self):
    method test_shearx_use_box_type (line 168) | def test_shearx_use_box_type(self):
    method test_repr (line 208) | def test_repr(self):
  class TestShearY (line 222) | class TestShearY(unittest.TestCase):
    method setUp (line 224) | def setUp(self):
    method test_sheary (line 239) | def test_sheary(self):
    method test_sheary_use_box_type (line 284) | def test_sheary_use_box_type(self):
    method test_repr (line 317) | def test_repr(self):
  class TestRotate (line 331) | class TestRotate(unittest.TestCase):
    method setUp (line 333) | def setUp(self):
    method test_rotate (line 348) | def test_rotate(self):
    method test_rotate_use_box_type (line 434) | def test_rotate_use_box_type(self):
    method test_repr (line 501) | def test_repr(self):
  class TestTranslateX (line 515) | class TestTranslateX(unittest.TestCase):
    method setUp (line 517) | def setUp(self):
    method test_translatex (line 532) | def test_translatex(self):
    method test_translatex_use_box_type (line 582) | def test_translatex_use_box_type(self):
    method test_repr (line 622) | def test_repr(self):
  class TestTranslateY (line 636) | class TestTranslateY(unittest.TestCase):
    method setUp (line 638) | def setUp(self):
    method test_translatey (line 653) | def test_translatey(self):
    method test_translatey_use_box_type (line 702) | def test_translatey_use_box_type(self):
    method test_repr (line 741) | def test_repr(self):

FILE: tests/test_datasets/test_transforms/test_instaboost.py
  class TestInstaboost (line 12) | class TestInstaboost(unittest.TestCase):
    method setUp (line 14) | def setUp(self):
    method test_transform (line 43) | def test_transform(self):
    method test_repr (line 54) | def test_repr(self):

FILE: tests/test_datasets/test_transforms/test_loading.py
  class TestLoadAnnotations (line 26) | class TestLoadAnnotations(unittest.TestCase):
    method setUp (line 28) | def setUp(self):
    method test_load_bboxes (line 58) | def test_load_bboxes(self):
    method test_load_labels (line 76) | def test_load_labels(self):
    method test_load_mask (line 89) | def test_load_mask(self):
    method test_load_mask_poly2mask (line 101) | def test_load_mask_poly2mask(self):
    method test_repr (line 113) | def test_repr(self):
  class TestFilterAnnotations (line 128) | class TestFilterAnnotations(unittest.TestCase):
    method setUp (line 130) | def setUp(self):
    method test_transform (line 151) | def test_transform(self):
    method test_repr (line 181) | def test_repr(self):
  class TestLoadPanopticAnnotations (line 191) | class TestLoadPanopticAnnotations(unittest.TestCase):
    method setUp (line 193) | def setUp(self):
    method tearDown (line 252) | def tearDown(self):
    method test_init_without_panopticapi (line 256) | def test_init_without_panopticapi(self):
    method test_transform (line 264) | def test_transform(self):
  class TestLoadImageFromNDArray (line 316) | class TestLoadImageFromNDArray(unittest.TestCase):
    method setUp (line 318) | def setUp(self):
    method test_transform (line 326) | def test_transform(self):
    method test_repr (line 339) | def test_repr(self):
  class TestLoadMultiChannelImageFromFiles (line 350) | class TestLoadMultiChannelImageFromFiles(unittest.TestCase):
    method setUp (line 352) | def setUp(self):
    method tearDown (line 366) | def tearDown(self):
    method test_transform (line 370) | def test_transform(self):
    method test_rper (line 383) | def test_rper(self):
  class TestLoadProposals (line 393) | class TestLoadProposals(unittest.TestCase):
    method test_transform (line 395) | def test_transform(self):
    method test_repr (line 444) | def test_repr(self):
  class TestLoadEmptyAnnotations (line 450) | class TestLoadEmptyAnnotations(unittest.TestCase):
    method test_transform (line 452) | def test_transform(self):
    method test_repr (line 467) | def test_repr(self):

FILE: tests/test_datasets/test_transforms/test_transforms.py
  class TestResize (line 35) | class TestResize(unittest.TestCase):
    method setUp (line 37) | def setUp(self):
    method test_resize (line 56) | def test_resize(self):
    method test_resize_use_box_type (line 90) | def test_resize_use_box_type(self):
    method test_repr (line 126) | def test_repr(self):
  class TestFIXShapeResize (line 135) | class TestFIXShapeResize(unittest.TestCase):
    method setUp (line 137) | def setUp(self):
    method test_resize (line 160) | def test_resize(self):
    method test_resize_with_boxlist (line 195) | def test_resize_with_boxlist(self):
    method test_repr (line 240) | def test_repr(self):
  class TestRandomFlip (line 249) | class TestRandomFlip(unittest.TestCase):
    method setUp (line 251) | def setUp(self):
    method test_transform (line 268) | def test_transform(self):
    method test_transform_use_box_type (line 307) | def test_transform_use_box_type(self):
    method test_repr (line 339) | def test_repr(self):
  class TestPad (line 345) | class TestPad(unittest.TestCase):
    method setUp (line 347) | def setUp(self):
    method test_transform (line 360) | def test_transform(self):
    method test_repr (line 391) | def test_repr(self):
  class TestMinIoURandomCrop (line 400) | class TestMinIoURandomCrop(unittest.TestCase):
    method test_transform (line 402) | def test_transform(self):
    method test_transform_use_box_type (line 430) | def test_transform_use_box_type(self):
    method test_repr (line 458) | def test_repr(self):
  class TestPhotoMetricDistortion (line 467) | class TestPhotoMetricDistortion(unittest.TestCase):
    method test_transform (line 469) | def test_transform(self):
    method test_repr (line 486) | def test_repr(self):
  class TestExpand (line 496) | class TestExpand(unittest.TestCase):
    method setUp (line 498) | def setUp(self):
    method test_transform (line 514) | def test_transform(self):
    method test_transform_use_box_type (line 522) | def test_transform_use_box_type(self):
    method test_repr (line 532) | def test_repr(self):
  class TestSegRescale (line 542) | class TestSegRescale(unittest.TestCase):
    method setUp (line 544) | def setUp(self) -> None:
    method test_transform (line 548) | def test_transform(self):
    method test_repr (line 558) | def test_repr(self):
  class TestRandomCrop (line 564) | class TestRandomCrop(unittest.TestCase):
    method test_init (line 566) | def test_init(self):
    method test_transform (line 593) | def test_transform(self):
    method test_transform_use_box_type (line 704) | def test_transform_use_box_type(self):
    method test_repr (line 793) | def test_repr(self):
  class TestCutOut (line 813) | class TestCutOut(unittest.TestCase):
    method setUp (line 815) | def setUp(self):
    method test_transform (line 825) | def test_transform(self):
    method test_repr (line 861) | def test_repr(self):
  class TestMosaic (line 875) | class TestMosaic(unittest.TestCase):
    method setUp (line 877) | def setUp(self):
    method test_transform (line 899) | def test_transform(self):
    method test_transform_with_no_gt (line 922) | def test_transform_with_no_gt(self):
    method test_transform_use_box_type (line 938) | def test_transform_use_box_type(self):
    method test_repr (line 951) | def test_repr(self):
  class TestMixUp (line 960) | class TestMixUp(unittest.TestCase):
    method setUp (line 962) | def setUp(self):
    method test_transform (line 984) | def test_transform(self):
    method test_transform_use_box_type (line 1007) | def test_transform_use_box_type(self):
    method test_repr (line 1021) | def test_repr(self):
  class TestRandomAffine (line 1036) | class TestRandomAffine(unittest.TestCase):
    method setUp (line 1038) | def setUp(self):
    method test_transform (line 1057) | def test_transform(self):
    method test_transform_use_box_type (line 1078) | def test_transform_use_box_type(self):
    method test_repr (line 1091) | def test_repr(self):
  class TestYOLOXHSVRandomAug (line 1106) | class TestYOLOXHSVRandomAug(unittest.TestCase):
    method setUp (line 1108) | def setUp(self):
    method test_transform (line 1129) | def test_transform(self):
    method test_repr (line 1140) | def test_repr(self):
  class TestRandomCenterCropPad (line 1148) | class TestRandomCenterCropPad(unittest.TestCase):
    method test_init (line 1150) | def test_init(self):
    method test_transform (line 1222) | def test_transform(self):
    method test_transform_use_box_type (line 1267) | def test_transform_use_box_type(self):
  class TestCopyPaste (line 1313) | class TestCopyPaste(unittest.TestCase):
    method setUp (line 1315) | def setUp(self):
    method test_transform (line 1348) | def test_transform(self):
    method test_transform_use_box_type (line 1412) | def test_transform_use_box_type(self):
    method test_repr (line 1477) | def test_repr(self):
  class TestAlbu (line 1486) | class TestAlbu(unittest.TestCase):
    method test_transform (line 1489) | def test_transform(self):
    method test_repr (line 1539) | def test_repr(self):
  class TestCorrupt (line 1550) | class TestCorrupt(unittest.TestCase):
    method test_transform (line 1552) | def test_transform(self):
    method test_repr (line 1569) | def test_repr(self):
  class TestRandomShift (line 1578) | class TestRandomShift(unittest.TestCase):
    method test_init (line 1580) | def test_init(self):
    method test_transform (line 1589) | def test_transform(self):
    method test_transform_use_box_type (line 1609) | def test_transform_use_box_type(self):
    method test_repr (line 1629) | def test_repr(self):
  class TestRandomErasing (line 1637) | class TestRandomErasing(unittest.TestCase):
    method setUp (line 1639) | def setUp(self):
    method test_transform (line 1647) | def test_transform(self):
    method test_transform_use_box_type (line 1668) | def test_transform_use_box_type(self):
    method test_repr (line 1692) | def test_repr(self):

FILE: tests/test_datasets/test_transforms/test_wrappers.py
  class TestMultiBranch (line 14) | class TestMultiBranch(unittest.TestCase):
    method setUp (line 16) | def setUp(self):
    method test_transform (line 89) | def test_transform(self):
    method test_repr (line 127) | def test_repr(self):
  class TestRandomOrder (line 136) | class TestRandomOrder(unittest.TestCase):
    method setUp (line 138) | def setUp(self):
    method test_transform (line 154) | def test_transform(self):
    method test_repr (line 169) | def test_repr(self):

FILE: tests/test_datasets/test_transforms/utils.py
  function create_random_bboxes (line 9) | def create_random_bboxes(num_bboxes, img_w, img_h):
  function create_full_masks (line 18) | def create_full_masks(gt_bboxes, img_w, img_h):
  function construct_toy_data (line 28) | def construct_toy_data(poly2mask, use_box_type=False):
  function check_result_same (line 55) | def check_result_same(results, pipeline_results, check_keys):

FILE: tests/test_datasets/test_tta.py
  class TestMuitiScaleFlipAug (line 12) | class TestMuitiScaleFlipAug(TestCase):
    method test_exception (line 14) | def test_exception(self):
    method test_multi_scale_flip_aug (line 22) | def test_multi_scale_flip_aug(self):

FILE: tests/test_engine/test_hooks/test_checkloss_hook.py
  class TestCheckInvalidLossHook (line 10) | class TestCheckInvalidLossHook(TestCase):
    method test_after_train_iter (line 12) | def test_after_train_iter(self):

FILE: tests/test_engine/test_hooks/test_mean_teacher_hook.py
  class ToyModel (line 21) | class ToyModel(nn.Module):
    method __init__ (line 23) | def __init__(self):
    method forward (line 27) | def forward(self, inputs, data_samples, mode='tensor'):
  class ToyModel1 (line 41) | class ToyModel1(BaseModel, ToyModel):
    method __init__ (line 43) | def __init__(self):
    method forward (line 46) | def forward(self, *args, **kwargs):
  class ToyModel2 (line 50) | class ToyModel2(BaseModel):
    method __init__ (line 52) | def __init__(self):
    method forward (line 57) | def forward(self, *args, **kwargs):
  class DummyDataset (line 62) | class DummyDataset(Dataset):
    method metainfo (line 68) | def metainfo(self):
    method __len__ (line 71) | def __len__(self):
    method __getitem__ (line 74) | def __getitem__(self, index):
  class ToyMetric1 (line 78) | class ToyMetric1(BaseMetric):
    method __init__ (line 80) | def __init__(self, collect_device='cpu', dummy_metrics=None):
    method process (line 84) | def process(self, data_batch, predictions):
    method compute_metrics (line 88) | def compute_metrics(self, results):
  class TestMeanTeacherHook (line 92) | class TestMeanTeacherHook(TestCase):
    method setUp (line 94) | def setUp(self):
    method tearDown (line 97) | def tearDown(self):
    method test_mean_teacher_hook (line 100) | def test_mean_teacher_hook(self):

FILE: tests/test_engine/test_hooks/test_memory_profiler_hook.py
  class TestMemoryProfilerHook (line 8) | class TestMemoryProfilerHook(TestCase):
    method test_after_train_iter (line 10) | def test_after_train_iter(self):
    method test_after_val_iter (line 20) | def test_after_val_iter(self):
    method test_after_test_iter (line 30) | def test_after_test_iter(self):

FILE: tests/test_engine/test_hooks/test_num_class_check_hook.py
  class TestNumClassCheckHook (line 14) | class TestNumClassCheckHook(TestCase):
    method setUp (line 16) | def setUp(self):
    method test_before_train_epch (line 66) | def test_before_train_epch(self):
    method test_before_val_epoch (line 87) | def test_before_val_epoch(self):

FILE: tests/test_engine/test_hooks/test_sync_norm_hook.py
  class TestSyncNormHook (line 10) | class TestSyncNormHook(TestCase):
    method test_before_val_epoch_non_dist (line 14) | def test_before_val_epoch_non_dist(self, mock):
    method test_before_val_epoch_dist (line 25) | def test_before_val_epoch_dist(self, mock):
    method test_before_val_epoch_dist_no_norm (line 36) | def test_before_val_epoch_dist_no_norm(self, mock):

FILE: tests/test_engine/test_hooks/test_visualization_hook.py
  function _rand_bboxes (line 16) | def _rand_bboxes(num_boxes, h, w):
  class TestVisualizationHook (line 28) | class TestVisualizationHook(TestCase):
    method setUp (line 30) | def setUp(self) -> None:
    method test_after_val_iter (line 45) | def test_after_val_iter(self):
    method test_after_test_iter (line 51) | def test_after_test_iter(self):

FILE: tests/test_engine/test_hooks/test_yolox_mode_switch_hook.py
  class TestYOLOXModeSwitchHook (line 8) | class TestYOLOXModeSwitchHook(TestCase):
    method test_is_model_wrapper_and_persistent_workers_on (line 11) | def test_is_model_wrapper_and_persistent_workers_on(
    method test_not_model_wrapper_and_persistent_workers_off (line 34) | def test_not_model_wrapper_and_persistent_workers_off(self):

FILE: tests/test_engine/test_optimizers/test_layer_decay_optimizer_constructor.py
  class ToyConvNeXt (line 90) | class ToyConvNeXt(nn.Module):
    method __init__ (line 92) | def __init__(self):
  class ToyDetector (line 116) | class ToyDetector(nn.Module):
    method __init__ (line 118) | def __init__(self, backbone):
  class PseudoDataParallel (line 124) | class PseudoDataParallel(nn.Module):
    method __init__ (line 126) | def __init__(self, model):
  function check_optimizer_lr_wd (line 131) | def check_optimizer_lr_wd(optimizer, gt_lr_wd):
  function test_learning_rate_decay_optimizer_constructor (line 144) | def test_learning_rate_decay_optimizer_constructor():

FILE: tests/test_engine/test_runner/test_loops.py
  class ToyModel (line 20) | class ToyModel(nn.Module):
    method __init__ (line 22) | def __init__(self):
    method forward (line 26) | def forward(self, inputs, data_samples, mode='tensor'):
  class ToyModel1 (line 40) | class ToyModel1(BaseModel, ToyModel):
    method __init__ (line 42) | def __init__(self):
    method forward (line 45) | def forward(self, *args, **kwargs):
  class ToyModel2 (line 49) | class ToyModel2(BaseModel):
    method __init__ (line 51) | def __init__(self):
    method forward (line 57) | def forward(self, *args, **kwargs):
  class DummyDataset (line 62) | class DummyDataset(Dataset):
    method metainfo (line 68) | def metainfo(self):
    method __len__ (line 71) | def __len__(self):
    method __getitem__ (line 74) | def __getitem__(self, index):
  class TestTeacherStudentValLoop (line 78) | class TestTeacherStudentValLoop(TestCase):
    method setUp (line 80) | def setUp(self):
    method tearDown (line 83) | def tearDown(self):
    method test_teacher_student_val_loop (line 86) | def test_teacher_student_val_loop(self):

FILE: tests/test_engine/test_schedulers/test_quadratic_warmup.py
  class ToyModel (line 15) | class ToyModel(torch.nn.Module):
    method __init__ (line 17) | def __init__(self):
    method forward (line 22) | def forward(self, x):
  class TestQuadraticWarmupScheduler (line 26) | class TestQuadraticWarmupScheduler(TestCase):
    method setUp (line 28) | def setUp(self):
    method _test_scheduler_value (line 38) | def _test_scheduler_value(self,
    method test_quadratic_warmup_scheduler (line 59) | def test_quadratic_warmup_scheduler(self):
    method test_quadratic_warmup_scheduler_convert_iterbased (line 72) | def test_quadratic_warmup_scheduler_convert_iterbased(self):
    method test_quadratic_warmup_lr (line 89) | def test_quadratic_warmup_lr(self):
    method test_quadratic_warmup_momentum (line 99) | def test_quadratic_warmup_momentum(self):

FILE: tests/test_evaluation/test_metrics/test_cityscapes_metric.py
  class TestCityScapesMetric (line 18) | class TestCityScapesMetric(unittest.TestCase):
    method setUp (line 20) | def setUp(self):
    method tearDown (line 23) | def tearDown(self):
    method test_init (line 28) | def test_init(self):
    method test_evaluate (line 42) | def test_evaluate(self):

FILE: tests/test_evaluation/test_metrics/test_coco_metric.py
  class TestCocoMetric (line 13) | class TestCocoMetric(TestCase):
    method _create_dummy_coco_json (line 15) | def _create_dummy_coco_json(self, json_name):
    method _create_dummy_results (line 89) | def _create_dummy_results(self):
    method setUp (line 102) | def setUp(self):
    method tearDown (line 105) | def tearDown(self):
    method test_init (line 108) | def test_init(self):
    method test_evaluate (line 114) | def test_evaluate(self):
    method test_classwise_evaluate (line 198) | def test_classwise_evaluate(self):
    method test_manually_set_iou_thrs (line 224) | def test_manually_set_iou_thrs(self):
    method test_fast_eval_recall (line 235) | def test_fast_eval_recall(self):
    method test_evaluate_proposal (line 265) | def test_evaluate_proposal(self):
    method test_empty_results (line 288) | def test_empty_results(self):
    method test_evaluate_without_json (line 309) | def test_evaluate_without_json(self):
    method test_format_only (line 374) | def test_format_only(self):

FILE: tests/test_evaluation/test_metrics/test_coco_occluded_metric.py
  function test_coco_occluded_separated_metric (line 12) | def test_coco_occluded_separated_metric():

FILE: tests/test_evaluation/test_metrics/test_coco_panoptic_metric.py
  class TestCocoPanopticMetric (line 20) | class TestCocoPanopticMetric(unittest.TestCase):
    method _create_panoptic_gt_annotations (line 22) | def _create_panoptic_gt_annotations(self, ann_file, seg_map_dir):
    method _create_panoptic_data_samples (line 110) | def _create_panoptic_data_samples(self):
    method setUp (line 159) | def setUp(self):
    method tearDown (line 184) | def tearDown(self):
    method test_init (line 188) | def test_init(self):
    method test_evaluate_without_json (line 193) | def test_evaluate_without_json(self):
    method test_evaluate_with_json (line 222) | def test_evaluate_with_json(self):
    method test_format_only (line 262) | def test_format_only(self):

FILE: tests/test_evaluation/test_metrics/test_crowdhuman_metric.py
  class TestCrowdHumanMetric (line 11) | class TestCrowdHumanMetric(TestCase):
    method _create_dummy_results (line 13) | def _create_dummy_results(self):
    method setUp (line 22) | def setUp(self):
    method tearDown (line 27) | def tearDown(self):
    method test_init (line 30) | def test_init(self):
    method test_evaluate (line 34) | def test_evaluate(self):

FILE: tests/test_evaluation/test_metrics/test_dump_det_results.py
  class TestDumpResults (line 14) | class TestDumpResults(TestCase):
    method test_init (line 16) | def test_init(self):
    method test_process (line 21) | def test_process(self):
    method test_compute_metrics (line 40) | def test_compute_metrics(self):

FILE: tests/test_evaluation/test_metrics/test_lvis_metric.py
  class TestLVISMetric (line 19) | class TestLVISMetric(unittest.TestCase):
    method _create_dummy_lvis_json (line 21) | def _create_dummy_lvis_json(self, json_name):
    method _create_dummy_results (line 95) | def _create_dummy_results(self):
    method setUp (line 108) | def setUp(self):
    method tearDown (line 111) | def tearDown(self):
    method test_init (line 115) | def test_init(self):
    method test_evaluate (line 122) | def test_evaluate(self):
    method test_classwise_evaluate (line 215) | def test_classwise_evaluate(self):
    method test_manually_set_iou_thrs (line 246) | def test_manually_set_iou_thrs(self):
    method test_fast_eval_recall (line 259) | def test_fast_eval_recall(self):
    method test_evaluate_proposal (line 292) | def test_evaluate_proposal(self):
    method test_empty_results (line 314) | def test_empty_results(self):
    method test_format_only (line 337) | def test_format_only(self):

FILE: tests/test_evaluation/test_metrics/test_openimages_metric.py
  class TestOpenImagesMetric (line 12) | class TestOpenImagesMetric(unittest.TestCase):
    method _create_dummy_results (line 14) | def _create_dummy_results(self):
    method test_init (line 25) | def test_init(self):
    method test_eval (line 36) | def test_eval(self):

FILE: tests/test_models/test_backbones/test_csp_darknet.py
  function test_csp_darknet_backbone (line 10) | def test_csp_darknet_backbone():

FILE: tests/test_models/test_backbones/test_detectors_resnet.py
  function test_detectorrs_resnet_backbone (line 7) | def test_detectorrs_resnet_backbone():

FILE: tests/test_models/test_backbones/test_efficientnet.py
  function test_efficientnet_backbone (line 7) | def test_efficientnet_backbone():

FILE: tests/test_models/test_backbones/test_hourglass.py
  function test_hourglass_backbone (line 8) | def test_hourglass_backbone():

FILE: tests/test_models/test_backbones/test_hrnet.py
  function test_hrmodule (line 10) | def test_hrmodule(block):
  function test_hrnet_backbone (line 54) | def test_hrnet_backbone():

FILE: tests/test_models/test_backbones/test_mobilenet_v2.py
  function test_mobilenetv2_backbone (line 11) | def test_mobilenetv2_backbone():

FILE: tests/test_models/test_backbones/test_pvt.py
  function test_pvt_block (line 9) | def test_pvt_block():
  function test_pvt (line 21) | def test_pvt():
  function test_pvtv2 (line 67) | def test_pvtv2():

FILE: tests/test_models/test_backbones/test_regnet.py
  function test_regnet_backbone (line 36) | def test_regnet_backbone(arch_name, arch, out_channels):

FILE: tests/test_models/test_backbones/test_renext.py
  function test_renext_bottleneck (line 10) | def test_renext_bottleneck():
  function test_resnext_backbone (line 59) | def test_resnext_backbone():

FILE: tests/test_models/test_backbones/test_res2net.py
  function test_res2net_bottle2neck (line 10) | def test_res2net_bottle2neck():
  function test_res2net_backbone (line 44) | def test_res2net_backbone():

FILE: tests/test_models/test_backbones/test_resnest.py
  function test_resnest_bottleneck (line 9) | def test_resnest_bottleneck():
  function test_resnest_backbone (line 27) | def test_resnest_backbone():

FILE: tests/test_models/test_backbones/test_resnet.py
  function assert_params_all_zeros (line 14) | def assert_params_all_zeros(module) -> bool:
  function test_resnet_basic_block (line 37) | def test_resnet_basic_block():
  function test_resnet_bottleneck (line 86) | def test_resnet_bottleneck():
  function test_simplied_basic_block (line 220) | def test_simplied_basic_block():
  function test_resnet_res_layer (line 273) | def test_resnet_res_layer():
  function test_resnest_stem (line 329) | def test_resnest_stem():
  function test_resnet_backbone (line 369) | def test_resnet_backbone():

FILE: tests/test_models/test_backbones/test_swin.py
  function test_swin_block (line 7) | def test_swin_block():
  function test_swin_transformer (line 26) | def test_swin_transformer():

FILE: tests/test_models/test_backbones/test_trident_resnet.py
  function test_trident_resnet_bottleneck (line 9) | def test_trident_resnet_bottleneck():
  function test_trident_resnet_backbone (line 156) | def test_trident_resnet_backbone():

FILE: tests/test_models/test_backbones/utils.py
  function is_block (line 11) | def is_block(modules):
  function is_norm (line 19) | def is_norm(modules):
  function check_norm_state (line 26) | def check_norm_state(modules, train_state):

FILE: tests/test_models/test_data_preprocessors/test_batch_resize.py
  class TestDetDataPreprocessor (line 8) | class TestDetDataPreprocessor(TestCase):
    method test_batch_resize (line 10) | def test_batch_resize(self):

FILE: tests/test_models/test_data_preprocessors/test_boxinst_preprocessor.py
  class TestBoxInstDataPreprocessor (line 11) | class TestBoxInstDataPreprocessor(TestCase):
    method test_forward (line 13) | def test_forward(self):

FILE: tests/test_models/test_data_preprocessors/test_data_preprocessor.py
  class TestDetDataPreprocessor (line 15) | class TestDetDataPreprocessor(TestCase):
    method test_init (line 17) | def test_init(self):
    method test_forward (line 37) | def test_forward(self):
    method test_batch_sync_random_resize (line 127) | def test_batch_sync_random_resize(self):
    method test_batch_fixed_size_pad (line 156) | def test_batch_fixed_size_pad(self):
  class TestMultiBranchDataPreprocessor (line 303) | class TestMultiBranchDataPreprocessor(TestCase):
    method setUp (line 305) | def setUp(self):
    method test_multi_data_preprocessor (line 342) | def test_multi_data_preprocessor(self):

FILE: tests/test_models/test_dense_heads/test_anchor_head.py
  class TestAnchorHead (line 12) | class TestAnchorHead(TestCase):
    method test_anchor_head_loss (line 14) | def test_anchor_head_loss(self):

FILE: tests/test_models/test_dense_heads/test_atss_head.py
  class TestATSSHead (line 12) | class TestATSSHead(TestCase):
    method test_atss_head_loss (line 14) | def test_atss_head_loss(self):

FILE: tests/test_models/test_dense_heads/test_autoassign_head.py
  class TestAutoAssignHead (line 10) | class TestAutoAssignHead(TestCase):
    method test_autoassign_head_loss (line 12) | def test_autoassign_head_loss(self):

FILE: tests/test_models/test_dense_heads/test_boxinst_head.py
  function _rand_masks (line 14) | def _rand_masks(num_items, bboxes, img_w, img_h):
  function _fake_mask_feature_head (line 25) | def _fake_mask_feature_head():
  class TestBoxInstHead (line 38) | class TestBoxInstHead(TestCase):
    method test_boxinst_maskhead_loss (line 40) | def test_boxinst_maskhead_loss(self):

FILE: tests/test_models/test_dense_heads/test_cascade_rpn_head.py
  class TestStageCascadeRPNHead (line 84) | class TestStageCascadeRPNHead(TestCase):
    method test_cascade_rpn_head_loss (line 86) | def test_cascade_rpn_head_loss(self):
    method test_cascade_rpn_head_loss_and_predict (line 136) | def test_cascade_rpn_head_loss_and_predict(self):
    method test_cascade_rpn_head_predict (line 162) | def test_cascade_rpn_head_predict(self):

FILE: tests/test_models/test_dense_heads/test_centernet_head.py
  class TestCenterNetHead (line 11) | class TestCenterNetHead(TestCase):
    method test_center_head_loss (line 13) | def test_center_head_loss(self):
    method test_centernet_head_get_targets (line 57) | def test_centernet_head_get_targets(self):
    method test_centernet_head_get_results (line 96) | def test_centernet_head_get_results(self):

FILE: tests/test_models/test_dense_heads/test_centernet_update_head.py
  class TestCenterNetUpdateHead (line 10) | class TestCenterNetUpdateHead(TestCase):
    method test_centernet_update_head_loss (line 12) | def test_centernet_update_head_loss(self):

FILE: tests/test_models/test_dense_heads/test_centripetal_head.py
  class TestCentripetalHead (line 10) | class TestCentripetalHead(TestCase):
    method test_centripetal_head_loss (line 12) | def test_centripetal_head_loss(self):

FILE: tests/test_models/test_dense_heads/test_condinst_head.py
  function _rand_masks (line 13) | def _rand_masks(num_items, bboxes, img_w, img_h):
  function _fake_mask_feature_head (line 24) | def _fake_mask_feature_head():
  class TestCondInstHead (line 37) | class TestCondInstHead(TestCase):
    method test_condinst_bboxhead_loss (line 39) | def test_condinst_bboxhead_loss(self):
    method test_condinst_maskhead_loss (line 131) | def test_condinst_maskhead_loss(self):

FILE: tests/test_models/test_dense_heads/test_corner_head.py
  class TestCornerHead (line 11) | class TestCornerHead(TestCase):
    method test_corner_head_loss (line 13) | def test_corner_head_loss(self):
    method test_corner_head_encode_and_decode_heatmap (line 104) | def test_corner_head_encode_and_decode_heatmap(self):

FILE: tests/test_models/test_dense_heads/test_ddod_head.py
  class TestDDODHead (line 12) | class TestDDODHead(TestCase):
    method test_ddod_head_loss (line 14) | def test_ddod_head_loss(self):

FILE: tests/test_models/test_dense_heads/test_embedding_rpn_head.py
  class TestEmbeddingRPNHead (line 12) | class TestEmbeddingRPNHead(TestCase):
    method test_init (line 14) | def test_init(self):
    method test_loss_and_predict (line 22) | def test_loss_and_predict(self):

FILE: tests/test_models/test_dense_heads/test_fcos_head.py
  class TestFCOSHead (line 10) | class TestFCOSHead(TestCase):
    method test_fcos_head_loss (line 12) | def test_fcos_head_loss(self):

FILE: tests/test_models/test_dense_heads/test_fovea_head.py
  class TestFOVEAHead (line 10) | class TestFOVEAHead(TestCase):
    method test_fovea_head_loss (line 12) | def test_fovea_head_loss(self):

FILE: tests/test_models/test_dense_heads/test_free_anchor_head.py
  class TestFreeAnchorRetinaHead (line 11) | class TestFreeAnchorRetinaHead(TestCase):
    method test_free_anchor_head_loss (line 13) | def test_free_anchor_head_loss(self):

FILE: tests/test_models/test_dense_heads/test_fsaf_head.py
  class TestFSAFHead (line 12) | class TestFSAFHead(TestCase):
    method test_fsaf_head_loss (line 14) | def test_fsaf_head_loss(self):

FILE: tests/test_models/test_dense_heads/test_ga_retina_head.py
  class TestGARetinaHead (line 81) | class TestGARetinaHead(TestCase):
    method test_ga_retina_head_init_and_forward (line 83) | def test_ga_retina_head_init_and_forward(self):

FILE: tests/test_models/test_dense_heads/test_ga_rpn_head.py
  class TestGARPNHead (line 84) | class TestGARPNHead(TestCase):
    method test_ga_rpn_head_loss (line 86) | def test_ga_rpn_head_loss(self):
    method test_ga_rpn_head_predict_by_feat (line 121) | def test_ga_rpn_head_predict_by_feat(self):

FILE: tests/test_models/test_dense_heads/test_gfl_head.py
  class TestGFLHead (line 12) | class TestGFLHead(TestCase):
    method test_gfl_head_loss (line 14) | def test_gfl_head_loss(self):

FILE: tests/test_models/test_dense_heads/test_guided_anchor_head.py
  class TestGuidedAnchorHead (line 81) | class TestGuidedAnchorHead(TestCase):
    method test_guided_anchor_head_loss (line 83) | def test_guided_anchor_head_loss(self):
    method test_guided_anchor_head_predict_by_feat (line 142) | def test_guided_anchor_head_predict_by_feat(self):

FILE: tests/test_models/test_dense_heads/test_lad_head.py
  class TestLADHead (line 14) | class TestLADHead(TestCase):
    method test_lad_head_loss (line 16) | def test_lad_head_loss(self):

FILE: tests/test_models/test_dense_heads/test_ld_head.py
  class TestLDHead (line 12) | class TestLDHead(TestCase):
    method test_ld_head_loss (line 14) | def test_ld_head_loss(self):

FILE: tests/test_models/test_dense_heads/test_nasfcos_head.py
  class TestNASFCOSHead (line 10) | class TestNASFCOSHead(TestCase):
    method test_nasfcos_head_loss (line 12) | def test_nasfcos_head_loss(self):

FILE: tests/test_models/test_dense_heads/test_paa_head.py
  class TestPAAHead (line 14) | class TestPAAHead(TestCase):
    method test_paa_head_loss (line 16) | def test_paa_head_loss(self):

FILE: tests/test_models/test_dense_heads/test_pisa_retinanet_head.py
  class TestPISARetinaHead (line 13) | class TestPISARetinaHead(TestCase):
    method test_pisa_reitnanet_head_loss (line 15) | def test_pisa_reitnanet_head_loss(self):

FILE: tests/test_models/test_dense_heads/test_pisa_ssd_head.py
  class TestPISASSDHead (line 13) | class TestPISASSDHead(TestCase):
    method test_pisa_ssd_head_loss (line 15) | def test_pisa_ssd_head_loss(self):

FILE: tests/test_models/test_dense_heads/test_reppoints_head.py
  class TestRepPointsHead (line 12) | class TestRepPointsHead(unittest.TestCase):
    method test_head_loss (line 15) | def test_head_loss(self, transform_method='moment'):

FILE: tests/test_models/test_dense_heads/test_retina_sepBN_head.py
  class TestRetinaSepBNHead (line 12) | class TestRetinaSepBNHead(TestCase):
    method test_init (line 14) | def test_init(self):
    method test_retina_sepbn_head_loss (line 23) | def test_retina_sepbn_head_loss(self):

FILE: tests/test_models/test_dense_heads/test_rpn_head.py
  class TestRPNHead (line 13) | class TestRPNHead(TestCase):
    method test_init (line 15) | def test_init(self):
    method test_rpn_head_loss (line 28) | def test_rpn_head_loss(self):
    method test_bbox_post_process (line 107) | def test_bbox_post_process(self):

FILE: tests/test_models/test_dense_heads/test_sabl_retina_head.py
  class TestSABLRetinaHead (line 11) | class TestSABLRetinaHead(TestCase):
    method test_sabl_retina_head (line 13) | def test_sabl_retina_head(self):

FILE: tests/test_models/test_dense_heads/test_solo_head.py
  function _rand_masks (line 16) | def _rand_masks(num_items, bboxes, img_w, img_h):
  class TestSOLOHead (line 27) | class TestSOLOHead(TestCase):
    method test_mask_head_loss (line 31) | def test_mask_head_loss(self, MaskHead):
    method test_solo_head_empty_result (line 92) | def test_solo_head_empty_result(self):
    method test_decoupled_solo_head_empty_result (line 118) | def test_decoupled_solo_head_empty_result(self):

FILE: tests/test_models/test_dense_heads/test_solov2_head.py
  function _rand_masks (line 14) | def _rand_masks(num_items, bboxes, img_w, img_h):
  function _fake_mask_feature_head (line 25) | def _fake_mask_feature_head():
  class TestSOLOv2Head (line 36) | class TestSOLOv2Head(TestCase):
    method test_solov2_head_loss (line 38) | def test_solov2_head_loss(self):
    method test_solov2_head_empty_result (line 102) | def test_solov2_head_empty_result(self):

FILE: tests/test_models/test_dense_heads/test_ssd_head.py
  class TestSSDHead (line 13) | class TestSSDHead(TestCase):
    method test_ssd_head_loss (line 15) | def test_ssd_head_loss(self):

FILE: tests/test_models/test_dense_heads/test_tood_head.py
  function _tood_head (line 12) | def _tood_head(anchor_type):
  class TestTOODHead (line 68) | class TestTOODHead(TestCase):
    method test_tood_head_anchor_free_loss (line 70) | def test_tood_head_anchor_free_loss(self):
    method test_tood_head_anchor_based_loss (line 158) | def test_tood_head_anchor_based_loss(self):

FILE: tests/test_models/test_dense_heads/test_vfnet_head.py
  class TestVFNetHead (line 12) | class TestVFNetHead(TestCase):
    method test_vfnet_head_loss (line 14) | def test_vfnet_head_loss(self):
    method test_vfnet_head_loss_without_atss (line 75) | def test_vfnet_head_loss_without_atss(self):

FILE: tests/test_models/test_dense_heads/test_yolo_head.py
  class TestYOLOV3Head (line 11) | class TestYOLOV3Head(TestCase):
    method test_yolo_head_loss (line 13) | def test_yolo_head_loss(self):

FILE: tests/test_models/test_dense_heads/test_yolof_head.py
  class TestYOLOFHead (line 12) | class TestYOLOFHead(TestCase):
    method test_yolof_head_loss (line 14) | def test_yolof_head_loss(self):

FILE: tests/test_models/test_dense_heads/test_yolox_head.py
  class TestYOLOXHead (line 14) | class TestYOLOXHead(TestCase):
    method test_init_weights (line 16) | def test_init_weights(self):
    method test_predict_by_feat (line 28) | def test_predict_by_feat(self):
    method test_loss_by_feat (line 64) | def test_loss_by_feat(self):

FILE: tests/test_models/test_detectors/test_conditional_detr.py
  class TestConditionalDETR (line 13) | class TestConditionalDETR(TestCase):
    method setUp (line 15) | def setUp(self) -> None:
    method test_conditional_detr_head_loss (line 18) | def test_conditional_detr_head_loss(self):

FILE: tests/test_models/test_detectors/test_cornernet.py
  class TestCornerNet (line 13) | class TestCornerNet(TestCase):
    method setUp (line 15) | def setUp(self) -> None:
    method test_init (line 42) | def test_init(self):
    method test_cornernet_forward_loss_mode (line 55) | def test_cornernet_forward_loss_mode(self):
    method test_cornernet_forward_predict_mode (line 67) | def test_cornernet_forward_predict_mode(self):
    method test_cornernet_forward_tensor_mode (line 84) | def test_cornernet_forward_tensor_mode(self):

FILE: tests/test_models/test_detectors/test_dab_detr.py
  class TestDABDETR (line 13) | class TestDABDETR(TestCase):
    method setUp (line 15) | def setUp(self) -> None:
    method test_dab_detr_head_loss (line 18) | def test_dab_detr_head_loss(self):

FILE: tests/test_models/test_detectors/test_deformable_detr.py
  class TestDeformableDETR (line 13) | class TestDeformableDETR(TestCase):
    method setUp (line 15) | def setUp(self):
    method test_deformable_detr_head_loss (line 18) | def test_deformable_detr_head_loss(self):

FILE: tests/test_models/test_detectors/test_detr.py
  class TestDETR (line 13) | class TestDETR(TestCase):
    method setUp (line 15) | def setUp(self) -> None:
    method test_detr_head_loss (line 18) | def test_detr_head_loss(self):

FILE: tests/test_models/test_detectors/test_dino.py
  class TestDINO (line 13) | class TestDINO(TestCase):
    method setUp (line 15) | def setUp(self):
    method test_dino_head_loss (line 18) | def test_dino_head_loss(self):

FILE: tests/test_models/test_detectors/test_kd_single_stage.py
  class TestKDSingleStageDetector (line 14) | class TestKDSingleStageDetector(TestCase):
    method setUp (line 16) | def setUp(self):
    method test_init (line 20) | def test_init(self, cfg_file):
    method test_single_stage_forward_train (line 32) | def test_single_stage_forward_train(self, cfg_file, devices):
    method test_single_stage_forward_test (line 55) | def test_single_stage_forward_test(self, cfg_file, devices):

FILE: tests/test_models/test_detectors/test_maskformer.py
  class TestMaskFormer (line 13) | class TestMaskFormer(unittest.TestCase):
    method setUp (line 15) | def setUp(self):
    method _create_model_cfg (line 18) | def _create_model_cfg(self):
    method test_init (line 50) | def test_init(self):
    method test_forward_loss_mode (line 58) | def test_forward_loss_mode(self, device):
    method test_forward_predict_mode (line 78) | def test_forward_predict_mode(self, device):
    method test_forward_tensor_mode (line 99) | def test_forward_tensor_mode(self, device):
  class TestMask2Former (line 116) | class TestMask2Former(unittest.TestCase):
    method setUp (line 118) | def setUp(self):
    method _create_model_cfg (line 121) | def _create_model_cfg(self, cfg_path):
    method test_init (line 153) | def test_init(self):
    method test_forward_loss_mode (line 167) | def test_forward_loss_mode(self, device, cfg_path):
    method test_forward_predict_mode (line 194) | def test_forward_predict_mode(self, device, cfg_path):
    method test_forward_tensor_mode (line 221) | def test_forward_tensor_mode(self, device, cfg_path):

FILE: tests/test_models/test_detectors/test_panoptic_two_stage_segmentor.py
  class TestTwoStagePanopticSegmentor (line 13) | class TestTwoStagePanopticSegmentor(unittest.TestCase):
    method setUp (line 15) | def setUp(self):
    method _create_model_cfg (line 18) | def _create_model_cfg(self):
    method test_init (line 26) | def test_init(self):
    method test_forward_loss_mode (line 38) | def test_forward_loss_mode(self, device):
    method test_forward_predict_mode (line 58) | def test_forward_predict_mode(self, device):
    method test_forward_tensor_mode (line 79) | def test_forward_tensor_mode(self, device):

FILE: tests/test_models/test_detectors/test_rpn.py
  class TestRPN (line 13) | class TestRPN(TestCase):
    method setUp (line 15) | def setUp(self):
    method test_init (line 19) | def test_init(self, cfg_file):
    method test_rpn_forward_loss_mode (line 38) | def test_rpn_forward_loss_mode(self, cfg_file, devices):
    method test_rpn_forward_predict_mode (line 63) | def test_rpn_forward_predict_mode(self, cfg_file, devices):
    method test_rpn_forward_tensor_mode (line 91) | def test_rpn_forward_tensor_mode(self, cfg_file, devices):

FILE: tests/test_models/test_detectors/test_semi_base.py
  class TestSemiBase (line 13) | class TestSemiBase(TestCase):
    method test_init (line 19) | def test_init(self, cfg_file):

FILE: tests/test_models/test_detectors/test_single_stage.py
  class TestSingleStageDetector (line 15) | class TestSingleStageDetector(TestCase):
    method setUp (line 17) | def setUp(self):
    method test_init (line 28) | def test_init(self, cfg_file):
    method test_single_stage_forward_loss_mode (line 48) | def test_single_stage_forward_loss_mode(self, cfg_file, devices):
    method test_single_stage_forward_predict_mode (line 83) | def test_single_stage_forward_predict_mode(self, cfg_file, devices):
    method test_single_stage_forward_tensor_mode (line 117) | def test_single_stage_forward_tensor_mode(self, cfg_file, devices):

FILE: tests/test_models/test_detectors/test_single_stage_instance_seg.py
  class TestSingleStageInstanceSegmentor (line 13) | class TestSingleStageInstanceSegmentor(TestCase):
    method setUp (line 15) | def setUp(self):
    method test_init (line 26) | def test_init(self, cfg_file):
    method test_single_stage_forward_loss_mode (line 46) | def test_single_stage_forward_loss_mode(self, cfg_file, devices):
    method test_single_stage_forward_predict_mode (line 79) | def test_single_stage_forward_predict_mode(self, cfg_file, devices):
    method test_single_stage_forward_tensor_mode (line 115) | def test_single_stage_forward_tensor_mode(self, cfg_file, devices):

FILE: tests/test_models/test_detectors/test_two_stage.py
  class TestTwoStageBBox (line 13) | class TestTwoStageBBox(TestCase):
    method setUp (line 15) | def setUp(self):
    method test_init (line 23) | def test_init(self, cfg_file):
    method test_two_stage_forward_loss_mode (line 48) | def test_two_stage_forward_loss_mode(self, cfg_file):
    method test_two_stage_forward_predict_mode (line 74) | def test_two_stage_forward_predict_mode(self, cfg_file):
  class TestTwoStageMask (line 126) | class TestTwoStageMask(TestCase):
    method setUp (line 128) | def setUp(self):
    method test_init (line 136) | def test_init(self, cfg_file):
    method test_two_stage_forward_loss_mode (line 162) | def test_two_stage_forward_loss_mode(self, cfg_file):
    method test_two_stage_forward_predict_mode (line 188) | def test_two_stage_forward_predict_mode(self, cfg_file):

FILE: tests/test_models/test_layers/test_brick_wrappers.py
  function test_adaptive_avg_pool2d (line 16) | def test_adaptive_avg_pool2d():
  function test_AdaptiveAvgPool2d (line 41) | def test_AdaptiveAvgPool2d():

FILE: tests/test_models/test_layers/test_conv_upsample.py
  function test_conv_upsample (line 9) | def test_conv_upsample(num_layers):

FILE: tests/test_models/test_layers/test_ema.py
  class TestEMA (line 13) | class TestEMA(TestCase):
    method test_exp_momentum_ema (line 15) | def test_exp_momentum_ema(self):
    method test_exp_momentum_ema_update_buffer (line 49) | def test_exp_momentum_ema_update_buffer(self):

FILE: tests/test_models/test_layers/test_inverted_residual.py
  function test_inverted_residual (line 10) | def test_inverted_residual():

FILE: tests/test_models/test_layers/test_plugins.py
  function test_dropblock (line 15) | def test_dropblock():
  class TestPixelDecoder (line 39) | class TestPixelDecoder(unittest.TestCase):
    method test_forward (line 41) | def test_forward(self):
  class TestTransformerEncoderPixelDecoder (line 65) | class TestTransformerEncoderPixelDecoder(unittest.TestCase):
    method test_forward (line 67) | def test_forward(self):
  class TestMSDeformAttnPixelDecoder (line 120) | class TestMSDeformAttnPixelDecoder(unittest.TestCase):
    method test_forward (line 122) | def test_forward(self):

FILE: tests/test_models/test_layers/test_position_encoding.py
  function test_sine_positional_encoding (line 9) | def test_sine_positional_encoding(num_feats=16, batch_size=2):
  function test_learned_positional_encoding (line 29) | def test_learned_positional_encoding(num_feats=16,

FILE: tests/test_models/test_layers/test_se_layer.py
  function test_se_layer (line 10) | def test_se_layer():
  function test_dyrelu (line 29) | def test_dyrelu():

FILE: tests/test_models/test_layers/test_transformer.py
  function test_adaptive_padding (line 12) | def test_adaptive_padding():
  function test_patch_embed (line 104) | def test_patch_embed():
  function test_patch_merging (line 318) | def test_patch_merging():
  function test_detr_transformer_encoder_decoder (line 468) | def test_detr_transformer_encoder_decoder():

FILE: tests/test_models/test_losses/test_gaussian_focal_loss.py
  class TestGaussianFocalLoss (line 8) | class TestGaussianFocalLoss(unittest.TestCase):
    method test_forward (line 10) | def test_forward(self):

FILE: tests/test_models/test_losses/test_loss.py
  function test_iou_type_loss_zeros_weight (line 21) | def test_iou_type_loss_zeros_weight(loss_class):
  function test_loss_with_reduction_override (line 37) | def test_loss_with_reduction_override(loss_class):
  function test_QualityFocalLoss_Loss (line 52) | def test_QualityFocalLoss_Loss(loss_class, activated):
  function test_regression_losses (line 75) | def test_regression_losses(loss_class, input_shape):
  function test_classification_losses (line 112) | def test_classification_losses(loss_class, input_shape):
  function test_FocalLoss_loss (line 150) | def test_FocalLoss_loss(loss_class, input_shape):
  function test_GHMR_loss (line 186) | def test_GHMR_loss(loss_class, input_shape):
  function test_loss_with_ignore_index (line 199) | def test_loss_with_ignore_index(use_sigmoid, reduction, avg_non_ignore):
  function test_dice_loss (line 241) | def test_dice_loss(naive_dice):

FILE: tests/test_models/test_necks/test_ct_resnet_neck.py
  class TestCTResNetNeck (line 9) | class TestCTResNetNeck(unittest.TestCase):
    method test_init (line 11) | def test_init(self):
    method test_forward (line 26) | def test_forward(self):

FILE: tests/test_models/test_necks/test_necks.py
  function test_fpn (line 11) | def test_fpn():
  function test_channel_mapper (line 196) | def test_channel_mapper():
  function test_dilated_encoder (line 233) | def test_dilated_encoder():
  function test_yolov3_neck (line 244) | def test_yolov3_neck():
  function test_ssd_neck (line 293) | def test_ssd_neck():
  function test_yolox_pafpn (line 360) | def test_yolox_pafpn():
  function test_dyhead (line 390) | def test_dyhead():
  function test_fpg (line 413) | def test_fpg():
  function test_fpn_carafe (line 530) | def test_fpn_carafe():
  function test_nas_fpn (line 563) | def test_nas_fpn():
  function test_nasfcos_fpn (line 600) | def test_nasfcos_fpn():
  function test_ssh_neck (line 634) | def test_ssh_neck():

FILE: tests/test_models/test_roi_heads/test_bbox_heads/test_bbox_head.py
  class TestBboxHead (line 13) | class TestBboxHead(TestCase):
    method test_init (line 15) | def test_init(self):
    method test_bbox_head_get_results (line 31) | def test_bbox_head_get_results(self):
    method test_bbox_head_refine_bboxes (line 110) | def test_bbox_head_refine_bboxes(self):

FILE: tests/test_models/test_roi_heads/test_bbox_heads/test_double_bbox_head.py
  class TestDoubleBboxHead (line 11) | class TestDoubleBboxHead(TestCase):
    method test_forward_loss (line 14) | def test_forward_loss(self, device):

FILE: tests/test_models/test_roi_heads/test_bbox_heads/test_multi_instance_bbox_head.py
  class TestMultiInstanceBBoxHead (line 11) | class TestMultiInstanceBBoxHead(TestCase):
    method test_init (line 13) | def test_init(self):
    method test_bbox_head_get_results (line 28) | def test_bbox_head_get_results(self):

FILE: tests/test_models/test_roi_heads/test_bbox_heads/test_sabl_bbox_head.py
  class TestSABLBboxHead (line 12) | class TestSABLBboxHead(TestCase):
    method test_init (line 14) | def test_init(self):
    method test_bbox_head_get_results (line 27) | def test_bbox_head_get_results(self):
    method test_bbox_head_refine_bboxes (line 106) | def test_bbox_head_refine_bboxes(self):

FILE: tests/test_models/test_roi_heads/test_bbox_heads/test_scnet_bbox_head.py
  class TestSCNetBBoxHead (line 8) | class TestSCNetBBoxHead(unittest.TestCase):
    method test_forward (line 10) | def test_forward(self):

FILE: tests/test_models/test_roi_heads/test_cascade_roi_head.py
  class TestCascadeRoIHead (line 13) | class TestCascadeRoIHead(TestCase):
    method test_init (line 17) | def test_init(self, cfg_file):
    method test_cascade_roi_head_loss (line 27) | def test_cascade_roi_head_loss(self, cfg_file):

FILE: tests/test_models/test_roi_heads/test_dynamic_roi_head.py
  class TestDynamicRoIHead (line 13) | class TestDynamicRoIHead(TestCase):
    method setUp (line 15) | def setUp(self):
    method test_init (line 20) | def test_init(self):
    method test_dynamic_roi_head_loss (line 25) | def test_dynamic_roi_head_loss(self, device):

FILE: tests/test_models/test_roi_heads/test_grid_roi_head.py
  class TestGridRoIHead (line 13) | class TestGridRoIHead(TestCase):
    method setUp (line 15) | def setUp(self):
    method test_init (line 20) | def test_init(self):
    method test_grid_roi_head_loss (line 25) | def test_grid_roi_head_loss(self, device):
    method test_grid_roi_head_predict (line 75) | def test_grid_roi_head_predict(self, device):
    method test_grid_roi_head_forward (line 103) | def test_grid_roi_head_forward(self, device):

FILE: tests/test_models/test_roi_heads/test_htc_roi_head.py
  class TestHTCRoIHead (line 13) | class TestHTCRoIHead(TestCase):
    method test_init (line 16) | def test_init(self, cfg_file):
    method test_htc_roi_head_loss (line 26) | def test_htc_roi_head_loss(self, cfg_file):
    method test_htc_roi_head_predict (line 84) | def test_htc_roi_head_predict(self, cfg_file):

FILE: tests/test_models/test_roi_heads/test_mask_heads/test_coarse_mask_head.py
  class TestCoarseMaskHead (line 9) | class TestCoarseMaskHead(unittest.TestCase):
    method test_init (line 11) | def test_init(self):
    method test_forward (line 19) | def test_forward(self, device):

FILE: tests/test_models/test_roi_heads/test_mask_heads/test_fcn_mask_head.py
  class TestFCNMaskHead (line 13) | class TestFCNMaskHead(TestCase):
    method test_get_seg_masks (line 16) | def test_get_seg_masks(self, device):

FILE: tests/test_models/test_roi_heads/test_mask_heads/test_feature_relay_head.py
  class TestFeatureRelayHead (line 12) | class TestFeatureRelayHead(TestCase):
    method test_forward (line 15) | def test_forward(self, device):

FILE: tests/test_models/test_roi_heads/test_mask_heads/test_fused_semantic_head.py
  class TestFusedSemanticHead (line 12) | class TestFusedSemanticHead(TestCase):
    method test_forward_loss (line 15) | def test_forward_loss(self, device):

FILE: tests/test_models/test_roi_heads/test_mask_heads/test_global_context_head.py
  class TestGlobalContextHead (line 12) | class TestGlobalContextHead(TestCase):
    method test_forward_loss (line 15) | def test_forward_loss(self, device):

FILE: tests/test_models/test_roi_heads/test_mask_heads/test_grid_head.py
  class TestGridHead (line 16) | class TestGridHead(TestCase):
    method test_grid_head_loss (line 19) | def test_grid_head_loss(self, device):
    method test_mask_iou_head_predict_by_feat (line 58) | def test_mask_iou_head_predict_by_feat(self, device):

FILE: tests/test_models/test_roi_heads/test_mask_heads/test_htc_mask_head.py
  class TestHTCMaskHead (line 12) | class TestHTCMaskHead(TestCase):
    method test_forward (line 15) | def test_forward(self, device):

FILE: tests/test_models/test_roi_heads/test_mask_heads/test_maskiou_head.py
  class TestMaskIoUHead (line 17) | class TestMaskIoUHead(TestCase):
    method test_mask_iou_head_loss_and_target (line 20) | def test_mask_iou_head_loss_and_target(self, device):
    method test_mask_iou_head_predict_by_feat (line 71) | def test_mask_iou_head_predict_by_feat(self, device):

FILE: tests/test_models/test_roi_heads/test_mask_heads/test_scnet_mask_head.py
  class TestSCNetMaskHead (line 12) | class TestSCNetMaskHead(TestCase):
    method test_forward (line 15) | def test_forward(self, device):

FILE: tests/test_models/test_roi_heads/test_mask_heads/test_scnet_semantic_head.py
  class TestSCNetSemanticHead (line 12) | class TestSCNetSemanticHead(TestCase):
    method test_forward_loss (line 15) | def test_forward_loss(self, device):

FILE: tests/test_models/test_roi_heads/test_mask_scoring_roI_head.py
  class TestMaskScoringRoiHead (line 12) | class TestMaskScoringRoiHead(TestCase):
    method setUp (line 14) | def setUp(self):
    method test_init (line 19) | def test_init(self):
    method test_mask_scoring_roi_head_loss (line 25) | def test_mask_scoring_roi_head_loss(self):
    method test_mask_scoring_roi_head_predict (line 81) | def test_mask_scoring_roi_head_predict(self):
    method test_mask_scoring_roi_head_forward (line 107) | def test_mask_scoring_roi_head_forward(self):

FILE: tests/test_models/test_roi_heads/test_multi_instance_roi_head.py
  function _fake_roi_head (line 15) | def _fake_roi_head():
  class TestMultiInstanceRoIHead (line 73) | class TestMultiInstanceRoIHead(TestCase):
    method test_init (line 75) | def test_init(self):
    method test_standard_roi_head_loss (line 81) | def test_standard_roi_head_loss(self):

FILE: tests/test_models/test_roi_heads/test_pisa_roi_head.py
  class TestPISARoIHead (line 13) | class TestPISARoIHead(TestCase):
    method setUp (line 15) | def setUp(self):
    method test_init (line 20) | def test_init(self):
    method test_pisa_roi_head (line 25) | def test_pisa_roi_head(self, device):

FILE: tests/test_models/test_roi_heads/test_point_rend_roi_head.py
  class TestHTCRoIHead (line 13) | class TestHTCRoIHead(TestCase):
    method test_init (line 17) | def test_init(self, cfg_file):
    method test_point_rend_roi_head_loss (line 27) | def test_point_rend_roi_head_loss(self, cfg_file):
    method test_point_rend_roi_head_predict (line 78) | def test_point_rend_roi_head_predict(self, cfg_file):

FILE: tests/test_models/test_roi_heads/test_roi_extractors/test_generic_roi_extractor.py
  class TestGenericRoIExtractor (line 8) | class TestGenericRoIExtractor(unittest.TestCase):
    method test_init (line 10) | def test_init(self):
    method test_forward (line 26) | def test_forward(self):

FILE: tests/test_models/test_roi_heads/test_roi_extractors/test_single_level_roi_extractor.py
  class TestSingleRoIExtractor (line 8) | class TestSingleRoIExtractor(unittest.TestCase):
    method test_forward (line 10) | def test_forward(self):

FILE: tests/test_models/test_roi_heads/test_scnet_roi_head.py
  class TestSCNetRoIHead (line 13) | class TestSCNetRoIHead(TestCase):
    method test_init (line 16) | def test_init(self, cfg_file):
    method test_scnet_roi_head_loss (line 28) | def test_scnet_roi_head_loss(self, cfg_file):
    method test_scnet_roi_head_predict (line 86) | def test_scnet_roi_head_predict(self, cfg_file):

FILE: tests/test_models/test_roi_heads/test_sparse_roi_head.py
  class TestCascadeRoIHead (line 14) | class TestCascadeRoIHead(TestCase):
    method test_init (line 17) | def test_init(self, cfg_file):
    method test_cascade_roi_head_loss (line 27) | def test_cascade_roi_head_loss(self, cfg_file):

FILE: tests/test_models/test_roi_heads/test_standard_roi_head.py
  function _fake_roi_head (line 16) | def _fake_roi_head(with_shared_head=False):
  class TestStandardRoIHead (line 124) | class TestStandardRoIHead(TestCase):
    method test_init (line 126) | def test_init(self):
    method test_standard_roi_head_loss (line 142) | def test_standard_roi_head_loss(self, with_shared_head):

FILE: tests/test_models/test_roi_heads/test_trident_roi_head.py
  class TestTridentRoIHead (line 13) | class TestTridentRoIHead(TestCase):
    method setUp (line 15) | def setUp(self):
    method test_init (line 20) | def test_init(self):
    method test_trident_roi_head_predict (line 26) | def test_trident_roi_head_predict(self):

FILE: tests/test_models/test_seg_heads/test_heuristic_fusion_head.py
  class TestHeuristicFusionHead (line 12) | class TestHeuristicFusionHead(unittest.TestCase):
    method test_loss (line 14) | def test_loss(self):
    method test_predict (line 20) | def test_predict(self):

FILE: tests/test_models/test_seg_heads/test_maskformer_fusion_head.py
  class TestMaskFormerFusionHead (line 11) | class TestMaskFormerFusionHead(unittest.TestCase):
    method test_loss (line 13) | def test_loss(self):
    method test_predict (line 19) | def test_predict(self):

FILE: tests/test_models/test_seg_heads/test_panoptic_fpn_head.py
  class TestPanopticFPNHead (line 11) | class TestPanopticFPNHead(unittest.TestCase):
    method test_init_weights (line 13) | def test_init_weights(self):
    method test_loss (line 23) | def test_loss(self):
    method test_predict (line 42) | def test_predict(self):

FILE: tests/test_models/test_task_modules/test_assigners/test_approx_max_iou_assigner.py
  class TestApproxIoUAssigner (line 10) | class TestApproxIoUAssigner(TestCase):
    method test_approx_iou_assigner (line 12) | def test_approx_iou_assigner(self):
    method test_approx_iou_assigner_with_empty_gt (line 40) | def test_approx_iou_assigner_with_empty_gt(self):
    method test_approx_iou_assigner_with_empty_boxes (line 66) | def test_approx_iou_assigner_with_empty_boxes(self):
    method test_approx_iou_assigner_with_empty_boxes_and_gt (line 89) | def test_approx_iou_assigner_with_empty_boxes_and_gt(self):

FILE: tests/test_models/test_task_modules/test_assigners/test_atss_assigner.py
  class TestATSSAssigner (line 10) | class TestATSSAssigner(TestCase):
    method test_atss_assigner (line 12) | def test_atss_assigner(self):
    method test_atss_assigner_with_ignore (line 38) | def test_atss_assigner_with_ignore(self):
    method test_atss_assigner_with_empty_gt (line 68) | def test_atss_assigner_with_empty_gt(self):
    method test_atss_assigner_with_empty_boxes (line 89) | def test_atss_assigner_with_empty_boxes(self):
    method test_atss_assigner_with_empty_boxes_and_ignore (line 107) | def test_atss_assigner_with_empty_boxes_and_ignore(self):
    method test_atss_assigner_with_empty_boxes_and_gt (line 134) | def test_atss_assigner_with_empty_boxes_and_gt(self):

FILE: tests/test_models/test_task_modules/test_assigners/test_center_region_assigner.py
  class TestCenterRegionAssigner (line 10) | class TestCenterRegionAssigner(TestCase):
    method test_center_region_assigner (line 12) | def test_center_region_assigner(self):
    method test_center_region_assigner_with_ignore (line 41) | def test_center_region_assigner_with_ignore(self):
    method test_center_region_assigner_with_empty_gt (line 71) | def test_center_region_assigner_with_empty_gt(self):
    method test_center_region_assigner_with_empty_boxes (line 92) | def test_center_region_assigner_with_empty_boxes(self):
    method test_center_region_assigner_with_empty_boxes_and_ignore (line 110) | def test_center_region_assigner_with_empty_boxes_and_ignore(self):
    method test_center_region_assigner_with_empty_boxes_and_gt (line 136) | def test_center_region_assigner_with_empty_boxes_and_gt(self):

FILE: tests/test_models/test_task_modules/test_assigners/test_dynamic_soft_label_assigner.py
  class TestDynamicSoftLabelAssigner (line 12) | class TestDynamicSoftLabelAssigner(TestCase):
    method test_assign (line 14) | def test_assign(self):
    method test_assign_with_no_valid_bboxes (line 30) | def test_assign_with_no_valid_bboxes(self):
    method test_assign_with_empty_gt (line 45) | def test_assign_with_empty_gt(self):
    method test_box_type_input (line 60) | def test_box_type_input(self):

FILE: tests/test_models/test_task_modules/test_assigners/test_grid_assigner.py
  class TestGridAssigner (line 11) | class TestGridAssigner(TestCase):
    method test_assign (line 13) | def test_assign(self):
    method test_assign_with_empty_gt (line 56) | def test_assign_with_empty_gt(self):
    method test_assign_with_empty_priors (line 69) | def test_assign_with_empty_priors(self):

FILE: tests/test_models/test_task_modules/test_assigners/test_hungarian_assigner.py
  class TestHungarianAssigner (line 11) | class TestHungarianAssigner(TestCase):
    method test_init (line 13) | def test_init(self):
    method test_hungarian_match_assigner (line 17) | def test_hungarian_match_assigner(self):
    method test_bbox_match_cost (line 50) | def test_bbox_match_cost(self):
    method test_cls_match_cost (line 80) | def test_cls_match_cost(self):
    method test_mask_match_cost (line 109) | def test_mask_match_cost(self):

FILE: tests/test_models/test_task_modules/test_assigners/test_max_iou_assigner.py
  function test_max_iou_assigner (line 16) | def test_max_iou_assigner(neg_iou_thr):
  function test_max_iou_assigner_with_ignore (line 44) | def test_max_iou_assigner_with_ignore():
  function test_max_iou_assigner_with_empty_gt (line 76) | def test_max_iou_assigner_with_empty_gt():
  function test_max_iou_assigner_with_empty_priors (line 99) | def test_max_iou_assigner_with_empty_priors():
  function test_max_iou_assigner_with_empty_boxes_and_ignore (line 120) | def test_max_iou_assigner_with_empty_boxes_and_ignore():
  function test_max_iou_assigner_with_empty_priors_and_gt (line 149) | def test_max_iou_assigner_with_empty_priors_and_gt():

FILE: tests/test_models/test_task_modules/test_assigners/test_point_assigner.py
  class TestPointAssigner (line 11) | class TestPointAssigner(unittest.TestCase):
    method test_point_assigner (line 13) | def test_point_assigner(self):
    method test_point_assigner_with_empty_gt (line 33) | def test_point_assigner_with_empty_gt(self):
    method test_point_assigner_with_empty_boxes_and_gt (line 52) | def test_point_assigner_with_empty_boxes_and_gt(self):

FILE: tests/test_models/test_task_modules/test_assigners/test_region_assigner.py
  class TestRegionAssigner (line 11) | class TestRegionAssigner(TestCase):
    method setUp (line 13) | def setUp(self):
    method test_region_assigner (line 19) | def test_region_assigner(self):
    method test_region_assigner_with_ignore (line 47) | def test_region_assigner_with_ignore(self):
    method test_region_assigner_with_empty_gt (line 80) | def test_region_assigner_with_empty_gt(self):
    method test_atss_assigner_with_empty_boxes (line 103) | def test_atss_assigner_with_empty_boxes(self):
    method test_atss_assigner_with_empty_boxes_and_gt (line 123) | def test_atss_assigner_with_empty_boxes_and_gt(self):

FILE: tests/test_models/test_task_modules/test_assigners/test_simota_assigner.py
  class TestSimOTAAssigner (line 11) | class TestSimOTAAssigner(TestCase):
    method test_assign (line 13) | def test_assign(self):
    method test_assign_with_no_valid_bboxes (line 32) | def test_assign_with_no_valid_bboxes(self):
    method test_assign_with_empty_gt (line 50) | def test_assign_with_empty_gt(self):

FILE: tests/test_models/test_task_modules/test_assigners/test_task_aligned_assigner.py
  class TestTaskAlignedAssigner (line 10) | class TestTaskAlignedAssigner(TestCase):
    method test_task_aligned_assigner (line 12) | def test_task_aligned_assigner(self):

FILE: tests/test_models/test_task_modules/test_assigners/test_task_uniform_assigner.py
  class TestUniformAssigner (line 11) | class TestUniformAssigner(TestCase):
    method test_uniform_assigner (line 13) | def test_uniform_assigner(self):
    method test_uniform_assigner_with_empty_gt (line 45) | def test_uniform_assigner_with_empty_gt(self):
    method test_uniform_assigner_with_empty_boxes (line 73) | def test_uniform_assigner_with_empty_boxes(self):

FILE: tests/test_models/test_task_modules/test_coder/test_delta_xywh_bbox_coder.py
  function test_delta_bbox_coder (line 8) | def test_delta_bbox_coder():

FILE: tests/test_models/test_task_modules/test_iou2d_calculator.py
  function test_bbox_overlaps_2d (line 11) | def test_bbox_overlaps_2d(eps=1e-7):
  function test_voc_recall_overlaps (line 111) | def test_voc_recall_overlaps():

FILE: tests/test_models/test_task_modules/test_prior_generators/test_anchor_generator.py
  function test_standard_points_generator (line 12) | def test_standard_points_generator():
  function test_sparse_prior (line 107) | def test_sparse_prior():
  function test_standard_anchor_generator (line 275) | def test_standard_anchor_generator():
  function test_strides (line 290) | def test_strides():
  function test_ssd_anchor_generator (line 312) | def test_ssd_anchor_generator():
  function test_anchor_generator_with_tuples (line 474) | def test_anchor_generator_with_tuples():
  function test_yolo_anchor_generator (line 509) | def test_yolo_anchor_generator():
  function test_retina_anchor (line 552) | def test_retina_anchor():
  function test_guided_anchor (line 651) | def test_guided_anchor():

FILE: tests/test_models/test_tta/test_det_tta.py
  class TestDetTTAModel (line 14) | class TestDetTTAModel(TestCase):
    method setUp (line 16) | def setUp(self):
    method test_det_tta_model (line 19) | def test_det_tta_model(self):

FILE: tests/test_models/test_utils/test_misc.py
  function test_parse_gt_instance_info (line 13) | def test_parse_gt_instance_info():
  function test_process_empty_roi (line 22) | def test_process_empty_roi():
  function test_filter_gt_instances (line 55) | def test_filter_gt_instances():
  function test_rename_loss_dict (line 97) | def test_rename_loss_dict():
  function test_reweight_loss_dict (line 105) | def test_reweight_loss_dict():

FILE: tests/test_models/test_utils/test_model_misc.py
  function test_interpolate_as (line 9) | def test_interpolate_as():
  function test_sigmoid_geometric_mean (line 31) | def test_sigmoid_geometric_mean():

FILE: tests/test_structures/test_bbox/test_base_boxes.py
  class TestBaseBoxes (line 10) | class TestBaseBoxes(TestCase):
    method test_init (line 12) | def test_init(self):
    method test_getitem (line 31) | def test_getitem(self):
    method test_setitem (line 74) | def test_setitem(self):
    method test_tensor_like_functions (line 119) | def test_tensor_like_functions(self):
    method test_misc (line 258) | def test_misc(self):

FILE: tests/test_structures/test_bbox/test_box_type.py
  class TestBoxType (line 13) | class TestBoxType(TestCase):
    method setUp (line 15) | def setUp(self):
    method tearDown (line 20) | def tearDown(self):
    method test_register_box (line 30) | def test_register_box(self):
    method test_register_box_converter (line 70) | def test_register_box_converter(self):
    method test_get_box_type (line 120) | def test_get_box_type(self):
    method test_convert_box_type (line 142) | def test_convert_box_type(self):

FILE: tests/test_structures/test_bbox/test_horizontal_boxes.py
  class TestHorizontalBoxes (line 14) | class TestHorizontalBoxes(TestCase):
    method test_init (line 16) | def test_init(self):
    method test_cxcywh (line 29) | def test_cxcywh(self):
    method test_propoerty (line 40) | def test_propoerty(self):
    method test_flip (line 57) | def test_flip(self):
    method test_translate (line 78) | def test_translate(self):
    method test_clip (line 85) | def test_clip(self):
    method test_rotate (line 93) | def test_rotate(self):
    method test_project (line 105) | def test_project(self):
    method test_rescale (line 130) | def test_rescale(self):
    method test_resize (line 139) | def test_resize(self):
    method test_is_inside (line 147) | def test_is_inside(self):
    method test_find_inside_points (line 157) | def test_find_inside_points(self):
    method test_from_instance_masks (line 170) | def test_from_instance_masks(self):

FILE: tests/test_structures/test_bbox/utils.py
  class ToyBaseBoxes (line 4) | class ToyBaseBoxes(BaseBoxes):
    method centers (line 9) | def centers(self):
    method areas (line 13) | def areas(self):
    method widths (line 17) | def widths(self):
    method heights (line 21) | def heights(self):
    method flip_ (line 24) | def flip_(self, img_shape, direction='horizontal'):
    method translate_ (line 27) | def translate_(self, distances):
    method clip_ (line 30) | def clip_(self, img_shape):
    method rotate_ (line 33) | def rotate_(self, center, angle):
    method project_ (line 36) | def project_(self, homography_matrix):
    method rescale_ (line 39) | def rescale_(self, scale_factor):
    method resize_ (line 42) | def resize_(self, scale_factor):
    method is_inside (line 45) | def is_inside(self, img_shape):
    method find_inside_points (line 48) | def find_inside_points(self, points, is_aligned=False):
    method overlaps (line 51) | def overlaps(bboxes1, bboxes2, mode='iou', is_aligned=False, eps=1e-6):
    method from_instance_masks (line 54) | def from_instance_masks(masks):

FILE: tests/test_structures/test_det_data_sample.py
  function _equal (line 11) | def _equal(a, b):
  class TestDetDataSample (line 18) | class TestDetDataSample(TestCase):
    method test_init (line 20) | def test_init(self):
    method test_setter (line 31) | def test_setter(self):
    method test_deleter (line 126) | def test_deleter(self):

FILE: tests/test_structures/test_mask/test_mask_structures.py
  class TestMaskStructures (line 9) | class TestMaskStructures(TestCase):
    method test_bitmap_translate_same_size (line 11) | def test_bitmap_translate_same_size(self):
    method test_bitmap_translate_diff_size (line 22) | def test_bitmap_translate_diff_size(self):
    method test_bitmap_cat (line 45) | def test_bitmap_cat(self):
    method test_polygon_cat (line 60) | def test_polygon_cat(self):

FILE: tests/test_utils/test_benchmark.py
  class ToyDetector (line 19) | class ToyDetector(nn.Module):
    method __init__ (line 21) | def __init__(self, *args, **kwargs):
    method forward (line 24) | def forward(self, data_batch, return_loss=False):
  class ToyDataset (line 29) | class ToyDataset(Dataset):
    method __init__ (line 34) | def __init__(self):
    method __len__ (line 37) | def __len__(self):
    method get_data_info (line 40) | def get_data_info(self, index):
    method __getitem__ (line 43) | def __getitem__(self, index):
  class ToyFullInitDataset (line 48) | class ToyFullInitDataset(Dataset):
    method __init__ (line 53) | def __init__(self):
    method __len__ (line 56) | def __len__(self):
    method get_data_info (line 59) | def get_data_info(self, index):
    method full_init (line 62) | def full_init(self):
    method __getitem__ (line 65) | def __getitem__(self, index):
  class TestInferenceBenchmark (line 69) | class TestInferenceBenchmark(unittest.TestCase):
    method setUp (line 71) | def setUp(self) -> None:
    method test_init_and_run (line 88) | def test_init_and_run(self):
  class TestDataLoaderBenchmark (line 164) | class TestDataLoaderBenchmark(unittest.TestCase):
    method setUp (line 166) | def setUp(self) -> None:
    method test_init_and_run (line 192) | def test_init_and_run(self):
  class TestDatasetBenchmark (line 243) | class TestDatasetBenchmark(unittest.TestCase):
    method setUp (line 245) | def setUp(self) -> None:
    method test_init_and_run (line 270) | def test_init_and_run(self):

FILE: tests/test_utils/test_memory.py
  function test_avoidoom (line 9) | def test_avoidoom():
  function test_cast_tensor_type (line 62) | def test_cast_tensor_type():

FILE: tests/test_utils/test_replace_cfg_vals.py
  function test_replace_cfg_vals (line 11) | def test_replace_cfg_vals():

FILE: tests/test_utils/test_setup_env.py
  class TestSetupEnv (line 10) | class TestSetupEnv(TestCase):
    method test_register_all_modules (line 12) | def test_register_all_modules(self):

FILE: tests/test_visualization/test_local_visualizer.py
  function _rand_bboxes (line 14) | def _rand_bboxes(num_boxes, h, w):
  function _create_panoptic_data (line 26) | def _create_panoptic_data(num_boxes, h, w):
  class TestDetLocalVisualizer (line 37) | class TestDetLocalVisualizer(TestCase):
    method test_add_datasample (line 39) | def test_add_datasample(self):
    method _assert_image_and_shape (line 116) | def _assert_image_and_shape(self, out_file, out_shape):

FILE: tests/test_visualization/test_palette.py
  function test_palette (line 8) | def test_palette():
  function test_jitter_color (line 54) | def test_jitter_color():

FILE: tools/analysis_tools/analyze_logs.py
  function cal_train_time (line 11) | def cal_train_time(log_dicts, args):
  function plot_curve (line 36) | def plot_curve(log_dicts, args):
  function add_plot_parser (line 101) | def add_plot_parser(subparsers):
  function add_time_parser (line 139) | def add_time_parser(subparsers):
  function parse_args (line 155) | def parse_args():
  function load_json_logs (line 165) | def load_json_logs(json_logs):
  function main (line 198) | def main():

FILE: tools/analysis_tools/analyze_results.py
  function bbox_map_eval (line 23) | def bbox_map_eval(det_result, annotation, nproc=4):
  class ResultVisualizer (line 74) | class ResultVisualizer:
    method __init__ (line 85) | def __init__(self, show=False, wait_time=0, score_thr=0, runner=None):
    method _save_image_gts_results (line 93) | def _save_image_gts_results(self,
    method evaluate_and_show (line 164) | def evaluate_and_show(self,
    method detection_evaluate (line 208) | def detection_evaluate(self, dataset, results, topk=20, eval_fn=None):
    method panoptic_evaluate (line 267) | def panoptic_evaluate(self, dataset, results, topk=20):
  function parse_args (line 311) | def parse_args():
  function main (line 350) | def main():

FILE: tools/analysis_tools/benchmark.py
  function parse_args (line 15) | def parse_args():
  function inference_benchmark (line 71) | def inference_benchmark(args, cfg, distributed, logger):
  function dataloader_benchmark (line 84) | def dataloader_benchmark(args, cfg, distributed, logger):
  function dataset_benchmark (line 96) | def dataset_benchmark(args, cfg, distributed, logger):
  function main (line 107) | def main():

FILE: tools/analysis_tools/browse_dataset.py
  function parse_args (line 14) | def parse_args():
  function main (line 42) | def main():

FILE: tools/analysis_tools/coco_error_analysis.py
  function makeplot (line 13) | def makeplot(rs, ps, outDir, class_name, iou_type):
  function autolabel (line 54) | def autolabel(ax, rects):
  function makebarplot (line 73) | def makebarplot(rs, ps, outDir, class_name, iou_type):
  function get_gt_area_group_numbers (line 108) | def get_gt_area_group_numbers(cocoEval):
  function make_gt_area_group_numbers_plot (line 123) | def make_gt_area_group_numbers_plot(cocoEval, outDir, verbose=True):
  function make_gt_area_histogram_plot (line 152) | def make_gt_area_histogram_plot(cocoEval, outDir):
  function analyze_individual_category (line 174) | def analyze_individual_category(k,
  function analyze_results (line 235) | def analyze_results(res_file,
  function main (line 308) | def main():

FILE: tools/analysis_tools/coco_occluded_separated_recall.py
  function main (line 11) | def main():

FILE: tools/analysis_tools/confusion_matrix.py
  function parse_args (line 18) | def parse_args():
  function calculate_confusion_matrix (line 62) | def calculate_confusion_matrix(dataset,
  function analyze_per_img_dets (line 93) | def analyze_per_img_dets(confusion_matrix,
  function plot_confusion_matrix (line 153) | def plot_confusion_matrix(confusion_matrix,
  function main (line 237) | def main():

FILE: tools/analysis_tools/eval_metric.py
  function parse_args (line 12) | def parse_args():
  function main (line 31) | def main():

FILE: tools/analysis_tools/get_flops.py
  function parse_args (line 23) | def parse_args():
  function inference (line 46) | def inference(args, logger):
  function main (line 146) | def main():

FILE: tools/analysis_tools/optimize_anchors.py
  function parse_args (line 39) | def parse_args():
  class BaseAnchorOptimizer (line 70) | class BaseAnchorOptimizer:
    method __init__ (line 84) | def __init__(self,
    method get_whs_and_shapes (line 101) | def get_whs_and_shapes(self):
    method get_zero_center_bbox_tensor (line 129) | def get_zero_center_bbox_tensor(self):
    method optimize (line 142) | def optimize(self):
    method save_result (line 145) | def save_result(self, anchors, path=None):
  class YOLOKMeansAnchorOptimizer (line 156) | class YOLOKMeansAnchorOptimizer(BaseAnchorOptimizer):
    method __init__ (line 165) | def __init__(self, num_anchors, iters, **kwargs):
    method optimize (line 171) | def optimize(self):
    method kmeans_anchors (line 175) | def kmeans_anchors(self):
    method kmeans_maximization (line 211) | def kmeans_maximization(self, bboxes, assignments, centers):
    method kmeans_expectation (line 220) | def kmeans_expectation(self, bboxes, assignments, centers):
  class YOLODEAnchorOptimizer (line 228) | class YOLODEAnchorOptimizer(BaseAnchorOptimizer):
    method __init__ (line 263) | def __init__(self,
    method optimize (line 283) | def optimize(self):
    method differential_evolution (line 287) | def differential_evolution(self):
    method avg_iou_cost (line 313) | def avg_iou_cost(anchor_params, bboxes):
  function main (line 327) | def main():

FILE: tools/analysis_tools/robustness_eval.py
  function print_coco_results (line 9) | def print_coco_results(results):
  function get_coco_style_results (line 38) | def get_coco_style_results(filename,
  function get_voc_style_results (line 124) | def get_voc_style_results(filename, prints='mPC', aggregate='benchmark'):
  function get_results (line 168) | def get_results(filename,
  function get_distortions_from_file (line 196) | def get_distortions_from_file(filename):
  function get_distortions_from_results (line 203) | def get_distortions_from_results(eval_output):
  function main (line 210) | def main():

FILE: tools/analysis_tools/test_robustness.py
  function parse_args (line 18) | def parse_args():
  function main (line 95) | def main():

FILE: tools/dataset_converters/cityscapes.py
  function collect_files (line 15) | def collect_files(img_dir, gt_dir):
  function collect_annotations (line 32) | def collect_annotations(files, nproc=1):
  function load_img_info (line 42) | def load_img_info(files):
  function cvt_annotations (line 87) | def cvt_annotations(image_infos, out_json_name):
  function parse_args (line 116) | def parse_args():
  function main (line 129) | def main():

FILE: tools/dataset_converters/images2coco.py
  function parse_args (line 10) | def parse_args():
  function collect_image_infos (line 31) | def collect_image_infos(path, exclude_extensions=None):
  function cvt_to_coco_json (line 50) | def cvt_to_coco_json(img_infos, classes):
  function main (line 81) | def main():

FILE: tools/dataset_converters/pascal_voc.py
  function parse_xml (line 15) | def parse_xml(args):
  function cvt_annotations (line 69) | def cvt_annotations(devkit_path, years, split, out_file):
  function cvt_to_coco_json (line 97) | def cvt_to_coco_json(annotations):
  function parse_args (line 184) | def parse_args():
  function main (line 198) | def main():

FILE: tools/deployment/mmdet2torchserve.py
  function mmdet2torchserve (line 16) | def mmdet2torchserve(
  function parse_args (line 71) | def parse_args():

FILE: tools/deployment/mmdet_handler.py
  class MMdetHandler (line 13) | class MMdetHandler(BaseHandler):
    method initialize (line 16) | def initialize(self, context):
    method preprocess (line 32) | def preprocess(self, data):
    method inference (line 44) | def inference(self, data, *args, **kwargs):
    method postprocess (line 48) | def postprocess(self, data):

FILE: tools/deployment/test_torchserver.py
  function parse_args (line 14) | def parse_args():
  function align_ts_output (line 37) | def align_ts_output(inputs, metainfo, device):
  function main (line 56) | def main(args):

FILE: tools/misc/download_dataset.py
  function parse_args (line 13) | def parse_args():
  function download (line 37) | def download(url, dir, unzip=True, delete=False, threads=1):
  function download_objects365v2 (line 67) | def download_objects365v2(url, dir, unzip=True, delete=False, threads=1):
  function main (line 131) | def main():

FILE: tools/misc/gen_coco_panoptic_test_info.py
  function parse_args (line 7) | def parse_args():
  function main (line 17) | def main():

FILE: tools/misc/get_crowdhuman_id_hw.py
  function parse_args (line 22) | def parse_args():
  function get_image_metas (line 38) | def get_image_metas(anno_str, img_prefix):
  function main (line 50) | def main():

FILE: tools/misc/get_image_metas.py
  function parse_args (line 20) | def parse_args():
  function get_metas_from_csv_style_ann_file (line 42) | def get_metas_from_csv_style_ann_file(ann_file):
  function get_metas_from_txt_style_ann_file (line 58) | def get_metas_from_txt_style_ann_file(ann_file):
  function get_image_metas (line 71) | def get_image_metas(data_info, img_prefix):
  function main (line 86) | def main():

FILE: tools/misc/print_config.py
  function parse_args (line 10) | def parse_args():
  function main (line 32) | def main():

FILE: tools/misc/split_coco.py
  function parse_args (line 16) | def parse_args():
  function split_coco (line 43) | def split_coco(data_root, out_dir, percent, fold):
  function multi_wrapper (line 101) | def multi_wrapper(args):

FILE: tools/model_converters/detectron2_to_mmdet.py
  function convert (line 10) | def convert(src: str, dst: str, prefix: str = 'd2_model') -> None:
  function main (line 36) | def main():

FILE: tools/model_converters/detectron2pytorch.py
  function convert_bn (line 11) | def convert_bn(blobs, state_dict, caffe_name, torch_name, converted_names):
  function convert_conv_fc (line 24) | def convert_conv_fc(blobs, state_dict, caffe_name, torch_name,
  function convert (line 35) | def convert(src, dst, depth):
  function main (line 73) | def main():

FILE: tools/model_converters/publish_model.py
  function parse_args (line 9) | def parse_args():
  function process_checkpoint (line 24) | def process_checkpoint(in_file, out_file, save_keys=['meta', 'state_dict...
  function main (line 55) | def main():

FILE: tools/model_converters/regnet2mmdet.py
  function convert_stem (line 8) | def convert_stem(model_key, model_weight, state_dict, converted_names):
  function convert_head (line 16) | def convert_head(model_key, model_weight, state_dict, converted_names):
  function convert_reslayer (line 23) | def convert_reslayer(model_key, model_weight, state_dict, converted_names):
  function convert (line 55) | def convert(src, dst):
  function main (line 81) | def main():

FILE: tools/model_converters/selfsup2mmdet.py
  function moco_convert (line 8) | def moco_convert(src, dst):
  function main (line 28) | def main():

FILE: tools/model_converters/upgrade_model_version.py
  function is_head (line 11) | def is_head(key):
  function parse_config (line 19) | def parse_config(config_strings):
  function reorder_cls_channel (line 46) | def reorder_cls_channel(val, num_classes=81):
  function truncate_cls_channel (line 68) | def truncate_cls_channel(val, num_classes=81):
  function truncate_reg_channel (line 90) | def truncate_reg_channel(val, num_classes=81):
  function convert (line 115) | def convert(in_file, out_file, num_classes):
  function main (line 196) | def main():

FILE: tools/model_converters/upgrade_ssd_version.py
  function parse_config (line 10) | def parse_config(config_strings):
  function convert (line 22) | def convert(in_file, out_file):
  function main (line 48) | def main():

FILE: tools/test.py
  function parse_args (line 18) | def parse_args():
  function main (line 62) | def main():

FILE: tools/train.py
  function parse_args (line 13) | def parse_args():
  function main (line 57) | def main():