SYMBOL INDEX (4298 symbols across 311 files)

FILE: dataset/mot/gen_labels_MOT.py
  function mkdirs (line 25) | def mkdirs(d):

FILE: ppdet/core/config/schema.py
  function doc_parse (line 27) | def doc_parse(*args):
  function check_type (line 35) | def check_type(*args):
  class SchemaValue (line 42) | class SchemaValue(object):
    method __init__ (line 43) | def __init__(self, name, doc='', type=None):
    method set_default (line 49) | def set_default(self, value):
    method has_default (line 52) | def has_default(self):
  class SchemaDict (line 56) | class SchemaDict(dict):
    method __init__ (line 57) | def __init__(self, **kwargs):
    method __setitem__ (line 64) | def __setitem__(self, key, value):
    method __missing__ (line 72) | def __missing__(self, key):
    method copy (line 80) | def copy(self):
    method set_schema (line 86) | def set_schema(self, key, value):
    method set_strict (line 90) | def set_strict(self, strict):
    method has_default (line 93) | def has_default(self, key):
    method is_default (line 96) | def is_default(self, key):
    method find_default_keys (line 104) | def find_default_keys(self):
    method mandatory (line 110) | def mandatory(self):
    method find_missing_keys (line 113) | def find_missing_keys(self):
    method find_extra_keys (line 121) | def find_extra_keys(self):
    method find_mismatch_keys (line 124) | def find_mismatch_keys(self):
    method validate (line 135) | def validate(self):
  class SharedConfig (line 150) | class SharedConfig(object):
    method __init__ (line 165) | def __init__(self, key, default_value=None):
  function extract_schema (line 171) | def extract_schema(cls):

FILE: ppdet/core/config/yaml_helpers.py
  function represent_dictionary_order (line 24) | def represent_dictionary_order(self, dict_data):
  function setup_orderdict (line 28) | def setup_orderdict():
  function _make_python_constructor (line 33) | def _make_python_constructor(cls):
  function _make_python_representer (line 50) | def _make_python_representer(cls):
  function serializable (line 70) | def serializable(cls):
  class Callable (line 91) | class Callable(object):
    method __init__ (line 99) | def __init__(self, full_type, args=[], kwargs={}):
    method __call__ (line 105) | def __call__(self):

FILE: ppdet/core/workspace.py
  function dump_value (line 46) | def dump_value(value):
  class AttrDict (line 58) | class AttrDict(dict):
    method __init__ (line 61) | def __init__(self, **kwargs):
    method __getattr__ (line 65) | def __getattr__(self, key):
    method __setattr__ (line 70) | def __setattr__(self, key, value):
    method copy (line 73) | def copy(self):
  function _load_config_with_base (line 86) | def _load_config_with_base(file_path):
  function load_config (line 110) | def load_config(file_path):
  function dict_merge (line 130) | def dict_merge(dct, merge_dct):
  function merge_config (line 151) | def merge_config(config, another_cfg=None):
  function get_registered_modules (line 165) | def get_registered_modules():
  function make_partial (line 169) | def make_partial(cls):
  function register (line 192) | def register(cls):
  function create (line 210) | def create(cls_or_name, **kwargs):

FILE: ppdet/data/crop_utils/annotation_cropper.py
  class AnnoCropper (line 29) | class AnnoCropper(object):
    method __init__ (line 30) | def __init__(self,
    method crop_anno_records (line 65) | def crop_anno_records(self, records: List[dict]):
    method _add_to_cur_im_chips (line 146) | def _add_to_cur_im_chips(self, chips, pos_chip2boxes_idx, neg_chip2box...
    method _trans_all_chips2annotations (line 158) | def _trans_all_chips2annotations(self, r):
    method _trans_pos_chips2annotations (line 177) | def _trans_pos_chips2annotations(self, im_file, gt_bbox, is_crowd,
    method _sample_neg_chips (line 201) | def _sample_neg_chips(self):
    method _trans_neg_chips2annotations (line 216) | def _trans_neg_chips2annotations(self,
    method _get_current_scale_parameters (line 242) | def _get_current_scale_parameters(self, scale_i, r):
    method _get_current_scale (line 249) | def _get_current_scale(self, im_target_size, im_size):
    method _create_chips (line 252) | def _create_chips(self, h: int, w: int, scale: float):
    method _get_valid_boxes_and_pos_chips (line 295) | def _get_valid_boxes_and_pos_chips(self, gt_bbox, chips):
    method _validate_boxes (line 307) | def _validate_boxes(self,
    method _find_pos_chips (line 331) | def _find_pos_chips(self,
    method _find_chips_to_cover_overlaped_boxes (line 350) | def _find_chips_to_cover_overlaped_boxes(self, iob, overlap_threshold):
    method _assign_boxes_to_pos_chips (line 353) | def _assign_boxes_to_pos_chips(self, iob, overlap_threshold, pos_chip_...
    method _get_neg_boxes_and_chips (line 364) | def _get_neg_boxes_and_chips(self,
    method _find_neg_boxes (line 391) | def _find_neg_boxes(self,
    method _find_neg_chips (line 408) | def _find_neg_chips(self, chips: 'Cx4', pos_chip_ids: 'D',
    method crop_infer_anno_records (line 428) | def crop_infer_anno_records(self, records: List[dict]):
    method _get_chips_records (line 458) | def _get_chips_records(self, rec, chips, scale_i):
    method aggregate_chips_detections (line 484) | def aggregate_chips_detections(self, results, records=None):
    method _transform_chip2image_bboxes (line 500) | def _transform_chip2image_bboxes(self, results, records):
    method _nms_dets (line 545) | def _nms_dets(self, img_id2bbox):
    method _reformat_results (line 565) | def _reformat_results(self, img_id2bbox):

FILE: ppdet/data/crop_utils/chip_box_utils.py
  function bbox_area (line 18) | def bbox_area(boxes):
  function intersection_over_box (line 22) | def intersection_over_box(chips, boxes):
  function clip_boxes (line 48) | def clip_boxes(boxes, im_shape):
  function transform_chip_box (line 66) | def transform_chip_box(gt_bbox: 'Gx4', boxes_idx: 'B', chip: '4'):
  function find_chips_to_cover_overlaped_boxes (line 83) | def find_chips_to_cover_overlaped_boxes(iob, overlap_threshold):
  function transform_chip_boxes2image_boxes (line 105) | def transform_chip_boxes2image_boxes(chip_boxes, chip, img_h, img_w):
  function nms (line 117) | def nms(dets, thresh):

FILE: ppdet/data/culane_utils.py
  function lane_to_linestrings (line 7) | def lane_to_linestrings(lanes):
  function linestrings_to_lanes (line 15) | def linestrings_to_lanes(lines):
  function sample_lane (line 23) | def sample_lane(points, sample_ys, img_w):
  function filter_lane (line 57) | def filter_lane(lane):
  function transform_annotation (line 69) | def transform_annotation(img_w, img_h, max_lanes, n_offsets, offsets_ys,

FILE: ppdet/data/reader.py
  class Compose (line 43) | class Compose(object):
    method __init__ (line 44) | def __init__(self, transforms, num_classes=80):
    method _update_transforms_cls (line 56) | def _update_transforms_cls(self, data):
    method __call__ (line 76) | def __call__(self, data):
  class BatchCompose (line 91) | class BatchCompose(Compose):
    method __init__ (line 92) | def __init__(self, transforms, num_classes=80, collate_batch=True):
    method __call__ (line 96) | def __call__(self, data):
  class BaseDataLoader (line 133) | class BaseDataLoader(object):
    method __init__ (line 162) | def __init__(self,
    method __call__ (line 185) | def __call__(self,
    method __len__ (line 230) | def __len__(self):
    method __iter__ (line 233) | def __iter__(self):
    method __next__ (line 236) | def __next__(self):
    method next (line 243) | def next(self):
  class TrainReader (line 249) | class TrainReader(BaseDataLoader):
    method __init__ (line 252) | def __init__(self,
  class EvalReader (line 267) | class EvalReader(BaseDataLoader):
    method __init__ (line 270) | def __init__(self,
  class TestReader (line 284) | class TestReader(BaseDataLoader):
    method __init__ (line 287) | def __init__(self,
  class EvalMOTReader (line 301) | class EvalMOTReader(BaseDataLoader):
    method __init__ (line 304) | def __init__(self,
  class TestMOTReader (line 318) | class TestMOTReader(BaseDataLoader):
    method __init__ (line 321) | def __init__(self,
  class Compose_SSOD (line 335) | class Compose_SSOD(object):
    method __init__ (line 336) | def __init__(self, base_transforms, weak_aug, strong_aug, num_classes=...
    method __call__ (line 367) | def __call__(self, data):
  class BatchCompose_SSOD (line 404) | class BatchCompose_SSOD(Compose):
    method __init__ (line 405) | def __init__(self, transforms, num_classes=80, collate_batch=True):
    method __call__ (line 409) | def __call__(self, data):
  class CombineSSODLoader (line 469) | class CombineSSODLoader(object):
    method __init__ (line 470) | def __init__(self, label_loader, unlabel_loader):
    method __iter__ (line 474) | def __iter__(self):
    method __call__ (line 495) | def __call__(self):
  class BaseSemiDataLoader (line 499) | class BaseSemiDataLoader(object):
    method __init__ (line 500) | def __init__(self,
    method __call__ (line 534) | def __call__(self,
    method __len__ (line 605) | def __len__(self):
    method __iter__ (line 608) | def __iter__(self):
    method __next__ (line 611) | def __next__(self):
    method next (line 614) | def next(self):
  class SemiTrainReader (line 620) | class SemiTrainReader(BaseSemiDataLoader):
    method __init__ (line 623) | def __init__(self,

FILE: ppdet/data/shm_utils.py
  function _parse_size_in_M (line 36) | def _parse_size_in_M(size_str):
  function _get_shared_memory_size_in_M (line 47) | def _get_shared_memory_size_in_M():

FILE: ppdet/data/source/category.py
  function get_categories (line 29) | def get_categories(metric_type, anno_file=None, arch=None):
  function _mot_category (line 169) | def _mot_category(category='pedestrian'):
  function _coco17_category (line 184) | def _coco17_category():
  function _dota_category (line 363) | def _dota_category():
  function _vocall_category (line 391) | def _vocall_category():
  function _widerface_category (line 407) | def _widerface_category():
  function _oid19_category (line 417) | def _oid19_category():
  function _visdrone_category (line 927) | def _visdrone_category():

FILE: ppdet/data/source/coco.py
  class COCODataSet (line 37) | class COCODataSet(DetDataset):
    method __init__ (line 56) | def __init__(self,
    method _sample_empty (line 79) | def _sample_empty(self, records, num):
    method parse_dataset (line 89) | def parse_dataset(self):
  class SlicedCOCODataSet (line 256) | class SlicedCOCODataSet(COCODataSet):
    method __init__ (line 259) | def __init__(
    method parse_dataset (line 285) | def parse_dataset(self):
  class SemiCOCODataSet (line 379) | class SemiCOCODataSet(COCODataSet):
    method __init__ (line 382) | def __init__(self,
    method parse_dataset (line 399) | def parse_dataset(self):
    method __getitem__ (line 567) | def __getitem__(self, idx):
  class COCODetDataset (line 597) | class COCODetDataset(COCODataSet):
  class COCOInstSegDataset (line 604) | class COCOInstSegDataset(COCODataSet):

FILE: ppdet/data/source/culane.py
  class CULaneDataSet (line 25) | class CULaneDataSet(DetDataset):
    method __init__ (line 26) | def __init__(
    method __len__ (line 52) | def __len__(self):
    method check_or_download_dataset (line 55) | def check_or_download_dataset(self):
    method parse_dataset (line 69) | def parse_dataset(self):
    method load_annotation (line 93) | def load_annotation(self, line):
    method set_images (line 128) | def set_images(self, images):
    method _find_images (line 132) | def _find_images(self):
    method _load_images (line 145) | def _load_images(self):
    method get_imid2path (line 166) | def get_imid2path(self):
    method __getitem__ (line 169) | def __getitem__(self, idx):

FILE: ppdet/data/source/dataset.py
  class DetDataset (line 33) | class DetDataset(Dataset):
    method __init__ (line 47) | def __init__(self,
    method __len__ (line 67) | def __len__(self, ):
    method __call__ (line 70) | def __call__(self, *args, **kwargs):
    method __getitem__ (line 73) | def __getitem__(self, idx):
    method check_or_download_dataset (line 115) | def check_or_download_dataset(self):
    method set_kwargs (line 119) | def set_kwargs(self, **kwargs):
    method set_transform (line 126) | def set_transform(self, transform):
    method set_epoch (line 129) | def set_epoch(self, epoch_id):
    method parse_dataset (line 132) | def parse_dataset(self, ):
    method get_anno (line 136) | def get_anno(self):
  function _is_valid_file (line 142) | def _is_valid_file(f, extensions=('.jpg', '.jpeg', '.png', '.bmp')):
  function _make_dataset (line 146) | def _make_dataset(dir):
  class ImageFolder (line 161) | class ImageFolder(DetDataset):
    method __init__ (line 162) | def __init__(self,
    method check_or_download_dataset (line 179) | def check_or_download_dataset(self):
    method get_anno (line 182) | def get_anno(self):
    method parse_dataset (line 190) | def parse_dataset(self, ):
    method _parse (line 194) | def _parse(self):
    method get_images (line 207) | def get_images(self):
    method _load_images (line 216) | def _load_images(self, do_eval=False):
    method get_image_id (line 237) | def get_image_id(self, image, coco):
    method get_imid2path (line 246) | def get_imid2path(self):
    method set_images (line 249) | def set_images(self, images, do_eval=False):
    method set_slice_images (line 253) | def set_slice_images(self,
    method get_label_list (line 303) | def get_label_list(self):
  class CommonDataset (line 309) | class CommonDataset(object):
    method __init__ (line 310) | def __init__(self, **dataset_args):
    method __call__ (line 316) | def __call__(self):
  class TrainDataset (line 321) | class TrainDataset(CommonDataset):
  class EvalMOTDataset (line 326) | class EvalMOTDataset(CommonDataset):
  class TestMOTDataset (line 331) | class TestMOTDataset(CommonDataset):
  class EvalDataset (line 336) | class EvalDataset(CommonDataset):
  class TestDataset (line 341) | class TestDataset(CommonDataset):

FILE: ppdet/data/source/keypoint_coco.py
  class KeypointBottomUpBaseDataset (line 29) | class KeypointBottomUpBaseDataset(DetDataset):
    method __init__ (line 48) | def __init__(self,
    method parse_dataset (line 67) | def parse_dataset(self):
    method __len__ (line 70) | def __len__(self):
    method _get_imganno (line 74) | def _get_imganno(self, idx):
    method __getitem__ (line 78) | def __getitem__(self, idx):
    method parse_dataset (line 88) | def parse_dataset(self):
  class KeypointBottomUpCocoDataset (line 94) | class KeypointBottomUpCocoDataset(KeypointBottomUpBaseDataset):
    method __init__ (line 132) | def __init__(self,
    method parse_dataset (line 155) | def parse_dataset(self):
    method _get_mapping_id_name (line 182) | def _get_mapping_id_name(imgs):
    method _get_imganno (line 202) | def _get_imganno(self, idx):
    method _get_joints (line 244) | def _get_joints(self, anno, idx):
    method _get_bboxs (line 260) | def _get_bboxs(self, anno, idx):
    method _get_labels (line 272) | def _get_labels(self, anno, idx):
    method _get_areas (line 282) | def _get_areas(self, anno, idx):
    method _get_mask (line 291) | def _get_mask(self, anno, idx):
  class KeypointBottomUpCrowdPoseDataset (line 317) | class KeypointBottomUpCrowdPoseDataset(KeypointBottomUpCocoDataset):
    method __init__ (line 352) | def __init__(self,
    method parse_dataset (line 367) | def parse_dataset(self):
  class KeypointTopDownBaseDataset (line 388) | class KeypointTopDownBaseDataset(DetDataset):
    method __init__ (line 403) | def __init__(self,
    method __len__ (line 419) | def __len__(self):
    method _get_db (line 423) | def _get_db(self):
    method __getitem__ (line 427) | def __getitem__(self, idx):
  class KeypointTopDownCocoDataset (line 441) | class KeypointTopDownCocoDataset(KeypointTopDownBaseDataset):
    method __init__ (line 484) | def __init__(self,
    method parse_dataset (line 507) | def parse_dataset(self):
    method _load_coco_keypoint_annotations (line 513) | def _load_coco_keypoint_annotations(self):
    method _box2cs (line 572) | def _box2cs(self, box):
    method _load_coco_person_detection_results (line 594) | def _load_coco_person_detection_results(self):
  class KeypointTopDownCocoWholeBodyHandDataset (line 640) | class KeypointTopDownCocoWholeBodyHandDataset(KeypointTopDownBaseDataset):
    method __init__ (line 681) | def __init__(self,
    method _box2cs (line 696) | def _box2cs(self, box):
    method parse_dataset (line 715) | def parse_dataset(self):
  class KeypointTopDownMPIIDataset (line 756) | class KeypointTopDownMPIIDataset(KeypointTopDownBaseDataset):
    method __init__ (line 790) | def __init__(self,
    method parse_dataset (line 801) | def parse_dataset(self):

FILE: ppdet/data/source/lvis.py
  class LVISDataSet (line 36) | class LVISDataSet(DetDataset):
    method __init__ (line 55) | def __init__(self,
    method _sample_empty (line 78) | def _sample_empty(self, records, num):
    method parse_dataset (line 88) | def parse_dataset(self):

FILE: ppdet/data/source/mot.py
  class MOTDataSet (line 33) | class MOTDataSet(DetDataset):
    method __init__ (line 77) | def __init__(self,
    method get_anno (line 95) | def get_anno(self):
    method parse_dataset (line 105) | def parse_dataset(self):
  class MCMOTDataSet (line 233) | class MCMOTDataSet(DetDataset):
    method __init__ (line 259) | def __init__(self,
    method get_anno (line 277) | def get_anno(self):
    method parse_dataset (line 287) | def parse_dataset(self):
  class MOTImageFolder (line 460) | class MOTImageFolder(DetDataset):
    method __init__ (line 472) | def __init__(self,
    method check_or_download_dataset (line 492) | def check_or_download_dataset(self):
    method parse_dataset (line 495) | def parse_dataset(self, ):
    method _load_video_images (line 503) | def _load_video_images(self):
    method _find_images (line 535) | def _find_images(self):
    method _load_images (line 548) | def _load_images(self):
    method get_imid2path (line 566) | def get_imid2path(self):
    method set_images (line 569) | def set_images(self, images):
    method set_video (line 573) | def set_video(self, video_file, frame_rate):
    method get_anno (line 581) | def get_anno(self):
  function _is_valid_video (line 585) | def _is_valid_video(f, extensions=('.mp4', '.avi', '.mov', '.rmvb', 'flv...
  function video2frames (line 589) | def video2frames(video_path, outpath, frame_rate, **kargs):
  function mot_label (line 620) | def mot_label():
  function visdrone_mcmot_label (line 625) | def visdrone_mcmot_label():

FILE: ppdet/data/source/pose3d_cmb.py
  class Pose3DDataset (line 28) | class Pose3DDataset(DetDataset):
    method __init__ (line 48) | def __init__(self,
    method get_mask (line 68) | def get_mask(self, mvm_percent=0.3):
    method filterjoints (line 96) | def filterjoints(self, x):
    method parse_dataset (line 108) | def parse_dataset(self):
    method get_temp_num (line 167) | def get_temp_num(self):
    method __len__ (line 171) | def __len__(self):
    method _get_imganno (line 175) | def _get_imganno(self, idx):
    method __getitem__ (line 179) | def __getitem__(self, idx):
    method check_or_download_dataset (line 189) | def check_or_download_dataset(self):
  class Keypoint3DMultiFramesDataset (line 204) | class Keypoint3DMultiFramesDataset(Dataset):
    method __init__ (line 217) | def __init__(
    method _generate_multi_frames_list (line 237) | def _generate_multi_frames_list(self):
    method __call__ (line 263) | def __call__(self, *args, **kwargs):
    method __getitem__ (line 266) | def __getitem__(self, index):  # 拿一个连续的序列
    method kps3d_process (line 326) | def kps3d_process(self, kps3d_path):
    method __len__ (line 357) | def __len__(self):
    method get_anno (line 360) | def get_anno(self):
    method check_or_download_dataset (line 365) | def check_or_download_dataset(self):
    method parse_dataset (line 368) | def parse_dataset(self, ):
    method set_transform (line 371) | def set_transform(self, transform):
    method set_epoch (line 374) | def set_epoch(self, epoch_id):
    method set_kwargs (line 377) | def set_kwargs(self, **kwargs):

FILE: ppdet/data/source/sniper_coco.py
  class SniperCOCODataSet (line 37) | class SniperCOCODataSet(COCODataSet):
    method __init__ (line 40) | def __init__(self,
    method parse_dataset (line 83) | def parse_dataset(self):
    method set_proposals_file (line 93) | def set_proposals_file(self, file_path):
    method init_anno_cropper (line 96) | def init_anno_cropper(self):
    method generate_chips_roidbs (line 109) | def generate_chips_roidbs(self, roidbs, is_trainset):
    method _parse_proposals (line 116) | def _parse_proposals(self):
    method _merge_anno_proposals (line 129) | def _merge_anno_proposals(self):
    method get_ori_roidbs (line 140) | def get_ori_roidbs(self):
    method get_roidbs (line 145) | def get_roidbs(self):
    method set_roidbs (line 150) | def set_roidbs(self, roidbs):
    method check_or_download_dataset (line 153) | def check_or_download_dataset(self):
    method _parse (line 156) | def _parse(self):
    method _load_images (line 169) | def _load_images(self):
    method get_imid2path (line 187) | def get_imid2path(self):
    method set_images (line 190) | def set_images(self, images):

FILE: ppdet/data/source/voc.py
  class VOCDataSet (line 30) | class VOCDataSet(DetDataset):
    method __init__ (line 52) | def __init__(self,
    method _sample_empty (line 73) | def _sample_empty(self, records, num):
    method parse_dataset (line 83) | def parse_dataset(self, ):
    method get_label_list (line 207) | def get_label_list(self):
  function pascalvoc_label (line 211) | def pascalvoc_label():

FILE: ppdet/data/source/widerface.py
  class WIDERFaceDataSet (line 29) | class WIDERFaceDataSet(DetDataset):
    method __init__ (line 42) | def __init__(self,
    method parse_dataset (line 62) | def parse_dataset(self):
    method _load_file_list (line 114) | def _load_file_list(self, input_txt):
  function widerface_label (line 180) | def widerface_label():
  class WIDERFaceValDataset (line 187) | class WIDERFaceValDataset(WIDERFaceDataSet):
    method __init__ (line 188) | def __init__(self,
    method parse_dataset (line 214) | def parse_dataset(self):
    method get_gt_infos (line 245) | def get_gt_infos(self):

FILE: ppdet/data/transform/atss_assigner.py
  function bbox_overlaps (line 27) | def bbox_overlaps(bboxes1, bboxes2, mode='iou', is_aligned=False, eps=1e...
  function topk_ (line 145) | def topk_(input, k, axis=1, largest=True):
  class ATSSAssigner (line 171) | class ATSSAssigner(object):
    method __init__ (line 184) | def __init__(self, topk=9):
    method __call__ (line 187) | def __call__(self,
    method get_vlr_region (line 302) | def get_vlr_region(self,

FILE: ppdet/data/transform/autoaugment_utils.py
  function policy_v0 (line 38) | def policy_v0():
  function policy_v1 (line 53) | def policy_v1():
  function policy_vtest (line 83) | def policy_vtest():
  function policy_v2 (line 92) | def policy_v2():
  function policy_v3 (line 126) | def policy_v3():
  function _equal (line 151) | def _equal(val1, val2, eps=1e-8):
  function blend (line 155) | def blend(image1, image2, factor):
  function cutout (line 198) | def cutout(image, pad_size, replace=0):
  function solarize (line 250) | def solarize(image, threshold=128):
  function solarize_add (line 257) | def solarize_add(image, addition=0, threshold=128):
  function color (line 267) | def color(image, factor):
  function contrast (line 275) | def contrast(img, factor):
  function brightness (line 280) | def brightness(image, factor):
  function posterize (line 286) | def posterize(image, bits):
  function rotate (line 292) | def rotate(image, degrees, replace):
  function random_shift_bbox (line 313) | def random_shift_bbox(image,
  function _clip_bbox (line 433) | def _clip_bbox(min_y, min_x, max_y, max_x):
  function _check_bbox_area (line 452) | def _check_bbox_area(min_y, min_x, max_y, max_x, delta=0.05):
  function _scale_bbox_only_op_probability (line 486) | def _scale_bbox_only_op_probability(prob):
  function _apply_bbox_augmentation (line 503) | def _apply_bbox_augmentation(image, bbox, augmentation_func, *args):
  function _concat_bbox (line 558) | def _concat_bbox(bbox, bboxes):
  function _apply_bbox_augmentation_wrapper (line 573) | def _apply_bbox_augmentation_wrapper(image, bbox, new_bboxes, prob,
  function _apply_multi_bbox_augmentation (line 618) | def _apply_multi_bbox_augmentation(image, bboxes, prob, aug_func,
  function _apply_multi_bbox_augmentation_wrapper (line 698) | def _apply_multi_bbox_augmentation_wrapper(image, bboxes, prob, aug_func,
  function rotate_only_bboxes (line 710) | def rotate_only_bboxes(image, bboxes, prob, degrees, replace):
  function shear_x_only_bboxes (line 718) | def shear_x_only_bboxes(image, bboxes, prob, level, replace):
  function shear_y_only_bboxes (line 726) | def shear_y_only_bboxes(image, bboxes, prob, level, replace):
  function translate_x_only_bboxes (line 734) | def translate_x_only_bboxes(image, bboxes, prob, pixels, replace):
  function translate_y_only_bboxes (line 742) | def translate_y_only_bboxes(image, bboxes, prob, pixels, replace):
  function flip_only_bboxes (line 750) | def flip_only_bboxes(image, bboxes, prob):
  function solarize_only_bboxes (line 758) | def solarize_only_bboxes(image, bboxes, prob, threshold):
  function equalize_only_bboxes (line 766) | def equalize_only_bboxes(image, bboxes, prob):
  function cutout_only_bboxes (line 774) | def cutout_only_bboxes(image, bboxes, prob, pad_size, replace):
  function _rotate_bbox (line 782) | def _rotate_bbox(bbox, image_height, image_width, degrees):
  function rotate_with_bboxes (line 833) | def rotate_with_bboxes(image, bboxes, degrees, replace):
  function translate_x (line 848) | def translate_x(image, pixels, replace):
  function translate_y (line 855) | def translate_y(image, pixels, replace):
  function _shift_bbox (line 862) | def _shift_bbox(bbox, image_height, image_width, pixels, shift_horizontal):
  function translate_bbox (line 903) | def translate_bbox(image, bboxes, pixels, replace, shift_horizontal):
  function shear_x (line 938) | def shear_x(image, level, replace):
  function shear_y (line 949) | def shear_y(image, level, replace):
  function _shear_bbox (line 960) | def _shear_bbox(bbox, image_height, image_width, level, shear_horizontal):
  function shear_with_bboxes (line 1007) | def shear_with_bboxes(image, bboxes, level, replace, shear_horizontal):
  function autocontrast (line 1043) | def autocontrast(image):
  function sharpness (line 1082) | def sharpness(image, factor):
  function equalize (line 1095) | def equalize(image):
  function wrap (line 1137) | def wrap(image):
  function unwrap (line 1145) | def unwrap(image, replace):
  function _cutout_inside_bbox (line 1187) | def _cutout_inside_bbox(image, bbox, pad_fraction):
  function bbox_cutout (line 1257) | def bbox_cutout(image, bboxes, pad_fraction, replace_with_mean):
  function _randomly_negate_tensor (line 1348) | def _randomly_negate_tensor(tensor):
  function _rotate_level_to_arg (line 1355) | def _rotate_level_to_arg(level):
  function _shrink_level_to_arg (line 1361) | def _shrink_level_to_arg(level):
  function _enhance_level_to_arg (line 1370) | def _enhance_level_to_arg(level):
  function _shear_level_to_arg (line 1374) | def _shear_level_to_arg(level):
  function _translate_level_to_arg (line 1381) | def _translate_level_to_arg(level, translate_const):
  function _bbox_cutout_level_to_arg (line 1388) | def _bbox_cutout_level_to_arg(level, hparams):
  function level_to_arg (line 1394) | def level_to_arg(hparams):
  function bbox_wrapper (line 1437) | def bbox_wrapper(func):
  function _parse_policy_info (line 1446) | def _parse_policy_info(name, prob, level, replace_value, augmentation_hp...
  function _apply_func_with_prob (line 1471) | def _apply_func_with_prob(func, image, args, prob, bboxes):
  function select_and_apply_random_policy (line 1490) | def select_and_apply_random_policy(policies, image, bboxes):
  function build_and_apply_nas_policy (line 1500) | def build_and_apply_nas_policy(policies, image, bboxes, augmentation_hpa...
  function distort_image_with_autoaugment (line 1554) | def distort_image_with_autoaugment(image, bboxes, augmentation_name):

FILE: ppdet/data/transform/batch_operators.py
  class PadBatch (line 49) | class PadBatch(BaseOperator):
    method __init__ (line 58) | def __init__(self, pad_to_stride=0):
    method __call__ (line 62) | def __call__(self, samples, context=None):
  class BatchRandomResize (line 110) | class BatchRandomResize(BaseOperator):
    method __init__ (line 121) | def __init__(self,
    method __call__ (line 147) | def __call__(self, samples, context=None):
  class Gt2YoloTarget (line 164) | class Gt2YoloTarget(BaseOperator):
    method __init__ (line 171) | def __init__(self,
    method __call__ (line 184) | def __call__(self, samples, context=None):
  class Gt2FCOSTarget (line 280) | class Gt2FCOSTarget(BaseOperator):
    method __init__ (line 285) | def __init__(self,
    method _compute_points (line 307) | def _compute_points(self, w, h):
    method _convert_xywh2xyxy (line 328) | def _convert_xywh2xyxy(self, gt_bbox, w, h):
    method _check_inside_boxes_limited (line 343) | def _check_inside_boxes_limited(self, gt_bbox, xs, ys,
    method __call__ (line 379) | def __call__(self, samples, context=None):
  class Gt2GFLTarget (line 488) | class Gt2GFLTarget(BaseOperator):
    method __init__ (line 494) | def __init__(self,
    method get_grid_cells (line 509) | def get_grid_cells(self, featmap_size, scale, stride, offset=0):
    method get_sample (line 535) | def get_sample(self, assign_gt_inds, gt_bboxes):
    method __call__ (line 550) | def __call__(self, samples, context=None):
  class Gt2TTFTarget (line 626) | class Gt2TTFTarget(BaseOperator):
    method __init__ (line 639) | def __init__(self, num_classes=80, down_ratio=4, alpha=0.54):
    method __call__ (line 645) | def __call__(self, samples, context=None):
    method draw_truncate_gaussian (line 705) | def draw_truncate_gaussian(self, heatmap, center, h_radius, w_radius):
  class Gt2Solov2Target (line 728) | class Gt2Solov2Target(BaseOperator):
    method __init__ (line 739) | def __init__(self,
    method _scale_size (line 751) | def _scale_size(self, im, scale):
    method __call__ (line 758) | def __call__(self, samples, context=None):
  class Gt2SparseTarget (line 910) | class Gt2SparseTarget(BaseOperator):
    method __init__ (line 911) | def __init__(self, use_padding_shape=False):
    method __call__ (line 915) | def __call__(self, samples, context=None):
  class PadMaskBatch (line 942) | class PadMaskBatch(BaseOperator):
    method __init__ (line 953) | def __init__(self, pad_to_stride=0, return_pad_mask=True):
    method __call__ (line 958) | def __call__(self, samples, context=None):
  class Gt2CenterNetTarget (line 1003) | class Gt2CenterNetTarget(BaseOperator):
    method __init__ (line 1014) | def __init__(self, num_classes=80, down_ratio=4, max_objs=128):
    method __call__ (line 1020) | def __call__(self, sample, context=None):
  class PadGT (line 1087) | class PadGT(BaseOperator):
    method __init__ (line 1096) | def __init__(self, return_gt_mask=True, pad_img=False, minimum_gtnum=0...
    method _impad (line 1103) | def _impad(self,
    method checkmaxshape (line 1187) | def checkmaxshape(self, samples):
    method __call__ (line 1197) | def __call__(self, samples, context=None):
  class PadRGT (line 1287) | class PadRGT(BaseOperator):
    method __init__ (line 1296) | def __init__(self, return_gt_mask=True):
    method pad_field (line 1300) | def pad_field(self, sample, field, num_gt):
    method __call__ (line 1308) | def __call__(self, samples, context=None):
  class Gt2CenterTrackTarget (line 1341) | class Gt2CenterTrackTarget(BaseOperator):
    method __init__ (line 1352) | def __init__(self,
    method _get_pre_dets (line 1374) | def _get_pre_dets(self, input_h, input_w, trans_input_pre, gt_bbox_pre,
    method __call__ (line 1425) | def __call__(self, sample, context=None):
  class BatchRandomResizeForSSOD (line 1513) | class BatchRandomResizeForSSOD(BaseOperator):
    method __init__ (line 1524) | def __init__(self,
    method __call__ (line 1550) | def __call__(self, samples, context=None):

FILE: ppdet/data/transform/culane_operators.py
  function trainTransforms (line 16) | def trainTransforms(img_h, img_w):
  class CULaneTrainProcess (line 65) | class CULaneTrainProcess(BaseOperator):
    method __init__ (line 66) | def __init__(self, img_w, img_h):
    method apply (line 94) | def apply(self, sample, context=None):
  class CULaneDataProcess (line 106) | class CULaneDataProcess(BaseOperator):
    method __init__ (line 107) | def __init__(self, img_w, img_h, num_points, max_lanes):
    method apply (line 119) | def apply(self, sample, context=None):
  class CULaneResize (line 156) | class CULaneResize(BaseOperator):
    method __init__ (line 157) | def __init__(self, img_h, img_w, prob=0.5):
    method apply (line 163) | def apply(self, sample, context=None):
  class HorizontalFlip (line 188) | class HorizontalFlip(BaseOperator):
    method __init__ (line 189) | def __init__(self, prob=0.5):
    method apply (line 193) | def apply(self, sample, context=None):
  class ChannelShuffle (line 213) | class ChannelShuffle(BaseOperator):
    method __init__ (line 214) | def __init__(self, prob=0.1):
    method apply (line 218) | def apply(self, sample, context=None):
  class MultiplyAndAddToBrightness (line 238) | class MultiplyAndAddToBrightness(BaseOperator):
    method __init__ (line 239) | def __init__(self, mul=(0.85, 1.15), add=(-10, 10), prob=0.5):
    method apply (line 245) | def apply(self, sample, context=None):
  class AddToHueAndSaturation (line 268) | class AddToHueAndSaturation(BaseOperator):
    method __init__ (line 269) | def __init__(self, value=(-10, 10), prob=0.5):
    method apply (line 274) | def apply(self, sample, context=None):
  class OneOfBlur (line 295) | class OneOfBlur(BaseOperator):
    method __init__ (line 296) | def __init__(self, MotionBlur_k=(3, 5), MedianBlur_k=(3, 5), prob=0.5):
    method apply (line 302) | def apply(self, sample, context=None):
  class CULaneAffine (line 328) | class CULaneAffine(BaseOperator):
    method __init__ (line 329) | def __init__(self,
    method apply (line 344) | def apply(self, sample, context=None):

FILE: ppdet/data/transform/gridmask_utils.py
  class Gridmask (line 26) | class Gridmask(object):
    method __init__ (line 27) | def __init__(self,
    method __call__ (line 47) | def __call__(self, x, curr_iter):

FILE: ppdet/data/transform/keypoint_operators.py
  function register_keypointop (line 49) | def register_keypointop(cls):
  class KeyPointFlip (line 54) | class KeyPointFlip(object):
    method __init__ (line 69) | def __init__(self, flip_permutation, hmsize=None, flip_prob=0.5):
    method _flipjoints (line 76) | def _flipjoints(self, records, sizelst):
    method _flipmask (line 102) | def _flipmask(self, records, sizelst):
    method _flipbbox (line 113) | def _flipbbox(self, records, sizelst):
    method __call__ (line 124) | def __call__(self, records):
  class RandomAffine (line 142) | class RandomAffine(object):
    method __init__ (line 160) | def __init__(self,
    method _get_affine_matrix_old (line 178) | def _get_affine_matrix_old(self, center, scale, res, rot=0):
    method _get_affine_matrix (line 204) | def _get_affine_matrix(self, center, scale, res, rot=0):
    method _affine_joints_mask (line 230) | def _affine_joints_mask(self,
    method __call__ (line 265) | def __call__(self, records):
  class EvalAffine (line 352) | class EvalAffine(object):
    method __init__ (line 365) | def __init__(self, size, stride=64):
    method __call__ (line 370) | def __call__(self, records):
  class NormalizePermute (line 388) | class NormalizePermute(object):
    method __init__ (line 389) | def __init__(self,
    method __call__ (line 398) | def __call__(self, records):
  class TagGenerate (line 414) | class TagGenerate(object):
    method __init__ (line 427) | def __init__(self, num_joints, max_people=30):
    method __call__ (line 432) | def __call__(self, records):
  class ToHeatmaps (line 450) | class ToHeatmaps(object):
    method __init__ (line 464) | def __init__(self, num_joints, hmsize, sigma=None):
    method __call__ (line 478) | def __call__(self, records):
  class RandomFlipHalfBodyTransform (line 511) | class RandomFlipHalfBodyTransform(object):
    method __init__ (line 531) | def __init__(self,
    method halfbody_transform (line 555) | def halfbody_transform(self, joints, joints_vis):
    method flip_joints (line 588) | def flip_joints(self, joints, joints_vis, width, matched_parts):
    method __call__ (line 598) | def __call__(self, records):
  class AugmentationbyInformantionDropping (line 633) | class AugmentationbyInformantionDropping(object):
    method __init__ (line 648) | def __init__(self,
    method _cutout (line 658) | def _cutout(self, img, joints, joints_vis):
    method __call__ (line 681) | def __call__(self, records):
  class TopDownRandomFlip (line 692) | class TopDownRandomFlip(object):
    method __init__ (line 701) | def __init__(self, flip_perm=[], flip_prob=0.5):
    method flip_joints (line 705) | def flip_joints(self, joints_3d, joints_3d_visible, img_width, flip_pa...
    method __call__ (line 726) | def __call__(self, results):
  class TopDownRandomShiftBboxCenter (line 762) | class TopDownRandomShiftBboxCenter(object):
    method __init__ (line 771) | def __init__(self, shift_factor=0.16, shift_prob=0.3):
    method __call__ (line 775) | def __call__(self, results):
  class TopDownGetRandomScaleRotation (line 786) | class TopDownGetRandomScaleRotation(object):
    method __init__ (line 795) | def __init__(self, rot_factor=40, scale_factor=0.5, rot_prob=0.6):
    method __call__ (line 800) | def __call__(self, results):
  class TopDownAffine (line 820) | class TopDownAffine(object):
    method __init__ (line 833) | def __init__(self, trainsize, use_udp=False):
    method __call__ (line 837) | def __call__(self, records):
  class SinglePoseAffine (line 870) | class SinglePoseAffine(object):
    method __init__ (line 883) | def __init__(self,
    method __call__ (line 895) | def __call__(self, records):
  class NoiseJitter (line 957) | class NoiseJitter(object):
    method __init__ (line 968) | def __init__(self, noise_factor=0.4):
    method __call__ (line 971) | def __call__(self, records):
  class FlipPose (line 986) | class FlipPose(object):
    method __init__ (line 997) | def __init__(self, flip_prob=0.5, img_res=224, num_joints=14):
    method __call__ (line 1010) | def __call__(self, records):
  class TopDownEvalAffine (line 1033) | class TopDownEvalAffine(object):
    method __init__ (line 1046) | def __init__(self, trainsize, use_udp=False):
    method __call__ (line 1050) | def __call__(self, records):
  class ToHeatmapsTopDown (line 1077) | class ToHeatmapsTopDown(object):
    method __init__ (line 1090) | def __init__(self, hmsize, sigma):
    method __call__ (line 1095) | def __call__(self, records):
  class ToHeatmapsTopDown_DARK (line 1149) | class ToHeatmapsTopDown_DARK(object):
    method __init__ (line 1162) | def __init__(self, hmsize, sigma):
    method __call__ (line 1167) | def __call__(self, records):
  class ToHeatmapsTopDown_UDP (line 1207) | class ToHeatmapsTopDown_UDP(object):
    method __init__ (line 1224) | def __init__(self, hmsize, sigma):
    method __call__ (line 1229) | def __call__(self, records):
  function _scale_size (line 1284) | def _scale_size(
  function rescale_size (line 1302) | def rescale_size(old_size: tuple,
  function imrescale (line 1341) | def imrescale(img: np.ndarray,
  function imresize (line 1373) | def imresize(
  class PETR_Resize (line 1422) | class PETR_Resize:
    method __init__ (line 1467) | def __init__(self,
    method random_select (line 1504) | def random_select(img_scales):
    method random_sample (line 1522) | def random_sample(img_scales):
    method random_sample_ratio (line 1547) | def random_sample_ratio(img_scale, ratio_range):
    method _random_scale (line 1573) | def _random_scale(self, results):
    method _resize_img (line 1605) | def _resize_img(self, results):
    method _resize_bboxes (line 1639) | def _resize_bboxes(self, results):
    method _resize_masks (line 1649) | def _resize_masks(self, results):
    method _resize_seg (line 1659) | def _resize_seg(self, results):
    method _resize_keypoints (line 1676) | def _resize_keypoints(self, results):
    method _resize_areas (line 1688) | def _resize_areas(self, results):
    method __call__ (line 1696) | def __call__(self, results):
    method __repr__ (line 1734) | def __repr__(self):

FILE: ppdet/data/transform/keypoints_3d_operators.py
  function register_keypointop (line 45) | def register_keypointop(cls):
  function register_op (line 49) | def register_op(cls):
  class BaseOperator (line 58) | class BaseOperator(object):
    method __init__ (line 59) | def __init__(self, name=None):
    method apply (line 64) | def apply(self, sample, context=None):
    method __call__ (line 74) | def __call__(self, sample, context=None):
    method __str__ (line 90) | def __str__(self):
  class CropAndFlipImages (line 95) | class CropAndFlipImages(object):
    method __init__ (line 98) | def __init__(self, crop_range, flip_pairs=None):
    method __call__ (line 103) | def __call__(self, records):  # tuple
  class PermuteImages (line 126) | class PermuteImages(BaseOperator):
    method __init__ (line 127) | def __init__(self):
    method apply (line 133) | def apply(self, sample, context=None):
  class RandomFlipHalfBody3DTransformImages (line 143) | class RandomFlipHalfBody3DTransformImages(object):
    method __init__ (line 160) | def __init__(self,
    method halfbody_transform (line 186) | def halfbody_transform(self, joints, joints_vis):
    method flip_joints (line 219) | def flip_joints(self, joints, joints_vis, width, matched_parts, kps2d=...
    method __call__ (line 242) | def __call__(self, records):

FILE: ppdet/data/transform/mot_operators.py
  class RGBReverse (line 45) | class RGBReverse(BaseOperator):
    method __init__ (line 49) | def __init__(self):
    method apply (line 52) | def apply(self, sample, context=None):
  class LetterBoxResize (line 59) | class LetterBoxResize(BaseOperator):
    method __init__ (line 60) | def __init__(self, target_size):
    method apply_image (line 76) | def apply_image(self, img, height, width, color=(127.5, 127.5, 127.5)):
    method apply_bbox (line 96) | def apply_bbox(self, bbox0, h, w, ratio, padw, padh):
    method apply (line 104) | def apply(self, sample, context=None):
  class MOTRandomAffine (line 134) | class MOTRandomAffine(BaseOperator):
    method __init__ (line 153) | def __init__(self,
    method apply (line 168) | def apply(self, sample, context=None):
  class Gt2JDETargetThres (line 266) | class Gt2JDETargetThres(BaseOperator):
    method __init__ (line 280) | def __init__(self,
    method generate_anchor (line 297) | def generate_anchor(self, nGh, nGw, anchor_hw):
    method encode_delta (line 312) | def encode_delta(self, gt_box_list, fg_anchor_list):
    method pad_box (line 323) | def pad_box(self, sample, num_max):
    method __call__ (line 353) | def __call__(self, samples, context=None):
  class Gt2JDETargetMax (line 428) | class Gt2JDETargetMax(BaseOperator):
    method __init__ (line 440) | def __init__(self,
    method __call__ (line 453) | def __call__(self, samples, context=None):
  class Gt2FairMOTTarget (line 526) | class Gt2FairMOTTarget(Gt2TTFTarget):
    method __init__ (line 540) | def __init__(self, num_classes=1, down_ratio=4, max_objs=500):
    method __call__ (line 546) | def __call__(self, samples, context=None):

FILE: ppdet/data/transform/op_helper.py
  function meet_emit_constraint (line 26) | def meet_emit_constraint(src_bbox, sample_bbox):
  function clip_bbox (line 37) | def clip_bbox(src_bbox):
  function bbox_area (line 45) | def bbox_area(src_bbox):
  function is_overlap (line 54) | def is_overlap(object_bbox, sample_bbox):
  function filter_and_process (line 64) | def filter_and_process(sample_bbox, bboxes, labels, scores=None,
  function bbox_area_sampling (line 111) | def bbox_area_sampling(bboxes, labels, scores, target_size, min_size):
  function generate_sample_bbox (line 131) | def generate_sample_bbox(sampler):
  function generate_sample_bbox_square (line 148) | def generate_sample_bbox_square(sampler, image_width, image_height):
  function data_anchor_sampling (line 169) | def data_anchor_sampling(bbox_labels, image_width, image_height, scale_a...
  function jaccard_overlap (line 254) | def jaccard_overlap(sample_bbox, object_bbox):
  function intersect_bbox (line 273) | def intersect_bbox(bbox1, bbox2):
  function bbox_coverage (line 285) | def bbox_coverage(bbox1, bbox2):
  function satisfy_sample_constraint (line 296) | def satisfy_sample_constraint(sampler,
  function satisfy_sample_constraint_coverage (line 326) | def satisfy_sample_constraint_coverage(sampler, sample_bbox, gt_bboxes):
  function crop_image_sampling (line 366) | def crop_image_sampling(img, sample_bbox, image_width, image_height,
  function is_poly (line 410) | def is_poly(segm):
  function gaussian_radius (line 416) | def gaussian_radius(bbox_size, min_overlap):
  function draw_gaussian (line 439) | def draw_gaussian(heatmap, center, radius, k=1, delte=6):
  function gaussian2D (line 457) | def gaussian2D(shape, sigma_x=1, sigma_y=1):
  function draw_umich_gaussian (line 467) | def draw_umich_gaussian(heatmap, center, radius, k=1):
  function get_border (line 490) | def get_border(border, size):

FILE: ppdet/data/transform/operators.py
  function register_op (line 63) | def register_op(cls):
  class BboxError (line 72) | class BboxError(ValueError):
  class ImageError (line 76) | class ImageError(ValueError):
  class BaseOperator (line 80) | class BaseOperator(object):
    method __init__ (line 81) | def __init__(self, name=None):
    method apply (line 86) | def apply(self, sample, context=None):
    method __call__ (line 96) | def __call__(self, sample, context=None):
    method __str__ (line 111) | def __str__(self):
  class Decode (line 116) | class Decode(BaseOperator):
    method __init__ (line 117) | def __init__(self, rtn_im_file=False):
    method apply (line 123) | def apply(self, sample, context=None):
  function _make_dirs (line 164) | def _make_dirs(dirname):
  class DecodeCache (line 173) | class DecodeCache(BaseOperator):
    method __init__ (line 174) | def __init__(self, cache_root=None):
    method apply (line 185) | def apply(self, sample, context=None):
    method cache_path (line 221) | def cache_path(dir_oot, im_file):
    method load (line 225) | def load(path):
    method dump (line 231) | def dump(obj, path):
  class SniperDecodeCrop (line 245) | class SniperDecodeCrop(BaseOperator):
    method __init__ (line 246) | def __init__(self):
    method __call__ (line 249) | def __call__(self, sample, context=None):
  class Permute (line 280) | class Permute(BaseOperator):
    method __init__ (line 281) | def __init__(self):
    method apply (line 287) | def apply(self, sample, context=None):
  class Lighting (line 300) | class Lighting(BaseOperator):
    method __init__ (line 309) | def __init__(self, eigval, eigvec, alphastd=0.1):
    method apply (line 315) | def apply(self, sample, context=None):
  class RandomErasingImage (line 325) | class RandomErasingImage(BaseOperator):
    method __init__ (line 326) | def __init__(self, prob=0.5, lower=0.02, higher=0.4, aspect_ratio=0.3):
    method apply (line 341) | def apply(self, sample, context=None):
  class NormalizeImage (line 375) | class NormalizeImage(BaseOperator):
    method __init__ (line 376) | def __init__(self,
    method apply (line 401) | def apply(self, sample, context=None):
  class GridMask (line 440) | class GridMask(BaseOperator):
    method __init__ (line 441) | def __init__(self,
    method apply (line 483) | def apply(self, sample, context=None):
  class RandomDistort (line 489) | class RandomDistort(BaseOperator):
    method __init__ (line 502) | def __init__(self,
    method apply_hue (line 521) | def apply_hue(self, img):
    method apply_saturation (line 531) | def apply_saturation(self, img):
    method apply_contrast (line 539) | def apply_contrast(self, img):
    method apply_brightness (line 547) | def apply_brightness(self, img):
    method apply (line 555) | def apply(self, sample, context=None):
  class PhotoMetricDistortion (line 590) | class PhotoMetricDistortion(BaseOperator):
    method __init__ (line 611) | def __init__(self,
    method apply (line 622) | def apply(self, results, context=None):
    method __repr__ (line 680) | def __repr__(self):
  class AutoAugment (line 692) | class AutoAugment(BaseOperator):
    method __init__ (line 693) | def __init__(self, autoaug_type="v1"):
    method apply (line 701) | def apply(self, sample, context=None):
  class RandomFlip (line 736) | class RandomFlip(BaseOperator):
    method __init__ (line 737) | def __init__(self, prob=0.5):
    method apply_segm (line 747) | def apply_segm(self, segms, height, width):
    method apply_keypoint (line 772) | def apply_keypoint(self, gt_keypoint, width):
    method apply_image (line 779) | def apply_image(self, image):
    method apply_bbox (line 782) | def apply_bbox(self, bbox, width):
    method apply (line 789) | def apply(self, sample, context=None):
  class Resize (line 826) | class Resize(BaseOperator):
    method __init__ (line 827) | def __init__(self, target_size, keep_ratio, interp=cv2.INTER_LINEAR):
    method apply_image (line 848) | def apply_image(self, image, scale):
    method apply_bbox (line 859) | def apply_bbox(self, bbox, scale, size):
    method apply_area (line 868) | def apply_area(self, area, scale):
    method apply_joints (line 872) | def apply_joints(self, joints, scale, size):
    method apply_segm (line 881) | def apply_segm(self, segms, im_size, scale):
    method apply (line 920) | def apply(self, sample, context=None):
  class MultiscaleTestResize (line 1033) | class MultiscaleTestResize(BaseOperator):
    method __init__ (line 1034) | def __init__(self,
    method apply (line 1064) | def apply(self, sample, context=None):
  class RandomResize (line 1083) | class RandomResize(BaseOperator):
    method __init__ (line 1084) | def __init__(self,
    method apply (line 1128) | def apply(self, sample, context=None):
  class RandomExpand (line 1152) | class RandomExpand(BaseOperator):
    method __init__ (line 1160) | def __init__(self, ratio=4., prob=0.5, fill_value=(127.5, 127.5, 127.5)):
    method apply (line 1173) | def apply(self, sample, context=None):
  class CropWithSampling (line 1197) | class CropWithSampling(BaseOperator):
    method __init__ (line 1198) | def __init__(self, batch_sampler, satisfy_all=False, avoid_no_bbox=True):
    method apply (line 1222) | def apply(self, sample, context):
  class CropWithDataAchorSampling (line 1277) | class CropWithDataAchorSampling(BaseOperator):
    method __init__ (line 1278) | def __init__(self,
    method apply (line 1317) | def apply(self, sample, context):
  class RandomCrop (line 1459) | class RandomCrop(BaseOperator):
    method __init__ (line 1473) | def __init__(self,
    method crop_segms (line 1494) | def crop_segms(self, segms, valid_ids, crop, height, width):
    method polygon_to_rle (line 1564) | def polygon_to_rle(self, polygons, height, width):
    method rle_to_polygon (line 1577) | def rle_to_polygon(self, rle_mask, min_area=5):
    method set_fake_bboxes (line 1593) | def set_fake_bboxes(self, sample):
    method apply (line 1612) | def apply(self, sample, context=None):
    method random_crop (line 1629) | def random_crop(self, sample, fake_bboxes=False):
    method _iou_matrix (line 1752) | def _iou_matrix(self, a, b):
    method _gtcropiou_matrix (line 1762) | def _gtcropiou_matrix(self, a, b):
    method _crop_box_with_center_constraint (line 1772) | def _crop_box_with_center_constraint(self, box, crop):
    method _crop_image (line 1788) | def _crop_image(self, img, crop):
    method _crop_segm (line 1792) | def _crop_segm(self, segm, crop):
    method _crop_joints (line 1796) | def _crop_joints(self, joints, crop):
  class RandomScaledCrop (line 1808) | class RandomScaledCrop(BaseOperator):
    method __init__ (line 1819) | def __init__(self,
    method apply_image (line 1841) | def apply_image(self, img, output_size, offset_x, offset_y):
    method apply_bbox (line 1852) | def apply_bbox(self, gt_bbox, gt_class, scale, offset_x, offset_y):
    method apply_segm (line 1867) | def apply_segm(self, segms, output_size, offset_x, offset_y, valid=None):
    method apply (line 1881) | def apply(self, sample, context=None):
  class Cutmix (line 1920) | class Cutmix(BaseOperator):
    method __init__ (line 1921) | def __init__(self, alpha=1.5, beta=1.5):
    method apply_image (line 1937) | def apply_image(self, img1, img2, factor):
    method __call__ (line 1964) | def __call__(self, sample, context=None):
  class Mixup (line 2009) | class Mixup(BaseOperator):
    method __init__ (line 2010) | def __init__(self, alpha=1.5, beta=1.5):
    method apply_image (line 2024) | def apply_image(self, img1, img2, factor):
    method __call__ (line 2034) | def __call__(self, sample, context=None):
  class NormalizeBox (line 2087) | class NormalizeBox(BaseOperator):
    method __init__ (line 2090) | def __init__(self, retain_origin_box=False):
    method apply (line 2094) | def apply(self, sample, context):
  class BboxXYXY2XYWH (line 2126) | class BboxXYXY2XYWH(BaseOperator):
    method __init__ (line 2131) | def __init__(self):
    method apply (line 2134) | def apply(self, sample, context=None):
  class PadBox (line 2146) | class PadBox(BaseOperator):
    method __init__ (line 2147) | def __init__(self, num_max_boxes=50):
    method apply (line 2156) | def apply(self, sample, context=None):
  class DebugVisibleImage (line 2198) | class DebugVisibleImage(BaseOperator):
    method __init__ (line 2204) | def __init__(self, output_dir='output/debug', is_normalized=False):
    method apply (line 2213) | def apply(self, sample, context=None):
  class Pad (line 2262) | class Pad(BaseOperator):
    method __init__ (line 2263) | def __init__(self,
    method apply_segm (line 2301) | def apply_segm(self, segms, offsets, im_size, size):
    method apply_bbox (line 2335) | def apply_bbox(self, bbox, offsets):
    method apply_keypoint (line 2338) | def apply_keypoint(self, keypoints, offsets):
    method apply_image (line 2342) | def apply_image(self, image, offsets, im_size, size):
    method apply (line 2351) | def apply(self, sample, context=None):
  class Poly2Mask (line 2409) | class Poly2Mask(BaseOperator):
    method __init__ (line 2416) | def __init__(self, del_poly=False):
    method _poly2mask (line 2422) | def _poly2mask(self, mask_ann, img_h, img_w):
    method apply (line 2437) | def apply(self, sample, context=None):
  class AugmentHSV (line 2452) | class AugmentHSV(BaseOperator):
    method __init__ (line 2463) | def __init__(self,
    method apply (line 2477) | def apply(self, sample, context=None):
  class Norm2PixelBbox (line 2520) | class Norm2PixelBbox(BaseOperator):
    method __init__ (line 2525) | def __init__(self):
    method apply (line 2528) | def apply(self, sample, context=None):
  class BboxCXCYWH2XYXY (line 2539) | class BboxCXCYWH2XYXY(BaseOperator):
    method __init__ (line 2545) | def __init__(self):
    method apply (line 2548) | def apply(self, sample, context=None):
  class RandomResizeCrop (line 2560) | class RandomResizeCrop(BaseOperator):
    method __init__ (line 2578) | def __init__(self,
    method _format_size (line 2607) | def _format_size(self, size):
    method apply (line 2612) | def apply(self, sample, context=None):
    method _random_crop (line 2627) | def _random_crop(croper, sample, size, context=None):
    method _resize (line 2728) | def _resize(resizer, sample, size, mode='short', context=None):
  class RandomSelect (line 2825) | class RandomSelect(BaseOperator):
    method __init__ (line 2834) | def __init__(self, transforms1, transforms2, p=0.5):
    method apply (line 2840) | def apply(self, sample, context=None):
  class RandomSelects (line 2847) | class RandomSelects(BaseOperator):
    method __init__ (line 2856) | def __init__(self, transforms_list, p=None):
    method apply (line 2866) | def apply(self, sample, context=None):
  class RandomShortSideResize (line 2877) | class RandomShortSideResize(BaseOperator):
    method __init__ (line 2878) | def __init__(self,
    method get_size_with_aspect_ratio (line 2909) | def get_size_with_aspect_ratio(self, image_shape, size, max_size=None):
    method resize (line 2931) | def resize(self,
    method apply_bbox (line 2996) | def apply_bbox(self, bbox, scale, size):
    method apply_joints (line 3005) | def apply_joints(self, joints, scale, size):
    method apply_area (line 3018) | def apply_area(self, area, scale):
    method apply_segm (line 3022) | def apply_segm(self, segms, im_size, scale):
    method apply (line 3061) | def apply(self, sample, context=None):
  class RandomShortSideRangeResize (line 3070) | class RandomShortSideRangeResize(RandomShortSideResize):
    method __init__ (line 3071) | def __init__(self, scales, interp=cv2.INTER_LINEAR, random_interp=False):
    method random_sample (line 3088) | def random_sample(self, img_scales):
    method apply (line 3098) | def apply(self, sample, context=None):
  class RandomSizeCrop (line 3108) | class RandomSizeCrop(BaseOperator):
    method __init__ (line 3121) | def __init__(self, min_size, max_size, keep_empty=True):
    method get_crop_params (line 3131) | def get_crop_params(img_shape, output_size):
    method crop (line 3154) | def crop(self, sample, region):
    method apply_bbox (line 3214) | def apply_bbox(self, bbox, region):
    method _crop_joints (line 3222) | def _crop_joints(self, joints, region):
    method apply_segm (line 3235) | def apply_segm(self, segms, region, image_shape):
    method apply (line 3305) | def apply(self, sample, context=None):
  class WarpAffine (line 3316) | class WarpAffine(BaseOperator):
    method __init__ (line 3317) | def __init__(self,
    method apply (line 3338) | def apply(self, sample, context=None):
  class FlipWarpAffine (line 3381) | class FlipWarpAffine(BaseOperator):
    method __init__ (line 3382) | def __init__(self,
    method __call__ (line 3413) | def __call__(self, samples, context=None):
  class CenterRandColor (line 3510) | class CenterRandColor(BaseOperator):
    method __init__ (line 3518) | def __init__(self, saturation=0.4, contrast=0.4, brightness=0.4):
    method apply_saturation (line 3524) | def apply_saturation(self, img, img_gray):
    method apply_contrast (line 3530) | def apply_contrast(self, img, img_gray):
    method apply_brightness (line 3536) | def apply_brightness(self, img, img_gray):
    method _blend (line 3542) | def _blend(self, alpha, img, img_mean):
    method apply (line 3547) | def apply(self, sample, context=None):
  class Mosaic (line 3573) | class Mosaic(BaseOperator):
    method __init__ (line 3596) | def __init__(self,
    method get_mosaic_coords (line 3621) | def get_mosaic_coords(self, mosaic_idx, xc, yc, w, h, input_h, input_w):
    method random_affine_augment (line 3644) | def random_affine_augment(self,
    method __call__ (line 3701) | def __call__(self, sample, context=None):
    method mixup_augment (line 3842) | def mixup_augment(self, origin_img, origin_labels, input_dim, cp_labels,
  class PadResize (line 3927) | class PadResize(BaseOperator):
    method __init__ (line 3935) | def __init__(self, target_size, fill_value=114):
    method _resize (line 3942) | def _resize(self, img, bboxes, labels):
    method _pad (line 3956) | def _pad(self, img):
    method apply (line 3967) | def apply(self, sample, context=None):
  class RandomShift (line 3979) | class RandomShift(BaseOperator):
    method __init__ (line 3989) | def __init__(self, prob=0.5, max_shift=32, filter_thr=1):
    method calc_shift_coor (line 3995) | def calc_shift_coor(self, im_h, im_w, shift_h, shift_w):
    method apply (line 4001) | def apply(self, sample, context=None):
  class StrongAugImage (line 4040) | class StrongAugImage(BaseOperator):
    method __init__ (line 4041) | def __init__(self, transforms):
    method apply (line 4045) | def apply(self, sample, context=None):
  class RandomColorJitter (line 4054) | class RandomColorJitter(BaseOperator):
    method __init__ (line 4055) | def __init__(self,
    method apply (line 4068) | def apply(self, sample, context=None):
  class RandomGrayscale (line 4079) | class RandomGrayscale(BaseOperator):
    method __init__ (line 4080) | def __init__(self, prob=0.2):
    method apply (line 4084) | def apply(self, sample, context=None):
  class RandomGaussianBlur (line 4093) | class RandomGaussianBlur(BaseOperator):
    method __init__ (line 4094) | def __init__(self, prob=0.5, sigma=[0.1, 2.0]):
    method apply (line 4099) | def apply(self, sample, context=None):
  class RandomErasing (line 4108) | class RandomErasing(BaseOperator):
    method __init__ (line 4109) | def __init__(self,
    method _erase (line 4135) | def _erase(self, img, i, j, h, w, v, inplace=False):
    method _get_param (line 4141) | def _get_param(self, img, scale, ratio, value):
    method apply (line 4163) | def apply(self, sample, context=None):
  class RandomErasingCrop (line 4184) | class RandomErasingCrop(BaseOperator):
    method __init__ (line 4185) | def __init__(self):
    method apply (line 4194) | def apply(self, sample, context=None):

FILE: ppdet/data/transform/rotated_operators.py
  class RRotate (line 39) | class RRotate(BaseOperator):
    method __init__ (line 49) | def __init__(self, scale=1.0, angle=0., fill_value=0., auto_bound=True):
    method get_rotated_matrix (line 56) | def get_rotated_matrix(self, angle, scale, h, w):
    method get_rect_from_pts (line 77) | def get_rect_from_pts(self, pts, h, w):
    method apply_image (line 90) | def apply_image(self, image, matrix, h, w):
    method apply_pts (line 94) | def apply_pts(self, pts, matrix, h, w):
    method apply (line 105) | def apply(self, sample, context=None):
  class RandomRRotate (line 121) | class RandomRRotate(BaseOperator):
    method __init__ (line 133) | def __init__(self,
    method get_angle (line 150) | def get_angle(self, angle, angle_mode):
    method get_scale (line 162) | def get_scale(self, scale, scale_mode):
    method apply (line 174) | def apply(self, sample, context=None):
  class Poly2RBox (line 185) | class Poly2RBox(BaseOperator):
    method __init__ (line 195) | def __init__(self, filter_threshold=4, filter_mode=None, rbox_type='le...
    method filter (line 200) | def filter(self, size, threshold, mode):
    method get_rbox (line 209) | def get_rbox(self, polys):
    method apply (line 230) | def apply(self, sample, context=None):
  class Poly2Array (line 242) | class Poly2Array(BaseOperator):
    method __init__ (line 246) | def __init__(self):
    method apply (line 249) | def apply(self, sample, context=None):
  class RResize (line 258) | class RResize(BaseOperator):
    method __init__ (line 259) | def __init__(self, target_size, keep_ratio, interp=cv2.INTER_LINEAR):
    method apply_image (line 280) | def apply_image(self, image, scale):
    method apply_pts (line 291) | def apply_pts(self, pts, scale, size):
    method apply (line 300) | def apply(self, sample, context=None):
  class RandomRFlip (line 360) | class RandomRFlip(BaseOperator):
    method __init__ (line 361) | def __init__(self, prob=0.5):
    method apply_image (line 371) | def apply_image(self, image):
    method apply_pts (line 374) | def apply_pts(self, pts, width):
    method apply (line 379) | def apply(self, sample, context=None):
  class VisibleRBox (line 406) | class VisibleRBox(BaseOperator):
    method __init__ (line 412) | def __init__(self, output_dir='debug'):
    method apply (line 418) | def apply(self, sample, context=None):
  class Rbox2Poly (line 463) | class Rbox2Poly(BaseOperator):
    method __init__ (line 468) | def __init__(self):
    method apply (line 471) | def apply(self, sample, context=None):

FILE: ppdet/data/utils.py
  function default_collate_fn (line 25) | def default_collate_fn(batch):

FILE: ppdet/engine/callbacks.py
  class Callback (line 42) | class Callback(object):
    method __init__ (line 43) | def __init__(self, model):
    method on_step_begin (line 52) | def on_step_begin(self, status):
    method on_step_end (line 55) | def on_step_end(self, status):
    method on_epoch_begin (line 58) | def on_epoch_begin(self, status):
    method on_epoch_end (line 61) | def on_epoch_end(self, status):
    method on_train_begin (line 64) | def on_train_begin(self, status):
    method on_train_end (line 67) | def on_train_end(self, status):
  class ComposeCallback (line 71) | class ComposeCallback(object):
    method __init__ (line 72) | def __init__(self, callbacks):
    method on_step_begin (line 79) | def on_step_begin(self, status):
    method on_step_end (line 83) | def on_step_end(self, status):
    method on_epoch_begin (line 87) | def on_epoch_begin(self, status):
    method on_epoch_end (line 91) | def on_epoch_end(self, status):
    method on_train_begin (line 95) | def on_train_begin(self, status):
    method on_train_end (line 99) | def on_train_end(self, status):
  class LogPrinter (line 104) | class LogPrinter(Callback):
    method __init__ (line 105) | def __init__(self, model):
    method on_step_end (line 108) | def on_step_end(self, status):
    method on_epoch_end (line 167) | def on_epoch_end(self, status):
  class Checkpointer (line 177) | class Checkpointer(Callback):
    method __init__ (line 178) | def __init__(self, model):
    method on_epoch_end (line 188) | def on_epoch_end(self, status):
  class WiferFaceEval (line 291) | class WiferFaceEval(Callback):
    method __init__ (line 292) | def __init__(self, model):
    method on_epoch_begin (line 295) | def on_epoch_begin(self, status):
  class VisualDLWriter (line 303) | class VisualDLWriter(Callback):
    method __init__ (line 308) | def __init__(self, model):
    method on_step_end (line 325) | def on_step_end(self, status):
    method on_epoch_end (line 349) | def on_epoch_end(self, status):
  class WandbCallback (line 361) | class WandbCallback(Callback):
    method __init__ (line 362) | def __init__(self, model):
    method run (line 392) | def run(self):
    method save_model (line 404) | def save_model(self,
    method on_step_end (line 446) | def on_step_end(self, status):
    method on_epoch_end (line 474) | def on_epoch_end(self, status):
    method on_train_end (line 544) | def on_train_end(self, status):
  class SniperProposalsGenerator (line 548) | class SniperProposalsGenerator(Callback):
    method __init__ (line 549) | def __init__(self, model):
    method _create_new_dataset (line 557) | def _create_new_dataset(self, ori_dataset):
    method _eval_with_loader (line 569) | def _eval_with_loader(self, loader):
    method on_train_end (line 585) | def on_train_end(self, status):
  class SemiLogPrinter (line 607) | class SemiLogPrinter(LogPrinter):
    method __init__ (line 608) | def __init__(self, model):
    method on_step_end (line 611) | def on_step_end(self, status):
  class SemiCheckpointer (line 665) | class SemiCheckpointer(Checkpointer):
    method __init__ (line 666) | def __init__(self, model):
    method every_n_iters (line 683) | def every_n_iters(self, iter_id, n):
    method on_step_end (line 686) | def on_step_end(self, status):
    method on_epoch_end (line 706) | def on_epoch_end(self, status):

FILE: ppdet/engine/env.py
  function init_fleet_env (line 29) | def init_fleet_env(find_unused_parameters=False):
  function init_parallel_env (line 35) | def init_parallel_env():
  function set_random_seed (line 47) | def set_random_seed(seed):

FILE: ppdet/engine/export_utils.py
  function apply_to_static (line 199) | def apply_to_static(config, model):
  function _prune_input_spec (line 207) | def _prune_input_spec(input_spec, program, targets):
  function _parse_reader (line 236) | def _parse_reader(reader_cfg, dataset_cfg, metric, arch, image_shape):
  function _parse_tracker (line 283) | def _parse_tracker(tracker_cfg):
  function _dump_infer_config (line 290) | def _dump_infer_config(config, path, image_shape, model):

FILE: ppdet/engine/naive_sync_bn.py
  class _AllReduce (line 7) | class _AllReduce(paddle.autograd.PyLayer):
    method forward (line 9) | def forward(ctx, input):
    method backward (line 17) | def backward(ctx, grad_output):
  function differentiable_all_reduce (line 22) | def differentiable_all_reduce(input):
  class NaiveSyncBatchNorm (line 35) | class NaiveSyncBatchNorm(nn.BatchNorm2D):
    method __init__ (line 37) | def __init__(self, *args, stats_mode="", **kwargs):
    method forward (line 42) | def forward(self, input):
  function convert_syncbn (line 91) | def convert_syncbn(model):

FILE: ppdet/engine/tracker.py
  class Tracker (line 52) | class Tracker(object):
    method __init__ (line 53) | def __init__(self, cfg, mode='eval'):
    method _init_callbacks (line 89) | def _init_callbacks(self):
    method _init_metrics (line 93) | def _init_metrics(self):
    method _reset_metrics (line 109) | def _reset_metrics(self):
    method register_callbacks (line 113) | def register_callbacks(self, callbacks):
    method register_metrics (line 121) | def register_metrics(self, metrics):
    method load_weights_jde (line 128) | def load_weights_jde(self, weights):
    method load_weights_sde (line 131) | def load_weights_sde(self, det_weights, reid_weights):
    method _eval_seq_centertrack (line 142) | def _eval_seq_centertrack(self,
    method _eval_seq_jde (line 189) | def _eval_seq_jde(self,
    method _eval_seq_sde (line 244) | def _eval_seq_sde(self,
    method mot_evaluate (line 485) | def mot_evaluate(self,
    method get_infer_images (line 591) | def get_infer_images(self, infer_dir):
    method mot_predict_seq (line 607) | def mot_predict_seq(self,
  function get_trick_hyperparams (line 702) | def get_trick_hyperparams(video_name, ori_buffer, ori_thresh):

FILE: ppdet/engine/trainer.py
  class Trainer (line 66) | class Trainer(object):
    method __init__ (line 67) | def __init__(self, cfg, mode='train'):
    method _init_callbacks (line 263) | def _init_callbacks(self):
    method _init_metrics (line 289) | def _init_metrics(self, validate=False):
    method _reset_metrics (line 460) | def _reset_metrics(self):
    method register_callbacks (line 464) | def register_callbacks(self, callbacks):
    method register_metrics (line 472) | def register_metrics(self, metrics):
    method load_weights (line 479) | def load_weights(self, weights, ARSL_eval=False):
    method load_weights_sde (line 486) | def load_weights_sde(self, det_weights, reid_weights):
    method resume_weights (line 494) | def resume_weights(self, weights):
    method train (line 504) | def train(self, validate=False):
    method _eval_with_loader (line 705) | def _eval_with_loader(self, loader):
    method evaluate (line 753) | def evaluate(self):
    method _eval_with_loader_slice (line 766) | def _eval_with_loader_slice(self,
    method evaluate_slice (line 847) | def evaluate_slice(self,
    method slice_predict (line 858) | def slice_predict(self,
    method predict (line 1014) | def predict(self,
    method _get_save_image_name (line 1149) | def _get_save_image_name(self, output_dir, image_path):
    method _get_infer_cfg_and_input_spec (line 1157) | def _get_infer_cfg_and_input_spec(self,
    method export (line 1272) | def export(self, output_dir='output_inference', for_fd=False):
    method post_quant (line 1309) | def post_quant(self, output_dir='output_inference'):
    method _flops (line 1331) | def _flops(self, loader):
    method parse_mot_images (line 1360) | def parse_mot_images(self, cfg):
    method predict_culane (line 1386) | def predict_culane(self,
    method reset_norm_param_attr (line 1490) | def reset_norm_param_attr(self, layer, **kwargs):

FILE: ppdet/engine/trainer_cot.py
  class TrainerCot (line 22) | class TrainerCot(Trainer):
    method __init__ (line 27) | def __init__(self, cfg, mode='train'):
    method cotuning_init (line 31) | def cotuning_init(self):

FILE: ppdet/engine/trainer_ssod.py
  class Trainer_DenseTeacher (line 46) | class Trainer_DenseTeacher(Trainer):
    method __init__ (line 47) | def __init__(self, cfg, mode='train'):
    method load_weights (line 147) | def load_weights(self, weights):
    method resume_weights (line 156) | def resume_weights(self, weights, exchange=True):
    method train (line 167) | def train(self, validate=False):
    method evaluate (line 407) | def evaluate(self):
    method _eval_with_loader (line 420) | def _eval_with_loader(self, loader):
  class Trainer_ARSL (line 475) | class Trainer_ARSL(Trainer):
    method __init__ (line 476) | def __init__(self, cfg, mode='train'):
    method resume_weights (line 538) | def resume_weights(self, weights):
    method train (line 547) | def train(self, validate=False):
    method merge_data (line 661) | def merge_data(self, data1, data2):
    method run_step_full_semisup (line 670) | def run_step_full_semisup(self, data):
    method export (line 738) | def export(self, output_dir='output_inference'):
    method _eval_with_loader (line 800) | def _eval_with_loader(self, loader, mode="teacher"):
    method evaluate (line 834) | def evaluate(self):
    method _update_teacher_model (line 839) | def _update_teacher_model(self, keep_rate=0.996):
  class EnsembleTSModel (line 854) | class EnsembleTSModel(nn.Layer):
    method __init__ (line 855) | def __init__(self, modelTeacher, modelStudent):
  class Trainer_Semi_RTDETR (line 861) | class Trainer_Semi_RTDETR(Trainer):
    method __init__ (line 862) | def __init__(self, cfg, mode='train'):
    method load_semi_weights (line 940) | def load_semi_weights(self, t_weights, s_weights):
    method resume_weights (line 951) | def resume_weights(self, weights, exchange=True):
    method train (line 963) | def train(self, validate=False):
    method _eval_with_loader (line 1122) | def _eval_with_loader(self, loader):
    method evaluate (line 1190) | def evaluate(self):

FILE: ppdet/ext_op/csrc/matched_rbox_iou/matched_rbox_iou.cc
  function matched_rbox_iou_cpu_kernel (line 22) | void matched_rbox_iou_cpu_kernel(const int rbox_num, const T *rbox1_data...
  function MatchedRboxIouCPUForward (line 35) | std::vector<paddle::Tensor>
  function MatchedRboxIouForward (line 63) | std::vector<paddle::Tensor> MatchedRboxIouForward(const paddle::Tensor &...
  function MatchedRboxIouInferShape (line 75) | std::vector<std::vector<int64_t>>
  function MatchedRboxIouInferDtype (line 81) | std::vector<paddle::DataType> MatchedRboxIouInferDtype(paddle::DataType t1,

FILE: ppdet/ext_op/csrc/nms_rotated/nms_rotated.cc
  function nms_rotated_cpu_kernel (line 19) | void nms_rotated_cpu_kernel(const T *boxes_data, const float threshold,
  function NMSRotatedCPUForward (line 59) | std::vector<paddle::Tensor> NMSRotatedCPUForward(const paddle::Tensor &b...
  function NMSRotatedForward (line 92) | std::vector<paddle::Tensor> NMSRotatedForward(const paddle::Tensor &boxes,
  function NMSRotatedInferShape (line 104) | std::vector<std::vector<int64_t>>
  function NMSRotatedInferDtype (line 110) | std::vector<paddle::DataType> NMSRotatedInferDtype(paddle::DataType t1,

FILE: ppdet/ext_op/csrc/rbox_iou/rbox_iou.cc
  function rbox_iou_cpu_kernel (line 22) | void rbox_iou_cpu_kernel(const int rbox1_num, const int rbox2_num,
  function RboxIouCPUForward (line 39) | std::vector<paddle::Tensor> RboxIouCPUForward(const paddle::Tensor &rbox1,
  function RboxIouForward (line 67) | std::vector<paddle::Tensor> RboxIouForward(const paddle::Tensor &rbox1,
  function RboxIouInferShape (line 79) | std::vector<std::vector<int64_t>>
  function RboxIouInferDtype (line 85) | std::vector<paddle::DataType> RboxIouInferDtype(paddle::DataType t1,

FILE: ppdet/ext_op/csrc/rbox_iou/rbox_iou_utils.h
  function T (line 58) | T dot_2d(const Point<T> &A, const Point<T> &B) {
  function T (line 63) | T cross_2d(const Point<T> &A, const Point<T> &B) {
  function get_rotated_vertices (line 68) | void get_rotated_vertices(const RotatedBox<T> &box,
  function get_intersection_points (line 89) | int get_intersection_points(const Point<T> (&pts1)[4],
  function HOST_DEVICE (line 354) | HOST_DEVICE inline int CeilDiv(const int a, const int b) {

FILE: ppdet/ext_op/setup.py
  function get_extensions (line 7) | def get_extensions():

FILE: ppdet/ext_op/unittest/test_matched_rbox_iou.py
  function rbox2poly_single (line 11) | def rbox2poly_single(rrect, get_best_begin_point=False):
  function intersection (line 31) | def intersection(g, p):
  function matched_rbox_overlaps (line 71) | def matched_rbox_overlaps(anchors, gt_bboxes, use_cv2=False):
  function gen_sample (line 100) | def gen_sample(n):
  class MatchedRBoxIoUTest (line 107) | class MatchedRBoxIoUTest(unittest.TestCase):
    method setUp (line 108) | def setUp(self):
    method initTestCase (line 113) | def initTestCase(self):
    method assertAllClose (line 116) | def assertAllClose(self, x, y, msg, atol=5e-1, rtol=1e-2):
    method get_places (line 119) | def get_places(self):
    method check_output (line 126) | def check_output(self, place):
    method test_output (line 142) | def test_output(self):

FILE: ppdet/ext_op/unittest/test_rbox_iou.py
  function rbox2poly_single (line 11) | def rbox2poly_single(rrect, get_best_begin_point=False):
  function intersection (line 31) | def intersection(g, p):
  function rbox_overlaps (line 71) | def rbox_overlaps(anchors, gt_bboxes, use_cv2=False):
  function gen_sample (line 101) | def gen_sample(n):
  class RBoxIoUTest (line 108) | class RBoxIoUTest(unittest.TestCase):
    method setUp (line 109) | def setUp(self):
    method initTestCase (line 114) | def initTestCase(self):
    method assertAllClose (line 118) | def assertAllClose(self, x, y, msg, atol=5e-1, rtol=1e-2):
    method get_places (line 121) | def get_places(self):
    method check_output (line 128) | def check_output(self, place):
    method test_output (line 144) | def test_output(self):

FILE: ppdet/metrics/coco_utils.py
  function get_infer_results (line 31) | def get_infer_results(outs, catid, bias=0, save_threshold=0):
  function cocoapi_eval (line 81) | def cocoapi_eval(jsonfile,
  function json_eval_results (line 179) | def json_eval_results(metric, json_directory, dataset):

FILE: ppdet/metrics/culane_metrics.py
  function draw_lane (line 39) | def draw_lane(lane, img=None, img_shape=None, width=30):
  function discrete_cross_iou (line 49) | def discrete_cross_iou(xs, ys, width=30, img_shape=(590, 1640, 3)):
  function continuous_cross_iou (line 60) | def continuous_cross_iou(xs, ys, width=30, img_shape=(590, 1640, 3)):
  function interp (line 82) | def interp(points, n=50):
  function culane_metric (line 91) | def culane_metric(pred,
  function load_culane_img_data (line 129) | def load_culane_img_data(path):
  function load_culane_data (line 141) | def load_culane_data(data_dir, file_list_path):
  function eval_predictions (line 158) | def eval_predictions(pred_dir,
  class CULaneMetric (line 230) | class CULaneMetric(Metric):
    method __init__ (line 231) | def __init__(self,
    method reset (line 248) | def reset(self):
    method get_prediction_string (line 254) | def get_prediction_string(self, pred):
    method accumulate (line 272) | def accumulate(self):
    method update (line 316) | def update(self, inputs, outputs):
    method log (line 322) | def log(self):
    method get_results (line 326) | def get_results(self):

FILE: ppdet/metrics/fast_cocoeval/ext/cocoeval.cc
  function SortInstancesByDetectionScore (line 30) | void SortInstancesByDetectionScore(
  function SortInstancesByIgnore (line 46) | void SortInstancesByIgnore(
  function MatchDetectionsToGroundTruth (line 73) | void MatchDetectionsToGroundTruth(
  function EvaluateImages (line 154) | std::vector<ImageEvaluation> EvaluateImages(
  function list_to_vec (line 215) | std::vector<T> list_to_vec(const py::list& l) {
  function BuildSortedDetectionList (line 235) | int BuildSortedDetectionList(
  function ComputePrecisionRecallCurve (line 296) | void ComputePrecisionRecallCurve(
  function Accumulate (line 384) | py::dict Accumulate(
  function PYBIND11_MODULE (line 517) | PYBIND11_MODULE(cocoeval_ext, m) {

FILE: ppdet/metrics/fast_cocoeval/ext/cocoeval.h
  type InstanceAnnotation (line 29) | struct InstanceAnnotation {
  type ImageEvaluation (line 47) | struct ImageEvaluation {

FILE: ppdet/metrics/fast_cocoeval/fast_cocoeval.py
  class FastCOCOeval (line 29) | class FastCOCOeval(COCOeval):
    method evaluate (line 35) | def evaluate(self):
    method accumulate (line 116) | def accumulate(self, p=None):

FILE: ppdet/metrics/json_results.py
  function get_det_res (line 18) | def get_det_res(bboxes,
  function get_det_poly_res (line 52) | def get_det_poly_res(bboxes, bbox_nums, image_id, label_to_cat_id_map, b...
  function strip_mask (line 76) | def strip_mask(mask):
  function get_seg_res (line 84) | def get_seg_res(masks, bboxes, mask_nums, image_id, label_to_cat_id_map):
  function get_solov2_segm_res (line 117) | def get_solov2_segm_res(results, image_id, num_id_to_cat_id_map):
  function get_keypoint_res (line 146) | def get_keypoint_res(results, im_id):
  function get_pose3d_res (line 170) | def get_pose3d_res(results, im_id):

FILE: ppdet/metrics/keypoint_metrics.py
  class KeyPointTopDownCOCOEval (line 33) | class KeyPointTopDownCOCOEval(object):
    method __init__ (line 39) | def __init__(self,
    method reset (line 60) | def reset(self):
    method update (line 70) | def update(self, inputs, outputs):
    method _write_coco_keypoint_results (line 96) | def _write_coco_keypoint_results(self, keypoints):
    method _coco_keypoint_results_one_category_kernel (line 121) | def _coco_keypoint_results_one_category_kernel(self, data_pack):
    method get_final_results (line 146) | def get_final_results(self, preds, all_boxes, img_path):
    method accumulate (line 193) | def accumulate(self):
    method log (line 213) | def log(self):
    method get_results (line 228) | def get_results(self):
  class KeyPointTopDownCOCOWholeBadyHandEval (line 232) | class KeyPointTopDownCOCOWholeBadyHandEval(object):
    method __init__ (line 233) | def __init__(self,
    method parse_dataset (line 249) | def parse_dataset(self):
    method reset (line 278) | def reset(self):
    method update (line 286) | def update(self, inputs, outputs):
    method accumulate (line 293) | def accumulate(self):
    method get_final_results (line 302) | def get_final_results(self, preds):
    method _write_keypoint_results (line 309) | def _write_keypoint_results(self, keypoints):
    method log (line 327) | def log(self):
    method get_results (line 333) | def get_results(self):
    method evaluate (line 336) | def evaluate(self, res_file, metrics, pck_thr=0.2, auc_nor=30):
  class KeyPointTopDownMPIIEval (line 390) | class KeyPointTopDownMPIIEval(object):
    method __init__ (line 391) | def __init__(self,
    method reset (line 404) | def reset(self):
    method update (line 409) | def update(self, inputs, outputs):
    method accumulate (line 424) | def accumulate(self):
    method _mpii_keypoint_results_save (line 433) | def _mpii_keypoint_results_save(self):
    method log (line 448) | def log(self):
    method get_results (line 454) | def get_results(self):
    method evaluate (line 457) | def evaluate(self, outputs, savepath=None):
    method _sort_and_unique_bboxes (line 563) | def _sort_and_unique_bboxes(self, kpts, key='bbox_id'):

FILE: ppdet/metrics/lvis_utils.py
  function lvisapi_eval (line 23) | def lvisapi_eval(jsonfile,

FILE: ppdet/metrics/map_utils.py
  function draw_pr_curve (line 41) | def draw_pr_curve(precision,
  function bbox_area (line 65) | def bbox_area(bbox, is_bbox_normalized):
  function jaccard_overlap (line 75) | def jaccard_overlap(pred, gt, is_bbox_normalized=False):
  function calc_rbox_iou (line 94) | def calc_rbox_iou(pred, gt_poly):
  function prune_zero_padding (line 131) | def prune_zero_padding(gt_box, gt_label, difficult=None):
  class DetectionMAP (line 141) | class DetectionMAP(object):
    method __init__ (line 164) | def __init__(self,
    method update (line 186) | def update(self, bbox, score, label, gt_box, gt_label, difficult=None):
    method reset (line 227) | def reset(self):
    method accumulate (line 235) | def accumulate(self):
    method get_map (line 296) | def get_map(self):
    method _get_tp_fp_accum (line 337) | def _get_tp_fp_accum(self, score_pos_list):
  function ap_per_class (line 355) | def ap_per_class(tp, conf, pred_cls, target_cls):
  function compute_ap (line 409) | def compute_ap(recall, precision):

FILE: ppdet/metrics/mcmot_metrics.py
  function parse_accs_metrics (line 82) | def parse_accs_metrics(seq_acc, index_name, verbose=False):
  function seqs_overall_metrics (line 98) | def seqs_overall_metrics(summary_df, verbose=False):
  class MCMOTMetricOverall (line 132) | class MCMOTMetricOverall(object):
    method motp_overall (line 133) | def motp_overall(summary_df, overall_dic):
    method mota_overall (line 139) | def mota_overall(summary_df, overall_dic):
    method precision_overall (line 146) | def precision_overall(summary_df, overall_dic):
    method recall_overall (line 152) | def recall_overall(summary_df, overall_dic):
    method idp_overall (line 158) | def idp_overall(summary_df, overall_dic):
    method idr_overall (line 164) | def idr_overall(summary_df, overall_dic):
    method idf1_overall (line 170) | def idf1_overall(summary_df, overall_dic):
  function read_mcmot_results_union (line 177) | def read_mcmot_results_union(filename, is_gt, is_ignore):
  function read_mcmot_results (line 227) | def read_mcmot_results(filename, is_gt, is_ignore):
  function read_results (line 255) | def read_results(filename,
  function unzip_objs (line 279) | def unzip_objs(objs):
  function unzip_objs_cls (line 288) | def unzip_objs_cls(objs):
  class MCMOTEvaluator (line 300) | class MCMOTEvaluator(object):
    method __init__ (line 301) | def __init__(self, data_root, seq_name, data_type, num_classes):
    method load_annotations (line 319) | def load_annotations(self):
    method reset_accumulator (line 328) | def reset_accumulator(self):
    method eval_frame_dict (line 331) | def eval_frame_dict(self, trk_objs, gt_objs, rtn_events=False, union=F...
    method eval_file (line 368) | def eval_file(self, result_filename):
    method get_summary (line 401) | def get_summary(accs,
    method save_summary (line 417) | def save_summary(summary, filename):
  class MCMOTMetric (line 424) | class MCMOTMetric(Metric):
    method __init__ (line 425) | def __init__(self, num_classes, save_summary=False):
    method reset (line 434) | def reset(self):
    method update (line 438) | def update(self, data_root, seq, data_type, result_root, result_filena...
    method accumulate (line 455) | def accumulate(self):
    method log (line 466) | def log(self):
    method get_results (line 472) | def get_results(self):

FILE: ppdet/metrics/metrics.py
  class Metric (line 53) | class Metric(paddle.metric.Metric):
    method name (line 54) | def name(self):
    method reset (line 57) | def reset(self):
    method accumulate (line 60) | def accumulate(self):
    method log (line 67) | def log(self):
    method get_results (line 71) | def get_results(self):
  class COCOMetric (line 75) | class COCOMetric(Metric):
    method __init__ (line 76) | def __init__(self, anno_file, **kwargs):
    method reset (line 99) | def reset(self):
    method update (line 104) | def update(self, inputs, outputs):
    method accumulate (line 134) | def accumulate(self):
    method log (line 224) | def log(self):
    method get_results (line 227) | def get_results(self):
  class LVISMetric (line 230) | class LVISMetric(Metric):
    method __init__ (line 231) | def __init__(self, anno_file, **kwargs):
    method reset (line 252) | def reset(self):
    method update (line 257) | def update(self, inputs, outputs):
    method accumulate (line 281) | def accumulate(self):
    method log (line 372) | def log(self):
    method get_results (line 376) | def get_results(self):
  class VOCMetric (line 379) | class VOCMetric(Metric):
    method __init__ (line 380) | def __init__(self,
    method reset (line 410) | def reset(self):
    method update (line 414) | def update(self, inputs, outputs):
    method accumulate (line 467) | def accumulate(self):
    method log (line 480) | def log(self):
    method get_results (line 485) | def get_results(self):
  class WiderFaceMetric (line 489) | class WiderFaceMetric(Metric):
    method __init__ (line 490) | def __init__(self, iou_thresh=0.5):
    method reset (line 494) | def reset(self):
    method update (line 503) | def update(self, data, outs):
    method accumulate (line 531) | def accumulate(self):
    method log (line 565) | def log(self):
    method get_results (line 572) | def get_results(self):
  class RBoxMetric (line 578) | class RBoxMetric(Metric):
    method __init__ (line 579) | def __init__(self, anno_file, **kwargs):
    method reset (line 602) | def reset(self):
    method update (line 606) | def update(self, inputs, outputs):
    method save_results (line 655) | def save_results(self, results, output_dir, imid2path):
    method accumulate (line 683) | def accumulate(self):
    method log (line 691) | def log(self):
    method get_results (line 696) | def get_results(self):
  class SNIPERCOCOMetric (line 700) | class SNIPERCOCOMetric(COCOMetric):
    method __init__ (line 701) | def __init__(self, anno_file, **kwargs):
    method reset (line 706) | def reset(self):
    method update (line 712) | def update(self, inputs, outputs):
    method accumulate (line 724) | def accumulate(self):

FILE: ppdet/metrics/mot_metrics.py
  function read_mot_results (line 46) | def read_mot_results(filename, is_gt=False, is_ignore=False):
  function unzip_objs (line 110) | def unzip_objs(objs):
  class MOTEvaluator (line 119) | class MOTEvaluator(object):
    method __init__ (line 120) | def __init__(self, data_root, seq_name, data_type):
    method load_annotations (line 135) | def load_annotations(self):
    method reset_accumulator (line 147) | def reset_accumulator(self):
    method eval_frame (line 150) | def eval_frame(self, frame_id, trk_tlwhs, trk_ids, rtn_events=False):
    method eval_file (line 191) | def eval_file(self, filename):
    method get_summary (line 204) | def get_summary(accs,
    method save_summary (line 219) | def save_summary(summary, filename):
  class MOTMetric (line 226) | class MOTMetric(Metric):
    method __init__ (line 227) | def __init__(self, save_summary=False):
    method reset (line 233) | def reset(self):
    method update (line 237) | def update(self, data_root, seq, data_type, result_root, result_filena...
    method accumulate (line 243) | def accumulate(self):
    method log (line 255) | def log(self):
    method get_results (line 258) | def get_results(self):
  class JDEDetMetric (line 262) | class JDEDetMetric(Metric):
    method __init__ (line 265) | def __init__(self, overlap_thresh=0.5):
    method reset (line 269) | def reset(self):
    method update (line 273) | def update(self, inputs, outputs):
    method accumulate (line 313) | def accumulate(self):
    method log (line 317) | def log(self):
    method get_results (line 322) | def get_results(self):
  class tData (line 331) | class tData:
    method __init__ (line 335) | def __init__(self,frame=-1,obj_type="unset",truncation=-1,occlusion=-1,\
    method __str__ (line 363) | def __str__(self):
  class KITTIEvaluation (line 368) | class KITTIEvaluation(object):
    method __init__ (line 385) | def __init__(self, result_path, gt_path, min_overlap=0.5, max_truncati...
    method loadGroundtruth (line 461) | def loadGroundtruth(self):
    method loadTracker (line 468) | def loadTracker(self):
    method _loadData (line 477) | def _loadData(self,
    method boxoverlap (line 630) | def boxoverlap(self, a, b, criterion="union"):
    method compute3rdPartyMetrics (line 658) | def compute3rdPartyMetrics(self):
    method createSummary (line 1079) | def createSummary(self):
    method printEntry (line 1147) | def printEntry(self, key, val, width=(70, 10)):
    method saveToStats (line 1162) | def saveToStats(self, save_summary):
  class KITTIMOTMetric (line 1176) | class KITTIMOTMetric(Metric):
    method __init__ (line 1177) | def __init__(self, save_summary=True):
    method reset (line 1183) | def reset(self):
    method update (line 1189) | def update(self, data_root, seq, data_type, result_root, result_filena...
    method accumulate (line 1213) | def accumulate(self):
    method log (line 1242) | def log(self):
    method get_results (line 1245) | def get_results(self):

FILE: ppdet/metrics/munkres.py
  class Munkres (line 23) | class Munkres:
    method __init__ (line 29) | def __init__(self):
    method make_cost_matrix (line 40) | def make_cost_matrix(profit_matrix, inversion_function):
    method pad_matrix (line 51) | def pad_matrix(self, matrix, pad_value=0):
    method compute (line 87) | def compute(self, cost_matrix):
    method __copy_matrix (line 147) | def __copy_matrix(self, matrix):
    method __make_matrix (line 151) | def __make_matrix(self, n, val):
    method __step1 (line 158) | def __step1(self):
    method __step2 (line 174) | def __step2(self):
    method __step3 (line 193) | def __step3(self):
    method __step4 (line 214) | def __step4(self):
    method __step5 (line 247) | def __step5(self):
    method __step6 (line 283) | def __step6(self):
    method __find_smallest (line 299) | def __find_smallest(self):
    method __find_a_zero (line 309) | def __find_a_zero(self):
    method __find_star_in_row (line 335) | def __find_star_in_row(self, row):
    method __find_star_in_col (line 348) | def __find_star_in_col(self, col):
    method __find_prime_in_row (line 361) | def __find_prime_in_row(self, row):
    method __convert_path (line 374) | def __convert_path(self, path, count):
    method __clear_covers (line 381) | def __clear_covers(self):
    method __erase_primes (line 387) | def __erase_primes(self):
  function make_cost_matrix (line 395) | def make_cost_matrix(profit_matrix, inversion_function):

FILE: ppdet/metrics/pose3d_metrics.py
  class AverageMeter (line 27) | class AverageMeter(object):
    method __init__ (line 28) | def __init__(self):
    method reset (line 31) | def reset(self):
    method update (line 37) | def update(self, val, n=1):
  function mean_per_joint_position_error (line 44) | def mean_per_joint_position_error(pred, gt, has_3d_joints):
  function compute_similarity_transform (line 61) | def compute_similarity_transform(S1, S2):
  function compute_similarity_transform_batch (line 111) | def compute_similarity_transform_batch(S1, S2):
  function reconstruction_error (line 119) | def reconstruction_error(S1, S2, reduction='mean'):
  function all_gather (line 130) | def all_gather(data):
  class Pose3DEval (line 139) | class Pose3DEval(object):
    method __init__ (line 140) | def __init__(self, output_eval, save_prediction_only=False):
    method reset (line 147) | def reset(self):
    method get_human36m_joints (line 152) | def get_human36m_joints(self, input):
    method update (line 159) | def update(self, inputs, outputs):
    method accumulate (line 179) | def accumulate(self):
    method log (line 186) | def log(self):
    method get_results (line 199) | def get_results(self):

FILE: ppdet/metrics/widerface_utils.py
  function face_eval_run (line 32) | def face_eval_run(model,
  function detect_face (line 80) | def detect_face(model, image, shrink):
  function flip_test (line 115) | def flip_test(model, image, shrink):
  function multi_scale_test (line 128) | def multi_scale_test(model, image, max_shrink):
  function multi_scale_test_pyramid (line 163) | def multi_scale_test_pyramid(model, image, max_shrink):
  function to_chw (line 191) | def to_chw(image):
  function face_img_process (line 204) | def face_img_process(image,
  function get_shrink (line 217) | def get_shrink(height, width):
  function bbox_vote (line 256) | def bbox_vote(det):
  function save_widerface_bboxes (line 301) | def save_widerface_bboxes(image_path, bboxes_scores, output_dir):
  function save_fddb_bboxes (line 320) | def save_fddb_bboxes(bboxes_scores,
  function lmk2out (line 339) | def lmk2out(results, is_bbox_normalized=False):
  function image_eval (line 393) | def image_eval(pred, gt, ignore, iou_thresh):
  function bbox_overlaps (line 426) | def bbox_overlaps(boxes1, boxes2):
  function img_pr_info (line 460) | def img_pr_info(thresh_num, pred_info, proposal_list, pred_recall):
  function dataset_pr_info (line 477) | def dataset_pr_info(thresh_num, pr_curve, count_face):
  function voc_ap (line 485) | def voc_ap(rec, prec):

FILE: ppdet/model_zoo/model_zoo.py
  function list_model (line 38) | def list_model(filters=[]):
  function get_config_file (line 68) | def get_config_file(model_name):
  function get_weights_url (line 72) | def get_weights_url(model_name):
  function get_model (line 76) | def get_model(model_name, pretrained=True):

FILE: ppdet/model_zoo/tests/test_get_model.py
  class TestGetConfigFile (line 29) | class TestGetConfigFile(unittest.TestCase):
    method test_main (line 30) | def test_main(self):
  class TestGetModel (line 38) | class TestGetModel(unittest.TestCase):
    method test_main (line 39) | def test_main(self):

FILE: ppdet/model_zoo/tests/test_list_model.py
  class TestListModel (line 23) | class TestListModel(unittest.TestCase):
    method setUp (line 24) | def setUp(self):
    method test_main (line 27) | def test_main(self):
  class TestListModelYOLO (line 35) | class TestListModelYOLO(TestListModel):
    method setUp (line 36) | def setUp(self):
  class TestListModelRCNN (line 40) | class TestListModelRCNN(TestListModel):
    method setUp (line 41) | def setUp(self):
  class TestListModelSSD (line 45) | class TestListModelSSD(TestListModel):
    method setUp (line 46) | def setUp(self):
  class TestListModelMultiFilter (line 50) | class TestListModelMultiFilter(TestListModel):
    method setUp (line 51) | def setUp(self):
  class TestListModelError (line 55) | class TestListModelError(unittest.TestCase):
    method setUp (line 56) | def setUp(self):
    method test_main (line 59) | def test_main(self):

FILE: ppdet/modeling/architectures/blazeface.py
  class BlazeFace (line 28) | class BlazeFace(BaseArch):
    method __init__ (line 43) | def __init__(self, backbone, blaze_head, neck, post_process):
    method from_config (line 51) | def from_config(cls, cfg, *args, **kwargs):
    method _forward (line 67) | def _forward(self):
    method get_loss (line 99) | def get_loss(self, ):
    method get_pred (line 102) | def get_pred(self):

FILE: ppdet/modeling/architectures/bytetrack.py
  class ByteTrack (line 26) | class ByteTrack(BaseArch):
    method __init__ (line 37) | def __init__(self,
    method from_config (line 47) | def from_config(cls, cfg, *args, **kwargs):
    method _forward (line 63) | def _forward(self):
    method get_loss (line 78) | def get_loss(self):
    method get_pred (line 81) | def get_pred(self):

FILE: ppdet/modeling/architectures/cascade_rcnn.py
  class CascadeRCNN (line 27) | class CascadeRCNN(BaseArch):
    method __init__ (line 46) | def __init__(self,
    method from_config (line 65) | def from_config(cls, cfg, *args, **kwargs):
    method _forward (line 86) | def _forward(self):
    method get_loss (line 124) | def get_loss(self, ):
    method get_pred (line 135) | def get_pred(self):

FILE: ppdet/modeling/architectures/centernet.py
  class CenterNet (line 26) | class CenterNet(BaseArch):
    method __init__ (line 42) | def __init__(self,
    method from_config (line 56) | def from_config(cls, cfg, *args, **kwargs):
    method _forward (line 68) | def _forward(self):
    method get_pred (line 79) | def get_pred(self):
    method get_loss (line 102) | def get_loss(self):

FILE: ppdet/modeling/architectures/centertrack.py
  class CenterTrack (line 33) | class CenterTrack(BaseArch):
    method __init__ (line 45) | def __init__(self,
    method from_config (line 59) | def from_config(cls, cfg, *args, **kwargs):
    method _forward (line 73) | def _forward(self):
    method get_pred (line 131) | def get_pred(self):
    method get_loss (line 134) | def get_loss(self):
    method reset_tracking (line 137) | def reset_tracking(self):
    method get_additional_inputs (line 141) | def get_additional_inputs(self, dets, meta, with_hm=True):
  function affine_transform_bbox (line 170) | def affine_transform_bbox(bbox, trans, width, height):

FILE: ppdet/modeling/architectures/clrnet.py
  class CLRNet (line 9) | class CLRNet(BaseArch):
    method __init__ (line 12) | def __init__(self,
    method from_config (line 24) | def from_config(cls, cfg, *args, **kwargs):
    method _forward (line 40) | def _forward(self):
    method get_loss (line 63) | def get_loss(self):
    method get_pred (line 66) | def get_pred(self):

FILE: ppdet/modeling/architectures/deepsort.py
  class DeepSORT (line 28) | class DeepSORT(BaseArch):
    method __init__ (line 39) | def __init__(self,
    method from_config (line 49) | def from_config(cls, cfg, *args, **kwargs):
    method _forward (line 63) | def _forward(self):
    method get_pred (line 69) | def get_pred(self):

FILE: ppdet/modeling/architectures/detr.py
  class DETR (line 28) | class DETR(BaseArch):
    method __init__ (line 33) | def __init__(self,
    method from_config (line 53) | def from_config(cls, cfg, *args, **kwargs):
    method _forward (line 79) | def _forward(self):
    method get_loss (line 114) | def get_loss(self):
    method get_pred (line 117) | def get_pred(self):

FILE: ppdet/modeling/architectures/detr_ssod.py
  class DETR_SSOD (line 35) | class DETR_SSOD(MultiSteamDetector):
    method __init__ (line 36) | def __init__(self,
    method from_config (line 62) | def from_config(cls, cfg):
    method forward_train (line 77) | def forward_train(self, inputs, **kwargs):
    method foward_unsup_train (line 168) | def foward_unsup_train(self, data_unsup_w, data_unsup_s):
    method compute_pseudo_label_loss (line 226) | def compute_pseudo_label_loss(self, student_unsup, teacher_info,
  function box_cxcywh_to_xyxy (line 298) | def box_cxcywh_to_xyxy(x):
  function box_xyxy_to_cxcywh (line 304) | def box_xyxy_to_cxcywh(x):
  function get_size_with_aspect_ratio (line 310) | def get_size_with_aspect_ratio(image_size, size, max_size=None):
  function align_weak_strong_shape (line 331) | def align_weak_strong_shape(data_weak, data_strong):

FILE: ppdet/modeling/architectures/fairmot.py
  class FairMOT (line 27) | class FairMOT(BaseArch):
    method __init__ (line 42) | def __init__(self,
    method from_config (line 54) | def from_config(cls, cfg, *args, **kwargs):
    method _forward (line 70) | def _forward(self):
    method get_pred (line 94) | def get_pred(self):
    method get_loss (line 98) | def get_loss(self):

FILE: ppdet/modeling/architectures/faster_rcnn.py
  class FasterRCNN (line 28) | class FasterRCNN(BaseArch):
    method __init__ (line 42) | def __init__(self,
    method init_cot_head (line 55) | def init_cot_head(self, relationship):
    method from_config (line 59) | def from_config(cls, cfg, *args, **kwargs):
    method _forward (line 75) | def _forward(self):
    method get_loss (line 112) | def get_loss(self, ):
    method get_pred (line 121) | def get_pred(self):
    method target_bbox_forward (line 134) | def target_bbox_forward(self, data):
    method relationship_learning (line 144) | def relationship_learning(self, loader, num_classes_novel):

FILE: ppdet/modeling/architectures/fcos.py
  class FCOS (line 27) | class FCOS(BaseArch):
    method __init__ (line 41) | def __init__(self,
    method from_config (line 56) | def from_config(cls, cfg, *args, **kwargs):
    method _forward (line 71) | def _forward(self):
    method get_loss (line 85) | def get_loss(self):
    method get_pred (line 88) | def get_pred(self):
    method get_loss_keys (line 91) | def get_loss_keys(self):
    method get_ssod_loss (line 94) | def get_ssod_loss(self, student_head_outs, teacher_head_outs, train_cfg):
  class ARSL_FCOS (line 101) | class ARSL_FCOS(BaseArch):
    method __init__ (line 115) | def __init__(self,
    method from_config (line 127) | def from_config(cls, cfg, *args, **kwargs):
    method forward (line 146) | def forward(self, inputs, branch="supervised", teacher_prediction=None):
    method model_forward (line 170) | def model_forward(self):
    method get_loss (line 177) | def get_loss(self):
    method get_pseudo_loss (line 198) | def get_pseudo_loss(self, teacher_prediction):
    method get_pred (line 207) | def get_pred(self):
    method get_pseudo_pred (line 216) | def get_pseudo_pred(self):

FILE: ppdet/modeling/architectures/gfl.py
  class GFL (line 27) | class GFL(BaseArch):
    method __init__ (line 39) | def __init__(self, backbone, neck, head='GFLHead'):
    method from_config (line 46) | def from_config(cls, cfg, *args, **kwargs):
    method _forward (line 61) | def _forward(self):
    method get_loss (line 74) | def get_loss(self, ):
    method get_pred (line 84) | def get_pred(self):

FILE: ppdet/modeling/architectures/jde.py
  class JDE (line 26) | class JDE(BaseArch):
    method __init__ (line 41) | def __init__(self,
    method from_config (line 53) | def from_config(cls, cfg, *args, **kwargs):
    method _forward (line 67) | def _forward(self):
    method get_loss (line 106) | def get_loss(self):
    method get_pred (line 109) | def get_pred(self):

FILE: ppdet/modeling/architectures/keypoint_hrhrnet.py
  class HigherHRNet (line 33) | class HigherHRNet(BaseArch):
    method __init__ (line 36) | def __init__(self,
    method from_config (line 64) | def from_config(cls, cfg, *args, **kwargs):
    method _forward (line 78) | def _forward(self):
    method get_loss (line 111) | def get_loss(self):
    method get_pred (line 114) | def get_pred(self):
    method get_topk (line 120) | def get_topk(self, outputs):
  class HrHRNetPostProcess (line 143) | class HrHRNetPostProcess(object):
    method __init__ (line 160) | def __init__(self, max_num_people=30, heat_thresh=0.1, tag_thresh=1.):
    method lerp (line 165) | def lerp(self, j, y, x, heatmap):
    method __call__ (line 177) | def __call__(self, heatmap, tagmap, heat_k, inds_k, original_height,

FILE: ppdet/modeling/architectures/keypoint_hrnet.py
  class TopDownHRNet (line 33) | class TopDownHRNet(BaseArch):
    method __init__ (line 37) | def __init__(self,
    method from_config (line 67) | def from_config(cls, cfg, *args, **kwargs):
    method _forward (line 73) | def _forward(self):
    method get_loss (line 107) | def get_loss(self):
    method get_pred (line 110) | def get_pred(self):
    method flip_back (line 115) | def flip_back(self, output_flipped, matched_parts):
  class HRNetPostProcess (line 129) | class HRNetPostProcess(object):
    method __init__ (line 130) | def __init__(self, use_dark=True):
    method get_max_preds (line 133) | def get_max_preds(self, heatmaps):
    method gaussian_blur (line 169) | def gaussian_blur(self, heatmap, kernel):
    method dark_parse (line 185) | def dark_parse(self, hm, coord):
    method dark_postprocess (line 207) | def dark_postprocess(self, hm, coords, kernelsize):
    method get_final_preds (line 220) | def get_final_preds(self, heatmaps, center, scale, kernelsize=3):
    method __call__ (line 261) | def __call__(self, output, center, scale):
  class TinyPose3DPostProcess (line 271) | class TinyPose3DPostProcess(object):
    method __init__ (line 272) | def __init__(self):
    method __call__ (line 275) | def __call__(self, output, center, scale):
  function soft_argmax (line 294) | def soft_argmax(heatmaps, joint_num):
  class TinyPose3DHRHeatmapNet (line 320) | class TinyPose3DHRHeatmapNet(BaseArch):
    method __init__ (line 324) | def __init__(
    method from_config (line 347) | def from_config(cls, cfg, *args, **kwargs):
    method _forward (line 353) | def _forward(self):
    method get_loss (line 360) | def get_loss(self):
    method get_pred (line 366) | def get_pred(self):
    method flip_back (line 371) | def flip_back(self, output_flipped, matched_parts):
  class TinyPose3DHRNet (line 386) | class TinyPose3DHRNet(BaseArch):
    method __init__ (line 390) | def __init__(self,
    method from_config (line 419) | def from_config(cls, cfg, *args, **kwargs):
    method _forward (line 425) | def _forward(self):
    method get_loss (line 449) | def get_loss(self):
    method get_pred (line 452) | def get_pred(self):
    method flip_back (line 457) | def flip_back(self, output_flipped, matched_parts):

FILE: ppdet/modeling/architectures/keypoint_petr.py
  class PETR (line 30) | class PETR(BaseArch):
    method __init__ (line 34) | def __init__(self,
    method extract_feat (line 54) | def extract_feat(self, img):
    method get_inputs (line 61) | def get_inputs(self):
    method get_loss (line 89) | def get_loss(self):
    method get_pred_numpy (line 128) | def get_pred_numpy(self):
    method get_pred (line 146) | def get_pred(self):
    method simple_test (line 167) | def simple_test(self, inputs, img_metas, rescale=False):
    method bbox_kpt2result (line 195) | def bbox_kpt2result(self, bboxes, labels, kpts, num_classes):

FILE: ppdet/modeling/architectures/keypoint_vitpose.py
  class VitPose_TopDown (line 32) | class VitPose_TopDown(BaseArch):
    method __init__ (line 36) | def __init__(self, backbone, head, loss, post_process, flip_test):
    method from_config (line 53) | def from_config(cls, cfg, *args, **kwargs):
    method _forward_train (line 67) | def _forward_train(self):
    method _forward_test (line 73) | def _forward_test(self):
    method get_loss (line 97) | def get_loss(self):
    method get_pred (line 100) | def get_pred(self):
  class VitPosePostProcess (line 108) | class VitPosePostProcess(object):
    method __init__ (line 109) | def __init__(self, use_dark=False):
    method get_max_preds (line 112) | def get_max_preds(self, heatmaps):
    method post_datk_udp (line 148) | def post_datk_udp(self, coords, batch_heatmaps, kernel=3):
    method transform_preds_udp (line 211) | def transform_preds_udp(self,
    method get_final_preds (line 265) | def get_final_preds(self, heatmaps, center, scale, kernelsize=11):
    method __call__ (line 310) | def __call__(self, output, center, scale):

FILE: ppdet/modeling/architectures/mask_rcnn.py
  class MaskRCNN (line 27) | class MaskRCNN(BaseArch):
    method __init__ (line 47) | def __init__(self,
    method from_config (line 66) | def from_config(cls, cfg, *args, **kwargs):
    method _forward (line 87) | def _forward(self):
    method get_loss (line 135) | def get_loss(self, ):
    method get_pred (line 145) | def get_pred(self):

FILE: ppdet/modeling/architectures/meta_arch.py
  class BaseArch (line 17) | class BaseArch(nn.Layer):
    method __init__ (line 18) | def __init__(self, data_format='NCHW', use_extra_data=False):
    method load_meanstd (line 25) | def load_meanstd(self, cfg_transform):
    method forward (line 44) | def forward(self, inputs):
    method merge_multi_scale_predictions (line 85) | def merge_multi_scale_predictions(self, outs):
    method build_inputs (line 119) | def build_inputs(self, data, input_def):
    method model_arch (line 125) | def model_arch(self, ):
    method get_loss (line 128) | def get_loss(self, ):
    method get_pred (line 131) | def get_pred(self, ):

FILE: ppdet/modeling/architectures/multi_stream_detector.py
  class MultiSteamDetector (line 6) | class MultiSteamDetector(BaseArch):
    method __init__ (line 7) | def __init__(self,
    method forward (line 22) | def forward(self, inputs, return_loss=True, **kwargs):
    method get_loss (line 37) | def get_loss(self, **kwargs):
    method model (line 42) | def model(self, **kwargs) -> BaseArch:
    method freeze (line 52) | def freeze(self, model_ref: str):
    method update_ema_model (line 59) | def update_ema_model(self, momentum=0.9996):

FILE: ppdet/modeling/architectures/picodet.py
  class PicoDet (line 27) | class PicoDet(BaseArch):
    method __init__ (line 39) | def __init__(self, backbone, neck, head='PicoHead', nms_cpu=False):
    method from_config (line 49) | def from_config(cls, cfg, *args, **kwargs):
    method _forward (line 64) | def _forward(self):
    method get_loss (line 79) | def get_loss(self, ):
    method get_pred (line 89) | def get_pred(self):

FILE: ppdet/modeling/architectures/pose3d_metro.py
  function orthographic_projection (line 29) | def orthographic_projection(X, camera):
  class METRO_Body (line 45) | class METRO_Body(BaseArch):
    method __init__ (line 49) | def __init__(
    method from_config (line 72) | def from_config(cls, cfg, *args, **kwargs):
    method _forward (line 79) | def _forward(self):
    method get_loss (line 105) | def get_loss(self):
    method get_pred (line 111) | def get_pred(self):

FILE: ppdet/modeling/architectures/ppyoloe.py
  class PPYOLOE (line 30) | class PPYOLOE(BaseArch):
    method __init__ (line 50) | def __init__(self,
    method from_config (line 79) | def from_config(cls, cfg, *args, **kwargs):
    method _forward (line 94) | def _forward(self):
    method get_loss (line 140) | def get_loss(self):
    method get_pred (line 143) | def get_pred(self):
    method get_loss_keys (line 146) | def get_loss_keys(self):
    method get_ssod_loss (line 149) | def get_ssod_loss(self, student_head_outs, teacher_head_outs, train_cfg):
  class PPYOLOEWithAuxHead (line 156) | class PPYOLOEWithAuxHead(BaseArch):
    method __init__ (line 160) | def __init__(self,
    method from_config (line 191) | def from_config(cls, cfg, *args, **kwargs):
    method _forward (line 212) | def _forward(self):
    method get_loss (line 246) | def get_loss(self):
    method get_pred (line 249) | def get_pred(self):

FILE: ppdet/modeling/architectures/queryinst.py
  class QueryInst (line 28) | class QueryInst(BaseArch):
    method __init__ (line 32) | def __init__(self,
    method from_config (line 46) | def from_config(cls, cfg, *args, **kwargs):
    method _forward (line 62) | def _forward(self, targets=None):
    method get_loss (line 80) | def get_loss(self):
    method get_pred (line 102) | def get_pred(self):

FILE: ppdet/modeling/architectures/retinanet.py
  class RetinaNet (line 28) | class RetinaNet(BaseArch):
    method __init__ (line 31) | def __init__(self, backbone, neck, head):
    method from_config (line 38) | def from_config(cls, cfg, *args, **kwargs):
    method _forward (line 53) | def _forward(self):
    method get_loss (line 80) | def get_loss(self):
    method get_pred (line 83) | def get_pred(self):

FILE: ppdet/modeling/architectures/rtdetrv3.py
  class RTDETRV3 (line 28) | class RTDETRV3(BaseArch):
    method __init__ (line 33) | def __init__(self,
    method from_config (line 55) | def from_config(cls, cfg, *args, **kwargs):
    method _forward (line 85) | def _forward(self):
    method get_loss (line 131) | def get_loss(self):
    method get_pred (line 134) | def get_pred(self):

FILE: ppdet/modeling/architectures/s2anet.py
  class S2ANet (line 27) | class S2ANet(BaseArch):
    method __init__ (line 31) | def __init__(self, backbone, neck, head):
    method from_config (line 46) | def from_config(cls, cfg, *args, **kwargs):
    method _forward (line 57) | def _forward(self):
    method get_loss (line 77) | def get_loss(self, ):
    method get_pred (line 81) | def get_pred(self):

FILE: ppdet/modeling/architectures/solov2.py
  class SOLOv2 (line 28) | class SOLOv2(BaseArch):
    method __init__ (line 41) | def __init__(self, backbone, solov2_head, mask_head, neck=None):
    method from_config (line 49) | def from_config(cls, cfg, *args, **kwargs):
    method model_arch (line 66) | def model_arch(self):
    method get_loss (line 76) | def get_loss(self, ):
    method get_pred (line 100) | def get_pred(self):

FILE: ppdet/modeling/architectures/sparse_rcnn.py
  class SparseRCNN (line 26) | class SparseRCNN(BaseArch):
    method __init__ (line 30) | def __init__(self,
    method from_config (line 42) | def from_config(cls, cfg, *args, **kwargs):
    method _forward (line 57) | def _forward(self):
    method get_loss (line 70) | def get_loss(self):
    method get_pred (line 96) | def get_pred(self):

FILE: ppdet/modeling/architectures/ssd.py
  class SSD (line 28) | class SSD(BaseArch):
    method __init__ (line 41) | def __init__(self, backbone, ssd_head, post_process, r34_backbone=False):
    method from_config (line 56) | def from_config(cls, cfg, *args, **kwargs):
    method _forward (line 69) | def _forward(self):
    method get_loss (line 101) | def get_loss(self, ):
    method get_pred (line 104) | def get_pred(self):

FILE: ppdet/modeling/architectures/tood.py
  class TOOD (line 26) | class TOOD(BaseArch):
    method __init__ (line 37) | def __init__(self, backbone, neck, head):
    method from_config (line 44) | def from_config(cls, cfg, *args, **kwargs):
    method _forward (line 59) | def _forward(self):
    method get_loss (line 71) | def get_loss(self):
    method get_pred (line 74) | def get_pred(self):

FILE: ppdet/modeling/architectures/ttfnet.py
  class TTFNet (line 27) | class TTFNet(BaseArch):
    method __init__ (line 41) | def __init__(self,
    method from_config (line 53) | def from_config(cls, cfg, *args, **kwargs):
    method _forward (line 68) | def _forward(self):
    method get_loss (line 79) | def get_loss(self, ):
    method get_pred (line 92) | def get_pred(self):

FILE: ppdet/modeling/architectures/yolo.py
  class YOLOv3 (line 29) | class YOLOv3(BaseArch):
    method __init__ (line 34) | def __init__(self,
    method from_config (line 62) | def from_config(cls, cfg, *args, **kwargs):
    method _forward (line 80) | def _forward(self):
    method get_loss (line 146) | def get_loss(self):
    method get_pred (line 149) | def get_pred(self):

FILE: ppdet/modeling/architectures/yolof.py
  class YOLOF (line 26) | class YOLOF(BaseArch):
    method __init__ (line 29) | def __init__(self,
    method from_config (line 51) | def from_config(cls, cfg, *args, **kwargs):
    method _forward (line 69) | def _forward(self):
    method get_loss (line 84) | def get_loss(self):
    method get_pred (line 87) | def get_pred(self):

FILE: ppdet/modeling/architectures/yolox.py
  class YOLOX (line 31) | class YOLOX(BaseArch):
    method __init__ (line 47) | def __init__(self,
    method from_config (line 70) | def from_config(cls, cfg, *args, **kwargs):
    method _forward (line 88) | def _forward(self):
    method get_loss (line 104) | def get_loss(self):
    method get_pred (line 107) | def get_pred(self):
    method _preprocess (line 110) | def _preprocess(self):
    method _get_size (line 128) | def _get_size(self):

FILE: ppdet/modeling/assigners/atss_assigner.py
  class ATSSAssigner (line 34) | class ATSSAssigner(nn.Layer):
    method __init__ (line 40) | def __init__(self,
    method _gather_topk_pyramid (line 53) | def _gather_topk_pyramid(self, gt2anchor_distances, num_anchors_list,
    method forward (line 75) | def forward(self,

FILE: ppdet/modeling/assigners/clrnet_assigner.py
  function distance_cost (line 6) | def distance_cost(predictions, targets, img_w):
  function focal_cost (line 25) | def focal_cost(cls_pred, gt_labels, alpha=0.25, gamma=2, eps=1e-12):
  function dynamic_k_assign (line 44) | def dynamic_k_assign(cost, pair_wise_ious):
  function cdist_paddle (line 83) | def cdist_paddle(x1, x2, p=2):
  function assign (line 99) | def assign(predictions,

FILE: ppdet/modeling/assigners/fcosr_assigner.py
  class FCOSRAssigner (line 33) | class FCOSRAssigner(nn.Layer):
    method __init__ (line 45) | def __init__(self,
    method get_gaussian_distribution_score (line 61) | def get_gaussian_distribution_score(self, points, gt_rboxes, gt_polys):
    method get_rotated_inside_mask (line 96) | def get_rotated_inside_mask(self, points, gt_polys, scores):
    method get_inside_range_mask (line 101) | def get_inside_range_mask(self, points, gt_bboxes, gt_rboxes, stride_t...
    method forward (line 134) | def forward(self,

FILE: ppdet/modeling/assigners/hungarian_assigner.py
  class AssignResult (line 31) | class AssignResult:
    method __init__ (line 49) | def __init__(self, num_gts, gt_inds, max_overlaps, labels=None):
    method num_preds (line 58) | def num_preds(self):
    method set_extra_property (line 62) | def set_extra_property(self, key, value):
    method get_extra_property (line 67) | def get_extra_property(self, key):
    method info (line 72) | def info(self):
  class PoseHungarianAssigner (line 86) | class PoseHungarianAssigner:
    method __init__ (line 110) | def __init__(self,
    method assign (line 118) | def assign(self,
  class SamplingResult (line 221) | class SamplingResult:
    method __init__ (line 225) | def __init__(self, pos_inds, neg_inds, bboxes, gt_bboxes, assign_result,
    method bboxes (line 257) | def bboxes(self):
    method __nice__ (line 261) | def __nice__(self):
    method info (line 270) | def info(self):
  class PseudoSampler (line 284) | class PseudoSampler:
    method __init__ (line 287) | def __init__(self, **kwargs):
    method _sample_pos (line 290) | def _sample_pos(self, **kwargs):
    method _sample_neg (line 294) | def _sample_neg(self, **kwargs):
    method sample (line 298) | def sample(self, assign_result, bboxes, gt_bboxes, *args, **kwargs):

FILE: ppdet/modeling/assigners/max_iou_assigner.py
  class MaxIoUAssigner (line 25) | class MaxIoUAssigner(object):
    method __init__ (line 34) | def __init__(self,
    method __call__ (line 42) | def __call__(self, bboxes, gt_bboxes):

FILE: ppdet/modeling/assigners/pose_utils.py
  function masked_fill (line 28) | def masked_fill(x, mask, value):
  class KptL1Cost (line 34) | class KptL1Cost(object):
    method __init__ (line 43) | def __init__(self, weight=1.0):
    method __call__ (line 46) | def __call__(self, kpt_pred, gt_keypoints, valid_kpt_flag):
  class OksCost (line 84) | class OksCost(object):
    method __init__ (line 94) | def __init__(self, num_keypoints=17, weight=1.0):
    method __call__ (line 113) | def __call__(self, kpt_pred, gt_keypoints, valid_kpt_flag, gt_areas):
  class ClassificationCost (line 160) | class ClassificationCost:
    method __init__ (line 167) | def __init__(self, weight=1.):
    method __call__ (line 170) | def __call__(self, cls_pred, gt_labels):
  class FocalLossCost (line 190) | class FocalLossCost:
    method __init__ (line 202) | def __init__(self,
    method _focal_loss_cost (line 214) | def _focal_loss_cost(self, cls_pred, gt_labels):
    method _mask_focal_loss_cost (line 237) | def _mask_focal_loss_cost(self, cls_pred, gt_labels):
    method __call__ (line 262) | def __call__(self, cls_pred, gt_labels):

FILE: ppdet/modeling/assigners/rotated_task_aligned_assigner.py
  class RotatedTaskAlignedAssigner (line 31) | class RotatedTaskAlignedAssigner(nn.Layer):
    method __init__ (line 35) | def __init__(self, topk=13, alpha=1.0, beta=6.0, eps=1e-9):
    method forward (line 43) | def forward(self,

FILE: ppdet/modeling/assigners/simota_assigner.py
  class SimOTAAssigner (line 28) | class SimOTAAssigner(object):
    method __init__ (line 44) | def __init__(self,
    method get_in_gt_and_in_center_info (line 58) | def get_in_gt_and_in_center_info(self, flatten_center_and_stride,
    method dynamic_k_matching (line 115) | def dynamic_k_matching(self, cost_matrix, pairwise_ious, num_gt):
    method get_sample (line 145) | def get_sample(self, assign_gt_inds, gt_bboxes):
    method __call__ (line 160) | def __call__(self,

FILE: ppdet/modeling/assigners/task_aligned_assigner.py
  function is_close_gt (line 31) | def is_close_gt(anchor, gt, stride_lst, max_dist=2.0, alpha=2.):
  class TaskAlignedAssigner (line 56) | class TaskAlignedAssigner(nn.Layer):
    method __init__ (line 60) | def __init__(self,
    method forward (line 74) | def forward(self,

FILE: ppdet/modeling/assigners/task_aligned_assigner_cr.py
  class TaskAlignedAssigner_CR (line 32) | class TaskAlignedAssigner_CR(nn.Layer):
    method __init__ (line 36) | def __init__(self,
    method forward (line 50) | def forward(self,

FILE: ppdet/modeling/assigners/uniform_assigner.py
  function batch_p_dist (line 26) | def batch_p_dist(x, y, p=2):
  class UniformAssigner (line 37) | class UniformAssigner(nn.Layer):
    method __init__ (line 38) | def __init__(self, pos_ignore_thr, neg_ignore_thr, match_times=4):
    method forward (line 44) | def forward(self, bbox_pred, anchor, gt_bboxes, gt_labels=None):

FILE: ppdet/modeling/assigners/utils.py
  function pad_gt (line 29) | def pad_gt(gt_labels, gt_bboxes, gt_scores=None):
  function gather_topk_anchors (line 83) | def gather_topk_anchors(metrics, topk, largest=True, topk_mask=None, eps...
  function check_points_inside_bboxes (line 108) | def check_points_inside_bboxes(points,
  function compute_max_iou_anchor (line 153) | def compute_max_iou_anchor(ious):
  function compute_max_iou_gt (line 167) | def compute_max_iou_gt(ious):
  function generate_anchors_for_grid_cell (line 181) | def generate_anchors_for_grid_cell(feats,

FILE: ppdet/modeling/backbones/blazenet.py
  function hard_swish (line 30) | def hard_swish(x):
  class ConvBNLayer (line 34) | class ConvBNLayer(nn.Layer):
    method __init__ (line 35) | def __init__(self,
    method forward (line 64) | def forward(self, x):
  class BlazeBlock (line 78) | class BlazeBlock(nn.Layer):
    method __init__ (line 79) | def __init__(self,
    method forward (line 201) | def forward(self, x):
  class BlazeNet (line 218) | class BlazeNet(nn.Layer):
    method __init__ (line 228) | def __init__(
    method forward (line 306) | def forward(self, inputs):
    method out_shape (line 315) | def out_shape(self):

FILE: ppdet/modeling/backbones/clrnet_resnet.py
  class BasicBlock (line 49) | class BasicBlock(nn.Layer):
    method __init__ (line 52) | def __init__(self,
    method forward (line 78) | def forward(self, x):
  class BottleneckBlock (line 97) | class BottleneckBlock(nn.Layer):
    method __init__ (line 101) | def __init__(self,
    method forward (line 136) | def forward(self, x):
  class ResNet (line 159) | class ResNet(nn.Layer):
    method __init__ (line 191) | def __init__(self, block, depth=50, width=64, with_pool=True, groups=1):
    method _make_layer (line 234) | def _make_layer(self, block, planes, blocks, stride=1, dilate=False):
    method out_shape (line 268) | def out_shape(self):
    method forward (line 275) | def forward(self, x):
  class CLRResNet (line 299) | class CLRResNet(nn.Layer):
    method __init__ (line 300) | def __init__(self,
    method out_shape (line 327) | def out_shape(self):
    method forward (line 330) | def forward(self, x):
  function _resnet (line 337) | def _resnet(arch, Block, depth, pretrained, **kwargs):
  function resnet18 (line 350) | def resnet18(pretrained=False, **kwargs):
  function resnet34 (line 375) | def resnet34(pretrained=False, **kwargs):
  function resnet50 (line 400) | def resnet50(pretrained=False, **kwargs):
  function resnet101 (line 425) | def resnet101(pretrained=False, **kwargs):
  function resnet152 (line 450) | def resnet152(pretrained=False, **kwargs):
  function resnext50_32x4d (line 475) | def resnext50_32x4d(pretrained=False, **kwargs):
  function resnext50_64x4d (line 503) | def resnext50_64x4d(pretrained=False, **kwargs):
  function resnext101_32x4d (line 531) | def resnext101_32x4d(pretrained=False, **kwargs):
  function resnext101_64x4d (line 560) | def resnext101_64x4d(pretrained=False, **kwargs):
  function resnext152_32x4d (line 589) | def resnext152_32x4d(pretrained=False, **kwargs):
  function resnext152_64x4d (line 618) | def resnext152_64x4d(pretrained=False, **kwargs):
  function wide_resnet50_2 (line 647) | def wide_resnet50_2(pretrained=False, **kwargs):
  function wide_resnet101_2 (line 673) | def wide_resnet101_2(pretrained=False, **kwargs):

FILE: ppdet/modeling/backbones/convnext.py
  class Block (line 37) | class Block(nn.Layer):
    method __init__ (line 49) | def __init__(self, dim, drop_path=0., layer_scale_init_value=1e-6):
    method forward (line 69) | def forward(self, x):
  class LayerNorm (line 84) | class LayerNorm(nn.Layer):
    method __init__ (line 91) | def __init__(self, normalized_shape, eps=1e-6, data_format="channels_l...
    method forward (line 107) | def forward(self, x):
  class ConvNeXt (line 121) | class ConvNeXt(nn.Layer):
    method __init__ (line 157) | def __init__(
    method _init_weights (line 221) | def _init_weights(self, m):
    method forward_features (line 226) | def forward_features(self, x):
    method forward (line 239) | def forward(self, x):
    method out_shape (line 244) | def out_shape(self):

FILE: ppdet/modeling/backbones/csp_darknet.py
  class BaseConv (line 29) | class BaseConv(nn.Layer):
    method __init__ (line 30) | def __init__(self,
    method _init_weights (line 54) | def _init_weights(self):
    method forward (line 57) | def forward(self, x):
  class DWConv (line 64) | class DWConv(nn.Layer):
    method __init__ (line 67) | def __init__(self,
    method forward (line 92) | def forward(self, x):
  class Focus (line 96) | class Focus(nn.Layer):
    method __init__ (line 99) | def __init__(self,
    method forward (line 115) | def forward(self, inputs):
  class BottleNeck (line 126) | class BottleNeck(nn.Layer):
    method __init__ (line 127) | def __init__(self,
    method forward (line 149) | def forward(self, x):
  class SPPLayer (line 156) | class SPPLayer(nn.Layer):
    method __init__ (line 159) | def __init__(self,
    method forward (line 178) | def forward(self, x):
  class SPPFLayer (line 185) | class SPPFLayer(nn.Layer):
    method __init__ (line 190) | def __init__(self,
    method forward (line 206) | def forward(self, x):
  class CSPLayer (line 216) | class CSPLayer(nn.Layer):
    method __init__ (line 219) | def __init__(self,
    method forward (line 252) | def forward(self, x):
  class CSPDarkNet (line 263) | class CSPDarkNet(nn.Layer):
    method __init__ (line 292) | def __init__(self,
    method forward (line 388) | def forward(self, inputs):
    method out_shape (line 399) | def out_shape(self):

FILE: ppdet/modeling/backbones/cspresnet.py
  class ConvBNLayer (line 33) | class ConvBNLayer(nn.Layer):
    method __init__ (line 34) | def __init__(self,
    method forward (line 60) | def forward(self, x):
  class RepVggBlock (line 68) | class RepVggBlock(nn.Layer):
    method __init__ (line 69) | def __init__(self, ch_in, ch_out, act='relu', alpha=False):
    method forward (line 87) | def forward(self, x):
    method convert_to_deploy (line 98) | def convert_to_deploy(self):
    method get_equivalent_kernel_bias (line 113) | def get_equivalent_kernel_bias(self):
    method _pad_1x1_to_3x3_tensor (line 123) | def _pad_1x1_to_3x3_tensor(self, kernel1x1):
    method _fuse_bn_tensor (line 129) | def _fuse_bn_tensor(self, branch):
  class BasicBlock (line 143) | class BasicBlock(nn.Layer):
    method __init__ (line 144) | def __init__(self,
    method forward (line 156) | def forward(self, x):
  class EffectiveSELayer (line 165) | class EffectiveSELayer(nn.Layer):
    method __init__ (line 170) | def __init__(self, channels, act='hardsigmoid'):
    method forward (line 176) | def forward(self, x):
  class CSPResStage (line 182) | class CSPResStage(nn.Layer):
    method __init__ (line 183) | def __init__(self,
    method forward (line 217) | def forward(self, x):
  class CSPResNet (line 231) | class CSPResNet(nn.Layer):
    method __init__ (line 234) | def __init__(self,
    method forward (line 300) | def forward(self, inputs):
    method out_shape (line 316) | def out_shape(self):

FILE: ppdet/modeling/backbones/darknet.py
  class ConvBNLayer (line 26) | class ConvBNLayer(nn.Layer):
    method __init__ (line 27) | def __init__(self,
    method forward (line 75) | def forward(self, inputs):
  class DownSample (line 85) | class DownSample(nn.Layer):
    method __init__ (line 86) | def __init__(self,
    method forward (line 125) | def forward(self, inputs):
  class BasicBlock (line 130) | class BasicBlock(nn.Layer):
    method __init__ (line 131) | def __init__(self,
    method forward (line 178) | def forward(self, inputs):
  class Blocks (line 185) | class Blocks(nn.Layer):
    method __init__ (line 186) | def __init__(self,
    method forward (line 232) | def forward(self, inputs):
  class DarkNet (line 244) | class DarkNet(nn.Layer):
    method __init__ (line 247) | def __init__(self,
    method forward (line 327) | def forward(self, inputs):
    method out_shape (line 344) | def out_shape(self):

FILE: ppdet/modeling/backbones/dla.py
  class BasicBlock (line 25) | class BasicBlock(nn.Layer):
    method __init__ (line 26) | def __init__(self, ch_in, ch_out, stride=1):
    method forward (line 43) | def forward(self, inputs, residual=None):
  class Root (line 58) | class Root(nn.Layer):
    method __init__ (line 59) | def __init__(self, ch_in, ch_out, kernel_size, residual):
    method forward (line 70) | def forward(self, inputs):
  class Tree (line 80) | class Tree(nn.Layer):
    method __init__ (line 81) | def __init__(self,
    method forward (line 137) | def forward(self, x, residual=None, children=None):
  class DLA (line 155) | class DLA(nn.Layer):
    method __init__ (line 166) | def __init__(self,
    method _make_conv_level (line 247) | def _make_conv_level(self, ch_in, ch_out, conv_num, stride=1):
    method out_shape (line 263) | def out_shape(self):
    method forward (line 268) | def forward(self, inputs):

FILE: ppdet/modeling/backbones/esnet.py
  function make_divisible (line 36) | def make_divisible(v, divisor=16, min_value=None):
  class SEModule (line 45) | class SEModule(nn.Layer):
    method __init__ (line 46) | def __init__(self, channel, reduction=4):
    method forward (line 66) | def forward(self, inputs):
  class InvertedResidual (line 75) | class InvertedResidual(nn.Layer):
    method __init__ (line 76) | def __init__(self,
    method forward (line 110) | def forward(self, inputs):
  class InvertedResidualDS (line 124) | class InvertedResidualDS(nn.Layer):
    method __init__ (line 125) | def __init__(self,
    method forward (line 193) | def forward(self, inputs):
  class ESNet (line 209) | class ESNet(nn.Layer):
    method __init__ (line 210) | def __init__(self,
    method _update_out_channels (line 273) | def _update_out_channels(self, channel, feature_idx, feature_maps):
    method forward (line 277) | def forward(self, inputs):
    method out_shape (line 289) | def out_shape(self):

FILE: ppdet/modeling/backbones/focalnet.py
  class FocalModulation (line 190) | class FocalModulation(nn.Layer):
    method __init__ (line 202) | def __init__(self,
    method forward (line 253) | def forward(self, x):
  class FocalModulationBlock (line 281) | class FocalModulationBlock(nn.Layer):
    method __init__ (line 299) | def __init__(self,
    method forward (line 348) | def forward(self, x):
  class BasicLayer (line 377) | class BasicLayer(nn.Layer):
    method __init__ (line 398) | def __init__(self,
    method forward (line 450) | def forward(self, x, H, W):
  class PatchEmbed (line 470) | class PatchEmbed(nn.Layer):
    method __init__ (line 481) | def __init__(self,
    method forward (line 520) | def forward(self, x):
  class FocalNet (line 544) | class FocalNet(nn.Layer):
    method __init__ (line 571) | def __init__(
    method _freeze_stages (line 672) | def _freeze_stages(self):
    method _init_weights (line 686) | def _init_weights(self, m):
    method forward (line 695) | def forward(self, x):
    method out_shape (line 714) | def out_shape(self):

FILE: ppdet/modeling/backbones/ghostnet.py
  class ExtraBlockDW (line 31) | class ExtraBlockDW(nn.Layer):
    method __init__ (line 32) | def __init__(self,
    method forward (line 85) | def forward(self, inputs):
  class SEBlock (line 92) | class SEBlock(nn.Layer):
    method __init__ (line 93) | def __init__(self, num_channels, lr_mult, reduction_ratio=4, name=None):
    method forward (line 113) | def forward(self, inputs):
  class GhostModule (line 125) | class GhostModule(nn.Layer):
    method __init__ (line 126) | def __init__(self,
    method forward (line 172) | def forward(self, inputs):
  class GhostBottleneck (line 179) | class GhostBottleneck(nn.Layer):
    method __init__ (line 180) | def __init__(self,
    method forward (line 275) | def forward(self, inputs):
  class GhostNet (line 299) | class GhostNet(nn.Layer):
    method __init__ (line 302) | def __init__(
    method _update_out_channels (line 442) | def _update_out_channels(self, channel, feature_idx, feature_maps):
    method forward (line 446) | def forward(self, inputs):
    method out_shape (line 469) | def out_shape(self):

FILE: ppdet/modeling/backbones/hardnet.py
  function ConvLayer (line 23) | def ConvLayer(in_channels,
  function DWConvLayer (line 41) | def DWConvLayer(in_channels,
  function CombConvLayer (line 58) | def CombConvLayer(in_channels, out_channels, kernel_size=1, stride=1):
  class HarDBlock (line 67) | class HarDBlock(nn.Layer):
    method __init__ (line 68) | def __init__(self,
    method get_out_ch (line 94) | def get_out_ch(self):
    method get_link (line 97) | def get_link(self, layer, base_ch, growth_rate, grmul):
    method forward (line 120) | def forward(self, x):
  class HarDNet (line 146) | class HarDNet(nn.Layer):
    method __init__ (line 147) | def __init__(self, depth_wise=False, return_idx=[1, 3, 8, 13], arch=85):
    method forward (line 215) | def forward(self, inputs):
    method out_shape (line 225) | def out_shape(self):

FILE: ppdet/modeling/backbones/hgnet_v2.py
  class LearnableAffineBlock (line 35) | class LearnableAffineBlock(nn.Layer):
    method __init__ (line 36) | def __init__(self,
    method forward (line 53) | def forward(self, x):
  class ConvBNAct (line 57) | class ConvBNAct(nn.Layer):
    method __init__ (line 58) | def __init__(self,
    method forward (line 92) | def forward(self, x):
  class LightConvBNAct (line 102) | class LightConvBNAct(nn.Layer):
    method __init__ (line 103) | def __init__(self,
    method forward (line 128) | def forward(self, x):
  class StemBlock (line 134) | class StemBlock(nn.Layer):
    method __init__ (line 135) | def __init__(self,
    method forward (line 182) | def forward(self, x):
  class HG_Block (line 194) | class HG_Block(nn.Layer):
    method __init__ (line 195) | def __init__(self,
    method forward (line 236) | def forward(self, x):
  class HG_Stage (line 251) | class HG_Stage(nn.Layer):
    method __init__ (line 252) | def __init__(self,
    method forward (line 291) | def forward(self, x):
  function _freeze_norm (line 298) | def _freeze_norm(m: nn.BatchNorm2D):
  function reset_bn (line 314) | def reset_bn(model: nn.Layer, reset_func=_freeze_norm):
  class PPHGNetV2 (line 327) | class PPHGNetV2(nn.Layer):
    method __init__ (line 392) | def __init__(self,
    method _freeze_parameters (line 447) | def _freeze_parameters(self, m):
    method _init_weights (line 451) | def _init_weights(self):
    method out_shape (line 462) | def out_shape(self):
    method forward (line 469) | def forward(self, inputs):

FILE: ppdet/modeling/backbones/hrnet.py
  class ConvNormLayer (line 31) | class ConvNormLayer(nn.Layer):
    method __init__ (line 32) | def __init__(self,
    method forward (line 85) | def forward(self, inputs):
  class Layer1 (line 94) | class Layer1(nn.Layer):
    method __init__ (line 95) | def __init__(self,
    method forward (line 121) | def forward(self, input):
  class TransitionLayer (line 128) | class TransitionLayer(nn.Layer):
    method __init__ (line 129) | def __init__(self,
    method forward (line 172) | def forward(self, input):
  class Branches (line 185) | class Branches(nn.Layer):
    method __init__ (line 186) | def __init__(self,
    method forward (line 215) | def forward(self, inputs):
  class BottleneckBlock (line 226) | class BottleneckBlock(nn.Layer):
    method __init__ (line 227) | def __init__(self,
    method forward (line 289) | def forward(self, input):
  class BasicBlock (line 306) | class BasicBlock(nn.Layer):
    method __init__ (line 307) | def __init__(self,
    method forward (line 360) | def forward(self, input):
  class SELayer (line 376) | class SELayer(nn.Layer):
    method __init__ (line 377) | def __init__(self, num_channels, num_filters, reduction_ratio, name=No...
    method forward (line 397) | def forward(self, input):
  class Stage (line 409) | class Stage(nn.Layer):
    method __init__ (line 410) | def __init__(self,
    method forward (line 451) | def forward(self, input):
  class HighResolutionModule (line 458) | class HighResolutionModule(nn.Layer):
    method __init__ (line 459) | def __init__(self,
    method forward (line 488) | def forward(self, input):
  class FuseLayers (line 494) | class FuseLayers(nn.Layer):
    method __init__ (line 495) | def __init__(self,
    method forward (line 564) | def forward(self, input):
  class HRNet (line 588) | class HRNet(nn.Layer):
    method __init__ (line 603) | def __init__(self,
    method _make_layer (line 730) | def _make_layer(self,
    method _make_head (line 767) | def _make_head(self, pre_stage_channels, norm_momentum=0.9, has_se=Fal...
    method forward (line 820) | def forward(self, inputs):
    method out_shape (line 862) | def out_shape(self):

FILE: ppdet/modeling/backbones/lcnet.py
  function make_divisible (line 56) | def make_divisible(v, divisor=8, min_value=None):
  class ConvBNLayer (line 65) | class ConvBNLayer(nn.Layer):
    method __init__ (line 66) | def __init__(self,
    method forward (line 94) | def forward(self, x):
  class DepthwiseSeparable (line 101) | class DepthwiseSeparable(nn.Layer):
    method __init__ (line 102) | def __init__(self,
    method forward (line 127) | def forward(self, x):
  class AdaptiveAvgPool2D (line 134) | class AdaptiveAvgPool2D(nn.AdaptiveAvgPool2D):
    method __init__ (line 135) | def __init__(self, *args, **kwargs):
    method forward (line 151) | def forward(self, x):
  class SEModule (line 161) | class SEModule(nn.Layer):
    method __init__ (line 162) | def __init__(self, channel, reduction=4):
    method forward (line 180) | def forward(self, x):
  class LCNet (line 193) | class LCNet(nn.Layer):
    method __init__ (line 194) | def __init__(self, scale=1.0, feature_maps=[3, 4, 5], act='hard_swish'):
    method forward (line 278) | def forward(self, inputs):
    method out_shape (line 296) | def out_shape(self):

FILE: ppdet/modeling/backbones/lite_hrnet.py
  class ConvNormLayer (line 35) | class ConvNormLayer(nn.Layer):
    method __init__ (line 36) | def __init__(self,
    method forward (line 92) | def forward(self, inputs):
  class DepthWiseSeparableConvNormLayer (line 104) | class DepthWiseSeparableConvNormLayer(nn.Layer):
    method __init__ (line 105) | def __init__(self,
    method forward (line 137) | def forward(self, x):
  class CrossResolutionWeightingModule (line 143) | class CrossResolutionWeightingModule(nn.Layer):
    method __init__ (line 144) | def __init__(self,
    method forward (line 172) | def forward(self, x):
  class SpatialWeightingModule (line 186) | class SpatialWeightingModule(nn.Layer):
    method __init__ (line 187) | def __init__(self, in_channel, ratio=16, freeze_norm=False, norm_decay...
    method forward (line 207) | def forward(self, x):
  class ConditionalChannelWeightingBlock (line 214) | class ConditionalChannelWeightingBlock(nn.Layer):
    method __init__ (line 215) | def __init__(self,
    method forward (line 252) | def forward(self, x):
  class ShuffleUnit (line 266) | class ShuffleUnit(nn.Layer):
    method __init__ (line 267) | def __init__(self,
    method forward (line 329) | def forward(self, x):
  class IterativeHead (line 341) | class IterativeHead(nn.Layer):
    method __init__ (line 342) | def __init__(self,
    method forward (line 381) | def forward(self, x):
  class Stem (line 400) | class Stem(nn.Layer):
    method __init__ (line 401) | def __init__(self,
    method forward (line 473) | def forward(self, x):
  class LiteHRNetModule (line 486) | class LiteHRNetModule(nn.Layer):
    method __init__ (line 487) | def __init__(self,
    method _make_weighting_blocks (line 529) | def _make_weighting_blocks(self,
    method _make_naive_branches (line 547) | def _make_naive_branches(self,
    method _make_fuse_layers (line 567) | def _make_fuse_layers(self, freeze_norm=False, norm_decay=0.):
    method forward (line 640) | def forward(self, x):
  class LiteHRNet (line 670) | class LiteHRNet(nn.Layer):
    method __init__ (line 689) | def __init__(self,
    method _make_transition_layer (line 759) | def _make_transition_layer(self,
    method _make_stage (line 822) | def _make_stage(self,
    method forward (line 855) | def forward(self, inputs):
    method out_shape (line 886) | def out_shape(self):

FILE: ppdet/modeling/backbones/mobilenet_v1.py
  class ConvBNLayer (line 31) | class ConvBNLayer(nn.Layer):
    method __init__ (line 32) | def __init__(self,
    method forward (line 66) | def forward(self, x):
  class DepthwiseSeparable (line 76) | class DepthwiseSeparable(nn.Layer):
    method __init__ (line 77) | def __init__(self,
    method forward (line 116) | def forward(self, x):
  class ExtraBlock (line 122) | class ExtraBlock(nn.Layer):
    method __init__ (line 123) | def __init__(self,
    method forward (line 164) | def forward(self, x):
  class MobileNet (line 172) | class MobileNet(nn.Layer):
    method __init__ (line 175) | def __init__(self,
    method _update_out_channels (line 377) | def _update_out_channels(self, channel, feature_idx, feature_maps):
    method forward (line 381) | def forward(self, inputs):
    method out_shape (line 401) | def out_shape(self):

FILE: ppdet/modeling/backbones/mobilenet_v3.py
  function make_divisible (line 31) | def make_divisible(v, divisor=8, min_value=None):
  class ConvBNLayer (line 40) | class ConvBNLayer(nn.Layer):
    method __init__ (line 41) | def __init__(self,
    method forward (line 89) | def forward(self, x):
  class ResidualUnit (line 105) | class ResidualUnit(nn.Layer):
    method __init__ (line 106) | def __init__(self,
    method forward (line 170) | def forward(self, inputs):
  class SEModule (line 184) | class SEModule(nn.Layer):
    method __init__ (line 185) | def __init__(self, channel, lr_mult, conv_decay, reduction=4, name=""):
    method forward (line 210) | def forward(self, inputs):
  class ExtraBlockDW (line 219) | class ExtraBlockDW(nn.Layer):
    method __init__ (line 220) | def __init__(self,
    method forward (line 273) | def forward(self, inputs):
  class MobileNetV3 (line 282) | class MobileNetV3(nn.Layer):
    method __init__ (line 285) | def __init__(
    method _update_out_channels (line 450) | def _update_out_channels(self, channel, feature_idx, feature_maps):
    method forward (line 454) | def forward(self, inputs):
    method out_shape (line 477) | def out_shape(self):

FILE: ppdet/modeling/backbones/mobileone.py
  class MobileOneBlock (line 31) | class MobileOneBlock(nn.Layer):
    method __init__ (line 32) | def __init__(
    method forward (line 118) | def forward(self, x):
    method convert_to_deploy (line 146) | def convert_to_deploy(self):
    method get_equivalent_kernel_bias (line 182) | def get_equivalent_kernel_bias(self):
    method _pad_1x1_to_3x3_tensor (line 202) | def _pad_1x1_to_3x3_tensor(self, kernel1x1):
    method _fuse_bn_tensor (line 211) | def _fuse_bn_tensor(self, branch, kernel_size=3):

FILE: ppdet/modeling/backbones/name_adapter.py
  class NameAdapter (line 1) | class NameAdapter(object):
    method __init__ (line 4) | def __init__(self, model):
    method model_type (line 9) | def model_type(self):
    method variant (line 13) | def variant(self):
    method fix_conv_norm_name (line 16) | def fix_conv_norm_name(self, name):
    method fix_shortcut_name (line 26) | def fix_shortcut_name(self, name):
    method fix_bottleneck_name (line 31) | def fix_bottleneck_name(self, name):
    method fix_basicblock_name (line 44) | def fix_basicblock_name(self, name):
    method fix_layer_warp_name (line 55) | def fix_layer_warp_name(self, stage_num, count, i):
    method fix_c1_stage_name (line 68) | def fix_c1_stage_name(self):

FILE: ppdet/modeling/backbones/res2net.py
  class BottleNeck (line 34) | class BottleNeck(nn.Layer):
    method __init__ (line 35) | def __init__(self,
    method forward (line 121) | def forward(self, inputs):
  class Blocks (line 149) | class Blocks(nn.Layer):
    method __init__ (line 150) | def __init__(self,
    method forward (line 185) | def forward(self, inputs):
  class Res2Net (line 191) | class Res2Net(nn.Layer):
    method __init__ (line 215) | def __init__(self,
    method out_shape (line 313) | def out_shape(self):
    method forward (line 320) | def forward(self, inputs):
  class Res2NetC5 (line 335) | class Res2NetC5(nn.Layer):
    method __init__ (line 336) | def __init__(self, depth=50, width=26, scales=4, variant='b'):
    method out_shape (line 350) | def out_shape(self):
    method forward (line 355) | def forward(self, roi_feat, stage=0):

FILE: ppdet/modeling/backbones/resnet.py
  class ConvNormLayer (line 41) | class ConvNormLayer(nn.Layer):
    method __init__ (line 42) | def __init__(self,
    method forward (line 116) | def forward(self, inputs):
  class SELayer (line 135) | class SELayer(nn.Layer):
    method __init__ (line 136) | def __init__(self, ch, reduction_ratio=16):
    method forward (line 154) | def forward(self, inputs):
  class BasicBlock (line 166) | class BasicBlock(nn.Layer):
    method __init__ (line 170) | def __init__(self,
    method forward (line 244) | def forward(self, inputs):
  class BottleNeck (line 261) | class BottleNeck(nn.Layer):
    method __init__ (line 265) | def __init__(self,
    method forward (line 358) | def forward(self, inputs):
  class Blocks (line 378) | class Blocks(nn.Layer):
    method __init__ (line 379) | def __init__(self,
    method forward (line 420) | def forward(self, inputs):
  class ResNet (line 429) | class ResNet(nn.Layer):
    method __init__ (line 432) | def __init__(self,
    method _freeze_parameters (line 566) | def _freeze_parameters(self, m):
    method out_shape (line 571) | def out_shape(self):
    method forward (line 578) | def forward(self, inputs):
  class Res5Head (line 591) | class Res5Head(nn.Layer):
    method __init__ (line 592) | def __init__(self, depth=50):
    method out_shape (line 604) | def out_shape(self):
    method forward (line 609) | def forward(self, roi_feat, stage=0):

FILE: ppdet/modeling/backbones/senet.py
  class SENet (line 27) | class SENet(ResNet):
    method __init__ (line 30) | def __init__(self,
  class SERes5Head (line 83) | class SERes5Head(nn.Layer):
    method __init__ (line 84) | def __init__(self,
    method out_shape (line 134) | def out_shape(self):
    method forward (line 139) | def forward(self, roi_feat):

FILE: ppdet/modeling/backbones/shufflenet_v2.py
  class ConvBNLayer (line 35) | class ConvBNLayer(nn.Layer):
    method __init__ (line 36) | def __init__(self,
    method forward (line 63) | def forward(self, inputs):
  class InvertedResidual (line 71) | class InvertedResidual(nn.Layer):
    method __init__ (line 72) | def __init__(self, in_channels, out_channels, stride, act="relu"):
    method forward (line 99) | def forward(self, inputs):
  class InvertedResidualDS (line 111) | class InvertedResidualDS(nn.Layer):
    method __init__ (line 112) | def __init__(self, in_channels, out_channels, stride, act="relu"):
    method forward (line 158) | def forward(self, inputs):
  class ShuffleNetV2 (line 171) | class ShuffleNetV2(nn.Layer):
    method __init__ (line 172) | def __init__(self, scale=1.0, act="relu", feature_maps=[5, 13, 17]):
    method _update_out_channels (line 233) | def _update_out_channels(self, channel, feature_idx, feature_maps):
    method forward (line 237) | def forward(self, inputs):
    method out_shape (line 249) | def out_shape(self):

FILE: ppdet/modeling/backbones/swin_transformer.py
  class Mlp (line 84) | class Mlp(nn.Layer):
    method __init__ (line 85) | def __init__(self,
    method forward (line 99) | def forward(self, x):
  function window_partition (line 108) | def window_partition(x, window_size):
  function window_reverse (line 124) | def window_reverse(windows, window_size, H, W):
  class WindowAttention (line 142) | class WindowAttention(nn.Layer):
    method __init__ (line 156) | def __init__(self,
    method forward (line 203) | def forward(self, x, mask=None):
  class SwinTransformerBlock (line 248) | class SwinTransformerBlock(nn.Layer):
    method __init__ (line 265) | def __init__(self,
    method forward (line 307) | def forward(self, x, mask_matrix):
  class PatchMerging (line 377) | class PatchMerging(nn.Layer):
    method __init__ (line 384) | def __init__(self, dim, norm_layer=nn.LayerNorm):
    method forward (line 390) | def forward(self, x, H, W):
  class BasicLayer (line 422) | class BasicLayer(nn.Layer):
    method __init__ (line 439) | def __init__(self,
    method forward (line 480) | def forward(self, x, H, W):
  class PatchEmbed (line 523) | class PatchEmbed(nn.Layer):
    method __init__ (line 532) | def __init__(self, patch_size=4, in_chans=3, embed_dim=96, norm_layer=...
    method forward (line 547) | def forward(self, x):
  class SwinTransformer (line 568) | class SwinTransformer(nn.Layer):
    method __init__ (line 590) | def __init__(self,
    method _freeze_stages (line 694) | def _freeze_stages(self):
    method _init_weights (line 711) | def _init_weights(self, m):
    method forward (line 720) | def forward(self, x):
    method out_shape (line 746) | def out_shape(self):

FILE: ppdet/modeling/backbones/trans_encoder.py
  class BertEmbeddings (line 27) | class BertEmbeddings(nn.Layer):
    method __init__ (line 28) | def __init__(self, word_size, position_embeddings_size, word_type_size,
    method forward (line 39) | def forward(self, x, token_type_ids=None, position_ids=None):
  class BertSelfAttention (line 56) | class BertSelfAttention(nn.Layer):
    method __init__ (line 57) | def __init__(self,
    method forward (line 80) | def forward(self, x, attention_mask, head_mask=None):
  class BertAttention (line 119) | class BertAttention(nn.Layer):
    method __init__ (line 120) | def __init__(self,
    method forward (line 134) | def forward(self, x, attention_mask, head_mask=None):
  class BertFeedForward (line 145) | class BertFeedForward(nn.Layer):
    method __init__ (line 146) | def __init__(self,
    method forward (line 161) | def forward(self, x):
  class BertLayer (line 170) | class BertLayer(nn.Layer):
    method __init__ (line 171) | def __init__(self,
    method forward (line 188) | def forward(self, x, attention_mask, head_mask=None):
  class BertEncoder (line 197) | class BertEncoder(nn.Layer):
    method __init__ (line 198) | def __init__(self,
    method forward (line 217) | def forward(self, x, attention_mask, head_mask=None):
  class BertPooler (line 239) | class BertPooler(nn.Layer):
    method __init__ (line 240) | def __init__(self, hidden_size):
    method forward (line 245) | def forward(self, x):
  class METROEncoder (line 252) | class METROEncoder(nn.Layer):
    method __init__ (line 253) | def __init__(self,
    method init_weights (line 290) | def init_weights(self, module):
    method forward (line 305) | def forward(self, x):
  function gelu (line 338) | def gelu(x):
  class TransEncoder (line 346) | class TransEncoder(nn.Layer):
    method __init__ (line 347) | def __init__(self,
    method forward (line 379) | def forward(self, x):

FILE: ppdet/modeling/backbones/transformer_utils.py
  function drop_path (line 28) | def drop_path(x, drop_prob=0., training=False):
  class DropPath (line 44) | class DropPath(nn.Layer):
    method __init__ (line 45) | def __init__(self, drop_prob=None):
    method forward (line 49) | def forward(self, x):
  class Identity (line 53) | class Identity(nn.Layer):
    method __init__ (line 54) | def __init__(self):
    method forward (line 57) | def forward(self, input):
  function to_2tuple (line 64) | def to_2tuple(x):
  function add_parameter (line 70) | def add_parameter(layer, datas, name=None):
  function window_partition (line 78) | def window_partition(x, window_size):
  function window_unpartition (line 106) | def window_unpartition(x, pad_hw, num_hw, hw):

FILE: ppdet/modeling/backbones/vgg.py
  class ConvBlock (line 16) | class ConvBlock(nn.Layer):
    method __init__ (line 17) | def __init__(self,
    method forward (line 52) | def forward(self, inputs):
  class ExtraBlock (line 62) | class ExtraBlock(nn.Layer):
    method __init__ (line 63) | def __init__(self,
    method forward (line 86) | def forward(self, inputs):
  class L2NormScale (line 94) | class L2NormScale(nn.Layer):
    method __init__ (line 95) | def __init__(self, num_channels, scale=1.0):
    method forward (line 101) | def forward(self, inputs):
  class VGG (line 111) | class VGG(nn.Layer):
    method __init__ (line 112) | def __init__(self,
    method forward (line 178) | def forward(self, inputs):
    method out_shape (line 209) | def out_shape(self):

FILE: ppdet/modeling/backbones/vision_transformer.py
  class Mlp (line 28) | class Mlp(nn.Layer):
    method __init__ (line 29) | def __init__(self,
    method forward (line 43) | def forward(self, x):
  class Attention (line 52) | class Attention(nn.Layer):
    method __init__ (line 53) | def __init__(self,
    method forward (line 123) | def forward(self, x, rel_pos_bias=None):
  class Block (line 159) | class Block(nn.Layer):
    method __init__ (line 160) | def __init__(self,
    method forward (line 200) | def forward(self, x, rel_pos_bias=None):
  class PatchEmbed (line 214) | class PatchEmbed(nn.Layer):
    method __init__ (line 218) | def __init__(self,
    method num_patches_in_h (line 238) | def num_patches_in_h(self):
    method num_patches_in_w (line 242) | def num_patches_in_w(self):
    method forward (line 245) | def forward(self, x, mask=None):
  class RelativePositionBias (line 250) | class RelativePositionBias(nn.Layer):
    method __init__ (line 251) | def __init__(self, window_size, num_heads):
    method forward (line 285) | def forward(self):
  function get_sinusoid_encoding_table (line 293) | def get_sinusoid_encoding_table(n_position, d_hid, token=False):
  class VisionTransformer (line 315) | class VisionTransformer(nn.Layer):
    method __init__ (line 319) | def __init__(self,
    method init_weight (line 434) | def init_weight(self):
    method init_fpn (line 467) | def init_fpn(self, embed_dim=768, patch_size=16, out_with_norm=False):
    method interpolate_pos_encoding (line 500) | def interpolate_pos_encoding(self, x, w, h):
    method resize_pos_embed (line 537) | def resize_pos_embed(self, pos_embed, old_hw, new_hw):
    method build_2d_sincos_position_embedding (line 559) | def build_2d_sincos_position_embedding(
    method forward (line 588) | def forward(self, x):
    method num_layers (line 639) | def num_layers(self):
    method no_weight_decay (line 643) | def no_weight_decay(self):
    method out_shape (line 647) | def out_shape(self):

FILE: ppdet/modeling/backbones/vit_mae.py
  class Mlp (line 33) | class Mlp(nn.Layer):
    method __init__ (line 34) | def __init__(self,
    method _init_weights (line 59) | def _init_weights(self):
    method forward (line 63) | def forward(self, x):
  class Attention (line 69) | class Attention(nn.Layer):
    method __init__ (line 70) | def __init__(self,
    method _init_weights (line 118) | def _init_weights(self):
    method get_rel_pos (line 136) | def get_rel_pos(self, seq_size, rel_pos):
    method add_decomposed_rel_pos (line 161) | def add_decomposed_rel_pos(self, attn, q, h, w):
    method forward (line 183) | def forward(self, x):
  class Block (line 211) | class Block(nn.Layer):
    method __init__ (line 212) | def __init__(self,
    method forward (line 278) | def forward(self, x):
  class PatchEmbed (line 297) | class PatchEmbed(nn.Layer):
    method __init__ (line 301) | def __init__(self,
    method num_patches_in_h (line 319) | def num_patches_in_h(self):
    method num_patches_in_w (line 323) | def num_patches_in_w(self):
    method forward (line 326) | def forward(self, x):
  class VisionTransformer2D (line 333) | class VisionTransformer2D(nn.Layer):
    method __init__ (line 337) | def __init__(self,
    method get_vit_lr_decay_rate (line 454) | def get_vit_lr_decay_rate(self, layer_id, lr_decay_rate):
    method init_weight (line 457) | def init_weight(self):
    method init_fpn (line 490) | def init_fpn(self, embed_dim=768, patch_size=16, out_with_norm=False):
    method resize_pos_embed (line 523) | def resize_pos_embed(self, pos_embed, old_hw, new_hw):
    method get_2d_sincos_position_embedding (line 545) | def get_2d_sincos_position_embedding(self, h, w, temperature=10000.):
    method forward (line 568) | def forward(self, inputs):
    method num_layers (line 596) | def num_layers(self):
    method no_weight_decay (line 600) | def no_weight_decay(self):
    method out_shape (line 604) | def out_shape(self):
  class LayerNorm (line 612) | class LayerNorm(nn.Layer):
    method __init__ (line 622) | def __init__(self, normalized_shape, eps=1e-6):
    method forward (line 629) | def forward(self, x):
  class SimpleFeaturePyramid (line 639) | class SimpleFeaturePyramid(nn.Layer):
    method __init__ (line 640) | def __init__(self,
    method from_config (line 721) | def from_config(cls, cfg, input_shape):
    method out_shape (line 728) | def out_shape(self):
    method forward (line 734) | def forward(self, feats):

FILE: ppdet/modeling/backbones/vitpose.py
  function to_2tuple (line 29) | def to_2tuple(x):
  function drop_path (line 35) | def drop_path(x, drop_prob=0., training=False):
  class DropPath (line 50) | class DropPath(nn.Layer):
    method __init__ (line 54) | def __init__(self, drop_prob=None):
    method forward (line 58) | def forward(self, x):
  class Identity (line 62) | class Identity(nn.Layer):
    method __init__ (line 63) | def __init__(self):
    method forward (line 66) | def forward(self, input):
  class Mlp (line 70) | class Mlp(nn.Layer):
    method __init__ (line 71) | def __init__(self,
    method forward (line 85) | def forward(self, x):
  class Attention (line 94) | class Attention(nn.Layer):
    method __init__ (line 95) | def __init__(self,
    method forward (line 113) | def forward(self, x):
  class Block (line 132) | class Block(nn.Layer):
    method __init__ (line 133) | def __init__(self,
    method forward (line 175) | def forward(self, x):
  class PatchEmbed (line 182) | class PatchEmbed(nn.Layer):
    method __init__ (line 186) | def __init__(self,
    method forward (line 209) | def forward(self, x):
  class ViT (line 220) | class ViT(nn.Layer):
    method __init__ (line 233) | def __init__(self,
    method _init_weights (line 289) | def _init_weights(self):
    method forward_features (line 304) | def forward_features(self, x):

FILE: ppdet/modeling/bbox_utils.py
  function bbox2delta (line 20) | def bbox2delta(src_boxes, tgt_boxes, weights=[1.0, 1.0, 1.0, 1.0]):
  function delta2bbox (line 43) | def delta2bbox(deltas, boxes, weights=[1.0, 1.0, 1.0, 1.0], max_shape=No...
  function bbox2delta_v2 (line 84) | def bbox2delta_v2(src_boxes,
  function delta2bbox_v2 (line 112) | def delta2bbox_v2(deltas,
  function expand_bbox (line 169) | def expand_bbox(bboxes, scale):
  function clip_bbox (line 187) | def clip_bbox(boxes, im_shape):
  function nonempty_bbox (line 196) | def nonempty_bbox(boxes, min_size=0, return_mask=False):
  function bbox_area (line 206) | def bbox_area(boxes):
  function bbox_overlaps (line 210) | def bbox_overlaps(boxes1, boxes2):
  function batch_bbox_overlaps (line 242) | def batch_bbox_overlaps(bboxes1,
  function xywh2xyxy (line 336) | def xywh2xyxy(box):
  function make_grid (line 345) | def make_grid(h, w, dtype):
  function decode_yolo (line 350) | def decode_yolo(box, anchor, downsample_ratio):
  function batch_iou_similarity (line 376) | def batch_iou_similarity(box1, box2, eps=1e-9):
  function bbox_iou (line 399) | def bbox_iou(box1, box2, giou=False, diou=False, ciou=False, eps=1e-9):
  function bbox_iou_np_expand (line 457) | def bbox_iou_np_expand(box1, box2, x1y1x2y2=True, eps=1e-16):
  function bbox2distance (line 506) | def bbox2distance(points, bbox, max_dis=None, eps=0.1):
  function distance2bbox (line 528) | def distance2bbox(points, distance, max_shape=None):
  function bbox_center (line 550) | def bbox_center(boxes):
  function batch_distance2bbox (line 562) | def batch_distance2bbox(points, distance, max_shapes=None):
  function iou_similarity (line 587) | def iou_similarity(box1, box2, eps=1e-10):

FILE: ppdet/modeling/clrnet_utils.py
  class ConvModule (line 8) | class ConvModule(nn.Layer):
    method __init__ (line 9) | def __init__(self,
    method forward (line 43) | def forward(self, inputs):
  function LinearModule (line 52) | def LinearModule(hidden_dim):
  class FeatureResize (line 58) | class FeatureResize(nn.Layer):
    method __init__ (line 59) | def __init__(self, size=(10, 25)):
    method forward (line 63) | def forward(self, x):
  class ROIGather (line 68) | class ROIGather(nn.Layer):
    method __init__ (line 79) | def __init__(self,
    method roi_fea (line 148) | def roi_fea(self, x, layer_index):
    method forward (line 157) | def forward(self, roi_features, x, layer_index):
  class SegDecoder (line 205) | class SegDecoder(nn.Layer):
    method __init__ (line 210) | def __init__(self,
    method forward (line 222) | def forward(self, x):
  function accuracy (line 236) | def accuracy(pred, target, topk=1, thresh=None):
  class Accuracy (line 285) | class Accuracy(nn.Layer):
    method __init__ (line 286) | def __init__(self, topk=(1, ), thresh=None):
    method forward (line 299) | def forward(self, pred, target):

FILE: ppdet/modeling/cls_utils.py
  function _get_class_default_kwargs (line 16) | def _get_class_default_kwargs(cls, *args, **kwargs):

FILE: ppdet/modeling/heads/bbox_head.py
  class TwoFCHead (line 34) | class TwoFCHead(nn.Layer):
    method __init__ (line 44) | def __init__(self, in_channel=256, out_channel=1024, resolution=7):
    method from_config (line 63) | def from_config(cls, cfg, input_shape):
    method out_shape (line 69) | def out_shape(self):
    method forward (line 72) | def forward(self, rois_feat):
  class XConvNormHead (line 82) | class XConvNormHead(nn.Layer):
    method __init__ (line 99) | def __init__(self,
    method from_config (line 144) | def from_config(cls, cfg, input_shape):
    method out_shape (line 150) | def out_shape(self):
    method forward (line 153) | def forward(self, rois_feat):
  class BBoxHead (line 162) | class BBoxHead(nn.Layer):
    method __init__ (line 182) | def __init__(self,
    method init_cot_head (line 242) | def init_cot_head(self, relationship):
    method from_config (line 246) | def from_config(cls, cfg, input_shape):
    method forward (line 259) | def forward(self, body_feats=None, rois=None, rois_num=None, inputs=No...
    method get_loss (line 306) | def get_loss(self,
    method bbox_transform (line 403) | def bbox_transform(self, deltas, weights=[0.1, 0.1, 0.2, 0.2]):
    method get_prediction (line 433) | def get_prediction(self, score, delta):
    method get_head (line 437) | def get_head(self, ):
    method get_assigned_targets (line 440) | def get_assigned_targets(self, ):
    method get_assigned_rois (line 443) | def get_assigned_rois(self, ):

FILE: ppdet/modeling/heads/cascade_head.py
  class CascadeTwoFCHead (line 31) | class CascadeTwoFCHead(nn.Layer):
    method __init__ (line 43) | def __init__(self,
    method from_config (line 60) | def from_config(cls, cfg, input_shape):
    method out_shape (line 66) | def out_shape(self):
    method forward (line 69) | def forward(self, rois_feat, stage=0):
  class CascadeXConvNormHead (line 75) | class CascadeXConvNormHead(nn.Layer):
    method __init__ (line 92) | def __init__(self,
    method from_config (line 121) | def from_config(cls, cfg, input_shape):
    method out_shape (line 127) | def out_shape(self):
    method forward (line 130) | def forward(self, rois_feat, stage=0):
  class CascadeHead (line 136) | class CascadeHead(BBoxHead):
    method __init__ (line 154) | def __init__(self,
    method forward (line 218) | def forward(self, body_feats=None, rois=None, rois_num=None, inputs=No...
    method _get_rois_from_boxes (line 294) | def _get_rois_from_boxes(self, boxes, im_shape):
    method _get_pred_bbox (line 307) | def _get_pred_bbox(self, deltas, proposals, weights):
    method get_prediction (line 325) | def get_prediction(self, head_out_list):
    method get_refined_rois (line 336) | def get_refined_rois(self, ):

FILE: ppdet/modeling/heads/centernet_head.py
  class ConvLayer (line 24) | class ConvLayer(nn.Layer):
    method __init__ (line 25) | def __init__(self,
    method forward (line 52) | def forward(self, inputs):
  class CenterNetHead (line 58) | class CenterNetHead(nn.Layer):
    method __init__ (line 74) | def __init__(self,
    method from_config (line 149) | def from_config(cls, cfg, input_shape):
    method forward (line 154) | def forward(self, feat, inputs):
    method get_loss (line 169) | def get_loss(self, inputs, weights, head_outs):

FILE: ppdet/modeling/heads/centertrack_head.py
  class CenterTrackHead (line 27) | class CenterTrackHead(nn.Layer):
    method __init__ (line 40) | def __init__(self,
    method from_config (line 84) | def from_config(cls, cfg, input_shape):
    method forward (line 89) | def forward(self,
    method get_loss (line 111) | def get_loss(self, inputs, weights, head_outs):
    method generic_decode (line 167) | def generic_decode(self, head_outs, bboxes, bbox_inds, topk_ys, topk_xs):
    method centertrack_post_process (line 195) | def centertrack_post_process(self, dets, meta, out_thresh):
  function transform_preds_with_trans (line 233) | def transform_preds_with_trans(coords, trans):
  function _tranpose_and_gather_feat (line 240) | def _tranpose_and_gather_feat(feat, bbox_inds):

FILE: ppdet/modeling/heads/clrnet_head.py
  class CLRHead (line 17) | class CLRHead(nn.Layer):
    method __init__ (line 24) | def __init__(self,
    method init_weights (line 98) | def init_weights(self):
    method pool_prior_features (line 104) | def pool_prior_features(self, batch_features, num_priors, prior_xs):
    method generate_priors_from_embeddings (line 128) | def generate_priors_from_embeddings(self):
    method _init_prior_embeddings (line 146) | def _init_prior_embeddings(self):
    method forward (line 175) | def forward(self, x, inputs=None):
    method predictions_to_pred (line 271) | def predictions_to_pred(self, predictions):
    method lane_nms (line 317) | def lane_nms(self, predictions, scores, nms_overlap_thresh, top_k):
    method get_lanes (line 357) | def get_lanes(self, output, as_lanes=True):

FILE: ppdet/modeling/heads/detr_head.py
  class MLP (line 30) | class MLP(nn.Layer):
    method __init__ (line 35) | def __init__(self, input_dim, hidden_dim, output_dim, num_layers):
    method _reset_parameters (line 44) | def _reset_parameters(self):
    method forward (line 48) | def forward(self, x):
  class MultiHeadAttentionMap (line 54) | class MultiHeadAttentionMap(nn.Layer):
    method __init__ (line 61) | def __init__(self, query_dim, hidden_dim, num_heads, dropout=0.0,
    method forward (line 83) | def forward(self, q, k, mask=None):
  class MaskHeadFPNConv (line 104) | class MaskHeadFPNConv(nn.Layer):
    method __init__ (line 112) | def __init__(self, input_dim, fpn_dims, context_dim, num_groups=8):
    method _make_layers (line 148) | def _make_layers(self,
    method forward (line 166) | def forward(self, x, bbox_attention_map, fpns):
  class DETRHead (line 185) | class DETRHead(nn.Layer):
    method __init__ (line 189) | def __init__(self,
    method _reset_parameters (line 218) | def _reset_parameters(self):
    method from_config (line 222) | def from_config(cls, cfg, hidden_dim, nhead, input_shape):
    method get_gt_mask_from_polygons (line 231) | def get_gt_mask_from_polygons(gt_poly, pad_mask):
    method forward (line 248) | def forward(self, out_transformer, body_feats, inputs=None):
  class DeformableDETRHead (line 292) | class DeformableDETRHead(nn.Layer):
    method __init__ (line 296) | def __init__(self,
    method _reset_parameters (line 316) | def _reset_parameters(self):
    method from_config (line 327) | def from_config(cls, cfg, hidden_dim, nhead, input_shape):
    method forward (line 330) | def forward(self, out_transformer, body_feats, inputs=None):
  class DINOHead (line 368) | class DINOHead(nn.Layer):
    method __init__ (line 371) | def __init__(self, loss='DINOLoss', eval_idx=-1):
    method forward (line 376) | def forward(self, out_transformer, body_feats, inputs=None):
  class MaskDINOHead (line 468) | class MaskDINOHead(nn.Layer):
    method __init__ (line 471) | def __init__(self, loss='DINOLoss'):
    method forward (line 475) | def forward(self, out_transformer, body_feats, inputs=None):
  class DINOv3Head (line 542) | class DINOv3Head(nn.Layer):
    method __init__ (line 547) | def __init__(self, loss='DINOLoss', eval_idx=-1, o2m=4, o2m_branch=Fal...
    method forward (line 555) | def forward(self, out_transformer, body_feats, inputs=None):

FILE: ppdet/modeling/heads/face_head.py
  class FaceHead (line 24) | class FaceHead(nn.Layer):
    method __init__ (line 40) | def __init__(self,
    method from_config (line 83) | def from_config(cls, cfg, input_shape):
    method forward (line 86) | def forward(self, feats, image, gt_bbox=None, gt_class=None):
    method get_loss (line 110) | def get_loss(self, boxes, scores, gt_bbox, gt_class, prior_boxes):

FILE: ppdet/modeling/heads/fcos_head.py
  class ScaleReg (line 32) | class ScaleReg(nn.Layer):
    method __init__ (line 37) | def __init__(self):
    method forward (line 44) | def forward(self, inputs):
  class FCOSFeat (line 50) | class FCOSFeat(nn.Layer):
    method __init__ (line 62) | def __init__(self,
    method forward (line 106) | def forward(self, fpn_feat):
  class FCOSHead (line 116) | class FCOSHead(nn.Layer):
    method __init__ (line 134) | def __init__(self,
    method _compute_locations_by_level (line 211) | def _compute_locations_by_level(self, fpn_stride, feature, num_shift=0...
    method forward (line 234) | def forward(self, fpn_feats, targets=None):
    method get_loss (line 297) | def get_loss(self, fcos_head_outs, targets):
    method _post_process_by_level (line 317) | def _post_process_by_level(self,
    method post_process (line 342) | def post_process(self, fcos_head_outs, scale_factor):
  class FCOSHead_ARSL (line 367) | class FCOSHead_ARSL(FCOSHead):
    method __init__ (line 384) | def __init__(self,
    method forward (line 460) | def forward(self, fpn_feats, targets=None):
    method get_loss (line 496) | def get_loss(self, fcos_head_outs, tag_labels, tag_bboxes, tag_centern...

FILE: ppdet/modeling/heads/fcosr_head.py
  function trunc_div (line 32) | def trunc_div(a, b):
  function fmod (line 41) | def fmod(a, b):
  function fmod_eval (line 45) | def fmod_eval(a, b):
  class ConvBNLayer (line 49) | class ConvBNLayer(nn.Layer):
    method __init__ (line 50) | def __init__(self,
    method forward (line 87) | def forward(self, x):
  class FCOSRHead (line 96) | class FCOSRHead(nn.Layer):
    method __init__ (line 102) | def __init__(self,
    method _init_weights (line 170) | def _init_weights(self):
    method from_config (line 183) | def from_config(cls, cfg, input_shape):
    method _generate_anchors (line 186) | def _generate_anchors(self, feats):
    method forward (line 225) | def forward(self, feats, target=None):
    method forward_train (line 231) | def forward_train(self, feats, target=None):
    method forward_eval (line 262) | def forward_eval(self, feats, target=None):
    method _bbox_decode (line 291) | def _bbox_decode(self, points, reg_pred_list):
    method _box2corners (line 296) | def _box2corners(self, pred_bboxes):
    method get_loss (line 319) | def get_loss(self, head_outs, gt_meta):
    method _qfocal_loss (line 375) | def _qfocal_loss(score, label, gamma=2.0, reduction='sum'):
    method post_process (line 381) | def post_process(self, head_outs, scale_factor):

FILE: ppdet/modeling/heads/gfl_head.py
  class ScaleReg (line 37) | class ScaleReg(nn.Layer):
    method __init__ (line 42) | def __init__(self):
    method forward (line 49) | def forward(self, inputs):
  class Integral (line 54) | class Integral(nn.Layer):
    method __init__ (line 65) | def __init__(self, reg_max=16):
    method forward (line 71) | def forward(self, x):
  class DGQP (line 89) | class DGQP(nn.Layer):
    method __init__ (line 97) | def __init__(self, reg_topk=4, reg_channels=64, add_mean=True):
    method forward (line 124) | def forward(self, x):
  class GFLHead (line 149) | class GFLHead(nn.Layer):
    method __init__ (line 168) | def __init__(self,
    method forward (line 239) | def forward(self, fpn_feats):
    method _images_to_levels (line 276) | def _images_to_levels(self, target, num_level_anchors):
    method _grid_cells_to_center (line 288) | def _grid_cells_to_center(self, grid_cells):
    method get_loss (line 300) | def get_loss(self, gfl_head_outs, gt_meta):
    method get_single_level_center_point (line 413) | def get_single_level_center_point(self, featmap_size, stride,
    method post_process (line 431) | def post_process(self, gfl_head_outs, im_shape, scale_factor):
  class LDGFLHead (line 444) | class LDGFLHead(GFLHead):
    method __init__ (line 464) | def __init__(self,
    method forward (line 500) | def forward(self, fpn_feats):
    method get_loss (line 538) | def get_loss(self, gfl_head_outs, gt_meta, soft_label_list,

FILE: ppdet/modeling/heads/keypoint_hrhrnet_head.py
  class HrHRNetHead (line 24) | class HrHRNetHead(nn.Layer):
    method __init__ (line 27) | def __init__(self, num_joints, loss='HrHRNetLoss', swahr=False, width=...
    method forward (line 88) | def forward(self, feats, targets=None):

FILE: ppdet/modeling/heads/mask_head.py
  class MaskFeat (line 27) | class MaskFeat(nn.Layer):
    method __init__ (line 39) | def __init__(self,
    method from_config (line 93) | def from_config(cls, cfg, input_shape):
    method out_channels (line 98) | def out_channels(self):
    method forward (line 101) | def forward(self, feats):
  class MaskHead (line 106) | class MaskHead(nn.Layer):
    method __init__ (line 122) | def __init__(self,
    method from_config (line 151) | def from_config(cls, cfg, input_shape):
    method get_loss (line 163) | def get_loss(self, mask_logits, mask_label, mask_target, mask_weight):
    method forward_train (line 177) | def forward_train(self, body_feats, rois, rois_num, inputs, targets,
    method forward_test (line 200) | def forward_test(self,
    method forward (line 236) | def forward(self,

FILE: ppdet/modeling/heads/petr_head.py
  function bias_init_with_prob (line 34) | def bias_init_with_prob(prior_prob: float) -> float:
  function multi_apply (line 40) | def multi_apply(func, *args, **kwargs):
  function reduce_mean (line 63) | def reduce_mean(tensor):
  function gaussian_radius (line 76) | def gaussian_radius(det_size, min_overlap=0.7):
  function gaussian2D (line 101) | def gaussian2D(shape, sigma=1):
  function draw_umich_gaussian (line 112) | def draw_umich_gaussian(heatmap, center, radius, k=1):
  class PETRHead (line 136) | class PETRHead(nn.Layer):
    method __init__ (line 175) | def __init__(self,
    method _init_layers (line 236) | def _init_layers(self):
    method init_weights (line 280) | def init_weights(self):
    method forward (line 298) | def forward(self, mlvl_feats, img_metas):
    method forward_refine (line 389) | def forward_refine(self, memory, mlvl_masks, refine_targets, losses,
    method forward_train (line 500) | def forward_train(self,
    method loss (line 550) | def loss(self,
    method loss_heatmap (line 649) | def loss_heatmap(self, hm_pred, hm_mask, gt_keypoints, gt_labels,
    method loss_single (line 691) | def loss_single(self, cls_scores, kpt_preds, gt_labels_list,
    method get_targets (line 791) | def get_targets(self, cls_scores_list, kpt_preds_list, gt_labels_list,
    method _get_target_single (line 839) | def _get_target_single(self, cls_score, kpt_pred, gt_labels, gt_keypoi...
    method loss_single_rpn (line 925) | def loss_single_rpn(self, cls_scores, kpt_preds, gt_labels_list,
    method get_bboxes (line 992) | def get_bboxes(self,
    method _get_bboxes_single (line 1050) | def _get_bboxes_single(self,
    method simple_test (line 1136) | def simple_test(self, feats, img_metas, rescale=False):
    method get_loss (line 1160) | def get_loss(self, boxes, scores, gt_bbox, gt_class, prior_boxes):

FILE: ppdet/modeling/heads/pico_head.py
  function npu_avg_pool2d (line 42) | def npu_avg_pool2d(feat, w, h):
  class PicoSE (line 50) | class PicoSE(nn.Layer):
    method __init__ (line 51) | def __init__(self, feat_channels):
    method _init_weights (line 58) | def _init_weights(self):
    method forward (line 61) | def forward(self, feat, avg_feat):
  class PicoFeat (line 68) | class PicoFeat(nn.Layer):
    method __init__ (line 82) | def __init__(self,
    method act_func (line 167) | def act_func(self, x):
    method forward (line 176) | def forward(self, fpn_feat, stage_idx):
  class PicoHead (line 196) | class PicoHead(OTAVFLHead):
    method __init__ (line 217) | def __init__(self,
    method forward (line 310) | def forward(self, fpn_feats, export_post_process=True):
    method forward_train (line 321) | def forward_train(self, fpn_feats):
    method forward_eval (line 344) | def forward_eval(self, fpn_feats, export_post_process=True):
    method _generate_anchors (line 394) | def _generate_anchors(self, feats=None):
    method post_process (line 418) | def post_process(self,
  class PicoHeadV2 (line 444) | class PicoHeadV2(GFLHead):
    method __init__ (line 465) | def __init__(self,
    method forward (line 572) | def forward(self, fpn_feats, export_post_process=True):
    method forward_train (line 583) | def forward_train(self, fpn_feats):
    method forward_eval (line 620) | def forward_eval(self, fpn_feats, export_post_process=True):
    method get_loss (line 666) | def get_loss(self, head_outs, gt_meta):
    method _generate_anchors (line 773) | def _generate_anchors(self, feats=None):
    method post_process (line 797) | def post_process(self,

FILE: ppdet/modeling/heads/ppyoloe_contrast_head.py
  class PPYOLOEContrastHead (line 28) | class PPYOLOEContrastHead(PPYOLOEHead):
    method __init__ (line 35) | def __init__(self,
    method _init_contrast_encoder (line 76) | def _init_contrast_encoder(self):
    method forward_train (line 82) | def forward_train(self, feats, targets, aux_pred=None):
    method get_loss (line 112) | def get_loss(self, head_outs, gt_meta):

FILE: ppdet/modeling/heads/ppyoloe_head.py
  class ESEAttn (line 34) | class ESEAttn(nn.Layer):
    method __init__ (line 35) | def __init__(self, feat_channels, act='swish', attn_conv='convbn'):
    method _init_weights (line 46) | def _init_weights(self):
    method forward (line 49) | def forward(self, feat, avg_feat):
  class PPYOLOEHead (line 58) | class PPYOLOEHead(nn.Layer):
    method __init__ (line 65) | def __init__(self,
    method from_config (line 150) | def from_config(cls, cfg, input_shape):
    method _init_weights (line 153) | def _init_weights(self):
    method m_avg_pool2d (line 171) | def m_avg_pool2d(self, feat, w, h):
    method forward_train (line 179) | def forward_train(self, feats, targets, aux_pred=None):
    method _generate_anchors (line 214) | def _generate_anchors(self, feats=None, dtype='float32'):
    method forward_eval (line 236) | def forward_eval(self, feats):
    method forward (line 273) | def forward(self, feats, targets=None, aux_pred=None):
    method _focal_loss (line 291) | def _focal_loss(score, label, alpha=0.25, gamma=2.0):
    method _varifocal_loss (line 301) | def _varifocal_loss(pred_score, gt_score, label, alpha=0.75, gamma=2.0):
    method _bbox_decode (line 307) | def _bbox_decode(self, anchor_points, pred_dist):
    method _bbox_decode_fake (line 313) | def _bbox_decode_fake(self, pred_dist):
    method _bbox2distance (line 321) | def _bbox2distance(self, points, bbox):
    method _df_loss (line 328) | def _df_loss(self, pred_dist, target, lower_bound=0):
    method _bbox_loss (line 341) | def _bbox_loss(self, pred_dist, pred_bboxes, anchor_points, assigned_l...
    method get_loss (line 389) | def get_loss(self, head_outs, gt_meta, aux_pred=None):
    method get_loss_from_assign (line 488) | def get_loss_from_assign(self, pred_scores, pred_distri, pred_bboxes,
    method post_process (line 532) | def post_process(self, head_outs, scale_factor):
  function get_activation (line 556) | def get_activation(name="LeakyReLU"):
  class ConvNormLayer (line 570) | class ConvNormLayer(nn.Layer):
    method __init__ (line 571) | def __init__(self,
    method forward (line 603) | def forward(self, x):
  class ScaleReg (line 611) | class ScaleReg(nn.Layer):
    method __init__ (line 616) | def __init__(self, scale=1.0):
    method forward (line 624) | def forward(self, x):
  class SimpleConvHead (line 629) | class SimpleConvHead(nn.Layer):
    method __init__ (line 632) | def __init__(self,
    method forward (line 697) | def forward(self, feats):

FILE: ppdet/modeling/heads/ppyoloe_ins_head.py
  function custom_binary_cross_entropy_with_logits (line 33) | def custom_binary_cross_entropy_with_logits(x, y):
  class MaskProto (line 40) | class MaskProto(nn.Layer):
    method __init__ (line 42) | def __init__(self, ch_in, num_protos=256, num_masks=32, act='silu'):
    method forward (line 54) | def forward(self, x):
  function xyxy2xywh (line 58) | def xyxy2xywh(x):
  function crop_mask (line 74) | def crop_mask(masks, boxes):
  function process_mask_upsample (line 99) | def process_mask_upsample(protos, masks_in, bboxes, shape):
  class PPYOLOEInsHead (line 124) | class PPYOLOEInsHead(nn.Layer):
    method __init__ (line 131) | def __init__(self,
    method from_config (line 232) | def from_config(cls, cfg, input_shape):
    method _init_weights (line 237) | def _init_weights(self):
    method forward_train (line 255) | def forward_train(self, feats, targets):
    method _generate_anchors (line 293) | def _generate_anchors(self, feats=None, dtype='float32'):
    method forward_eval (line 315) | def forward_eval(self, feats):
    method forward (line 365) | def forward(self, feats, targets=None):
    method _focal_loss (line 374) | def _focal_loss(score, label, alpha=0.25, gamma=2.0):
    method _varifocal_loss (line 386) | def _varifocal_loss(pred_score, gt_score, label, alpha=0.75, gamma=2.0):
    method _bbox_decode (line 394) | def _bbox_decode(self, anchor_points, pred_dist):
    method _bbox_decode_fake (line 401) | def _bbox_decode_fake(self, pred_dist):
    method _bbox2distance (line 409) | def _bbox2distance(self, points, bbox):
    method _df_loss (line 428) | def _df_loss(self, pred_dist, target, lower_bound=0):
    method get_loss (line 441) | def get_loss(self, head_outs, gt_meta):
    method get_loss_from_assign (line 496) | def get_loss_from_assign(self, pred_scores, pred_distri, pred_bboxes,
    method calculate_segmentation_loss (line 588) | def calculate_segmentation_loss(self,
    method single_mask_loss (line 651) | def single_mask_loss(gt_mask, pred, proto, xyxy, area):
    method post_process (line 683) | def post_process(self,

FILE: ppdet/modeling/heads/ppyoloe_r_head.py
  class ESEAttn (line 29) | class ESEAttn(nn.Layer):
    method __init__ (line 30) | def __init__(self, feat_channels, act='swish'):
    method _init_weights (line 37) | def _init_weights(self):
    method forward (line 40) | def forward(self, feat, avg_feat):
  class PPYOLOERHead (line 46) | class PPYOLOERHead(nn.Layer):
    method __init__ (line 50) | def __init__(self,
    method from_config (line 115) | def from_config(cls, cfg, input_shape):
    method _init_weights (line 118) | def _init_weights(self):
    method _generate_anchors (line 136) | def _generate_anchors(self, feats):
    method forward (line 175) | def forward(self, feats, targets=None):
    method forward_train (line 184) | def forward_train(self, feats, targets):
    method forward_eval (line 209) | def forward_eval(self, feats):
    method _bbox_decode (line 239) | def _bbox_decode(self, points, pred_dist, pred_angle, stride_tensor):
    method get_loss (line 249) | def get_loss(self, head_outs, gt_meta):
    method _focal_loss (line 321) | def _focal_loss(score, label, alpha=0.25, gamma=2.0):
    method _varifocal_loss (line 331) | def _varifocal_loss(pred_score, gt_score, label, alpha=0.75, gamma=2.0):
    method _df_loss (line 338) | def _df_loss(pred_dist, target):
    method _bbox_loss (line 349) | def _bbox_loss(self, pred_angle, pred_bboxes, anchor_points,
    method _box2corners (line 385) | def _box2corners(self, pred_bboxes):
    method post_process (line 408) | def post_process(self, head_outs, scale_factor):

FILE: ppdet/modeling/heads/retina_head.py
  class RetinaFeat (line 34) | class RetinaFeat(FCOSFeat):
  class RetinaHead (line 42) | class RetinaHead(nn.Layer):
    method __init__ (line 51) | def __init__(self,
    method forward (line 94) | def forward(self, neck_feats, targets=None):
    method get_loss (line 109) | def get_loss(self, head_outputs, targets):
    method get_bboxes_single (line 192) | def get_bboxes_single(self,
    method decode (line 224) | def decode(self, anchors, cls_logits, bboxes_reg, im_shape, scale_fact...
    method post_process (line 240) | def post_process(self, head_outputs, im_shape, scale_factor):
    method get_scores_single (line 252) | def get_scores_single(self, cls_scores_list):
    method decode_cls_logits (line 268) | def decode_cls_logits(self, cls_logits_list):

FILE: ppdet/modeling/heads/roi_extractor.py
  function _to_list (line 21) | def _to_list(v):
  class RoIAlign (line 28) | class RoIAlign(nn.Layer):
    method __init__ (line 54) | def __init__(self,
    method from_config (line 74) | def from_config(cls, cfg, input_shape):
    method forward (line 77) | def forward(self, feats, roi, rois_num):

FILE: ppdet/modeling/heads/s2anet_head.py
  class S2ANetHead (line 31) | class S2ANetHead(nn.Layer):
    method __init__ (line 52) | def __init__(self,
    method forward (line 245) | def forward(self, feats, targets=None):
    method get_bboxes (line 325) | def get_bboxes(self, head_outs):
    method get_pred (line 341) | def get_pred(self, bboxes, bbox_num, im_shape, scale_factor):
    method get_bboxes_single (line 399) | def get_bboxes_single(self, cls_score_list, bbox_pred_list):
    method smooth_l1_loss (line 436) | def smooth_l1_loss(self, pred, label, delta=1.0 / 9.0):
    method get_fam_loss (line 451) | def get_fam_loss(self, fam_target, s2anet_head_out, reg_loss_type='l1'):
    method get_odm_loss (line 532) | def get_odm_loss(self, odm_target, s2anet_head_out, reg_loss_type='l1'):
    method get_loss (line 615) | def get_loss(self, head_outs, inputs):
    method bbox_decode (line 680) | def bbox_decode(self, preds, anchors, wh_ratio_clip=1e-6):
    method rbox2poly (line 709) | def rbox2poly(self, rboxes):

FILE: ppdet/modeling/heads/simota_head.py
  class OTAHead (line 40) | class OTAHead(GFLHead):
    method __init__ (line 61) | def __init__(self,
    method _get_target_single (line 107) | def _get_target_single(self, flatten_cls_pred, flatten_center_and_stride,
    method get_loss (line 117) | def get_loss(self, head_outs, gt_meta):
  class OTAVFLHead (line 283) | class OTAVFLHead(OTAHead):
    method __init__ (line 290) | def __init__(self,
    method get_loss (line 336) | def get_loss(self, head_outs, gt_meta):

FILE: ppdet/modeling/heads/solov2_head.py
  class SOLOv2MaskHead (line 35) | class SOLOv2MaskHead(nn.Layer):
    method __init__ (line 50) | def __init__(self,
    method forward (line 119) | def forward(self, inputs):
  class SOLOv2Head (line 154) | class SOLOv2Head(nn.Layer):
    method __init__ (line 174) | def __init__(self,
    method _points_nms (line 261) | def _points_nms(self, heat, kernel_size=2):
    method _split_feats (line 266) | def _split_feats(self, feats):
    method forward (line 279) | def forward(self, input):
    method _get_output_single (line 299) | def _get_output_single(self, input, idx):
    method get_loss (line 344) | def get_loss(self, cate_preds, kernel_preds, ins_pred, ins_labels,
    method get_prediction (line 409) | def get_prediction(self, cate_preds, kernel_preds, seg_pred, im_shape,
    method get_seg_single (line 455) | def get_seg_single(self, cate_preds, seg_preds, kernel_preds, featmap_...

FILE: ppdet/modeling/heads/sparse_roi_head.py
  class DynamicConv (line 36) | class DynamicConv(nn.Layer):
    method __init__ (line 37) | def __init__(self,
    method forward (line 65) | def forward(self, param_feature, input_feature):
  class FFN (line 93) | class FFN(nn.Layer):
    method __init__ (line 94) | def __init__(self,
    method forward (line 116) | def forward(self, x):
  class DynamicMaskHead (line 126) | class DynamicMaskHead(nn.Layer):
    method __init__ (line 129) | def __init__(self,
    method _init_weights (line 184) | def _init_weights(self):
    method forward (line 191) | def forward(self, roi_features, attn_features):
  class DIIHead (line 209) | class DIIHead(nn.Layer):
    method __init__ (line 212) | def __init__(self,
    method _init_weights (line 263) | def _init_weights(self):
    method forward (line 271) | def forward(self, roi_features, proposal_features):
    method refine_bboxes (line 306) | def refine_bboxes(proposal_bboxes, bbox_deltas):
  class SparseRoIHead (line 317) | class SparseRoIHead(nn.Layer):
    method __init__ (line 320) | def __init__(self,
    method from_config (line 346) | def from_config(cls, cfg, input_shape):
    method get_roi_features (line 362) | def get_roi_features(features, bboxes, roi_extractor):
    method _forward_train (line 376) | def _forward_train(self, body_feats, pro_bboxes, pro_feats, targets):
    method _forward_test (line 436) | def _forward_test(self, body_feats, pro_bboxes, pro_feats):
    method forward (line 457) | def forward(self,

FILE: ppdet/modeling/heads/sparsercnn_head.py
  class DynamicConv (line 37) | class DynamicConv(nn.Layer):
    method __init__ (line 38) | def __init__(
    method forward (line 62) | def forward(self, pro_features, roi_features):
  class RCNNHead (line 91) | class RCNNHead(nn.Layer):
    method __init__ (line 92) | def __init__(
    method forward (line 151) | def forward(self, features, bboxes, pro_features, pooler):
  class SparseRCNNHead (line 208) | class SparseRCNNHead(nn.Layer):
    method __init__ (line 228) | def __init__(
    method _reset_parameters (line 280) | def _reset_parameters(self):
    method _init_box_pooler (line 302) | def _init_box_pooler(input_shape):
    method forward (line 331) | def forward(self, features, input_whwh):
    method get_loss (line 366) | def get_loss(self, outputs, targets):
  function box_cxcywh_to_xyxy (line 377) | def box_cxcywh_to_xyxy(x):

FILE: ppdet/modeling/heads/ssd_head.py
  class SepConvLayer (line 26) | class SepConvLayer(nn.Layer):
    method __init__ (line 27) | def __init__(self,
    method forward (line 58) | def forward(self, x):
  class SSDExtraHead (line 65) | class SSDExtraHead(nn.Layer):
    method __init__ (line 66) | def __init__(self,
    method _make_layers (line 81) | def _make_layers(self, c_in, c_hidden, c_out, stride_3x3, padding_3x3):
    method forward (line 87) | def forward(self, x):
  class SSDHead (line 95) | class SSDHead(nn.Layer):
    method __init__ (line 114) | def __init__(self,
    method from_config (line 184) | def from_config(cls, cfg, input_shape):
    method forward (line 187) | def forward(self, feats, image, gt_bbox=None, gt_class=None):
    method get_loss (line 215) | def get_loss(self, boxes, scores, gt_bbox, gt_class, prior_boxes):

FILE: ppdet/modeling/heads/tood_head.py
  class ScaleReg (line 34) | class ScaleReg(nn.Layer):
    method __init__ (line 39) | def __init__(self, init_scale=1.):
    method forward (line 46) | def forward(self, inputs):
  class TaskDecomposition (line 51) | class TaskDecomposition(nn.Layer):
    method __init__ (line 56) | def __init__(
    method _init_weights (line 84) | def _init_weights(self):
    method forward (line 88) | def forward(self, feat, avg_feat):
  class TOODHead (line 103) | class TOODHead(nn.Layer):
    method __init__ (line 110) | def __init__(self,
    method from_config (line 189) | def from_config(cls, cfg, input_shape):
    method _init_weights (line 195) | def _init_weights(self):
    method _reg_grid_sample (line 209) | def _reg_grid_sample(self, feat, offset, anchor_points):
    method forward (line 223) | def forward(self, feats):
    method _focal_loss (line 285) | def _focal_loss(score, label, alpha=0.25, gamma=2.0):
    method get_loss (line 294) | def get_loss(self, head_outs, gt_meta):
    method post_process (line 359) | def post_process(self, head_outs, img_shape, scale_factor):

FILE: ppdet/modeling/heads/ttf_head.py
  class HMHead (line 27) | class HMHead(nn.Layer):
    method __init__ (line 44) | def __init__(
    method forward (line 100) | def forward(self, feat):
  class WHHead (line 107) | class WHHead(nn.Layer):
    method __init__ (line 122) | def __init__(self,
    method forward (line 174) | def forward(self, feat):
  class TTFHead (line 182) | class TTFHead(nn.Layer):
    method __init__ (line 213) | def __init__(self,
    method from_config (line 242) | def from_config(cls, cfg, input_shape):
    method forward (line 247) | def forward(self, feats):
    method filter_box_by_weight (line 252) | def filter_box_by_weight(self, pred, target, weight):
    method filter_loc_by_weight (line 263) | def filter_loc_by_weight(self, score, weight):
    method get_loss (line 269) | def get_loss(self, pred_hm, pred_wh, target_hm, box_target, target_wei...

FILE: ppdet/modeling/heads/vitpose_head.py
  class TopdownHeatmapSimpleHead (line 33) | class TopdownHeatmapSimpleHead(nn.Layer):
    method __init__ (line 34) | def __init__(self,
    method _get_deconv_cfg (line 128) | def _get_deconv_cfg(deconv_kernel):
    method _init_inputs (line 144) | def _init_inputs(self, in_channels, in_index, input_transform):
    method _transform_inputs (line 165) | def _transform_inputs(self, inputs):
    method forward (line 196) | def forward(self, x):
    method inference_model (line 204) | def inference_model(self, x, flip_pairs=None):
    method _make_deconv_layer (line 227) | def _make_deconv_layer(self, num_layers, num_filters, num_kernels):
    method init_weights (line 259) | def init_weights(self):

FILE: ppdet/modeling/heads/yolo_head.py
  function _de_sigmoid (line 34) | def _de_sigmoid(x, eps=1e-7):
  class YOLOv3Head (line 42) | class YOLOv3Head(nn.Layer):
    method __init__ (line 46) | def __init__(self,
    method parse_anchor (line 101) | def parse_anchor(self, anchors, anchor_masks):
    method forward (line 111) | def forward(self, feats, targets=None):
    method from_config (line 148) | def from_config(cls, cfg, input_shape):
  class YOLOXHead (line 153) | class YOLOXHead(nn.Layer):
    method __init__ (line 157) | def __init__(self,
    method from_config (line 228) | def from_config(cls, cfg, input_shape):
    method _init_weights (line 231) | def _init_weights(self):
    method _generate_anchor_point (line 242) | def _generate_anchor_point(self, feat_sizes, strides, offset=0.):
    method forward (line 261) | def forward(self, feats, targets=None):
    method get_loss (line 308) | def get_loss(self, head_outs, targets):
    method post_process (line 404) | def post_process(self, head_outs, img_shape, scale_factor):

FILE: ppdet/modeling/heads/yolof_head.py
  function reduce_mean (line 33) | def reduce_mean(tensor):
  function find_inside_anchor (line 41) | def find_inside_anchor(feat_size, stride, num_anchors, im_shape):
  class YOLOFFeat (line 54) | class YOLOFFeat(nn.Layer):
    method __init__ (line 55) | def __init__(self,
    method forward (line 111) | def forward(self, fpn_feat):
  class YOLOFHead (line 118) | class YOLOFHead(nn.Layer):
    method __init__ (line 125) | def __init__(self,
    method forward (line 197) | def forward(self, feats, targets=None):
    method get_loss (line 222) | def get_loss(self, head_outs, targets):
    method get_bboxes_single (line 301) | def get_bboxes_single(self,
    method decode (line 340) | def decode(self, anchors, cls_scores, bbox_preds, im_shape, scale_fact...
    method post_process (line 356) | def post_process(self, head_outs, im_shape, scale_factor):

FILE: ppdet/modeling/initializer.py
  function _no_grad_uniform_ (line 41) | def _no_grad_uniform_(tensor, a, b):
  function _no_grad_normal_ (line 49) | def _no_grad_normal_(tensor, mean=0., std=1.):
  function _no_grad_fill_ (line 55) | def _no_grad_fill_(tensor, value=0.):
  function uniform_ (line 61) | def uniform_(tensor, a, b):
  function normal_ (line 74) | def normal_(tensor, mean=0., std=1.):
  function constant_ (line 87) | def constant_(tensor, value=0.):
  function ones_ (line 99) | def ones_(tensor):
  function zeros_ (line 110) | def zeros_(tensor):
  function vector_ (line 121) | def vector_(tensor, vector):
  function _calculate_fan_in_and_fan_out (line 127) | def _calculate_fan_in_and_fan_out(tensor, reverse=False):
  function xavier_uniform_ (line 158) | def xavier_uniform_(tensor, gain=1., reverse=False):
  function xavier_normal_ (line 174) | def xavier_normal_(tensor, gain=1., reverse=False):
  function _calculate_correct_fan (line 190) | def _calculate_correct_fan(tensor, mode, reverse=False):
  function _calculate_gain (line 202) | def _calculate_gain(nonlinearity, param=None):
  function kaiming_uniform_ (line 230) | def kaiming_uniform_(tensor,
  function kaiming_normal_ (line 252) | def kaiming_normal_(tensor,
  function linear_init_ (line 273) | def linear_init_(module):
  function conv_init_ (line 280) | def conv_init_(module):
  function bias_init_with_prob (line 287) | def bias_init_with_prob(prior_prob=0.01):
  function reset_initialized_parameter (line 294) | def reset_initialized_parameter(model, include_self=True):

FILE: ppdet/modeling/keypoint_utils.py
  function get_affine_mat_kernel (line 23) | def get_affine_mat_kernel(h, w, s, inv=False):
  function get_affine_transform (line 45) | def get_affine_transform(center,
  function get_warp_matrix (line 102) | def get_warp_matrix(theta, size_input, size_dst, size_target):
  function _get_3rd_point (line 136) | def _get_3rd_point(a, b):
  function rotate_point (line 160) | def rotate_point(pt, angle_rad):
  function transpred (line 179) | def transpred(kpts, h, w, s):
  function warp_affine_joints (line 185) | def warp_affine_joints(joints, mat):
  function affine_transform (line 204) | def affine_transform(pt, t):
  function transform_preds (line 210) | def transform_preds(coords, center, scale, output_size):
  function oks_iou (line 218) | def oks_iou(g, d, a_g, a_d, sigmas=None, in_vis_thre=None):
  function oks_nms (line 243) | def oks_nms(kpts_db, thresh, sigmas=None, in_vis_thre=None):
  function rescore (line 283) | def rescore(overlap, scores, thresh, type='gaussian'):
  function soft_oks_nms (line 294) | def soft_oks_nms(kpts_db, thresh, sigmas=None, in_vis_thre=None):
  function resize (line 346) | def resize(input,
  function flip_back (line 369) | def flip_back(output_flipped, flip_pairs, target_type='GaussianHeatmap'):
  function _calc_distances (line 406) | def _calc_distances(preds, targets, mask, normalize):
  function _distance_acc (line 438) | def _distance_acc(distances, thr=0.5):
  function keypoint_pck_accuracy (line 459) | def keypoint_pck_accuracy(pred, gt, mask, thr, normalize):
  function keypoint_auc (line 498) | def keypoint_auc(pred, gt, mask, normalize, num_step=20):
  function keypoint_epe (line 530) | def keypoint_epe(pred, gt, mask):

FILE: ppdet/modeling/lane_utils.py
  class Lane (line 7) | class Lane:
    method __init__ (line 8) | def __init__(self, points=None, invalid_value=-2., metadata=None):
    method __repr__ (line 19) | def __repr__(self):
    method __call__ (line 22) | def __call__(self, lane_ys):
    method to_array (line 29) | def to_array(self, sample_y_range, img_w, img_h):
    method __iter__ (line 43) | def __iter__(self):
    method __next__ (line 46) | def __next__(self):
  function imshow_lanes (line 88) | def imshow_lanes(img, lanes, show=False, out_file=None, width=4):

FILE: ppdet/modeling/layers.py
  function _to_list (line 36) | def _to_list(l):
  class AlignConv (line 42) | class AlignConv(nn.Layer):
    method __init__ (line 43) | def __init__(self, in_channels, out_channels, kernel_size=3, groups=1):
    method get_offset (line 56) | def get_offset(self, anchors, featmap_size, stride):
    method forward (line 107) | def forward(self, x, refine_anchors, featmap_size, stride):
  class DeformableConvV2 (line 117) | class DeformableConvV2(nn.Layer):
    method __init__ (line 118) | def __init__(self,
    method forward (line 175) | def forward(self, x):
  class ConvNormLayer (line 186) | class ConvNormLayer(nn.Layer):
    method __init__ (line 187) | def __init__(self,
    method forward (line 264) | def forward(self, inputs):
  class LiteConv (line 271) | class LiteConv(nn.Layer):
    method __init__ (line 272) | def __init__(self,
    method forward (line 323) | def forward(self, inputs):
  class DropBlock (line 328) | class DropBlock(nn.Layer):
    method __init__ (line 329) | def __init__(self, block_size, keep_prob, name=None, data_format='NCHW'):
    method forward (line 345) | def forward(self, x):
  class AnchorGeneratorSSD (line 373) | class AnchorGeneratorSSD(object):
    method __init__ (line 374) | def __init__(self,
    method __call__ (line 420) | def __call__(self, inputs, image):
  class RCNNBox (line 442) | class RCNNBox(object):
    method __init__ (line 445) | def __init__(self,
    method __call__ (line 458) | def __call__(self, bbox_head_out, rois, im_shape, scale_factor):
  class MultiClassNMS (line 511) | class MultiClassNMS(object):
    method __init__ (line 512) | def __init__(self,
    method __call__ (line 535) | def __call__(self, bboxes, score, background_label=-1):
  class MatrixNMS (line 582) | class MatrixNMS(object):
    method __init__ (line 585) | def __init__(self,
    method __call__ (line 604) | def __call__(self, bbox, score, *args):
  class YOLOBox (line 620) | class YOLOBox(object):
    method __init__ (line 623) | def __init__(self,
    method __call__ (line 635) | def __call__(self,
  class SSDBox (line 664) | class SSDBox(object):
    method __init__ (line 665) | def __init__(self,
    method __call__ (line 674) | def __call__(self,
  class TTFBox (line 720) | class TTFBox(object):
    method __init__ (line 723) | def __init__(self, max_per_img=100, score_thresh=0.01, down_ratio=4):
    method _simple_nms (line 729) | def _simple_nms(self, heat, kernel=3):
    method _topk (line 738) | def _topk(self, scores):
    method _decode (line 766) | def _decode(self, hm, wh, im_shape, scale_factor):
    method __call__ (line 805) | def __call__(self, hm, wh, im_shape, scale_factor):
  class JDEBox (line 821) | class JDEBox(object):
    method __init__ (line 824) | def __init__(self, num_classes=1, conf_thresh=0.3, downsample_ratio=32):
    method generate_anchor (line 829) | def generate_anchor(self, nGh, nGw, anchor_wh):
    method decode_delta (line 848) | def decode_delta(self, delta, fg_anchor_list):
    method decode_delta_map (line 862) | def decode_delta_map(self, nA, nGh, nGw, delta_map, anchor_vec):
    method _postprocessing_by_level (line 873) | def _postprocessing_by_level(self, nA, stride, head_out, anchor_vec):
    method __call__ (line 898) | def __call__(self, yolo_head_out, anchors):
  class MaskMatrixNMS (line 919) | class MaskMatrixNMS(object):
    method __init__ (line 938) | def __init__(self,
    method _sort_score (line 951) | def _sort_score(self, scores, top_num):
    method __call__ (line 957) | def __call__(self,
  function Conv2d (line 1034) | def Conv2d(in_channels,
  function ConvTranspose2d (line 1062) | def ConvTranspose2d(in_channels,
  function BatchNorm2d (line 1092) | def BatchNorm2d(num_features, eps=1e-05, momentum=0.9, affine=True):
  function ReLU (line 1108) | def ReLU():
  function Upsample (line 1112) | def Upsample(scale_factor=None, mode='nearest', align_corners=False):
  function MaxPool (line 1116) | def MaxPool(kernel_size, stride, padding, ceil_mode=False):
  class Concat (line 1120) | class Concat(nn.Layer):
    method __init__ (line 1121) | def __init__(self, dim=0):
    method forward (line 1125) | def forward(self, inputs):
    method extra_repr (line 1128) | def extra_repr(self):
  function _convert_attention_mask (line 1132) | def _convert_attention_mask(attn_mask, dtype):
  class MultiHeadAttention (line 1154) | class MultiHeadAttention(nn.Layer):
    method __init__ (line 1189) | def __init__(self,
    method _reset_parameters (line 1230) | def _reset_parameters(self):
    method compute_qkv (line 1237) | def compute_qkv(self, tensor, index):
    method forward (line 1252) | def forward(self, query, key=None, value=None, attn_mask=None):
  class ConvMixer (line 1330) | class ConvMixer(nn.Layer):
    method __init__ (line 1331) | def __init__(
    method forward (line 1343) | def forward(self, x):
    method conv_mixer (line 1347) | def conv_mixer(

FILE: ppdet/modeling/losses/clrnet_line_iou_loss.py
  function line_iou (line 4) | def line_iou(pred, target, img_w, length=15, aligned=True):
  function liou_loss (line 40) | def liou_loss(pred, target, img_w, length=15):

FILE: ppdet/modeling/losses/clrnet_loss.py
  class SoftmaxFocalLoss (line 12) | class SoftmaxFocalLoss(nn.Layer):
    method __init__ (line 13) | def __init__(self, gamma, ignore_lb=255, *args, **kwargs):
    method forward (line 18) | def forward(self, logits, labels):
  function focal_loss (line 27) | def focal_loss(input: paddle.Tensor,
  class FocalLoss (line 90) | class FocalLoss(nn.Layer):
    method __init__ (line 129) | def __init__(self, alpha: float, gamma: float=2.0,
    method forward (line 137) | def forward(  # type: ignore
  class CLRNetLoss (line 144) | class CLRNetLoss(nn.Layer):
    method __init__ (line 147) | def __init__(self,
    method forward (line 175) | def forward(self, output, batch):

FILE: ppdet/modeling/losses/cot_loss.py
  class COTLoss (line 28) | class COTLoss(nn.Layer):
    method __init__ (line 30) | def __init__(self,
    method forward (line 39) | def forward(self, scores, targets, cot_relation):

FILE: ppdet/modeling/losses/ctfocal_loss.py
  class CTFocalLoss (line 28) | class CTFocalLoss(object):
    method __init__ (line 36) | def __init__(self, loss_weight=1., gamma=2.0):
    method __call__ (line 40) | def __call__(self, pred, target):

FILE: ppdet/modeling/losses/detr_loss.py
  class DETRLoss (line 31) | class DETRLoss(nn.Layer):
    method __init__ (line 35) | def __init__(self,
    method _get_loss_class (line 79) | def _get_loss_class(self,
    method _get_loss_bbox (line 141) | def _get_loss_bbox(self, boxes, gt_bbox, match_indices, num_gts,
    method _get_loss_mask (line 163) | def _get_loss_mask(self, masks, gt_mask, match_indices, num_gts,
    method _dice_loss (line 190) | def _dice_loss(self, inputs, targets, num_gts):
    method _get_loss_aux (line 199) | def _get_loss_aux(self,
    method _get_index_updates (line 278) | def _get_index_updates(self, num_query_objects, target, match_indices):
    method _get_src_target_assign (line 290) | def _get_src_target_assign(self, src, target, match_indices):
    method _get_num_gts (line 303) | def _get_num_gts(self, targets, dtype="float32"):
    method _get_prediction_loss (line 312) | def _get_prediction_loss(self,
    method forward (line 394) | def forward(self,
  class DINOLoss (line 452) | class DINOLoss(DETRLoss):
    method forward (line 453) | def forward(self,
    method get_dn_match_indices (line 504) | def get_dn_match_indices(labels, dn_positive_idx, dn_num_group):
  class DINOv3Loss (line 520) | class DINOv3Loss(DETRLoss):
    method forward (line 521) | def forward(self,
    method get_dn_match_indices (line 600) | def get_dn_match_indices(labels, dn_positive_idx, dn_num_group):
  class MaskDINOLoss (line 616) | class MaskDINOLoss(DETRLoss):
    method __init__ (line 620) | def __init__(self,
    method forward (line 650) | def forward(self,
    method _get_loss_mask (line 702) | def _get_loss_mask(self, masks, gt_mask, match_indices, num_gts,
    method _get_point_coords_by_uncertainty (line 736) | def _get_point_coords_by_uncertainty(self, masks):

FILE: ppdet/modeling/losses/fairmot_loss.py
  class FairMOTLoss (line 28) | class FairMOTLoss(nn.Layer):
    method __init__ (line 29) | def __init__(self):
    method forward (line 36) | def forward(self, det_loss, reid_loss):

FILE: ppdet/modeling/losses/fcos_loss.py
  function flatten_tensor (line 29) | def flatten_tensor(inputs, channel_first=False):
  class FCOSLoss (line 49) | class FCOSLoss(nn.Layer):
    method __init__ (line 60) | def __init__(self,
    method _iou_loss (line 73) | def _iou_loss(self,
    method forward (line 138) | def forward(self, cls_logits, bboxes_reg, centerness, tag_labels,
  class FCOSLossMILC (line 268) | class FCOSLossMILC(FCOSLoss):
    method __init__ (line 278) | def __init__(self,
    method iou_loss (line 289) | def iou_loss(self, pred, targets, weights=None, avg_factor=None):
    method _bbox_overlap_align (line 349) | def _bbox_overlap_align(self, pred, targets):
    method iou_based_soft_label_loss (line 376) | def iou_based_soft_label_loss(self,
    method forward (line 407) | def forward(self, cls_logits, bboxes_reg, centerness, tag_labels,
  function levels_to_images (line 519) | def levels_to_images(mlvl_tensor):
  function multi_apply (line 531) | def multi_apply(func, *args, **kwargs):
  class FCOSLossCR (line 554) | class FCOSLossCR(FCOSLossMILC):
    method __init__ (line 559) | def __init__(self,
    method iou_loss (line 572) | def iou_loss(self, pred, targets, weights=None, avg_factor=None):
    method bbox_overlap_align (line 632) | def bbox_overlap_align(self, pred, targets):
    method quality_focal_loss (line 659) | def quality_focal_loss(self,
    method compute_locations_by_level (line 686) | def compute_locations_by_level(self, fpn_stride, h, w):
    method decode_bbox (line 705) | def decode_bbox(self, ltrb, points):
    method encode_bbox (line 717) | def encode_bbox(self, bbox, points):
    method calcualate_iou (line 728) | def calcualate_iou(self, gt_bbox, predict_bbox):
    method hard_neg_mining (line 744) | def hard_neg_mining(self,
    method get_targets_per_img (line 861) | def get_targets_per_img(self, tea_cls, tea_loc, tea_iou, stu_cls, stu_...
    method forward (line 933) | def forward(self, student_prediction, teacher_prediction):

FILE: ppdet/modeling/losses/focal_loss.py
  class FocalLoss (line 27) | class FocalLoss(nn.Layer):
    method __init__ (line 35) | def __init__(self,
    method forward (line 48) | def forward(self, pred, target, reduction='none'):
  class Weighted_FocalLoss (line 65) | class Weighted_FocalLoss(FocalLoss):
    method __init__ (line 73) | def __init__(self,
    method forward (line 88) | def forward(self, pred, target, weight=None, avg_factor=None, reductio...

FILE: ppdet/modeling/losses/gfocal_loss.py
  function quality_focal_loss (line 31) | def quality_focal_loss(pred, target, beta=2.0, use_sigmoid=True):
  function distribution_focal_loss (line 83) | def distribution_focal_loss(pred, label):
  class QualityFocalLoss (line 107) | class QualityFocalLoss(nn.Layer):
    method __init__ (line 120) | def __init__(self,
    method forward (line 132) | def forward(self, pred, target, weight=None, avg_factor=None):
  class DistributionFocalLoss (line 171) | class DistributionFocalLoss(nn.Layer):
    method __init__ (line 180) | def __init__(self, reduction='mean', loss_weight=1.0):
    method forward (line 186) | def forward(self, pred, target, weight=None, avg_factor=None):

FILE: ppdet/modeling/losses/iou_aware_loss.py
  class IouAwareLoss (line 27) | class IouAwareLoss(IouLoss):
    method __init__ (line 36) | def __init__(self, loss_weight=1.0, giou=False, diou=False, ciou=False):
    method __call__ (line 40) | def __call__(self, ioup, pbox, gbox):

FILE: ppdet/modeling/losses/iou_loss.py
  class IouLoss (line 31) | class IouLoss(object):
    method __init__ (line 43) | def __init__(self,
    method __call__ (line 55) | def __call__(self, pbox, gbox):
  class GIoULoss (line 69) | class GIoULoss(object):
    method __init__ (line 78) | def __init__(self, loss_weight=1., eps=1e-10, reduction='none'):
    method bbox_overlap (line 84) | def bbox_overlap(self, box1, box2, eps=1e-10):
    method __call__ (line 113) | def __call__(self, pbox, gbox, iou_weight=1., loc_reweight=None):
  class DIouLoss (line 144) | class DIouLoss(GIoULoss):
    method __init__ (line 153) | def __init__(self, loss_weight=1., eps=1e-10, use_complete_iou_loss=Tr...
    method __call__ (line 157) | def __call__(self, pbox, gbox, iou_weight=1.):
  class SIoULoss (line 215) | class SIoULoss(GIoULoss):
    method __init__ (line 225) | def __init__(self, loss_weight=1., eps=1e-10, theta=4., reduction='non...
    method __call__ (line 232) | def __call__(self, pbox, gbox):

FILE: ppdet/modeling/losses/jde_loss.py
  class JDEDetectionLoss (line 28) | class JDEDetectionLoss(nn.Layer):
    method __init__ (line 31) | def __init__(self, num_classes=1, for_mot=True):
    method det_loss (line 36) | def det_loss(self, p_det, anchor, t_conf, t_box):
    method forward (line 74) | def forward(self, det_outs, targets, anchors):
  class JDEEmbeddingLoss (line 110) | class JDEEmbeddingLoss(nn.Layer):
    method __init__ (line 111) | def __init__(self, ):
    method emb_loss (line 115) | def emb_loss(self, p_ide, t_conf, t_ide, emb_scale, classifier):
    method forward (line 146) | def forward(self, ide_outs, targets, emb_scale, classifier):
  class JDELoss (line 159) | class JDELoss(nn.Layer):
    method __init__ (line 160) | def __init__(self):
    method forward (line 163) | def forward(self, loss_confs, loss_boxes, loss_ides, loss_params_cls,

FILE: ppdet/modeling/losses/keypoint_loss.py
  class KeyPointMSELoss (line 32) | class KeyPointMSELoss(nn.Layer):
    method __init__ (line 33) | def __init__(self, use_target_weight=True, loss_scale=0.5):
    method forward (line 45) | def forward(self, output, records):
  class HrHRNetLoss (line 72) | class HrHRNetLoss(nn.Layer):
    method __init__ (line 73) | def __init__(self, num_joints, swahr):
    method forward (line 89) | def forward(self, inputs, records):
  class HeatMapLoss (line 103) | class HeatMapLoss(object):
    method __init__ (line 104) | def __init__(self, loss_factor=1.0):
    method __call__ (line 108) | def __call__(self, preds, targets):
  class HeatMapSWAHRLoss (line 116) | class HeatMapSWAHRLoss(object):
    method __init__ (line 117) | def __init__(self, num_joints, loss_factor=1.0):
    method __call__ (line 122) | def __call__(self, preds, targets):
  class AELoss (line 149) | class AELoss(object):
    method __init__ (line 150) | def __init__(self, pull_factor=0.001, push_factor=0.001):
    method apply_single (line 155) | def apply_single(self, pred, tagmap):
    method __call__ (line 197) | def __call__(self, preds, tagmaps):
  class ZipLoss (line 208) | class ZipLoss(object):
    method __init__ (line 209) | def __init__(self, loss_funcs):
    method __call__ (line 213) | def __call__(self, inputs, targets):
  function recursive_sum (line 226) | def recursive_sum(inputs):
  function oks_overlaps (line 232) | def oks_overlaps(kpt_preds, kpt_gts, kpt_valids, kpt_areas, sigmas):
  function oks_loss (line 255) | def oks_loss(pred,
  class OKSLoss (line 325) | class OKSLoss(nn.Layer):
    method __init__ (line 338) | def __init__(self,
    method forward (line 362) | def forward(self,
  function center_focal_loss (line 415) | def center_focal_loss(pred, gt, weight=None, mask=None, avg_factor=None,...
  class CenterFocalLoss (line 487) | class CenterFocalLoss(nn.Layer):
    method __init__ (line 498) | def __init__(self,
    method forward (line 505) | def forward(self,
  function l1_loss (line 539) | def l1_loss(pred, target, weight=None, reduction='mean', avg_factor=None):
  class L1Loss (line 593) | class L1Loss(nn.Layer):
    method __init__ (line 602) | def __init__(self, reduction='mean', loss_weight=1.0):
    method forward (line 607) | def forward(self,

FILE: ppdet/modeling/losses/pose3d_loss.py
  class Pose3DLoss (line 34) | class Pose3DLoss(nn.Layer):
    method __init__ (line 35) | def __init__(self, weight_3d=1.0, weight_2d=0.0, reduction='none'):
    method forward (line 53) | def forward(self, pred3d, pred2d, inputs):
  function filter_3d_joints (line 76) | def filter_3d_joints(pred, gt, has_3d_joints):
  function mpjpe (line 91) | def mpjpe(pred, gt, has_3d_joints):
  function mpjpe_focal (line 101) | def mpjpe_focal(pred, gt, has_3d_joints):
  function mpjpe_mse (line 115) | def mpjpe_mse(pred, gt, has_3d_joints, weight=1.):
  function mpjpe_criterion (line 124) | def mpjpe_criterion(pred, gt, has_3d_joints, criterion_pose3d):
  function weighted_mpjpe (line 135) | def weighted_mpjpe(pred, gt, has_3d_joints):
  function normed_mpjpe (line 149) | def normed_mpjpe(pred, gt, has_3d_joints):
  function mpjpe_np (line 167) | def mpjpe_np(pred, gt, has_3d_joints):
  function mean_per_vertex_error (line 178) | def mean_per_vertex_error(pred, gt, has_smpl):
  function keypoint_2d_loss (line 191) | def keypoint_2d_loss(criterion_keypoints, pred_keypoints_2d, gt_keypoint...
  function keypoint_3d_loss (line 205) | def keypoint_3d_loss(criterion_keypoints, pred_keypoints_3d, gt_keypoint...
  function vertices_loss (line 229) | def vertices_loss(criterion_vertices, pred_vertices, gt_vertices, has_sm...
  function rectify_pose (line 244) | def rectify_pose(pose):

FILE: ppdet/modeling/losses/probiou_loss.py
  function gbb_form (line 29) | def gbb_form(boxes):
  function rotated_form (line 34) | def rotated_form(a_, b_, angles):
  function probiou_loss (line 43) | def probiou_loss(pred, target, eps=1e-3, mode='l1'):
  class ProbIoULoss (line 95) | class ProbIoULoss(object):
    method __init__ (line 98) | def __init__(self, mode='l1', eps=1e-3):
    method __call__ (line 103) | def __call__(self, pred_rboxes, assigned_rboxes):

FILE: ppdet/modeling/losses/queryinst_loss.py
  class QueryInstLoss (line 30) | class QueryInstLoss(object):
    method __init__ (line 33) | def __init__(self,
    method loss_classes (line 57) | def loss_classes(self, class_logits, targets, indices, avg_factor):
    method loss_bboxes (line 88) | def loss_bboxes(self, bbox_pred, targets, indices, avg_factor):
    method loss_masks (line 115) | def loss_masks(self, pos_bbox_pred, mask_logits, targets, indices,
    method _get_src_permutation_idx (line 171) | def _get_src_permutation_idx(indices):

FILE: ppdet/modeling/losses/smooth_l1_loss.py
  class SmoothL1Loss (line 27) | class SmoothL1Loss(nn.Layer):
    method __init__ (line 33) | def __init__(self,
    method forward (line 41) | def forward(self, pred, target, reduction='none'):

FILE: ppdet/modeling/losses/solov2_loss.py
  class SOLOv2Loss (line 28) | class SOLOv2Loss(object):
    method __init__ (line 37) | def __init__(self,
    method _dice_loss (line 45) | def _dice_loss(self, input, target):
    method __call__ (line 54) | def __call__(self, ins_pred_list, ins_label_list, cate_preds, cate_lab...

FILE: ppdet/modeling/losses/sparsercnn_loss.py
  class SparseRCNNLoss (line 35) | class SparseRCNNLoss(nn.Layer):
    method __init__ (line 43) | def __init__(self,
    method loss_labels (line 75) | def loss_labels(self, outputs, targets, indices, num_boxes, log=True):
    method loss_boxes (line 126) | def loss_boxes(self, outputs, targets, indices, num_boxes):
    method _get_src_permutation_idx (line 164) | def _get_src_permutation_idx(self, indices):
    method _get_tgt_permutation_idx (line 171) | def _get_tgt_permutation_idx(self, indices):
    method get_loss (line 178) | def get_loss(self, loss, outputs, targets, indices, num_boxes, **kwargs):
    method forward (line 186) | def forward(self, outputs, targets):
  class HungarianMatcher (line 238) | class HungarianMatcher(nn.Layer):
    method __init__ (line 245) | def __init__(self,
    method forward (line 266) | def forward(self, outputs, targets):
  function box_area (line 351) | def box_area(boxes):
  function boxes_iou (line 357) | def boxes_iou(boxes1, boxes2):
  function get_bboxes_giou (line 383) | def get_bboxes_giou(boxes1, boxes2, eps=1e-9):
  function sigmoid_focal_loss (line 410) | def sigmoid_focal_loss(inputs, targets, alpha, gamma, reduction="sum"):

FILE: ppdet/modeling/losses/ssd_loss.py
  class SSDLoss (line 29) | class SSDLoss(nn.Layer):
    method __init__ (line 43) | def __init__(self,
    method _bipartite_match_for_batch (line 56) | def _bipartite_match_for_batch(self, gt_bbox, gt_label, prior_boxes,
    method _mine_hard_example (line 106) | def _mine_hard_example(self,
    method forward (line 131) | def forward(self, boxes, scores, gt_bbox, gt_label, prior_boxes):

FILE: ppdet/modeling/losses/supcontrast.py
  class SupContrast (line 31) | class SupContrast(nn.Layer):
    method __init__ (line 35) | def __init__(self, num_classes=80, temperature=2.5, sample_num=4096, t...
    method forward (line 41) | def forward(self, features, labels, scores):

FILE: ppdet/modeling/losses/varifocal_loss.py
  function varifocal_loss (line 31) | def varifocal_loss(pred,
  class VarifocalLoss (line 82) | class VarifocalLoss(nn.Layer):
    method __init__ (line 83) | def __init__(self,
    method forward (line 116) | def forward(self, pred, target, weight=None, avg_factor=None):

FILE: ppdet/modeling/losses/yolo_loss.py
  function bbox_transform (line 29) | def bbox_transform(pbox, anchor, downsample):
  class YOLOv3Loss (line 36) | class YOLOv3Loss(nn.Layer):
    method __init__ (line 41) | def __init__(self,
    method obj_loss (line 71) | def obj_loss(self, pbox, gbox, pobj, tobj, anchor, downsample):
    method cls_loss (line 100) | def cls_loss(self, pcls, tcls):
    method yolov3_loss (line 113) | def yolov3_loss(self, p, t, gt_box, anchor, downsample, scale=1.,
    method forward (line 185) | def forward(self, inputs, targets, anchors):

FILE: ppdet/modeling/mot/matching/deepsort_matching.py
  function iou_1toN (line 36) | def iou_1toN(bbox, candidates):
  function iou_cost (line 68) | def iou_cost(tracks, detections, track_indices=None, detection_indices=N...
  function _nn_euclidean_distance (line 102) | def _nn_euclidean_distance(s, q):
  function _nn_cosine_distance (line 124) | def _nn_cosine_distance(s, q):
  class NearestNeighborDistanceMetric (line 143) | class NearestNeighborDistanceMetric(object):
    method __init__ (line 160) | def __init__(self, metric, matching_threshold, budget=None):
    method partial_fit (line 172) | def partial_fit(self, features, targets, active_targets):
    method distance (line 188) | def distance(self, features, targets):
  function min_cost_matching (line 207) | def min_cost_matching(distance_metric,
  function matching_cascade (line 274) | def matching_cascade(distance_metric,
  function gate_cost_matrix (line 338) | def gate_cost_matrix(kf,

FILE: ppdet/modeling/mot/matching/jde_matching.py
  function merge_matches (line 43) | def merge_matches(m1, m2, shape):
  function linear_assignment (line 62) | def linear_assignment(cost_matrix, thresh):
  function bbox_ious (line 84) | def bbox_ious(atlbrs, btlbrs):
  function iou_distance (line 109) | def iou_distance(atracks, btracks):
  function embedding_distance (line 126) | def embedding_distance(tracks, detections, metric='euclidean'):
  function fuse_motion (line 142) | def fuse_motion(kf,

FILE: ppdet/modeling/mot/matching/ocsort_matching.py
  function iou_batch (line 22) | def iou_batch(bboxes1, bboxes2):
  function speed_direction_batch (line 40) | def speed_direction_batch(dets, tracks):
  function linear_assignment (line 53) | def linear_assignment(cost_matrix):
  function associate (line 64) | def associate(detections, trackers, iou_threshold, velocities, previous_...
  function associate_only_iou (line 127) | def associate_only_iou(detections, trackers, iou_threshold):

FILE: ppdet/modeling/mot/motion/gmc.py
  class GMC (line 28) | class GMC:
    method __init__ (line 29) | def __init__(self, method='sparseOptFlow', downscale=2, verbose=None):
    method apply (line 95) | def apply(self, raw_frame, detections=None):
    method applyEcc (line 109) | def applyEcc(self, raw_frame, detections=None):
    method applyFeaures (line 145) | def applyFeaures(self, raw_frame, detections=None):
    method applySparseOptFlow (line 281) | def applySparseOptFlow(self, raw_frame, detections=None):
    method applyFile (line 357) | def applyFile(self, raw_frame, detections=None):

FILE: ppdet/modeling/mot/motion/kalman_filter.py
  function nb_project (line 26) | def nb_project(mean, covariance, std, _update_mat):
  function nb_multi_predict (line 33) | def nb_multi_predict(mean, covariance, motion_cov, motion_mat):
  function nb_update (line 40) | def nb_update(mean, covariance, proj_mean, proj_cov, measurement, meas_m...
  class KalmanFilter (line 74) | class KalmanFilter(object):
    method __init__ (line 91) | def __init__(self):
    method initiate (line 106) | def initiate(self, measurement):
    method predict (line 134) | def predict(self, mean, covariance):
    method project (line 165) | def project(self, mean, covariance):
    method multi_predict (line 193) | def multi_predict(self, mean, covariance):
    method update (line 241) | def update(self, mean, covariance, measurement):
    method gating_distance (line 269) | def gating_distance(self,

FILE: ppdet/modeling/mot/motion/ocsort_kalman_filter.py
  function nb_predict (line 27) | def nb_predict(x, F, P, Q):
  function nb_update (line 33) | def nb_update(x, z, H, P, R, _I):
  class OCSORTKalmanFilter (line 54) | class OCSORTKalmanFilter:
    method __init__ (line 55) | def __init__(self, dim_x, dim_z):
    method predict (line 68) | def predict(self):
    method update (line 75) | def update(self, z):

FILE: ppdet/modeling/mot/tracker/base_jde_tracker.py
  class TrackState (line 36) | class TrackState(object):
  class BaseTrack (line 45) | class BaseTrack(object):
    method end_frame (line 64) | def end_frame(self):
    method next_id (line 68) | def next_id(cls_id):
    method init_count (line 74) | def init_count(num_classes):
    method reset_track_count (line 83) | def reset_track_count(cls_id):
    method activate (line 86) | def activate(self, *args):
    method predict (line 89) | def predict(self):
    method update (line 92) | def update(self, *args, **kwargs):
    method mark_lost (line 95) | def mark_lost(self):
    method mark_removed (line 98) | def mark_removed(self):
  class STrack (line 104) | class STrack(BaseTrack):
    method __init__ (line 105) | def __init__(self, tlwh, score, cls_id, buff_size=30, temp_feat=None):
    method update_features (line 123) | def update_features(self, feat):
    method predict (line 135) | def predict(self):
    method multi_predict (line 143) | def multi_predict(tracks, kalman_filter):
    method multi_gmc (line 158) | def multi_gmc(stracks, H=np.eye(2, 3)):
    method reset_track_id (line 175) | def reset_track_id(self):
    method activate (line 178) | def activate(self, kalman_filter, frame_id):
    method re_activate (line 195) | def re_activate(self, new_track, frame_id, new_id=False):
    method update (line 207) | def update(self, new_track, frame_id, update_feature=True):
    method tlwh (line 222) | def tlwh(self):
    method tlbr (line 235) | def tlbr(self):
    method tlwh_to_xyah (line 244) | def tlwh_to_xyah(tlwh):
    method to_xyah (line 253) | def to_xyah(self):
    method tlbr_to_tlwh (line 257) | def tlbr_to_tlwh(tlbr):
    method tlwh_to_tlbr (line 263) | def tlwh_to_tlbr(tlwh):
    method __repr__ (line 268) | def __repr__(self):
  function joint_stracks (line 273) | def joint_stracks(tlista, tlistb):
  function sub_stracks (line 287) | def sub_stracks(tlista, tlistb):
  function remove_duplicate_stracks (line 298) | def remove_duplicate_stracks(stracksa, stracksb):

FILE: ppdet/modeling/mot/tracker/base_sde_tracker.py
  class TrackState (line 24) | class TrackState(object):
  class Track (line 39) | class Track(object):
    method __init__ (line 69) | def __init__(self,
    method to_tlwh (line 97) | def to_tlwh(self):
    method to_tlbr (line 104) | def to_tlbr(self):
    method predict (line 110) | def predict(self, kalman_filter):
    method update (line 120) | def update(self, kalman_filter, detection):
    method mark_missed (line 138) | def mark_missed(self):
    method is_tentative (line 146) | def is_tentative(self):
    method is_confirmed (line 150) | def is_confirmed(self):
    method is_deleted (line 154) | def is_deleted(self):

FILE: ppdet/modeling/mot/tracker/botsort_tracker.py
  class BOTSORTTracker (line 34) | class BOTSORTTracker(object):
    method __init__ (line 50) | def __init__(self,
    method update (line 79) | def update(self, output_results, img=None):

FILE: ppdet/modeling/mot/tracker/center_tracker.py
  class CenterTracker (line 31) | class CenterTracker(object):
    method __init__ (line 34) | def __init__(self,
    method init_track (line 55) | def init_track(self, results):
    method reset (line 67) | def reset(self):
    method update (line 71) | def update(self, results, public_det=None):
  function greedy_assignment (line 140) | def greedy_assignment(dist):

FILE: ppdet/modeling/mot/tracker/deepsort_tracker.py
  class DeepSORTTracker (line 35) | class DeepSORTTracker(object):
    method __init__ (line 61) | def __init__(self,
    method predict (line 86) | def predict(self):
    method update (line 94) | def update(self, pred_dets, pred_embs):
    method _match (line 142) | def _match(self, detections):
    method _initiate_track (line 184) | def _initiate_track(self, detection):

FILE: ppdet/modeling/mot/tracker/jde_tracker.py
  class JDETracker (line 35) | class JDETracker(object):
    method __init__ (line 68) | def __init__(self,
    method update (line 111) | def update(self, pred_dets, pred_embs=None):

FILE: ppdet/modeling/mot/tracker/ocsort_tracker.py
  function k_previous_obs (line 24) | def k_previous_obs(observations, cur_age, k):
  function convert_bbox_to_z (line 35) | def convert_bbox_to_z(bbox):
  function convert_x_to_bbox (line 50) | def convert_x_to_bbox(x, score=None):
  function speed_direction (line 68) | def speed_direction(bbox1, bbox2):
  class KalmanBoxTracker (line 76) | class KalmanBoxTracker(object):
    method __init__ (line 86) | def __init__(self, bbox, delta_t=3):
    method update (line 122) | def update(self, bbox, angle_cost=False):
    method predict (line 157) | def predict(self):
    method get_state (line 172) | def get_state(self):
  class OCSORTTracker (line 178) | class OCSORTTracker(object):
    method __init__ (line 196) | def __init__(self,
    method update (line 222) | def update(self, pred_dets, pred_embs=None):

FILE: ppdet/modeling/mot/utils.py
  class MOTTimer (line 34) | class MOTTimer(object):
    method __init__ (line 39) | def __init__(self):
    method tic (line 47) | def tic(self):
    method toc (line 52) | def toc(self, average=True):
    method clear (line 63) | def clear(self):
  class Detection (line 72) | class Detection(object):
    method __init__ (line 85) | def __init__(self, tlwh, score, feature, cls_id):
    method to_tlbr (line 91) | def to_tlbr(self):
    method to_xyah (line 100) | def to_xyah(self):
  function write_mot_results (line 111) | def write_mot_results(filename, results, data_type='mot', num_classes=1):
  function save_vis_results (line 147) | def save_vis_results(data,
  function load_det_results (line 189) | def load_det_results(det_file, num_frames):
  function scale_coords (line 209) | def scale_coords(coords, input_shape, im_shape, scale_factor):
  function clip_box (line 226) | def clip_box(xyxy, ori_image_shape):
  function get_crops (line 237) | def get_crops(xyxy, ori_img, w, h):
  function preprocess_reid (line 249) | def preprocess_reid(imgs,

FILE: ppdet/modeling/mot/visualization.py
  function get_color (line 19) | def get_color(idx):
  function plot_tracking (line 25) | def plot_tracking(image,
  function plot_tracking_dict (line 81) | def plot_tracking_dict(image,

FILE: ppdet/modeling/necks/bifpn.py
  class SeparableConvLayer (line 28) | class SeparableConvLayer(nn.Layer):
    method __init__ (line 29) | def __init__(self,
    method forward (line 67) | def forward(self, x):
  class BiFPNCell (line 77) | class BiFPNCell(nn.Layer):
    method __init__ (line 78) | def __init__(self,
    method _feature_fusion_cell (line 120) | def _feature_fusion_cell(self,
    method forward (line 145) | def forward(self, feats):
  class BiFPN (line 197) | class BiFPN(nn.Layer):
    method __init__ (line 217) | def __init__(self,
    method from_config (line 274) | def from_config(cls, cfg, input_shape):
    method out_shape (line 281) | def out_shape(self):
    method forward (line 287) | def forward(self, feats):

FILE: ppdet/modeling/necks/blazeface_fpn.py
  function hard_swish (line 26) | def hard_swish(x):
  class ConvBNLayer (line 30) | class ConvBNLayer(nn.Layer):
    method __init__ (line 31) | def __init__(self,
    method forward (line 60) | def forward(self, x):
  class FPN (line 74) | class FPN(nn.Layer):
    method __init__ (line 75) | def __init__(self, in_channels, out_channels, name=None):
    method forward (line 102) | def forward(self, input):
  class SSH (line 112) | class SSH(nn.Layer):
    method __init__ (line 113) | def __init__(self, in_channels, out_channels, name=None):
    method forward (line 157) | def forward(self, x):
  class BlazeNeck (line 169) | class BlazeNeck(nn.Layer):
    method __init__ (line 170) | def __init__(self, in_channel, neck_type="None", data_format='NCHW'):
    method forward (line 193) | def forward(self, inputs):
    method out_shape (line 209) | def out_shape(self):

FILE: ppdet/modeling/necks/centernet_fpn.py
  class BasicConv (line 31) | class BasicConv(nn.Layer):
    method __init__ (line 32) | def __init__(self,
    method forward (line 62) | def forward(self, x):
  class ChannelPool (line 71) | class ChannelPool(nn.Layer):
    method forward (line 72) | def forward(self, x):
  class SpatialGate (line 78) | class SpatialGate(nn.Layer):
    method __init__ (line 79) | def __init__(self):
    method forward (line 91) | def forward(self, x):
  function fill_up_weights (line 98) | def fill_up_weights(up):
  class IDAUp (line 111) | class IDAUp(nn.Layer):
    method __init__ (line 112) | def __init__(self, ch_ins, ch_out, up_strides, dcn_v2=True):
    method forward (line 163) | def forward(self, inputs, start_level, end_level):
  class DLAUp (line 174) | class DLAUp(nn.Layer):
    method __init__ (line 175) | def __init__(self, start_level, channels, scales, ch_in=None, dcn_v2=T...
    method forward (line 196) | def forward(self, inputs):
  class CenterNetDLAFPN (line 207) | class CenterNetDLAFPN(nn.Layer):
    method __init__ (line 222) | def __init__(self,
    method from_config (line 257) | def from_config(cls, cfg, input_shape):
    method forward (line 260) | def forward(self, body_feats):
    method out_shape (line 284) | def out_shape(self):
  class TransitionUp (line 288) | class TransitionUp(nn.Layer):
    method __init__ (line 289) | def __init__(self, in_channels, out_channels):
    method forward (line 292) | def forward(self, x, skip):
  class CenterNetHarDNetFPN (line 301) | class CenterNetHarDNetFPN(nn.Layer):
    method __init__ (line 316) | def __init__(self,
    method from_config (line 384) | def from_config(cls, cfg, input_shape):
    method forward (line 387) | def forward(self, body_feats):
    method out_shape (line 425) | def out_shape(self):

FILE: ppdet/modeling/necks/channel_mapper.py
  class ChannelMapper (line 29) | class ChannelMapper(nn.Layer):
    method __init__ (line 52) | def __init__(self,
    method forward (line 96) | def forward(self, inputs):
    method out_shape (line 109) | def out_shape(self):
    method init_weights (line 116) | def init_weights(self):

FILE: ppdet/modeling/necks/clrnet_fpn.py
  class CLRFPN (line 29) | class CLRFPN(nn.Layer):
    method __init__ (line 57) | def __init__(self,
    method init_weights (line 180) | def init_weights(self):
    method from_config (line 201) | def from_config(cls, cfg, input_shape):
    method forward (line 204) | def forward(self, body_feats):
    method out_shape (line 249) | def out_shape(self):

FILE: ppdet/modeling/necks/csp_pan.py
  class ConvBNLayer (line 28) | class ConvBNLayer(nn.Layer):
    method __init__ (line 29) | def __init__(self,
    method forward (line 52) | def forward(self, x):
  class DPModule (line 59) | class DPModule(nn.Layer):
    method __init__ (line 71) | def __init__(self,
    method forward (line 104) | def forward(self, x):
  class DarknetBottleneck (line 114) | class DarknetBottleneck(nn.Layer):
    method __init__ (line 132) | def __init__(self,
    method forward (line 157) | def forward(self, x):
  class CSPLayer (line 168) | class CSPLayer(nn.Layer):
    method __init__ (line 183) | def __init__(self,
    method forward (line 210) | def forward(self, x):
  class Channel_T (line 220) | class Channel_T(nn.Layer):
    method __init__ (line 221) | def __init__(self,
    method forward (line 232) | def forward(self, x):
  class CSPPAN (line 239) | class CSPPAN(nn.Layer):
    method __init__ (line 252) | def __init__(self,
    method forward (line 312) | def forward(self, inputs):
    method out_shape (line 354) | def out_shape(self):
    method from_config (line 362) | def from_config(cls, cfg, input_shape):

FILE: ppdet/modeling/necks/custom_pan.py
  function _get_clones (line 30) | def _get_clones(module, N):
  class SPP (line 34) | class SPP(nn.Layer):
    method __init__ (line 35) | def __init__(self,
    method forward (line 57) | def forward(self, x):
  class CSPStage (line 70) | class CSPStage(nn.Layer):
    method __init__ (line 71) | def __init__(self,
    method forward (line 100) | def forward(self, x):
  class TransformerEncoderLayer (line 109) | class TransformerEncoderLayer(nn.Layer):
    method __init__ (line 110) | def __init__(self,
    method _reset_parameters (line 137) | def _reset_parameters(self):
    method with_pos_embed (line 142) | def with_pos_embed(tensor, pos_embed):
    method forward (line 145) | def forward(self, src, src_mask=None, pos_embed=None):
  class TransformerEncoder (line 166) | class TransformerEncoder(nn.Layer):
    method __init__ (line 167) | def __init__(self, encoder_layer, num_layers, norm=None):
    method forward (line 173) | def forward(self, src, src_mask=None, pos_embed=None):
  class CustomCSPPAN (line 186) | class CustomCSPPAN(nn.Layer):
    method __init__ (line 192) | def __init__(self,
    method build_2d_sincos_position_embedding (line 324) | def build_2d_sincos_position_embedding(
    method forward (line 350) | def forward(self, blocks, for_mot=False):
    method from_config (line 393) | def from_config(cls, cfg, input_shape):
    method out_shape (line 397) | def out_shape(self):

FILE: ppdet/modeling/necks/dilated_encoder.py
  class Bottleneck (line 26) | class Bottleneck(nn.Layer):
    method __init__ (line 27) | def __init__(self, in_channels, mid_channels, dilation):
    method forward (line 76) | def forward(self, x):
  class DilatedEncoder (line 83) | class DilatedEncoder(nn.Layer):
    method __init__ (line 88) | def __init__(self,
    method forward (line 138) | def forward(self, inputs, for_mot=False):
    method from_config (line 145) | def from_config(cls, cfg, input_shape):
    method out_shape (line 149) | def out_shape(self):

FILE: ppdet/modeling/necks/es_pan.py
  class ES_Block (line 29) | class ES_Block(nn.Layer):
    method __init__ (line 30) | def __init__(self,
    method forward (line 77) | def forward(self, inputs):
  class ESPAN (line 91) | class ESPAN(nn.Layer):
    method __init__ (line 104) | def __init__(self,
    method forward (line 161) | def forward(self, inputs):
    method out_shape (line 203) | def out_shape(self):
    method from_config (line 211) | def from_config(cls, cfg, input_shape):

FILE: ppdet/modeling/necks/fpn.py
  class FPN (line 29) | class FPN(nn.Layer):
    method __init__ (line 58) | def __init__(self,
    method from_config (line 179) | def from_config(cls, cfg, input_shape):
    method forward (line 185) | def forward(self, body_feats):
    method out_shape (line 226) | def out_shape(self):

FILE: ppdet/modeling/necks/hrfpn.py
  class HRFPN (line 25) | class HRFPN(nn.Layer):
    method __init__ (line 35) | def __init__(self,
    method forward (line 81) | def forward(self, body_feats):
    method from_config (line 117) | def from_config(cls, cfg, input_shape):
    method out_shape (line 124) | def out_shape(self):

FILE: ppdet/modeling/necks/lc_pan.py
  class LCPAN (line 31) | class LCPAN(nn.Layer):
    method __init__ (line 43) | def __init__(self,
    method forward (line 118) | def forward(self, inputs):
    method out_shape (line 159) | def out_shape(self):
    method from_config (line 167) | def from_config(cls, cfg, input_shape):

FILE: ppdet/modeling/necks/ttf_fpn.py
  class Upsample (line 30) | class Upsample(nn.Layer):
    method __init__ (line 31) | def __init__(self, ch_in, ch_out, norm_type='bn'):
    method forward (line 50) | def forward(self, feat):
  class DeConv (line 58) | class DeConv(nn.Layer):
    method __init__ (line 59) | def __init__(self, ch_in, ch_out, norm_type='bn'):
    method forward (line 95) | def forward(self, inputs):
  class LiteUpsample (line 99) | class LiteUpsample(nn.Layer):
    method __init__ (line 100) | def __init__(self, ch_in, ch_out, norm_type='bn'):
    method forward (line 105) | def forward(self, inputs):
  class ShortCut (line 112) | class ShortCut(nn.Layer):
    method __init__ (line 113) | def __init__(self,
    method forward (line 151) | def forward(self, feat):
  class TTFFPN (line 158) | class TTFFPN(nn.Layer):
    method __init__ (line 179) | def __init__(self,
    method forward (line 224) | def forward(self, inputs):
    method from_config (line 237) | def from_config(cls, cfg, input_shape):
    method out_shape (line 241) | def out_shape(self):

FILE: ppdet/modeling/necks/yolo_fpn.py
  function add_coord (line 28) | def add_coord(x, data_format):
  class YoloDetBlock (line 50) | class YoloDetBlock(nn.Layer):
    method __init__ (line 51) | def __init__(self,
    method forward (line 107) | def forward(self, inputs):
  class SPP (line 113) | class SPP(nn.Layer):
    method __init__ (line 114) | def __init__(self,
    method forward (line 161) | def forward(self, x):
  class CoordConv (line 174) | class CoordConv(nn.Layer):
    method __init__ (line 175) | def __init__(self,
    method forward (line 209) | def forward(self, x):
  class PPYOLODetBlock (line 219) | class PPYOLODetBlock(nn.Layer):
    method __init__ (line 220) | def __init__(self, cfg, name, data_format='NCHW'):
    method forward (line 241) | def forward(self, inputs):
  class PPYOLOTinyDetBlock (line 247) | class PPYOLOTinyDetBlock(nn.Layer):
    method __init__ (line 248) | def __init__(self,
    method forward (line 309) | def forward(self, inputs):
  class PPYOLODetBlockCSP (line 317) | class PPYOLODetBlockCSP(nn.Layer):
    method __init__ (line 318) | def __init__(self,
    method forward (line 371) | def forward(self, inputs):
  class YOLOv3FPN (line 386) | class YOLOv3FPN(nn.Layer):
    method __init__ (line 389) | def __init__(self,
    method forward (line 446) | def forward(self, blocks, for_mot=False):
    method from_config (line 479) | def from_config(cls, cfg, input_shape):
    method out_shape (line 483) | def out_shape(self):
  class PPYOLOFPN (line 489) | class PPYOLOFPN(nn.Layer):
    method __init__ (line 492) | def __init__(self,
    method forward (line 625) | def forward(self, blocks, for_mot=False):
    method from_config (line 658) | def from_config(cls, cfg, input_shape):
    method out_shape (line 662) | def out_shape(self):
  class PPYOLOTinyFPN (line 668) | class PPYOLOTinyFPN(nn.Layer):
    method __init__ (line 671) | def __init__(self,
    method forward (line 744) | def forward(self, blocks, for_mot=False):
    method from_config (line 780) | def from_config(cls, cfg, input_shape):
    method out_shape (line 784) | def out_shape(self):
  class PPYOLOPAN (line 790) | class PPYOLOPAN(nn.Layer):
    method __init__ (line 793) | def __init__(self,
    method forward (line 939) | def forward(self, blocks, for_mot=False):
    method from_config (line 985) | def from_config(cls, cfg, input_shape):
    method out_shape (line 989) | def out_shape(self):
  class YOLOCSPPAN (line 995) | class YOLOCSPPAN(nn.Layer):
    method __init__ (line 1001) | def __init__(self,
    method forward (line 1059) | def forward(self, feats, for_mot=False):
    method from_config (line 1094) | def from_config(cls, cfg, input_shape):
    method out_shape (line 1098) | def out_shape(self):

FILE: ppdet/modeling/ops.py
  function identity (line 41) | def identity(x):
  function mish (line 45) | def mish(x):
  function silu (line 49) | def silu(x):
  function swish (line 53) | def swish(x):
  function get_act_fn (line 62) | def get_act_fn(act=None, trt=False):
  function batch_norm (line 86) | def batch_norm(ch,
  function anchor_generator (line 120) | def anchor_generator(input,
  function distribute_fpn_proposals (line 216) | def distribute_fpn_proposals(fpn_rois,
  function prior_box (line 346) | def prior_box(input,
  function multiclass_nms (line 438) | def multiclass_nms(bboxes,
  function matrix_nms (line 602) | def matrix_nms(bboxes,
  function box_coder (line 739) | def box_coder(prior_box,
  function generate_proposals (line 893) | def generate_proposals(scores,
  function sigmoid_cross_entropy_with_logits (line 1040) | def sigmoid_cross_entropy_with_logits(input,
  function smooth_l1 (line 1053) | def smooth_l1(input, label, inside_weight=None, outside_weight=None,
  function channel_shuffle (line 1066) | def channel_shuffle(x, groups):
  function get_static_shape (line 1077) | def get_static_shape(tensor):

FILE: ppdet/modeling/post_process.py
  class BBoxPostProcess (line 35) | class BBoxPostProcess(object):
    method __init__ (line 39) | def __init__(self,
    method __call__ (line 52) | def __call__(self, head_out, rois, im_shape, scale_factor):
    method get_pred (line 92) | def get_pred(self, bboxes, bbox_num, im_shape, scale_factor):
    method get_origin_shape (line 192) | def get_origin_shape(self, ):
  class MaskPostProcess (line 197) | class MaskPostProcess(object):
    method __init__ (line 206) | def __init__(self,
    method __call__ (line 215) | def __call__(self, mask_out, bboxes, bbox_num, origin_shape):
  class JDEBBoxPostProcess (line 269) | class JDEBBoxPostProcess(nn.Layer):
    method __init__ (line 273) | def __init__(self, num_classes=1, decode=None, nms=None, return_idx=Tr...
    method forward (line 296) | def forward(self, head_out, anchors):
  class CenterNetPostProcess (line 344) | class CenterNetPostProcess(object):
    method __init__ (line 359) | def __init__(self, max_per_img=500, down_ratio=4, regress_ltrb=True):
    method _simple_nms (line 366) | def _simple_nms(self, heat, kernel=3):
    method _topk (line 373) | def _topk(self, scores):
    method __call__ (line 398) | def __call__(self, hm, wh, reg, im_shape, scale_factor):
  class DETRPostProcess (line 451) | class DETRPostProcess(object):
    method __init__ (line 455) | def __init__(self,
    method _mask_postprocess (line 480) | def _mask_postprocess(self, mask_pred, score_pred):
    method __call__ (line 490) | def __call__(self, head_out, im_shape, scale_factor, pad_shape):
  class SparsePostProcess (line 589) | class SparsePostProcess(object):
    method __init__ (line 592) | def __init__(self,
    method __call__ (line 603) | def __call__(self, scores, bboxes, scale_factor, ori_shape, masks=None):
  function paste_mask (line 670) | def paste_mask(masks, boxes, im_h, im_w, assign_on_cpu=False):
  function multiclass_nms (line 696) | def multiclass_nms(bboxs, num_classes, match_threshold=0.6, match_metric...
  function nms (line 706) | def nms(dets, match_threshold=0.6, match_metric='iou'):
  class DETRBBoxSemiPostProcess (line 754) | class DETRBBoxSemiPostProcess(object):
    method __init__ (line 758) | def __init__(self,
    method __call__ (line 767) | def __call__(self, head_out):

FILE: ppdet/modeling/proposal_generator/anchor_generator.py
  class AnchorGenerator (line 30) | class AnchorGenerator(nn.Layer):
    method __init__ (line 49) | def __init__(self,
    method _broadcast_params (line 63) | def _broadcast_params(self, params, num_features):
    method generate_cell_anchors (line 70) | def generate_cell_anchors(self, sizes, aspect_ratios):
    method _calculate_anchors (line 81) | def _calculate_anchors(self, num_features):
    method _create_grid_offsets (line 94) | def _create_grid_offsets(self, size, stride, offset):
    method _grid_anchors (line 105) | def _grid_anchors(self, grid_sizes):
    method forward (line 119) | def forward(self, input):
    method num_anchors (line 125) | def num_anchors(self):
  class RetinaAnchorGenerator (line 138) | class RetinaAnchorGenerator(AnchorGenerator):
    method __init__ (line 139) | def __init__(self,
  class S2ANetAnchorGenerator (line 160) | class S2ANetAnchorGenerator(nn.Layer):
    method __init__ (line 165) | def __init__(self, base_size, scales, ratios, scale_major=True, ctr=No...
    method num_base_anchors (line 175) | def num_base_anchors(self):
    method gen_base_anchors (line 178) | def gen_base_anchors(self):
    method _meshgrid (line 205) | def _meshgrid(self, x, y, row_major=True):
    method forward (line 214) | def forward(self, featmap_size, stride=16):
    method valid_flags (line 230) | def valid_flags(self, featmap_size, valid_size):
    method rect2rbox (line 244) | def rect2rbox(self, bboxes):

FILE: ppdet/modeling/proposal_generator/embedding_rpn_head.py
  class EmbeddingRPNHead (line 26) | class EmbeddingRPNHead(nn.Layer):
    method __init__ (line 29) | def __init__(self, num_proposals, proposal_embedding_dim=256):
    method _init_layers (line 38) | def _init_layers(self):
    method _init_weights (line 43) | def _init_weights(self):
    method bbox_cxcywh_to_xyxy (line 50) | def bbox_cxcywh_to_xyxy(x):
    method forward (line 54) | def forward(self, img_whwh):

FILE: ppdet/modeling/proposal_generator/proposal_generator.py
  class ProposalGenerator (line 23) | class ProposalGenerator(object):
    method __init__ (line 46) | def __init__(self,
    method __call__ (line 61) | def __call__(self, scores, bbox_deltas, anchors, im_shape):

FILE: ppdet/modeling/proposal_generator/rpn_head.py
  class RPNFeat (line 27) | class RPNFeat(nn.Layer):
    method __init__ (line 36) | def __init__(self, in_channel=1024, out_channel=1024):
    method forward (line 48) | def forward(self, feats):
  class RPNHead (line 56) | class RPNHead(nn.Layer):
    method __init__ (line 73) | def __init__(self,
    method from_config (line 122) | def from_config(cls, cfg, input_shape):
    method forward (line 128) | def forward(self, feats, inputs):
    method _gen_proposal (line 148) | def _gen_proposal(self, scores, bbox_deltas, anchors, inputs):
    method get_loss (line 252) | def get_loss(self, pred_scores, pred_deltas, anchors, inputs):

FILE: ppdet/modeling/proposal_generator/target.py
  function rpn_anchor_target (line 20) | def rpn_anchor_target(anchors,
  function label_box (line 68) | def label_box(anchors,
  function subsample_labels (line 134) | def subsample_labels(labels,
  function generate_proposal_target (line 176) | def generate_proposal_target(rpn_rois,
  function sample_bbox (line 245) | def sample_bbox(matches,
  function polygons_to_mask (line 283) | def polygons_to_mask(polygons, height, width):
  function rasterize_polygons_within_box (line 301) | def rasterize_polygons_within_box(poly, box, resolution):
  function generate_mask_target (line 325) | def generate_mask_target(gt_segms, rois, labels_int32, sampled_gt_inds,
  function libra_sample_pos (line 397) | def libra_sample_pos(max_overlaps, max_classes, pos_inds, num_expected):
  function libra_sample_via_interval (line 430) | def libra_sample_via_interval(max_overlaps, full_set, num_expected, floo...
  function libra_sample_neg (line 469) | def libra_sample_neg(max_overlaps,
  function libra_label_box (line 530) | def libra_label_box(anchors, gt_boxes, gt_classes, positive_overlap,
  function libra_sample_bbox (line 564) | def libra_sample_bbox(matches,
  function libra_generate_proposal_target (line 621) | def libra_generate_proposal_target(rpn_rois,

FILE: ppdet/modeling/proposal_generator/target_layer.py
  class RPNTargetAssign (line 24) | class RPNTargetAssign(object):
    method __init__ (line 56) | def __init__(self,
    method __call__ (line 73) | def __call__(self, inputs, anchors):
  class BBoxAssigner (line 99) | class BBoxAssigner(object):
    method __init__ (line 133) | def __init__(self,
    method __call__ (line 154) | def __call__(self,
  class BBoxLibraAssigner (line 179) | class BBoxLibraAssigner(object):
    method __init__ (line 210) | def __init__(self,
    method __call__ (line 229) | def __call__(self,
  class MaskAssigner (line 251) | class MaskAssigner(object):
    method __init__ (line 266) | def __init__(self, num_classes=80, mask_resolution=14):
    method __call__ (line 271) | def __call__(self, rois, tgt_labels, tgt_gt_inds, inputs):
  class RBoxAssigner (line 282) | class RBoxAssigner(object):
    method __init__ (line 292) | def __init__(self,
    method anchor_valid (line 304) | def anchor_valid(self, anchors):
    method rbox2delta (line 321) | def rbox2delta(self,
    method assign_anchor (line 366) | def assign_anchor(self,
    method __call__ (line 430) | def __call__(self, anchors, gt_bboxes, gt_labels, is_crowd):

FILE: ppdet/modeling/rbox_utils.py
  function norm_angle (line 21) | def norm_angle(angle, range=[-np.pi / 4, np.pi]):
  function poly2rbox_le135_np (line 26) | def poly2rbox_le135_np(poly):
  function poly2rbox_oc_np (line 63) | def poly2rbox_oc_np(poly):
  function poly2rbox_np (line 91) | def poly2rbox_np(polys, rbox_type='oc'):
  function cal_line_length (line 108) | def cal_line_length(point1, point2):
  function get_best_begin_point_single (line 113) | def get_best_begin_point_single(coordinate):
  function rbox2poly_np (line 139) | def rbox2poly_np(rboxes):
  function box2corners (line 163) | def box2corners(box):
  function paddle_gather (line 192) | def paddle_gather(x, dim, index):
  function check_points_in_polys (line 213) | def check_points_in_polys(points, polys):
  function check_points_in_rotated_boxes (line 244) | def check_points_in_rotated_boxes(points, boxes):
  function rotated_iou_similarity (line 280) | def rotated_iou_similarity(box1, box2, eps=1e-9, func=''):

FILE: ppdet/modeling/reid/fairmot_embedding_head.py
  class FairMOTEmbeddingHead (line 28) | class FairMOTEmbeddingHead(nn.Layer):
    method __init__ (line 39) | def __init__(self,
    method from_config (line 78) | def from_config(cls, cfg, input_shape):
    method process_by_class (line 83) | def process_by_class(self, bboxes, embedding, bbox_inds, topk_clses):
    method forward (line 106) | def forward(self,
    method get_loss (line 134) | def get_loss(self, feat, inputs):
    method get_mc_loss (line 173) | def get_mc_loss(self, feat, inputs):

FILE: ppdet/modeling/reid/jde_embedding_head.py
  class LossParam (line 32) | class LossParam(nn.Layer):
    method __init__ (line 33) | def __init__(self, init_value=0., use_uncertainy=True):
    method forward (line 40) | def forward(self, inputs):
  class JDEEmbeddingHead (line 46) | class JDEEmbeddingHead(nn.Layer):
    method __init__ (line 61) | def __init__(
    method forward (line 117) | def forward(self,
    method scale_coords (line 159) | def scale_coords(self, coords, input_shape, im_shape, scale_factor):
    method get_emb_and_gt_outs (line 171) | def get_emb_and_gt_outs(self, ide_outs, targets):
    method get_emb_outs (line 198) | def get_emb_outs(self, ide_outs):

FILE: ppdet/modeling/reid/pplcnet_embedding.py
  function make_divisible (line 52) | def make_divisible(v, divisor=8, min_value=None):
  class ConvBNLayer (line 61) | class ConvBNLayer(nn.Layer):
    method __init__ (line 62) | def __init__(self,
    method forward (line 86) | def forward(self, x):
  class DepthwiseSeparable (line 93) | class DepthwiseSeparable(nn.Layer):
    method __init__ (line 94) | def __init__(self,
    method forward (line 116) | def forward(self, x):
  class SEModule (line 124) | class SEModule(nn.Layer):
    method __init__ (line 125) | def __init__(self, channel, reduction=4):
    method forward (line 143) | def forward(self, x):
  class PPLCNet (line 154) | class PPLCNet(nn.Layer):
    method __init__ (line 165) | def __init__(self, scale=1.0, class_expand=1280):
    method forward (line 237) | def forward(self, x):
  class FC (line 253) | class FC(nn.Layer):
    method __init__ (line 254) | def __init__(self, input_ch, output_ch):
    method forward (line 259) | def forward(self, x):
  class PPLCNetEmbedding (line 265) | class PPLCNetEmbedding(nn.Layer):
    method __init__ (line 273) | def __init__(self, scale=2.5, input_ch=1280, output_ch=512):
    method forward (line 278) | def forward(self, x):

FILE: ppdet/modeling/reid/pyramidal_embedding.py
  class PCBPyramid (line 31) | class PCBPyramid(nn.Layer):
    method __init__ (line 47) | def __init__(self,
    method basic_branch (line 73) | def basic_branch(self, num_conv_out_channels, input_ch):
    method pyramid_forward (line 104) | def pyramid_forward(self, feat):
    method forward (line 141) | def forward(self, x):

FILE: ppdet/modeling/reid/resnet.py
  class ConvBNLayer (line 30) | class ConvBNLayer(nn.Layer):
    method __init__ (line 31) | def __init__(self,
    method forward (line 61) | def forward(self, inputs):
  class BottleneckBlock (line 69) | class BottleneckBlock(nn.Layer):
    method __init__ (line 70) | def __init__(self,
    method forward (line 121) | def forward(self, inputs):
  class BasicBlock (line 134) | class BasicBlock(nn.Layer):
    method __init__ (line 135) | def __init__(self,
    method forward (line 169) | def forward(self, inputs):
  class ResNet (line 181) | class ResNet(nn.Layer):
    method __init__ (line 182) | def __init__(self,
    method forward (line 268) | def forward(self, inputs):
  function ResNet18 (line 276) | def ResNet18(**args):
  function ResNet34 (line 281) | def ResNet34(**args):
  function ResNet50 (line 286) | def ResNet50(pretrained=None, **args):
  function ResNet101 (line 298) | def ResNet101(pretrained=None, **args):
  function ResNet152 (line 310) | def ResNet152(**args):

FILE: ppdet/modeling/reid/resnet_embedding.py
  class ResNetEmbedding (line 26) | class ResNetEmbedding(nn.Layer):
    method __init__ (line 28) | def __init__(self, model_name='ResNet50', last_stride=1):
    method forward (line 36) | def forward(self, x):

FILE: ppdet/modeling/shape_spec.py
  class ShapeSpec (line 21) | class ShapeSpec(
    method __new__ (line 23) | def __new__(cls, channels=None, height=None, width=None, stride=None):

FILE: ppdet/modeling/ssod/losses.py
  class SSODFCOSLoss (line 37) | class SSODFCOSLoss(nn.Layer):
    method __init__ (line 38) | def __init__(self, loss_weight=1.0):
    method forward (line 42) | def forward(self, student_head_outs, teacher_head_outs, train_cfg):
  class SSODPPYOLOELoss (line 132) | class SSODPPYOLOELoss(nn.Layer):
    method __init__ (line 133) | def __init__(self, loss_weight=1.0):
    method forward (line 137) | def forward(self, student_head_outs, teacher_head_outs, train_cfg):

FILE: ppdet/modeling/ssod/utils.py
  function align_weak_strong_shape (line 19) | def align_weak_strong_shape(data_weak, data_strong):
  function QFLv2 (line 61) | def QFLv2(pred_sigmoid,
  function filter_invalid (line 85) | def filter_invalid(bbox, label=None, score=None, thr=0.0, min_size=0):

FILE: ppdet/modeling/tests/test_architectures.py
  class TestFasterRCNN (line 23) | class TestFasterRCNN(unittest.TestCase):
    method setUp (line 24) | def setUp(self):
    method set_config (line 27) | def set_config(self):
    method test_trainer (line 30) | def test_trainer(self):
  class TestMaskRCNN (line 38) | class TestMaskRCNN(TestFasterRCNN):
    method set_config (line 39) | def set_config(self):
  class TestCascadeRCNN (line 43) | class TestCascadeRCNN(TestFasterRCNN):
    method set_config (line 44) | def set_config(self):
  class TestYolov3 (line 48) | class TestYolov3(TestFasterRCNN):
    method set_config (line 49) | def set_config(self):
  class TestSSD (line 53) | class TestSSD(TestFasterRCNN):
    method set_config (line 54) | def set_config(self):
  class TestGFL (line 58) | class TestGFL(TestFasterRCNN):
    method set_config (line 59) | def set_config(self):
  class TestPicoDet (line 63) | class TestPicoDet(TestFasterRCNN):
    method set_config (line 64) | def set_config(self):

FILE: ppdet/modeling/tests/test_base.py
  class LayerTest (line 24) | class LayerTest(unittest.TestCase):
    method setUpClass (line 26) | def setUpClass(cls):
    method tearDownClass (line 30) | def tearDownClass(cls):
    method _get_place (line 33) | def _get_place(self, force_to_use_cpu=False):
    method static_graph (line 41) | def static_graph(self):
    method get_static_graph_result (line 51) | def get_static_graph_result(self,
    method dynamic_graph (line 64) | def dynamic_graph(self, force_to_use_cpu=False):

FILE: ppdet/modeling/tests/test_mstest.py
  class TestMultiScaleInference (line 25) | class TestMultiScaleInference(unittest.TestCase):
    method setUp (line 26) | def setUp(self):
    method set_config (line 29) | def set_config(self):
    method test_eval_mstest (line 33) | def test_eval_mstest(self):
    method test_infer_mstest (line 43) | def test_infer_mstest(self):

FILE: ppdet/modeling/tests/test_ops.py
  function make_rois (line 31) | def make_rois(h, w, rois_num, output_size):
  function softmax (line 43) | def softmax(x):
  class TestROIAlign (line 51) | class TestROIAlign(LayerTest):
    method test_roi_align (line 52) | def test_roi_align(self):
    method test_roi_align_error (line 95) | def test_roi_align_error(self):
  class TestROIPool (line 111) | class TestROIPool(LayerTest):
    method test_roi_pool (line 112) | def test_roi_pool(self):
    method test_roi_pool_error (line 155) | def test_roi_pool_error(self):
  class TestPriorBox (line 171) | class TestPriorBox(LayerTest):
    method test_prior_box (line 172) | def test_prior_box(self):
    method test_prior_box_error (line 212) | def test_prior_box_error(self):
  class TestMulticlassNms (line 230) | class TestMulticlassNms(LayerTest):
    method test_multiclass_nms (line 231) | def test_multiclass_nms(self):
    method test_multiclass_nms_error (line 293) | def test_multiclass_nms_error(self):
  class TestMatrixNMS (line 316) | class TestMatrixNMS(LayerTest):
    method test_matrix_nms (line 317) | def test_matrix_nms(self):
    method test_matrix_nms_error (line 371) | def test_matrix_nms_error(self):
  class TestBoxCoder (line 391) | class TestBoxCoder(LayerTest):
    method test_box_coder (line 392) | def test_box_coder(self):
    method test_box_coder_error (line 440) | def test_box_coder_error(self):

FILE: ppdet/modeling/tests/test_yolov3_loss.py
  function _split_output (line 35) | def _split_output(output, an_num, num_classes):
  function _split_target (line 83) | def _split_target(target):
  function _calc_obj_loss (line 100) | def _calc_obj_loss(output, obj, tobj, gt_box, batch_size, anchors, num_c...
  function fine_grained_loss (line 167) | def fine_grained_loss(output,
  function gt2yolotarget (line 232) | def gt2yolotarget(gt_bbox, gt_class, gt_score, anchors, mask, num_classe...
  class TestYolov3LossOp (line 282) | class TestYolov3LossOp(unittest.TestCase):
    method setUp (line 283) | def setUp(self):
    method initTestCase (line 313) | def initTestCase(self):
    method test_loss (line 331) | def test_loss(self):
  class TestYolov3LossNoGTScore (line 362) | class TestYolov3LossNoGTScore(TestYolov3LossOp):
    method initTestCase (line 363) | def initTestCase(self):
  class TestYolov3LossWithScaleXY (line 382) | class TestYolov3LossWithScaleXY(TestYolov3LossOp):
    method initTestCase (line 383) | def initTestCase(self):

FILE: ppdet/modeling/transformers/deformable_transformer.py
  class MSDeformableAttention (line 37) | class MSDeformableAttention(nn.Layer):
    method __init__ (line 38) | def __init__(self,
    method _reset_parameters (line 76) | def _reset_parameters(self):
    method forward (line 100) | def forward(self,
  class DeformableTransformerEncoderLayer (line 161) | class DeformableTransformerEncoderLayer(nn.Layer):
    method __init__ (line 162) | def __init__(self,
    method _reset_parameters (line 190) | def _reset_parameters(self):
    method with_pos_embed (line 196) | def with_pos_embed(self, tensor, pos):
    method forward_ffn (line 199) | def forward_ffn(self, src):
    method forward (line 205) | def forward(self,
  class DeformableTransformerEncoder (line 224) | class DeformableTransformerEncoder(nn.Layer):
    method __init__ (line 225) | def __init__(self, encoder_layer, num_layers):
    method get_reference_points (line 231) | def get_reference_points(spatial_shapes, valid_ratios, offset=0.5):
    method forward (line 246) | def forward(self,
  class DeformableTransformerDecoderLayer (line 265) | class DeformableTransformerDecoderLayer(nn.Layer):
    method __init__ (line 266) | def __init__(self,
    method _reset_parameters (line 302) | def _reset_parameters(self):
    method with_pos_embed (line 308) | def with_pos_embed(self, tensor, pos):
    method forward_ffn (line 311) | def forward_ffn(self, tgt):
    method forward (line 317) | def forward(self,
  class DeformableTransformerDecoder (line 344) | class DeformableTransformerDecoder(nn.Layer):
    method __init__ (line 345) | def __init__(self, decoder_layer, num_layers, return_intermediate=False):
    method forward (line 351) | def forward(self,
  class DeformableTransformer (line 376) | class DeformableTransformer(nn.Layer):
    method __init__ (line 379) | def __init__(self,
    method _reset_parameters (line 458) | def _reset_parameters(self):
    method from_config (line 469) | def from_config(cls, cfg, input_shape):
    method forward (line 472) | def forward(self, src_feats, src_mask=None, *args, **kwargs):
  class QRDeformableTransformerDecoder (line 540) | class QRDeformableTransformerDecoder(DeformableTransformerDecoder):
    method __init__ (line 541) | def __init__(self, decoder_layer, num_layers,
    method forward (line 548) | def forward(self,
  class QRDeformableTransformer (line 601) | class QRDeformableTransformer(DeformableTransformer):
    method __init__ (line 603) | def __init__(self,

FILE: ppdet/modeling/transformers/detr_transformer.py
  class TransformerEncoderLayer (line 35) | class TransformerEncoderLayer(nn.Layer):
    method __init__ (line 36) | def __init__(self,
    method _reset_parameters (line 63) | def _reset_parameters(self):
    method with_pos_embed (line 68) | def with_pos_embed(tensor, pos_embed):
    method forward (line 71) | def forward(self, src, src_mask=None, pos_embed=None):
  class TransformerEncoder (line 92) | class TransformerEncoder(nn.Layer):
    method __init__ (line 93) | def __init__(self, encoder_layer, num_layers, norm=None):
    method forward (line 99) | def forward(self, src, src_mask=None, pos_embed=None):
  class TransformerDecoderLayer (line 110) | class TransformerDecoderLayer(nn.Layer):
    method __init__ (line 111) | def __init__(self,
    method _reset_parameters (line 141) | def _reset_parameters(self):
    method with_pos_embed (line 146) | def with_pos_embed(tensor, pos_embed):
    method forward (line 149) | def forward(self,
  class TransformerDecoder (line 187) | class TransformerDecoder(nn.Layer):
    method __init__ (line 188) | def __init__(self,
    method forward (line 199) | def forward(self,
  class DETRTransformer (line 231) | class DETRTransformer(nn.Layer):
    method __init__ (line 234) | def __init__(self,
    method _reset_parameters (line 286) | def _reset_parameters(self):
    method from_config (line 294) | def from_config(cls, cfg, input_shape):
    method _convert_attention_mask (line 299) | def _convert_attention_mask(self, mask):
    method forward (line 302) | def forward(self, src, src_mask=None, *args, **kwargs):

FILE: ppdet/modeling/transformers/dino_transformer.py
  class DINOTransformerDecoderLayer (line 46) | class DINOTransformerDecoderLayer(nn.Layer):
    method __init__ (line 47) | def __init__(self,
    method _reset_parameters (line 83) | def _reset_parameters(self):
    method with_pos_embed (line 89) | def with_pos_embed(self, tensor, pos):
    method forward_ffn (line 92) | def forward_ffn(self, tgt):
    method forward (line 95) | def forward(self,
  class DINOTransformerDecoder (line 130) | class DINOTransformerDecoder(nn.Layer):
    method __init__ (line 131) | def __init__(self,
    method forward (line 144) | def forward(self,
  class DINOTransformer (line 184) | class DINOTransformer(nn.Layer):
    method __init__ (line 187) | def __init__(self,
    method _reset_parameters (line 286) | def _reset_parameters(self):
    method from_config (line 311) | def from_config(cls, cfg, input_shape):
    method _build_input_proj_layer (line 314) | def _build_input_proj_layer(self,
    method _get_encoder_input (line 345) | def _get_encoder_input(self, feats, pad_mask=None):
    method forward (line 400) | def forward(self, feats, pad_mask=None, gt_meta=None):
    method _get_encoder_output_anchors (line 451) | def _get_encoder_output_anchors(self,
    method _get_decoder_input (line 491) | def _get_decoder_input(self,

FILE: ppdet/modeling/transformers/ext_op/ms_deformable_attn_op.cc
  function MSDeformableAttnInferShape (line 32) | std::vector<std::vector<int64_t>>
  function MSDeformableAttnInferDtype (line 42) | std::vector<paddle::DataType>

FILE: ppdet/modeling/transformers/ext_op/test_ms_deformable_attn_op.py
  function get_test_tensors (line 57) | def get_test_tensors(channels):
  function check_forward_equal_with_paddle_float (line 73) | def check_forward_equal_with_paddle_float():
  function check_gradient_numerical (line 93) | def check_gradient_numerical(channels=4):

FILE: ppdet/modeling/transformers/group_detr_transformer.py
  class DINOTransformerEncoderLayer (line 44) | class DINOTransformerEncoderLayer(nn.Layer):
    method __init__ (line 45) | def __init__(self,
    method _reset_parameters (line 78) | def _reset_parameters(self):
    method with_pos_embed (line 84) | def with_pos_embed(self, tensor, pos):
    method forward_ffn (line 87) | def forward_ffn(self, src):
    method forward (line 93) | def forward(self,
  class DINOTransformerEncoder (line 112) | class DINOTransformerEncoder(nn.Layer):
    method __init__ (line 113) | def __init__(self, encoder_layer, num_layers):
    method get_reference_points (line 119) | def get_reference_points(spatial_shapes, valid_ratios, offset=0.5):
    method forward (line 134) | def forward(self,
  class DINOTransformerDecoderLayer (line 153) | class DINOTransformerDecoderLayer(nn.Layer):
    method __init__ (line 154) | def __init__(self,
    method _reset_parameters (line 205) | def _reset_parameters(self):
    method with_pos_embed (line 211) | def with_pos_embed(self, tensor, pos):
    method forward_ffn (line 214) | def forward_ffn(self, tgt):
    method forward (line 217) | def forward(self,
  class DINOTransformerDecoder (line 278) | class DINOTransformerDecoder(nn.Layer):
    method __init__ (line 279) | def __init__(self,
    method forward (line 295) | def forward(self,
  class GroupDINOTransformer (line 339) | class GroupDINOTransformer(nn.Layer):
    method __init__ (line 342) | def __init__(self,
    method _reset_parameters (line 488) | def _reset_parameters(self):
    method from_config (line 516) | def from_config(cls, cfg, input_shape):
    method _build_input_proj_layer (line 519) | def _build_input_proj_layer(self, backbone_feat_channels):
    method _get_encoder_input (line 547) | def _get_encoder_input(self, feats, pad_mask=None):
    method forward (line 607) | def forward(self, feats, pad_mask=None, gt_meta=None):
    method _get_encoder_output_anchors (line 689) | def _get_encoder_output_anchors(self,
    method _get_decoder_input (line 738) | def _get_decoder_input(self,

FILE: ppdet/modeling/transformers/hybrid_encoder.py
  class CSPRepLayer (line 32) | class CSPRepLayer(nn.Layer):
    method __init__ (line 33) | def __init__(self,
    method forward (line 62) | def forward(self, x):
  class TransformerLayer (line 70) | class TransformerLayer(nn.Layer):
    method __init__ (line 71) | def __init__(self,
    method _reset_parameters (line 98) | def _reset_parameters(self):
    method with_pos_embed (line 103) | def with_pos_embed(tensor, pos_embed):
    method forward (line 106) | def forward(self, src, src_mask=None, pos_embed=None):
  class HybridEncoder (line 129) | class HybridEncoder(nn.Layer):
    method __init__ (line 133) | def __init__(self,
    method _reset_parameters (line 207) | def _reset_parameters(self):
    method build_2d_sincos_position_embedding (line 217) | def build_2d_sincos_position_embedding(w,
    method forward (line 240) | def forward(self, feats, for_mot=False, is_teacher=False):
    method from_config (line 288) | def from_config(cls, cfg, input_shape):
    method out_shape (line 295) | def out_shape(self):
  class MaskFeatFPN (line 303) | class MaskFeatFPN(nn.Layer):
    method __init__ (line 304) | def __init__(self,
    method forward (line 348) | def forward(self, inputs):
  class MaskHybridEncoder (line 367) | class MaskHybridEncoder(HybridEncoder):
    method __init__ (line 371) | def __init__(self,
    method forward (line 420) | def forward(self, feats, for_mot=False, is_teacher=False):

FILE: ppdet/modeling/transformers/mask_dino_transformer.py
  class ConvGNBlock (line 45) | class ConvGNBlock(nn.Layer):
    method __init__ (line 46) | def __init__(self,
    method _init_weights (line 73) | def _init_weights(self):
    method forward (line 76) | def forward(self, x):
  class MaskDINOTransformerDecoder (line 83) | class MaskDINOTransformerDecoder(nn.Layer):
    method __init__ (line 84) | def __init__(self, hidden_dim, decoder_layer, num_layers):
    method forward (line 90) | def forward(self,
  class MaskDINO (line 131) | class MaskDINO(nn.Layer):
    method __init__ (line 134) | def __init__(self,
    method _reset_parameters (line 245) | def _reset_parameters(self):
    method from_config (line 264) | def from_config(cls, cfg, input_shape):
    method _build_input_proj_layer (line 267) | def _build_input_proj_layer(self,
    method _get_encoder_input (line 298) | def _get_encoder_input(self, feats, pad_mask=None):
    method forward (line 353) | def forward(self, feats, pad_mask=None, gt_meta=None):
    method _get_encoder_mask_feature (line 417) | def _get_encoder_mask_feature(self, in_feat, memory, spatial_shapes):
    method _get_encoder_output_anchors (line 430) | def _get_encoder_output_anchors(self,
    method _get_decoder_input (line 470) | def _get_decoder_input(self,
    method _get_pred_class_and_mask (line 528) | def _get_pred_class_and_mask(self, query_embed, mask_feat):

FILE: ppdet/modeling/transformers/mask_rtdetr_transformer.py
  function _get_pred_class_and_mask (line 35) | def _get_pred_class_and_mask(query_embed,
  class MaskTransformerDecoder (line 51) | class MaskTransformerDecoder(nn.Layer):
    method __init__ (line 52) | def __init__(self,
    method forward (line 66) | def forward(self,
  class MaskRTDETR (line 134) | class MaskRTDETR(nn.Layer):
    method __init__ (line 137) | def __init__(self,
    method _reset_parameters (line 231) | def _reset_parameters(self):
    method from_config (line 253) | def from_config(cls, cfg, input_shape):
    method _build_input_proj_layer (line 257) | def _build_input_proj_layer(self, backbone_feat_channels):
    method _get_encoder_input (line 288) | def _get_encoder_input(self, feats):
    method forward (line 317) | def forward(self, feats, pad_mask=None, gt_meta=None, is_teacher=False):
    method _generate_anchors (line 361) | def _generate_anchors(self,
    method _get_decoder_input (line 393) | def _get_decoder_input(self,

FILE: ppdet/modeling/transformers/matchers.py
  class HungarianMatcher (line 36) | class HungarianMatcher(nn.Layer):
    method __init__ (line 39) | def __init__(self,
    method forward (line 66) | def forward(self,

FILE: ppdet/modeling/transformers/petr_transformer.py
  function masked_fill (line 42) | def masked_fill(x, mask, value):
  function inverse_sigmoid (line 47) | def inverse_sigmoid(x, eps=1e-5):
  class TransformerEncoderLayer (line 67) | class TransformerEncoderLayer(nn.Layer):
    method __init__ (line 70) | def __init__(self,
    method _reset_parameters (line 102) | def _reset_parameters(self):
    method with_pos_embed (line 107) | def with_pos_embed(tensor, pos_embed):
    method forward (line 110) | def forward(self, src, src_mask=None, pos_embed=None, **kwargs):
  class TransformerEncoder (line 132) | class TransformerEncoder(nn.Layer):
    method __init__ (line 135) | def __init__(self, encoder_layer, num_layers, norm=None):
    method forward (line 142) | def forward(self, src, src_mask=None, pos_embed=None, **kwargs):
  class MSDeformableAttention (line 155) | class MSDeformableAttention(nn.Layer):
    method __init__ (line 156) | def __init__(self,
    method _reset_parameters (line 195) | def _reset_parameters(self):
    method forward (line 219) | def forward(self,
  class MultiScaleDeformablePoseAttention (line 283) | class MultiScaleDeformablePoseAttention(nn.Layer):
    method __init__ (line 303) | def __init__(self,
    method init_weights (line 364) | def init_weights(self):
    method forward (line 375) | def forward(self,
  class PETR_TransformerDecoderLayer (line 463) | class PETR_TransformerDecoderLayer(nn.Layer):
    method __init__ (line 466) | def __init__(self,
    method _reset_parameters (line 504) | def _reset_parameters(self):
    method with_pos_embed (line 509) | def with_pos_embed(tensor, pos_embed):
    method forward (line 512) | def forward(self,
  class PETR_TransformerDecoder (line 554) | class PETR_TransformerDecoder(nn.Layer):
    method __init__ (line 564) | def __init__(self,
    method forward (line 578) | def forward(self,
  class PETR_DeformableTransformerDecoder (line 643) | class PETR_DeformableTransformerDecoder(nn.Layer):
    method __init__ (line 646) | def __init__(self, decoder_layer, num_layers, return_intermediate=False):
    method forward (line 652) | def forward(self,
  class PETR_DeformableDetrTransformerDecoder (line 675) | class PETR_DeformableDetrTransformerDecoder(PETR_DeformableTransformerDe...
    method __init__ (line 684) | def __init__(self, *args, return_intermediate=False, **kwargs):
    method forward (line 690) | def forward(self,
  class PETRTransformer (line 762) | class PETRTransformer(nn.Layer):
    method __init__ (line 775) | def __init__(self,
    method init_layers (line 798) | def init_layers(self):
    method init_weights (line 813) | def init_weights(self):
    method gen_encoder_output_proposals (line 832) | def gen_encoder_output_proposals(self, memory, memory_padding_mask,
    method get_reference_points (line 900) | def get_reference_points(spatial_shapes, valid_ratios):
    method get_valid_ratio (line 930) | def get_valid_ratio(self, mask):
    method get_proposal_pos_embed (line 940) | def get_proposal_pos_embed(self,
    method forward (line 958) | def forward(self,
    method forward_refine (line 1143) | def forward_refine(self,

FILE: ppdet/modeling/transformers/position_encoding.py
  class PositionEmbedding (line 31) | class PositionEmbedding(nn.Layer):
    method __init__ (line 32) | def __init__(self,
    method forward (line 58) | def forward(self, mask):

FILE: ppdet/modeling/transformers/rtdetr_transformer.py
  class PPMSDeformableAttention (line 42) | class PPMSDeformableAttention(MSDeformableAttention):
    method forward (line 43) | def forward(self,
  class TransformerDecoderLayer (line 112) | class TransformerDecoderLayer(nn.Layer):
    method __init__ (line 113) | def __init__(self,
    method _reset_parameters (line 156) | def _reset_parameters(self):
    method with_pos_embed (line 162) | def with_pos_embed(self, tensor, pos):
    method forward_ffn (line 165) | def forward_ffn(self, tgt):
    method forward (line 168) | def forward(self,
  class TransformerDecoder (line 203) | class TransformerDecoder(nn.Layer):
    method __init__ (line 204) | def __init__(self, hidden_dim, decoder_layer, num_layers, eval_idx=-1):
    method forward (line 211) | def forward(self,
  class RTDETRTransformer (line 263) | class RTDETRTransformer(nn.Layer):
    method __init__ (line 266) | def __init__(self,
    method _reset_parameters (line 354) | def _reset_parameters(self):
    method from_config (line 381) | def from_config(cls, cfg, input_shape):
    method _build_input_proj_layer (line 384) | def _build_input_proj_layer(self, backbone_feat_channels):
    method _get_encoder_input (line 413) | def _get_encoder_input(self, feats):
    method forward (line 442) | def forward(self, feats, pad_mask=None, gt_meta=None, is_teacher=False):
    method _generate_anchors (line 480) | def _generate_anchors(self,
    method _get_decoder_input (line 512) | def _get_decoder_input(self,

FILE: ppdet/modeling/transformers/rtdetr_transformerv2.py
  class MSDeformableAttention (line 43) | class MSDeformableAttention(nn.Layer):
    method __init__ (line 44) | def __init__(self,
    method _reset_parameters (line 100) | def _reset_parameters(self):
    method forward (line 124) | def forward(self,
  class TransformerDecoderLayer (line 180) | class TransformerDecoderLayer(nn.Layer):
    method __init__ (line 181) | def __init__(self,
    method _reset_parameters (line 226) | def _reset_parameters(self):
    method with_pos_embed (line 232) | def with_pos_embed(self, tensor, pos):
    method forward_ffn (line 235) | def forward_ffn(self, tgt):
    method forward (line 238) | def forward(self,
  class RTDETRTransformerv2 (line 274) | class RTDETRTransformerv2(nn.Layer):
    method __init__ (line 277) | def __init__(self,
    method _reset_parameters (line 369) | def _reset_parameters(self):
    method from_config (line 396) | def from_config(cls, cfg, input_shape):
    method _build_input_proj_layer (line 399) | def _build_input_proj_layer(self, backbone_feat_channels):
    method _get_encoder_input (line 428) | def _get_encoder_input(self, feats):
    method forward (line 457) | def forward(self, feats, pad_mask=None, gt_meta=None, is_teacher=False):
    method _generate_anchors (line 495) | def _generate_anchors(self,
    method _get_decoder_input (line 527) | def _get_decoder_input(self,

FILE: ppdet/modeling/transformers/rtdetr_transformerv3.py
  class PPMSDeformableAttention (line 42) | class PPMSDeformableAttention(MSDeformableAttention):
    method forward (line 43) | def forward(self,
  class TransformerDecoderLayer (line 112) | class TransformerDecoderLayer(nn.Layer):
    method __init__ (line 113) | def __init__(self,
    method _reset_parameters (line 156) | def _reset_parameters(self):
    method with_pos_embed (line 162) | def with_pos_embed(self, tensor, pos):
    method forward_ffn (line 165) | def forward_ffn(self, tgt):
    method forward (line 168) | def forward(self,
  class TransformerDecoder (line 203) | class TransformerDecoder(nn.Layer):
    method __init__ (line 204) | def __init__(self, hidden_dim, decoder_layer, num_layers, eval_idx=-1):
    method forward (line 211) | def forward(self,
  class RTDETRTransformerv3 (line 263) | class RTDETRTransformerv3(nn.Layer):
    method __init__ (line 267) | def __init__(self,
    method _reset_parameters (line 391) | def _reset_parameters(self):
    method from_config (line 424) | def from_config(cls, cfg, input_shape):
    method _build_input_proj_layer (line 427) | def _build_input_proj_layer(self, backbone_feat_channels):
    method _get_encoder_input (line 456) | def _get_encoder_input(self, feats):
    method forward (line 485) | def forward(self, feats, pad_mask=None, gt_meta=None, is_teacher=False):
    method _generate_anchors (line 557) | def _generate_anchors(self,
    method _get_decoder_input (line 589) | def _get_decoder_input(self,

FILE: ppdet/modeling/transformers/utils.py
  function _get_clones (line 39) | def _get_clones(module, N):
  function bbox_cxcywh_to_xyxy (line 43) | def bbox_cxcywh_to_xyxy(x):
  function bbox_xyxy_to_cxcywh (line 48) | def bbox_xyxy_to_cxcywh(x):
  function sigmoid_focal_loss (line 54) | def sigmoid_focal_loss(logit, label, normalizer=1.0, alpha=0.25, gamma=2...
  function inverse_sigmoid (line 66) | def inverse_sigmoid(x, eps=1e-5):
  function deformable_attention_core_func (line 71) | def deformable_attention_core_func(value, value_spatial_shapes,
  function discrete_sample (line 116) | def discrete_sample(x, grid):
  function deformable_attention_core_func_v2 (line 136) | def deformable_attention_core_func_v2(value,
  function get_valid_ratio (line 202) | def get_valid_ratio(mask):
  function get_denoising_training_group (line 210) | def get_denoising_training_group(targets,
  function get_contrastive_denoising_training_group (line 309) | def get_contrastive_denoising_training_group(targets,
  function get_sine_pos_embed (line 423) | def get_sine_pos_embed(pos_tensor,
  function mask_to_box_coordinate (line 459) | def mask_to_box_coordinate(mask,
  function varifocal_loss_with_logits (line 496) | def varifocal_loss_with_logits(pred_logits,

FILE: ppdet/optimizer/adamw.py
  function layerwise_lr_decay (line 29) | def layerwise_lr_decay(decay_rate, name_dict, n_layers, param):
  class AdamWDL (line 62) | class AdamWDL(AdamW):
    method __init__ (line 160) | def __init__(self,
  function _append_optimize_op (line 213) | def _append_optimize_op(self, block, param_and_grad):
  function build_adamwdl (line 230) | def build_adamwdl(model,

FILE: ppdet/optimizer/ema.py
  class ModelEMA (line 29) | class ModelEMA(object):
    method __init__ (line 49) | def __init__(self,
    method reset (line 81) | def reset(self):
    method resume (line 90) | def resume(self, state_dict, step=0):
    method update (line 99) | def update(self, model=None):
    method apply (line 122) | def apply(self):
    method _match_ema_black_list (line 143) | def _match_ema_black_list(self, weight_name, ema_black_list=None):
  class SimpleModelEMA (line 153) | class SimpleModelEMA(object):
    method __init__ (line 164) | def __init__(self, model=None, decay=0.9996):
    method update (line 173) | def update(self, model, decay=None):
    method resume (line 187) | def resume(self, state_dict, step=0):

FILE: ppdet/optimizer/optimizer.py
  class CosineDecay (line 40) | class CosineDecay(object):
    method __init__ (line 54) | def __init__(self,
    method __call__ (line 64) | def __call__(self,
  class PiecewiseDecay (line 107) | class PiecewiseDecay(object):
    method __init__ (line 116) | def __init__(self,
    method __call__ (line 132) | def __call__(self,
  class LinearWarmup (line 158) | class LinearWarmup(object):
    method __init__ (line 169) | def __init__(self, steps=500, start_factor=1. / 3, epochs=None, epochs...
    method __call__ (line 176) | def __call__(self, base_lr, step_per_epoch):
  class ExpWarmup (line 196) | class ExpWarmup(object):
    method __init__ (line 206) | def __init__(self, steps=1000, epochs=None, power=2):
    method __call__ (line 212) | def __call__(self, base_lr, step_per_epoch):
  class LearningRate (line 226) | class LearningRate(object):
    method __init__ (line 236) | def __init__(self,
    method __call__ (line 254) | def __call__(self, step_per_epoch):
  class OptimizerBuilder (line 270) | class OptimizerBuilder():
    method __init__ (line 279) | def __init__(self,
    method __call__ (line 291) | def __call__(self, learning_rate, model=None):

FILE: ppdet/optimizer/utils.py
  function get_bn_running_state_names (line 25) | def get_bn_running_state_names(model: nn.Layer) -> List[str]:

FILE: ppdet/slim/__init__.py
  function build_slim_model (line 34) | def build_slim_model(cfg, slim_cfg, mode='train'):

FILE: ppdet/slim/distill_loss.py
  function parameter_init (line 42) | def parameter_init(mode="kaiming", value=0.):
  function feature_norm (line 54) | def feature_norm(feat):
  class DistillYOLOv3Loss (line 66) | class DistillYOLOv3Loss(nn.Layer):
    method __init__ (line 67) | def __init__(self, weight=1000):
    method obj_weighted_reg (line 71) | def obj_weighted_reg(self, sx, sy, sw, sh, tx, ty, tw, th, tobj):
    method obj_weighted_cls (line 80) | def obj_weighted_cls(self, scls, tcls, tobj):
    method obj_loss (line 85) | def obj_loss(self, sobj, tobj):
    method forward (line 92) | def forward(self, teacher_model, student_model):
  class KnowledgeDistillationKLDivLoss (line 112) | class KnowledgeDistillationKLDivLoss(nn.Layer):
    method __init__ (line 121) | def __init__(self, reduction='mean', loss_weight=1.0, T=10):
    method knowledge_distillation_kl_div_loss (line 129) | def knowledge_distillation_kl_div_loss(self,
    method forward (line 153) | def forward(self,
  class DistillPPYOLOELoss (line 204) | class DistillPPYOLOELoss(nn.Layer):
    method __init__ (line 205) | def __init__(
    method quality_focal_loss (line 286) | def quality_focal_loss(self,
    method bbox_loss (line 314) | def bbox_loss(self, s_bbox, t_bbox, weight_targets=None):
    method distribution_focal_loss (line 324) | def distribution_focal_loss(self,
    method main_kd (line 343) | def main_kd(self, mask_positive, pred_scores, soft_cls, num_classes):
    method forward (line 357) | def forward(self, teacher_model, student_model):
  class CWDFeatureLoss (line 429) | class CWDFeatureLoss(nn.Layer):
    method __init__ (line 430) | def __init__(self,
    method distill_softmax (line 451) | def distill_softmax(self, x, tau):
    method forward (line 457) | def forward(self, preds_s, preds_t, inputs=None):
  class FGDFeatureLoss (line 477) | class FGDFeatureLoss(nn.Layer):
    method __init__ (line 493) | def __init__(self,
    method spatial_channel_attention (line 558) | def spatial_channel_attention(self, x, t=0.5):
    method spatial_pool (line 574) | def spatial_pool(self, x, mode="teacher"):
    method mask_loss (line 591) | def mask_loss(self, stu_channel_att, tea_channel_att, stu_spatial_att,
    method feature_loss (line 600) | def feature_loss(self, stu_feature, tea_feature, mask_fg, mask_bg,
    method relation_loss (line 621) | def relation_loss(self, stu_feature, tea_feature):
    method mask_value (line 629) | def mask_value(self, mask, xl, xr, yl, yr, value):
    method forward (line 633) | def forward(self, stu_feature, tea_feature, inputs):
  class PKDFeatureLoss (line 728) | class PKDFeatureLoss(nn.Layer):
    method __init__ (line 740) | def __init__(self,
    method forward (line 751) | def forward(self, stu_feature, tea_feature, inputs=None):
  class MimicFeatureLoss (line 771) | class MimicFeatureLoss(nn.Layer):
    method __init__ (line 772) | def __init__(self,
    method forward (line 792) | def forward(self, stu_feature, tea_feature, inputs=None):
  class MGDFeatureLoss (line 805) | class MGDFeatureLoss(nn.Layer):
    method __init__ (line 806) | def __init__(self,
    method forward (line 840) | def forward(self, stu_feature, tea_feature, inputs=None):
  class SSIM (line 860) | class SSIM(nn.Layer):
    method __init__ (line 861) | def __init__(self, window_size=11, size_average=True):
    method gaussian (line 868) | def gaussian(self, window_size, sigma):
    method create_window (line 875) | def create_window(self, window_size, channel):
    method _ssim (line 881) | def _ssim(self, img1, img2, window, window_size, channel,
    method forward (line 909) | def forward(self, img1, img2):

FILE: ppdet/slim/distill_model.py
  class DistillModel (line 37) | class DistillModel(nn.Layer):
    method __init__ (line 45) | def __init__(self, cfg, slim_cfg):
    method build_loss (line 84) | def build_loss(self, distill_cfg):
    method parameters (line 90) | def parameters(self):
    method forward (line 93) | def forward(self, inputs):
  class FGDDistillModel (line 109) | class FGDDistillModel(DistillModel):
    method __init__ (line 117) | def __init__(self, cfg, slim_cfg):
    method build_loss (line 123) | def build_loss(self, distill_cfg):
    method forward (line 132) | def forward(self, inputs):
  class CWDDistillModel (line 183) | class CWDDistillModel(DistillModel):
    method __init__ (line 191) | def __init__(self, cfg, slim_cfg):
    method build_loss (line 196) | def build_loss(self, distill_cfg):
    method get_loss_retinanet (line 205) | def get_loss_retinanet(self, stu_fea_list, tea_fea_list, inputs):
    method get_loss_gfl (line 216) | def get_loss_gfl(self, stu_fea_list, tea_fea_list, inputs):
    method forward (line 250) | def forward(self, inputs):
  class LDDistillModel (line 283) | class LDDistillModel(DistillModel):
    method __init__ (line 291) | def __init__(self, cfg, slim_cfg):
    method forward (line 295) | def forward(self, inputs):
  class PPYOLOEDistillModel (line 317) | class PPYOLOEDistillModel(DistillModel):
    method __init__ (line 325) | def __init__(self, cfg, slim_cfg):
    method forward (line 330) | def forward(self, inputs, alpha=0.125):

FILE: ppdet/slim/ofa.py
  class OFA (line 21) | class OFA(object):
    method __init__ (line 22) | def __init__(self, ofa_config):
    method __call__ (line 26) | def __call__(self, model, param_state_dict):

FILE: ppdet/slim/prune.py
  function print_prune_params (line 27) | def print_prune_params(model):
  class Pruner (line 37) | class Pruner(object):
    method __init__ (line 38) | def __init__(self,
    method __call__ (line 51) | def __call__(self, model):
  class PrunerQAT (line 90) | class PrunerQAT(object):
    method __init__ (line 91) | def __init__(self, criterion, pruned_params, pruned_ratios,
    method __call__ (line 105) | def __call__(self, model):
    method save_quantized_model (line 149) | def save_quantized_model(self, layer, path, input_spec=None, **config):

FILE: ppdet/slim/quant.py
  class QAT (line 28) | class QAT(object):
    method __init__ (line 29) | def __init__(self, quant_config, print_model):
    method __call__ (line 34) | def __call__(self, model):
    method save_quantized_model (line 54) | def save_quantized_model(self, layer, path, input_spec=None, **config):
  class PTQ (line 61) | class PTQ(object):
    method __init__ (line 62) | def __init__(self,
    method __call__ (line 75) | def __call__(self, model):
    method save_quantized_model (line 84) | def save_quantized_model(self,

FILE: ppdet/slim/unstructured_prune.py
  class UnstructuredPruner (line 28) | class UnstructuredPruner(object):
    method __init__ (line 29) | def __init__(self,
    method __call__ (line 45) | def __call__(self, model, steps_per_epoch, skip_params_func=None):

FILE: ppdet/utils/cam_utils.py
  function get_test_images (line 14) | def get_test_images(infer_dir, infer_img):
  function compute_ious (line 45) | def compute_ious(boxes1, boxes2):
  function grad_cam (line 74) | def grad_cam(feat, grad):
  function resize_cam (line 89) | def resize_cam(explanation, resize_shape) -> np.ndarray:
  class BBoxCAM (line 114) | class BBoxCAM:
    method __init__ (line 115) | def __init__(self, FLAGS, cfg):
    method build_trainer (line 139) | def build_trainer(self, cfg):
    method set_hook (line 168) | def set_hook(self, cfg):
    method get_bboxes (line 193) | def get_bboxes(self):
    method get_bboxes_cams (line 206) | def get_bboxes_cams(self):

FILE: ppdet/utils/check.py
  function check_mlu (line 34) | def check_mlu(use_mlu):
  function check_npu (line 53) | def check_npu(use_npu):
  function check_xpu (line 73) | def check_xpu(use_xpu):
  function check_gpu (line 92) | def check_gpu(use_gpu):
  function check_version (line 111) | def check_version(version='2.2'):
  function check_config (line 138) | def check_config(cfg):

FILE: ppdet/utils/checkpoint.py
  function convert_to_dict (line 30) | def convert_to_dict(obj):
  function is_url (line 38) | def is_url(path):
  function _strip_postfix (line 49) | def _strip_postfix(path):
  function load_weight (line 56) | def load_weight(model, weight, optimizer=None, ema=None, exchange=True):
  function match_state_dict (line 135) | def match_state_dict(model_state_dict, weight_state_dict, mode='default'):
  function load_pretrain_weight (line 236) | def load_pretrain_weight(model, pretrain_weight, ARSL_eval=False):
  function save_model (line 291) | def save_model(model,
  function save_semi_model (line 351) | def save_semi_model(teacher_model, student_model, optimizer, save_dir,
  function save_model_info (line 387) | def save_model_info(model_info, save_path, prefix):
  function update_train_results (line 398) | def update_train_results(config,

FILE: ppdet/utils/cli.py
  class ColorTTY (line 24) | class ColorTTY(object):
    method __init__ (line 25) | def __init__(self):
    method __getattr__ (line 29) | def __getattr__(self, attr):
    method bold (line 39) | def bold(self, message):
    method with_code (line 42) | def with_code(self, code, message):
  class ArgsParser (line 46) | class ArgsParser(ArgumentParser):
    method __init__ (line 47) | def __init__(self):
    method parse_args (line 54) | def parse_args(self, argv=None):
    method _parse_opt (line 61) | def _parse_opt(self, opts):
  function merge_args (line 84) | def merge_args(config, args, exclude_args=['config', 'opt', 'slim_config...
  function print_total_cfg (line 91) | def print_total_cfg(config):

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

FILE: ppdet/utils/compact.py
  function imagedraw_textsize_c (line 3) | def imagedraw_textsize_c(draw, text, font=None):

FILE: ppdet/utils/download.py
  function must_mkdirs (line 120) | def must_mkdirs(path):
  function parse_url (line 129) | def parse_url(url):
  function get_weights_path (line 134) | def get_weights_path(url):
  function get_config_path (line 143) | def get_config_path(url):
  function get_dataset_path (line 180) | def get_dataset_path(path, annotation, image_dir):
  function create_voc_list (line 234) | def create_voc_list(data_dir, devkit_subdir='VOCdevkit'):
  function map_path (line 247) | def map_path(url, root_dir, path_depth=1):
  function get_path (line 261) | def get_path(url, root_dir, md5sum=None, check_exist=True):
  function download_dataset (line 305) | def download_dataset(path, dataset=None):
  function _dataset_exists (line 316) | def _dataset_exists(path, annotation, image_dir):
  function _download (line 342) | def _download(url, path, md5sum=None):
  function _download_dist (line 394) | def _download_dist(url, path, md5sum=None):
  function _check_exist_file_md5 (line 427) | def _check_exist_file_md5(filename, md5sum, url):
  function _md5check_from_url (line 435) | def _md5check_from_url(filename, url):
  function _md5check (line 450) | def _md5check(fullname, md5sum=None):
  function _decompress (line 468) | def _decompress(fname):
  function _decompress_dist (line 504) | def _decompress_dist(fname):
  function _move_and_merge_tree (line 540) | def _move_and_merge_tree(src, dst):

FILE: ppdet/utils/fuse_utils.py
  function fuse_conv_bn (line 22) | def fuse_conv_bn(model):
  function find_parent_layer_and_sub_name (line 44) | def find_parent_layer_and_sub_name(model, name):
  class Identity (line 75) | class Identity(nn.Layer):
    method __init__ (line 78) | def __init__(self, *args, **kwargs):
    method forward (line 81) | def forward(self, input):
  function fuse_layers (line 85) | def fuse_layers(model, layers_to_fuse, inplace=False):
  function _fuse_func (line 117) | def _fuse_func(layer_list):
  function _fuse_conv_bn (line 137) | def _fuse_conv_bn(conv, bn):
  function _fuse_conv_bn_eval (line 148) | def _fuse_conv_bn_eval(conv, bn):
  function _fuse_conv_bn_weights (line 164) | def _fuse_conv_bn_weights(conv_w, conv_b, bn_rm, bn_rv, bn_eps, bn_w, bn...

FILE: ppdet/utils/logger.py
  function setup_logger (line 26) | def setup_logger(name="ppdet", output=None, log_ranks="0"):

FILE: ppdet/utils/profiler.py
  class ProfilerOptions (line 27) | class ProfilerOptions(object):
    method __init__ (line 48) | def __init__(self, options_str):
    method _parse_from_string (line 62) | def _parse_from_string(self, options_str):
    method __getitem__ (line 80) | def __getitem__(self, name):
  function add_profiler_step (line 87) | def add_profiler_step(options_str=None):

FILE: ppdet/utils/stats.py
  class SmoothedValue (line 21) | class SmoothedValue(object):
    method __init__ (line 26) | def __init__(self, window_size=20, fmt=None):
    method update (line 34) | def update(self, value, n=1):
    method median (line 40) | def median(self):
    method avg (line 44) | def avg(self):
    method max (line 48) | def max(self):
    method value (line 52) | def value(self):
    method global_avg (line 56) | def global_avg(self):
    method __str__ (line 59) | def __str__(self):
  class TrainingStats (line 64) | class TrainingStats(object):
    method __init__ (line 65) | def __init__(self, window_size, delimiter=' '):
    method update (line 70) | def update(self, stats):
    method get (line 79) | def get(self, extras=None):
    method log (line 89) | def log(self, extras=None):

FILE: ppdet/utils/visualizer.py
  function visualize_results (line 35) | def visualize_results(image,
  function draw_mask (line 61) | def draw_mask(image, im_id, segms, threshold, alpha=0.7):
  function draw_bbox (line 87) | def draw_bbox(image, im_id, catid2name, bboxes, threshold):
  function save_result (line 144) | def save_result(save_path, results, catid2name, threshold):
  function draw_segm (line 172) | def draw_segm(image,
  function draw_pose (line 233) | def draw_pose(image,
  function draw_pose3d (line 336) | def draw_pose3d(image,

FILE: ppdet/utils/voc_utils.py
  function create_list (line 27) | def create_list(devkit_dir, years, output_dir):
  function _get_voc_dir (line 52) | def _get_voc_dir(devkit_dir, year, type):
  function _walk_voc_dir (line 56) | def _walk_voc_dir(devkit_dir, year, output_dir):

FILE: tools/anchor_cluster.py
  class BaseAnchorCluster (line 37) | class BaseAnchorCluster(object):
    method __init__ (line 38) | def __init__(self, n, cache_path, cache, verbose=True):
    method print_result (line 54) | def print_result(self, centers):
    method get_whs (line 58) | def get_whs(self):
    method calc_anchors (line 88) | def calc_anchors(self):
    method __call__ (line 92) | def __call__(self):
  class YOLOv2AnchorCluster (line 100) | class YOLOv2AnchorCluster(BaseAnchorCluster):
    method __init__ (line 101) | def __init__(self,
    method print_result (line 129) | def print_result(self, centers):
    method metric (line 134) | def metric(self, whs, centers):
    method kmeans_expectation (line 140) | def kmeans_expectation(self, whs, centers, assignments):
    method kmeans_maximizations (line 146) | def kmeans_maximizations(self, whs, centers, assignments):
    method calc_anchors (line 154) | def calc_anchors(self):
  function main (line 184) | def main():

FILE: tools/box_distribution.py
  function median (line 23) | def median(data):
  function draw_distribution (line 30) | def draw_distribution(width, height, out_path):
  function get_ratio_infos (line 48) | def get_ratio_infos(jsonfile, out_img, eval_size, small_stride):
  function main (line 120) | def main():

FILE: tools/cam_ppdet.py
  function parse_args (line 22) | def parse_args():
  function run (line 69) | def run(FLAGS, cfg):
  function main (line 82) | def main():

FILE: tools/eval.py
  function parse_args (line 43) | def parse_args():
  function run (line 124) | def run(FLAGS, cfg):
  function main (line 162) | def main():

FILE: tools/eval_mot.py
  function parse_args (line 38) | def parse_args():
  function run (line 72) | def run(FLAGS, cfg):
  function main (line 102) | def main():

FILE: tools/export_model.py
  function parse_args (line 42) | def parse_args():
  function run (line 64) | def run(FLAGS, cfg):
  function main (line 97) | def main():

FILE: tools/gen_semi_coco.py
  function save_json (line 21) | def save_json(path, images, annotations, categories):
  function gen_semi_data (line 33) | def gen_semi_data(data_dir,

FILE: tools/infer.py
  function parse_args (line 43) | def parse_args():
  function get_test_images (line 148) | def get_test_images(infer_dir, infer_img, infer_list=None):
  function run (line 186) | def run(FLAGS, cfg):
  function main (line 228) | def main():

FILE: tools/infer_culane.py
  function parse_args (line 43) | def parse_args():
  function get_test_images (line 74) | def get_test_images(infer_dir, infer_img):
  function run (line 105) | def run(FLAGS, cfg):
  function main (line 122) | def main():

FILE: tools/infer_mot.py
  function parse_args (line 37) | def parse_args():
  function run (line 88) | def run(FLAGS, cfg):
  function main (line 114) | def main():

FILE: tools/post_quant.py
  function parse_args (line 42) | def parse_args():
  function run (line 58) | def run(FLAGS, cfg):
  function main (line 75) | def main():

FILE: tools/slice_image.py
  function slice_data (line 19) | def slice_data(image_dir, dataset_json_path, output_dir, slice_size,
  function main (line 37) | def main():

FILE: tools/sniper_params_stats.py
  function get_default_params (line 23) | def get_default_params(architecture):
  function get_box_ratios (line 41) | def get_box_ratios(anno_file):
  function get_target_size_and_valid_box_ratios (line 70) | def get_target_size_and_valid_box_ratios(anchor_range, box_ratio_p2, box...
  function get_valid_ranges (line 106) | def get_valid_ranges(valid_ratios):
  function get_percentile (line 126) | def get_percentile(a_array, low_percent, high_percent):
  function sniper_anno_stats (line 144) | def sniper_anno_stats(architecture, anno_file):

FILE: tools/train.py
  function parse_args (line 48) | def parse_args():
  function run (line 122) | def run(FLAGS, cfg):
  function main (line 164) | def main():

FILE: tools/x2coco.py
  class MyEncoder (line 35) | class MyEncoder(json.JSONEncoder):
    method default (line 36) | def default(self, obj):
  function images_labelme (line 47) | def images_labelme(data, num):
  function images_cityscape (line 59) | def images_cityscape(data, num, img_file):
  function categories (line 68) | def categories(label, labels_list):
  function annotations_rectangle (line 76) | def annotations_rectangle(points, label, image_num, object_num, label_to...
  function annotations_polygon (line 95) | def annotations_polygon(height, width, points, label, image_num, object_...
  function get_bbox (line 108) | def get_bbox(height, width, points):
  function deal_json (line 128) | def deal_json(ds_type, img_path, json_path):
  function voc_get_label_anno (line 191) | def voc_get_label_anno(ann_dir_path, ann_ids_path, labels_path):
  function voc_get_image_info (line 210) | def voc_get_image_info(annotation_root, im_id):
  function voc_get_coco_annotation (line 228) | def voc_get_coco_annotation(obj, label2id):
  function voc_xmls_to_cocojson (line 250) | def voc_xmls_to_cocojson(annotation_paths, label2id, output_dir, output_...
  function widerface_to_cocojson (line 284) | def widerface_to_cocojson(root_path):
  function widerface_convert (line 301) | def widerface_convert(gt_txt, img_dir, save_path):
  function get_widerface_image_info (line 337) | def get_widerface_image_info(img_root, img_relative_path, img_id):
  function get_widerface_ann_info (line 351) | def get_widerface_ann_info(info):
  function main (line 369) | def main():