SYMBOL INDEX (3393 symbols across 496 files)

FILE: demo/body3d_pose_lifter_demo.py
  function parse_args (line 34) | def parse_args():
  function process_one_image (line 135) | def process_one_image(args, detector, frame, frame_idx, pose_estimator,
  function main (line 363) | def main():

FILE: demo/bottomup_demo.py
  function process_one_image (line 20) | def process_one_image(args,
  function parse_args (line 53) | def parse_args():
  function main (line 104) | def main():

FILE: demo/hand3d_internet_demo.py
  function parse_args (line 21) | def parse_args():
  function process_one_image (line 79) | def process_one_image(args, img, model, visualizer=None, show_interval=0):
  function main (line 155) | def main():

FILE: demo/image_demo.py
  function parse_args (line 13) | def parse_args():
  function main (line 62) | def main():

FILE: demo/inferencer_demo.py
  function parse_args (line 14) | def parse_args():
  function display_model_aliases (line 200) | def display_model_aliases(model_aliases: Dict[str, str]) -> None:
  function main (line 210) | def main():

FILE: demo/topdown_demo_with_mmdet.py
  function process_one_image (line 29) | def process_one_image(args,
  function main (line 74) | def main():

FILE: docs/en/collect_modelzoo.py
  function _get_model_docs (line 13) | def _get_model_docs():
  function _parse_model_doc_path (line 26) | def _parse_model_doc_path(path):
  function _get_paper_refs (line 68) | def _get_paper_refs():
  function _parse_paper_ref (line 84) | def _parse_paper_ref(fn):
  function main (line 105) | def main():

FILE: docs/en/collect_projects.py
  function _get_project_docs (line 9) | def _get_project_docs():
  function _parse_project_doc_path (line 25) | def _parse_project_doc_path(fn):
  function _get_project_intro_doc (line 50) | def _get_project_intro_doc():
  function _get_faq_doc (line 68) | def _get_faq_doc():
  function main (line 80) | def main():

FILE: docs/en/conf.py
  function get_version (line 32) | def get_version():
  function builder_inited_handler (line 103) | def builder_inited_handler(app):
  function setup (line 110) | def setup(app):

FILE: docs/en/stats.py
  function anchor (line 12) | def anchor(name):

FILE: docs/zh_cn/collect_modelzoo.py
  function _get_model_docs (line 13) | def _get_model_docs():
  function _parse_model_doc_path (line 26) | def _parse_model_doc_path(path):
  function _get_paper_refs (line 68) | def _get_paper_refs():
  function _parse_paper_ref (line 84) | def _parse_paper_ref(fn):
  function main (line 105) | def main():

FILE: docs/zh_cn/collect_projects.py
  function _get_project_docs (line 9) | def _get_project_docs():
  function _parse_project_doc_path (line 25) | def _parse_project_doc_path(fn):
  function _get_project_intro_doc (line 50) | def _get_project_intro_doc():
  function _get_faq_doc (line 70) | def _get_faq_doc():
  function main (line 82) | def main():

FILE: docs/zh_cn/conf.py
  function get_version (line 32) | def get_version():
  function builder_inited_handler (line 100) | def builder_inited_handler(app):
  function setup (line 107) | def setup(app):

FILE: docs/zh_cn/stats.py
  function anchor (line 12) | def anchor(name):

FILE: mmpose/apis/inference.py
  function dataset_meta_from_config (line 22) | def dataset_meta_from_config(config: Config,
  function init_model (line 68) | def init_model(config: Union[str, Path, Config],
  function inference_topdown (line 134) | def inference_topdown(model: nn.Module,
  function inference_bottomup (line 203) | def inference_bottomup(model: nn.Module, img: Union[np.ndarray, str]):
  function collect_multi_frames (line 233) | def collect_multi_frames(video, frame_id, indices, online=False):

FILE: mmpose/apis/inference_3d.py
  function convert_keypoint_definition (line 11) | def convert_keypoint_definition(keypoints, pose_det_dataset,
  function extract_pose_sequence (line 92) | def extract_pose_sequence(pose_results, frame_idx, causal, seq_len, step...
  function collate_pose_sequence (line 129) | def collate_pose_sequence(pose_results_2d,
  function inference_pose_lifter_model (line 229) | def inference_pose_lifter_model(model,

FILE: mmpose/apis/inference_tracking.py
  function _compute_iou (line 9) | def _compute_iou(bboxA, bboxB):
  function _track_by_iou (line 39) | def _track_by_iou(res, results_last, thr):
  function _track_by_oks (line 65) | def _track_by_oks(res, results_last, thr, sigmas=None):

FILE: mmpose/apis/inferencers/base_mmpose_inferencer.py
  class BaseMMPoseInferencer (line 47) | class BaseMMPoseInferencer(BaseInferencer):
    method __init__ (line 58) | def __init__(self,
    method _init_detector (line 67) | def _init_detector(
    method _load_weights_to_model (line 115) | def _load_weights_to_model(self, model: nn.Module,
    method _inputs_to_list (line 153) | def _inputs_to_list(self, inputs: InputsType) -> Iterable:
    method _get_webcam_inputs (line 217) | def _get_webcam_inputs(self, inputs: str) -> Generator:
    method _init_pipeline (line 291) | def _init_pipeline(self, cfg: ConfigType) -> Callable:
    method update_model_visualizer_settings (line 307) | def update_model_visualizer_settings(self, **kwargs):
    method preprocess (line 313) | def preprocess(self,
    method __call__ (line 359) | def __call__(
    method visualize (line 455) | def visualize(self,
    method save_visualization (line 549) | def save_visualization(self, visualization, vis_out_dir, img_name=None):
    method postprocess (line 584) | def postprocess(
    method _finalize_video_processing (line 660) | def _finalize_video_processing(

FILE: mmpose/apis/inferencers/hand3d_inferencer.py
  class Hand3DInferencer (line 32) | class Hand3DInferencer(BaseMMPoseInferencer):
    method __init__ (line 74) | def __init__(self,
    method preprocess_single (line 107) | def preprocess_single(self,
    method forward (line 183) | def forward(self,
    method visualize (line 248) | def visualize(

FILE: mmpose/apis/inferencers/mmpose_inferencer.py
  class MMPoseInferencer (line 26) | class MMPoseInferencer(BaseMMPoseInferencer):
    method __init__ (line 73) | def __init__(self,
    method preprocess (line 107) | def preprocess(self, inputs: InputsType, batch_size: int = 1, **kwargs):
    method forward (line 122) | def forward(self, inputs: InputType, **forward_kwargs) -> PredType:
    method __call__ (line 133) | def __call__(
    method visualize (line 223) | def visualize(self, inputs: InputsType, preds: PredType,

FILE: mmpose/apis/inferencers/pose2d_inferencer.py
  class Pose2DInferencer (line 31) | class Pose2DInferencer(BaseMMPoseInferencer):
    method __init__ (line 75) | def __init__(self,
    method update_model_visualizer_settings (line 108) | def update_model_visualizer_settings(self,
    method preprocess_single (line 131) | def preprocess_single(self,
    method forward (line 213) | def forward(self,

FILE: mmpose/apis/inferencers/pose3d_inferencer.py
  class Pose3DInferencer (line 34) | class Pose3DInferencer(BaseMMPoseInferencer):
    method __init__ (line 82) | def __init__(self,
    method preprocess_single (line 128) | def preprocess_single(self,
    method forward (line 305) | def forward(self,
    method visualize (line 355) | def visualize(self,

FILE: mmpose/apis/inferencers/utils/get_model_alias.py
  function get_model_aliases (line 7) | def get_model_aliases(scope: str = 'mmpose') -> Dict[str, str]:

FILE: mmpose/apis/visualization.py
  function visualize (line 14) | def visualize(

FILE: mmpose/codecs/annotation_processors.py
  class BaseAnnotationProcessor (line 13) | class BaseAnnotationProcessor(BaseKeypointCodec):
    method decode (line 16) | def decode(self, *args, **kwargs):
  class YOLOXPoseAnnotationProcessor (line 21) | class YOLOXPoseAnnotationProcessor(BaseAnnotationProcessor):
    method __init__ (line 51) | def __init__(self,
    method encode (line 57) | def encode(self,

FILE: mmpose/codecs/associative_embedding.py
  function _py_max_match (line 18) | def _py_max_match(scores):
  function _group_keypoints_by_tags (line 33) | def _group_keypoints_by_tags(vals: np.ndarray,
  class AssociativeEmbedding (line 146) | class AssociativeEmbedding(BaseKeypointCodec):
    method __init__ (line 205) | def __init__(
    method encode (line 245) | def encode(
    method _encode_keypoint_indices (line 301) | def _encode_keypoint_indices(self, heatmap_size: Tuple[int, int],
    method decode (line 316) | def decode(self, encoded: Any) -> Tuple[np.ndarray, np.ndarray]:
    method _get_batch_topk (line 319) | def _get_batch_topk(self, batch_heatmaps: Tensor, batch_tags: Tensor,
    method _group_keypoints (line 359) | def _group_keypoints(self, batch_vals: np.ndarray, batch_tags: np.ndar...
    method _fill_missing_keypoints (line 393) | def _fill_missing_keypoints(self, keypoints: np.ndarray,
    method batch_decode (line 445) | def batch_decode(self, batch_heatmaps: Tensor, batch_tags: Tensor

FILE: mmpose/codecs/base.py
  class BaseKeypointCodec (line 9) | class BaseKeypointCodec(metaclass=ABCMeta):
    method encode (line 26) | def encode(self,
    method decode (line 47) | def decode(self, encoded: Any) -> Tuple[np.ndarray, np.ndarray]:
    method batch_decode (line 60) | def batch_decode(self, batch_encoded: Any
    method support_batch_decoding (line 78) | def support_batch_decoding(self) -> bool:

FILE: mmpose/codecs/decoupled_heatmap.py
  class DecoupledHeatmap (line 16) | class DecoupledHeatmap(BaseKeypointCodec):
    method __init__ (line 77) | def __init__(
    method _get_instance_wise_sigmas (line 96) | def _get_instance_wise_sigmas(
    method encode (line 142) | def encode(self,
    method decode (line 242) | def decode(self, instance_heatmaps: np.ndarray,

FILE: mmpose/codecs/edpose_label.py
  class EDPoseLabel (line 12) | class EDPoseLabel(BaseKeypointCodec):
    method __init__ (line 44) | def __init__(self, num_select: int = 100, num_keypoints: int = 17):
    method encode (line 50) | def encode(
    method decode (line 106) | def decode(self, input_shapes: np.ndarray, pred_logits: np.ndarray,

FILE: mmpose/codecs/hand_3d_heatmap.py
  class Hand3DHeatmap (line 13) | class Hand3DHeatmap(BaseKeypointCodec):
    method __init__ (line 62) | def __init__(self,
    method encode (line 91) | def encode(
    method decode (line 164) | def decode(self, heatmaps: np.ndarray, root_depth: np.ndarray,

FILE: mmpose/codecs/image_pose_lifting.py
  class ImagePoseLifting (line 11) | class ImagePoseLifting(BaseKeypointCodec):
    method __init__ (line 53) | def __init__(self,
    method encode (line 105) | def encode(self,
    method decode (line 249) | def decode(self,

FILE: mmpose/codecs/integral_regression_label.py
  class IntegralRegressionLabel (line 14) | class IntegralRegressionLabel(BaseKeypointCodec):
    method __init__ (line 54) | def __init__(self,
    method encode (line 68) | def encode(self,
    method decode (line 105) | def decode(self, encoded: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:

FILE: mmpose/codecs/megvii_heatmap.py
  class MegviiHeatmap (line 14) | class MegviiHeatmap(BaseKeypointCodec):
    method __init__ (line 45) | def __init__(
    method encode (line 59) | def encode(self,
    method decode (line 110) | def decode(self, encoded: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:

FILE: mmpose/codecs/motionbert_label.py
  class MotionBERTLabel (line 14) | class MotionBERTLabel(BaseKeypointCodec):
    method __init__ (line 54) | def __init__(self,
    method encode (line 75) | def encode(self,
    method decode (line 185) | def decode(

FILE: mmpose/codecs/msra_heatmap.py
  class MSRAHeatmap (line 15) | class MSRAHeatmap(BaseKeypointCodec):
    method __init__ (line 53) | def __init__(self,
    method encode (line 77) | def encode(self,
    method decode (line 120) | def decode(self, encoded: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:

FILE: mmpose/codecs/regression_label.py
  class RegressionLabel (line 12) | class RegressionLabel(BaseKeypointCodec):
    method __init__ (line 38) | def __init__(self, input_size: Tuple[int, int]) -> None:
    method encode (line 43) | def encode(self,
    method decode (line 76) | def decode(self, encoded: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:

FILE: mmpose/codecs/simcc_label.py
  class SimCCLabel (line 14) | class SimCCLabel(BaseKeypointCodec):
    method __init__ (line 67) | def __init__(
    method encode (line 108) | def encode(self,
    method decode (line 156) | def decode(self, simcc_x: np.ndarray,
    method _map_coordinates (line 202) | def _map_coordinates(
    method _generate_standard (line 216) | def _generate_standard(
    method _generate_gaussian (line 260) | def _generate_gaussian(

FILE: mmpose/codecs/spr.py
  class SPR (line 16) | class SPR(BaseKeypointCodec):
    method __init__ (line 83) | def __init__(
    method _get_heatmap_weights (line 127) | def _get_heatmap_weights(self,
    method encode (line 145) | def encode(self,
    method decode (line 229) | def decode(self, heatmaps: Tensor,
    method get_keypoint_scores (line 283) | def get_keypoint_scores(self, heatmaps: Tensor, keypoints: Tensor):

FILE: mmpose/codecs/udp_heatmap.py
  class UDPHeatmap (line 14) | class UDPHeatmap(BaseKeypointCodec):
    method __init__ (line 63) | def __init__(self,
    method encode (line 86) | def encode(self,
    method decode (line 137) | def decode(self, encoded: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:

FILE: mmpose/codecs/utils/camera_image_projection.py
  function camera_to_image_coord (line 7) | def camera_to_image_coord(root_index: int, kpts_3d_cam: np.ndarray,
  function camera_to_pixel (line 50) | def camera_to_pixel(kpts_3d: np.ndarray,
  function pixel_to_camera (line 80) | def pixel_to_camera(kpts_3d: np.ndarray, fx: float, fy: float, cx: float,

FILE: mmpose/codecs/utils/gaussian_heatmap.py
  function generate_3d_gaussian_heatmaps (line 8) | def generate_3d_gaussian_heatmaps(
  function generate_gaussian_heatmaps (line 120) | def generate_gaussian_heatmaps(
  function generate_unbiased_gaussian_heatmaps (line 205) | def generate_unbiased_gaussian_heatmaps(
  function generate_udp_gaussian_heatmaps (line 263) | def generate_udp_gaussian_heatmaps(

FILE: mmpose/codecs/utils/instance_property.py
  function get_instance_root (line 7) | def get_instance_root(keypoints: np.ndarray,
  function get_instance_bbox (line 64) | def get_instance_bbox(keypoints: np.ndarray,
  function get_diagonal_lengths (line 92) | def get_diagonal_lengths(keypoints: np.ndarray,

FILE: mmpose/codecs/utils/offset_heatmap.py
  function generate_offset_heatmap (line 8) | def generate_offset_heatmap(
  function generate_displacement_heatmap (line 67) | def generate_displacement_heatmap(

FILE: mmpose/codecs/utils/post_processing.py
  function get_simcc_normalized (line 12) | def get_simcc_normalized(batch_pred_simcc, sigma=None):
  function get_simcc_maximum (line 41) | def get_simcc_maximum(simcc_x: np.ndarray,
  function get_heatmap_3d_maximum (line 108) | def get_heatmap_3d_maximum(heatmaps: np.ndarray
  function get_heatmap_maximum (line 156) | def get_heatmap_maximum(heatmaps: np.ndarray) -> Tuple[np.ndarray, np.nd...
  function gaussian_blur (line 201) | def gaussian_blur(heatmaps: np.ndarray, kernel: int = 11) -> np.ndarray:
  function gaussian_blur1d (line 233) | def gaussian_blur1d(simcc: np.ndarray, kernel: int = 11) -> np.ndarray:
  function batch_heatmap_nms (line 264) | def batch_heatmap_nms(batch_heatmaps: Tensor, kernel_size: int = 5):

FILE: mmpose/codecs/utils/refinement.py
  function refine_keypoints (line 9) | def refine_keypoints(keypoints: np.ndarray,
  function refine_keypoints_dark (line 49) | def refine_keypoints_dark(keypoints: np.ndarray, heatmaps: np.ndarray,
  function refine_keypoints_dark_udp (line 105) | def refine_keypoints_dark_udp(keypoints: np.ndarray, heatmaps: np.ndarray,
  function refine_simcc_dark (line 168) | def refine_simcc_dark(keypoints: np.ndarray, simcc: np.ndarray,

FILE: mmpose/codecs/video_pose_lifting.py
  class VideoPoseLifting (line 13) | class VideoPoseLifting(BaseKeypointCodec):
    method __init__ (line 55) | def __init__(self,
    method encode (line 77) | def encode(self,
    method decode (line 221) | def decode(self,

FILE: mmpose/datasets/builder.py
  function _concat_dataset (line 23) | def _concat_dataset(cfg, default_args=None):
  function build_dataset (line 56) | def build_dataset(cfg, default_args=None):
  function worker_init_fn (line 83) | def worker_init_fn(worker_id, num_workers, rank, seed):

FILE: mmpose/datasets/dataset_wrappers.py
  class CombinedDataset (line 15) | class CombinedDataset(BaseDataset):
    method __init__ (line 26) | def __init__(self,
    method metainfo (line 59) | def metainfo(self):
    method lens (line 63) | def lens(self):
    method __len__ (line 66) | def __len__(self):
    method _get_subset_index (line 69) | def _get_subset_index(self, index: int) -> Tuple[int, int]:
    method prepare_data (line 103) | def prepare_data(self, idx: int) -> Any:
    method get_data_info (line 123) | def get_data_info(self, idx: int) -> dict:
    method full_init (line 149) | def full_init(self):

FILE: mmpose/datasets/datasets/animal/animalkingdom_dataset.py
  class AnimalKingdomDataset (line 7) | class AnimalKingdomDataset(BaseCocoStyleDataset):

FILE: mmpose/datasets/datasets/animal/animalpose_dataset.py
  class AnimalPoseDataset (line 7) | class AnimalPoseDataset(BaseCocoStyleDataset):

FILE: mmpose/datasets/datasets/animal/ap10k_dataset.py
  class AP10KDataset (line 7) | class AP10KDataset(BaseCocoStyleDataset):

FILE: mmpose/datasets/datasets/animal/atrw_dataset.py
  class ATRWDataset (line 7) | class ATRWDataset(BaseCocoStyleDataset):

FILE: mmpose/datasets/datasets/animal/fly_dataset.py
  class FlyDataset (line 7) | class FlyDataset(BaseCocoStyleDataset):

FILE: mmpose/datasets/datasets/animal/horse10_dataset.py
  class Horse10Dataset (line 7) | class Horse10Dataset(BaseCocoStyleDataset):

FILE: mmpose/datasets/datasets/animal/locust_dataset.py
  class LocustDataset (line 12) | class LocustDataset(BaseCocoStyleDataset):
    method parse_data_info (line 98) | def parse_data_info(self, raw_data_info: dict) -> Optional[dict]:

FILE: mmpose/datasets/datasets/animal/macaque_dataset.py
  class MacaqueDataset (line 8) | class MacaqueDataset(BaseCocoStyleDataset):

FILE: mmpose/datasets/datasets/animal/zebra_dataset.py
  class ZebraDataset (line 12) | class ZebraDataset(BaseCocoStyleDataset):
    method parse_data_info (line 72) | def parse_data_info(self, raw_data_info: dict) -> Optional[dict]:

FILE: mmpose/datasets/datasets/base/base_coco_style_dataset.py
  class BaseCocoStyleDataset (line 21) | class BaseCocoStyleDataset(BaseDataset):
    method __init__ (line 66) | def __init__(self,
    method _load_metainfo (line 124) | def _load_metainfo(cls, metainfo: dict = None) -> dict:
    method prepare_data (line 147) | def prepare_data(self, idx) -> Any:
    method get_data_info (line 172) | def get_data_info(self, idx: int) -> dict:
    method load_data_list (line 198) | def load_data_list(self) -> List[dict]:
    method _load_annotations (line 217) | def _load_annotations(self) -> Tuple[List[dict], List[dict]]:
    method parse_data_info (line 259) | def parse_data_info(self, raw_data_info: dict) -> Optional[dict]:
    method _is_valid_instance (line 333) | def _is_valid_instance(data_info: Dict) -> bool:
    method _get_topdown_data_infos (line 354) | def _get_topdown_data_infos(self, instance_list: List[Dict]) -> List[D...
    method _get_bottomup_data_infos (line 361) | def _get_bottomup_data_infos(self, instance_list: List[Dict],
    method _load_detection_results (line 421) | def _load_detection_results(self) -> List[dict]:
    method filter_data (line 477) | def filter_data(self) -> List[dict]:

FILE: mmpose/datasets/datasets/base/base_mocap_dataset.py
  class BaseMocapDataset (line 21) | class BaseMocapDataset(BaseDataset):
    method __init__ (line 68) | def __init__(self,
    method _load_ann_file (line 139) | def _load_ann_file(self, ann_file: str) -> dict:
    method _load_metainfo (line 153) | def _load_metainfo(cls, metainfo: dict = None) -> dict:
    method prepare_data (line 176) | def prepare_data(self, idx) -> Any:
    method get_data_info (line 193) | def get_data_info(self, idx: int) -> dict:
    method load_data_list (line 219) | def load_data_list(self) -> List[dict]:
    method get_img_info (line 233) | def get_img_info(self, img_idx, img_name):
    method get_sequence_indices (line 256) | def get_sequence_indices(self) -> List[List[int]]:
    method _load_annotations (line 287) | def _load_annotations(self) -> Tuple[List[dict], List[dict]]:
    method get_camera_param (line 371) | def get_camera_param(self, imgname):
    method _is_valid_instance (line 379) | def _is_valid_instance(data_info: Dict) -> bool:
    method _get_topdown_data_infos (line 394) | def _get_topdown_data_infos(self, instance_list: List[Dict]) -> List[D...
    method _get_bottomup_data_infos (line 401) | def _get_bottomup_data_infos(self, instance_list: List[Dict],

FILE: mmpose/datasets/datasets/body/aic_dataset.py
  class AicDataset (line 7) | class AicDataset(BaseCocoStyleDataset):

FILE: mmpose/datasets/datasets/body/coco_dataset.py
  class CocoDataset (line 7) | class CocoDataset(BaseCocoStyleDataset):

FILE: mmpose/datasets/datasets/body/crowdpose_dataset.py
  class CrowdPoseDataset (line 7) | class CrowdPoseDataset(BaseCocoStyleDataset):

FILE: mmpose/datasets/datasets/body/exlpose_dataset.py
  class ExlposeDataset (line 7) | class ExlposeDataset(BaseCocoStyleDataset):

FILE: mmpose/datasets/datasets/body/humanart21_dataset.py
  class HumanArt21Dataset (line 12) | class HumanArt21Dataset(HumanArtDataset):
    method parse_data_info (line 84) | def parse_data_info(self, raw_data_info: dict) -> Optional[dict]:

FILE: mmpose/datasets/datasets/body/humanart_dataset.py
  class HumanArtDataset (line 7) | class HumanArtDataset(BaseCocoStyleDataset):

FILE: mmpose/datasets/datasets/body/jhmdb_dataset.py
  class JhmdbDataset (line 12) | class JhmdbDataset(BaseCocoStyleDataset):
    method parse_data_info (line 78) | def parse_data_info(self, raw_data_info: dict) -> Optional[dict]:

FILE: mmpose/datasets/datasets/body/mhp_dataset.py
  class MhpDataset (line 7) | class MhpDataset(BaseCocoStyleDataset):

FILE: mmpose/datasets/datasets/body/mpii_dataset.py
  class MpiiDataset (line 16) | class MpiiDataset(BaseCocoStyleDataset):
    method __init__ (line 85) | def __init__(self,
    method _load_annotations (line 137) | def _load_annotations(self) -> Tuple[List[dict], List[dict]]:

FILE: mmpose/datasets/datasets/body/mpii_trb_dataset.py
  class MpiiTrbDataset (line 15) | class MpiiTrbDataset(BaseCocoStyleDataset):
    method _load_annotations (line 106) | def _load_annotations(self) -> Tuple[List[dict], List[dict]]:

FILE: mmpose/datasets/datasets/body/ochuman_dataset.py
  class OCHumanDataset (line 7) | class OCHumanDataset(BaseCocoStyleDataset):

FILE: mmpose/datasets/datasets/body/posetrack18_dataset.py
  class PoseTrack18Dataset (line 7) | class PoseTrack18Dataset(BaseCocoStyleDataset):

FILE: mmpose/datasets/datasets/body/posetrack18_video_dataset.py
  class PoseTrack18VideoDataset (line 16) | class PoseTrack18VideoDataset(BaseCocoStyleDataset):
    method __init__ (line 106) | def __init__(self,
    method parse_data_info (line 201) | def parse_data_info(self, raw_data_info: dict) -> Optional[dict]:
    method _load_detection_results (line 288) | def _load_detection_results(self) -> List[dict]:

FILE: mmpose/datasets/datasets/body3d/h36m_dataset.py
  class Human36mDataset (line 15) | class Human36mDataset(BaseMocapDataset):
    method __init__ (line 110) | def __init__(self,
    method get_sequence_indices (line 181) | def get_sequence_indices(self) -> List[List[int]]:
    method _load_annotations (line 246) | def _load_annotations(self) -> Tuple[List[dict], List[dict]]:
    method _parse_h36m_imgname (line 293) | def _parse_h36m_imgname(imgname) -> Tuple[str, str, str]:
    method get_camera_param (line 304) | def get_camera_param(self, imgname) -> dict:
    method _load_keypoint_2d_detection (line 310) | def _load_keypoint_2d_detection(self, det_file):

FILE: mmpose/datasets/datasets/face/aflw_dataset.py
  class AFLWDataset (line 13) | class AFLWDataset(BaseCocoStyleDataset):
    method parse_data_info (line 65) | def parse_data_info(self, raw_data_info: dict) -> Optional[dict]:

FILE: mmpose/datasets/datasets/face/coco_wholebody_face_dataset.py
  class CocoWholeBodyFaceDataset (line 12) | class CocoWholeBodyFaceDataset(BaseCocoStyleDataset):
    method parse_data_info (line 62) | def parse_data_info(self, raw_data_info: dict) -> Optional[dict]:

FILE: mmpose/datasets/datasets/face/cofw_dataset.py
  class COFWDataset (line 7) | class COFWDataset(BaseCocoStyleDataset):

FILE: mmpose/datasets/datasets/face/face_300vw_dataset.py
  class Face300VWDataset (line 13) | class Face300VWDataset(BaseCocoStyleDataset):
    method parse_data_info (line 64) | def parse_data_info(self, raw_data_info: dict) -> Optional[dict]:

FILE: mmpose/datasets/datasets/face/face_300w_dataset.py
  class Face300WDataset (line 13) | class Face300WDataset(BaseCocoStyleDataset):
    method parse_data_info (line 62) | def parse_data_info(self, raw_data_info: dict) -> Optional[dict]:

FILE: mmpose/datasets/datasets/face/face_300wlp_dataset.py
  class Face300WLPDataset (line 8) | class Face300WLPDataset(BaseCocoStyleDataset):

FILE: mmpose/datasets/datasets/face/lapa_dataset.py
  class LapaDataset (line 7) | class LapaDataset(BaseCocoStyleDataset):

FILE: mmpose/datasets/datasets/face/wflw_dataset.py
  class WFLWDataset (line 13) | class WFLWDataset(BaseCocoStyleDataset):
    method parse_data_info (line 62) | def parse_data_info(self, raw_data_info: dict) -> Optional[dict]:

FILE: mmpose/datasets/datasets/fashion/deepfashion2_dataset.py
  class DeepFashion2Dataset (line 7) | class DeepFashion2Dataset(BaseCocoStyleDataset):

FILE: mmpose/datasets/datasets/fashion/deepfashion_dataset.py
  class DeepFashionDataset (line 9) | class DeepFashionDataset(BaseCocoStyleDataset):
    method __init__ (line 85) | def __init__(self,
    method _check_subset_and_metainfo (line 118) | def _check_subset_and_metainfo(cls, subset: str = '') -> None:

FILE: mmpose/datasets/datasets/hand/coco_wholebody_hand_dataset.py
  class CocoWholeBodyHandDataset (line 15) | class CocoWholeBodyHandDataset(BaseCocoStyleDataset):
    method _load_annotations (line 87) | def _load_annotations(self) -> Tuple[List[dict], List[dict]]:

FILE: mmpose/datasets/datasets/hand/freihand_dataset.py
  class FreiHandDataset (line 12) | class FreiHandDataset(BaseCocoStyleDataset):
    method parse_data_info (line 84) | def parse_data_info(self, raw_data_info: dict) -> Optional[dict]:

FILE: mmpose/datasets/datasets/hand/interhand2d_double_dataset.py
  class InterHand2DDoubleDataset (line 19) | class InterHand2DDoubleDataset(BaseCocoStyleDataset):
    method __init__ (line 118) | def __init__(self,
    method _load_annotations (line 180) | def _load_annotations(self) -> Tuple[List[dict], List[dict]]:
    method parse_data_info (line 228) | def parse_data_info(self, raw_data_info: dict) -> Optional[dict]:
    method encode_handtype (line 334) | def encode_handtype(hand_type):

FILE: mmpose/datasets/datasets/hand/onehand10k_dataset.py
  class OneHand10KDataset (line 7) | class OneHand10KDataset(BaseCocoStyleDataset):

FILE: mmpose/datasets/datasets/hand/panoptic_hand2d_dataset.py
  class PanopticHand2DDataset (line 12) | class PanopticHand2DDataset(BaseCocoStyleDataset):
    method parse_data_info (line 85) | def parse_data_info(self, raw_data_info: dict) -> Optional[dict]:

FILE: mmpose/datasets/datasets/hand/rhd2d_dataset.py
  class Rhd2DDataset (line 7) | class Rhd2DDataset(BaseCocoStyleDataset):

FILE: mmpose/datasets/datasets/hand3d/interhand_3d_dataset.py
  class InterHand3DDataset (line 19) | class InterHand3DDataset(BaseCocoStyleDataset):
    method __init__ (line 116) | def __init__(self,
    method _load_annotations (line 177) | def _load_annotations(self) -> Tuple[List[dict], List[dict]]:
    method parse_data_info (line 223) | def parse_data_info(self, raw_data_info: dict) -> Optional[dict]:
    method encode_handtype (line 339) | def encode_handtype(hand_type):

FILE: mmpose/datasets/datasets/utils.py
  function parse_pose_metainfo (line 9) | def parse_pose_metainfo(metainfo: dict):

FILE: mmpose/datasets/datasets/wholebody/coco_wholebody_dataset.py
  class CocoWholeBodyDataset (line 13) | class CocoWholeBodyDataset(BaseCocoStyleDataset):
    method parse_data_info (line 70) | def parse_data_info(self, raw_data_info: dict) -> Optional[dict]:

FILE: mmpose/datasets/datasets/wholebody/halpe_dataset.py
  class HalpeDataset (line 7) | class HalpeDataset(BaseCocoStyleDataset):

FILE: mmpose/datasets/datasets/wholebody/ubody2d_dataset.py
  class UBody2dDataset (line 7) | class UBody2dDataset(CocoWholeBodyDataset):

FILE: mmpose/datasets/datasets/wholebody3d/h3wb_dataset.py
  class H36MWholeBodyDataset (line 13) | class H36MWholeBodyDataset(Human36mDataset):
    method __init__ (line 94) | def __init__(self, test_mode: bool = False, **kwargs):
    method _load_ann_file (line 104) | def _load_ann_file(self, ann_file: str) -> dict:
    method get_sequence_indices (line 112) | def get_sequence_indices(self) -> List[List[int]]:
    method _load_annotations (line 115) | def _load_annotations(self) -> Tuple[List[dict], List[dict]]:

FILE: mmpose/datasets/datasets/wholebody3d/ubody3d_dataset.py
  class UBody3dDataset (line 15) | class UBody3dDataset(BaseMocapDataset):
    method __init__ (line 72) | def __init__(self,
    method _load_ann_file (line 89) | def _load_ann_file(self, ann_file: str) -> dict:
    method get_sequence_indices (line 94) | def get_sequence_indices(self) -> List[List[int]]:
    method _parse_image_name (line 155) | def _parse_image_name(self, image_path: str) -> Tuple[str, int]:
    method _load_annotations (line 168) | def _load_annotations(self):
    method load_data_list (line 270) | def load_data_list(self) -> List[dict]:

FILE: mmpose/datasets/samplers.py
  class MultiSourceSampler (line 15) | class MultiSourceSampler(Sampler):
    method __init__ (line 32) | def __init__(self,
    method _infinite_indices (line 77) | def _infinite_indices(self, sample_size: int) -> Iterator[int]:
    method _indices_of_rank (line 87) | def _indices_of_rank(self, sample_size: int) -> Iterator[int]:
    method __iter__ (line 93) | def __iter__(self) -> Iterator[int]:
    method __len__ (line 109) | def __len__(self) -> int:
    method set_epoch (line 112) | def set_epoch(self, epoch: int) -> None:

FILE: mmpose/datasets/transforms/bottomup_transforms.py
  class BottomupGetHeatmapMask (line 22) | class BottomupGetHeatmapMask(BaseTransform):
    method __init__ (line 39) | def __init__(self, get_invalid: bool = False):
    method _segs_to_mask (line 43) | def _segs_to_mask(self, segs: list, img_shape: Tuple[int,
    method transform (line 79) | def transform(self, results: Dict) -> Optional[dict]:
  class BottomupRandomAffine (line 146) | class BottomupRandomAffine(BaseTransform):
    method __init__ (line 190) | def __init__(self,
    method _random (line 241) | def _random(self,
    method _fix_aspect_ratio (line 256) | def _fix_aspect_ratio(self, scale: np.ndarray, aspect_ratio: float):
    method _get_transform_params (line 284) | def _get_transform_params(self) -> Tuple:
    method transform (line 322) | def transform(self, results: Dict) -> Optional[dict]:
  class BottomupResize (line 415) | class BottomupResize(BaseTransform):
    method __init__ (line 466) | def __init__(self,
    method _ceil_to_multiple (line 483) | def _ceil_to_multiple(size: Tuple[int, int], base: int):
    method _get_input_size (line 487) | def _get_input_size(self, img_size: Tuple[int, int],
    method transform (line 538) | def transform(self, results: Dict) -> Optional[dict]:
  class BottomupRandomCrop (line 615) | class BottomupRandomCrop(BaseTransform):
    method __init__ (line 675) | def __init__(self,
    method _crop_data (line 699) | def _crop_data(self, results: dict, crop_size: Tuple[int, int],
    method _rand_offset (line 806) | def _rand_offset(self, margin: Tuple[int, int]) -> Tuple[int, int]:
    method _get_crop_size (line 823) | def _get_crop_size(self, image_size: Tuple[int, int]) -> Tuple[int, int]:
    method transform (line 853) | def transform(self, results: dict) -> Union[dict, None]:
  class BottomupRandomChoiceResize (line 872) | class BottomupRandomChoiceResize(BaseTransform):
    method __init__ (line 911) | def __init__(
    method _random_select (line 930) | def _random_select(self) -> Tuple[int, int]:
    method _resize_img (line 943) | def _resize_img(self, results: dict) -> None:
    method _resize_bboxes (line 978) | def _resize_bboxes(self, results: dict) -> None:
    method _resize_keypoints (line 990) | def _resize_keypoints(self, results: dict) -> None:
    method transform (line 1004) | def transform(self, results: dict) -> dict:

FILE: mmpose/datasets/transforms/common_transforms.py
  class GetBBoxCenterScale (line 32) | class GetBBoxCenterScale(BaseTransform):
    method __init__ (line 52) | def __init__(self, padding: float = 1.25) -> None:
    method transform (line 57) | def transform(self, results: Dict) -> Optional[dict]:
    method __repr__ (line 84) | def __repr__(self) -> str:
  class RandomFlip (line 95) | class RandomFlip(BaseTransform):
    method __init__ (line 137) | def __init__(self,
    method _choose_direction (line 165) | def _choose_direction(self) -> str:
    method transform (line 188) | def transform(self, results: dict) -> dict:
    method __repr__ (line 251) | def __repr__(self) -> str:
  class RandomHalfBody (line 264) | class RandomHalfBody(BaseTransform):
    method __init__ (line 293) | def __init__(self,
    method _get_half_body_bbox (line 308) | def _get_half_body_bbox(self, keypoints: np.ndarray,
    method _random_select_half_body (line 335) | def _random_select_half_body(self, keypoints_visible: np.ndarray,
    method transform (line 386) | def transform(self, results: Dict) -> Optional[dict]:
    method __repr__ (line 419) | def __repr__(self) -> str:
  class RandomBBoxTransform (line 436) | class RandomBBoxTransform(BaseTransform):
    method __init__ (line 470) | def __init__(self,
    method _truncnorm (line 487) | def _truncnorm(low: float = -1.,
    method _get_transform_params (line 494) | def _get_transform_params(self, num_bboxes: int) -> Tuple:
    method transform (line 531) | def transform(self, results: Dict) -> Optional[dict]:
    method __repr__ (line 553) | def __repr__(self) -> str:
  class Albumentation (line 571) | class Albumentation(BaseTransform):
    method __init__ (line 616) | def __init__(self,
    method albu_builder (line 634) | def albu_builder(self, cfg: dict) -> albumentations:
    method transform (line 673) | def transform(self, results: dict) -> dict:
    method __repr__ (line 701) | def __repr__(self) -> str:
  class PhotometricDistortion (line 712) | class PhotometricDistortion(BaseTransform):
    method __init__ (line 741) | def __init__(self,
    method _random_flags (line 752) | def _random_flags(self) -> Sequence[Number]:
    method _convert (line 792) | def _convert(self,
    method transform (line 810) | def transform(self, results: dict) -> dict:
    method __repr__ (line 864) | def __repr__(self) -> str:
  class GenerateTarget (line 881) | class GenerateTarget(BaseTransform):
    method __init__ (line 916) | def __init__(self,
    method transform (line 945) | def transform(self, results: Dict) -> Optional[dict]:
    method __repr__ (line 1073) | def __repr__(self) -> str:
  class YOLOXHSVRandomAug (line 1087) | class YOLOXHSVRandomAug(BaseTransform):
    method __init__ (line 1106) | def __init__(self,
    method _get_hsv_gains (line 1115) | def _get_hsv_gains(self):
    method transform (line 1125) | def transform(self, results: dict) -> dict:
    method __repr__ (line 1138) | def __repr__(self):
  class FilterAnnotations (line 1147) | class FilterAnnotations(BaseTransform):
    method __init__ (line 1187) | def __init__(self,
    method transform (line 1205) | def transform(self, results: dict) -> Union[dict, None]:
    method __repr__ (line 1250) | def __repr__(self):

FILE: mmpose/datasets/transforms/converting.py
  class KeypointConverter (line 11) | class KeypointConverter(BaseTransform):
    method __init__ (line 60) | def __init__(self, num_keypoints: int,
    method transform (line 92) | def transform(self, results: dict) -> dict:
    method __repr__ (line 152) | def __repr__(self) -> str:
  class SingleHandConverter (line 165) | class SingleHandConverter(BaseTransform):
    method __init__ (line 204) | def __init__(self, num_keypoints: int,
    method transform (line 215) | def transform(self, results: dict) -> dict:
    method __repr__ (line 231) | def __repr__(self) -> str:

FILE: mmpose/datasets/transforms/formatting.py
  function image_to_tensor (line 14) | def image_to_tensor(img: Union[np.ndarray,
  function keypoints_to_tensor (line 40) | def keypoints_to_tensor(keypoints: Union[np.ndarray, Sequence[np.ndarray]]
  class PackPoseInputs (line 64) | class PackPoseInputs(BaseTransform):
    method __init__ (line 141) | def __init__(self,
    method transform (line 151) | def transform(self, results: dict) -> dict:
    method __repr__ (line 247) | def __repr__(self) -> str:

FILE: mmpose/datasets/transforms/hand_transforms.py
  class HandRandomFlip (line 10) | class HandRandomFlip(RandomFlip):
    method __init__ (line 41) | def __init__(self, prob: Union[float, List[float]] = 0.5) -> None:
    method transform (line 44) | def transform(self, results: dict) -> dict:

FILE: mmpose/datasets/transforms/loading.py
  class LoadImage (line 11) | class LoadImage(LoadImageFromFile):
    method transform (line 42) | def transform(self, results: dict) -> Optional[dict]:

FILE: mmpose/datasets/transforms/mix_img_transforms.py
  class MixImageTransform (line 18) | class MixImageTransform(BaseTransform, metaclass=ABCMeta):
    method __init__ (line 28) | def __init__(self,
    method transform (line 39) | def transform(self, results: dict) -> dict:
    method _get_mixed_data_list (line 60) | def _get_mixed_data_list(self, dataset):
  class Mosaic (line 88) | class Mosaic(MixImageTransform):
    method __init__ (line 153) | def __init__(
    method apply_mix (line 168) | def apply_mix(self, results: dict) -> dict:
    method _create_mosaic_image (line 197) | def _create_mosaic_image(self, results, mixed_data_list):
    method _mosaic_combine (line 264) | def _mosaic_combine(
    method __repr__ (line 294) | def __repr__(self) -> str:
  class YOLOXMixUp (line 304) | class YOLOXMixUp(MixImageTransform):
    method __init__ (line 366) | def __init__(self,
    method apply_mix (line 382) | def apply_mix(self, results: dict) -> dict:
    method _create_mixup_image (line 412) | def _create_mixup_image(self, results, mixed_data_list):
    method __repr__ (line 495) | def __repr__(self) -> str:

FILE: mmpose/datasets/transforms/pose3d_transforms.py
  class RandomFlipAroundRoot (line 13) | class RandomFlipAroundRoot(BaseTransform):
    method __init__ (line 46) | def __init__(self,
    method transform (line 58) | def transform(self, results: Dict) -> dict:

FILE: mmpose/datasets/transforms/topdown_transforms.py
  class TopdownAffine (line 14) | class TopdownAffine(BaseTransform):
    method __init__ (line 44) | def __init__(self,
    method _fix_aspect_ratio (line 56) | def _fix_aspect_ratio(bbox_scale: np.ndarray, aspect_ratio: float):
    method transform (line 73) | def transform(self, results: Dict) -> Optional[dict]:
    method __repr__ (line 139) | def __repr__(self) -> str:

FILE: mmpose/engine/hooks/badcase_hook.py
  class BadCaseAnalysisHook (line 23) | class BadCaseAnalysisHook(Hook):
    method __init__ (line 60) | def __init__(
    method check_badcase (line 106) | def check_badcase(self, data_batch, data_sample):
    method after_test_iter (line 133) | def after_test_iter(self, runner: Runner, batch_idx: int, data_batch: ...
    method after_test_epoch (line 216) | def after_test_epoch(self,

FILE: mmpose/engine/hooks/ema_hook.py
  class ExpMomentumEMA (line 14) | class ExpMomentumEMA(ExponentialMovingAverage):
    method __init__ (line 40) | def __init__(self,
    method avg_func (line 56) | def avg_func(self, averaged_param: Tensor, source_param: Tensor,

FILE: mmpose/engine/hooks/mode_switch_hooks.py
  class YOLOXPoseModeSwitchHook (line 14) | class YOLOXPoseModeSwitchHook(Hook):
    method __init__ (line 34) | def __init__(self,
    method _modify_dataloader (line 42) | def _modify_dataloader(self, runner: Runner):
    method before_train_epoch (line 56) | def before_train_epoch(self, runner: Runner):
  class RTMOModeSwitchHook (line 70) | class RTMOModeSwitchHook(Hook):
    method __init__ (line 90) | def __init__(self, epoch_attributes: Dict[int, Dict]):
    method before_train_epoch (line 93) | def before_train_epoch(self, runner: Runner):

FILE: mmpose/engine/hooks/sync_norm_hook.py
  function get_norm_states (line 11) | def get_norm_states(module: nn.Module) -> OrderedDict:
  class SyncNormHook (line 22) | class SyncNormHook(Hook):
    method before_val_epoch (line 25) | def before_val_epoch(self, runner):

FILE: mmpose/engine/hooks/visualization_hook.py
  class PoseVisualizationHook (line 18) | class PoseVisualizationHook(Hook):
    method __init__ (line 49) | def __init__(
    method after_val_iter (line 77) | def after_val_iter(self, runner: Runner, batch_idx: int, data_batch: d...
    method after_test_iter (line 118) | def after_test_iter(self, runner: Runner, batch_idx: int, data_batch: ...

FILE: mmpose/engine/optim_wrappers/force_default_constructor.py
  class ForceDefaultOptimWrapperConstructor (line 17) | class ForceDefaultOptimWrapperConstructor(DefaultOptimWrapperConstructor):
    method add_params (line 132) | def add_params(self,

FILE: mmpose/engine/optim_wrappers/layer_decay_optim_wrapper.py
  function get_num_layer_for_vit (line 7) | def get_num_layer_for_vit(var_name, num_max_layer):
  class LayerDecayOptimWrapperConstructor (line 21) | class LayerDecayOptimWrapperConstructor(DefaultOptimWrapperConstructor):
    method __init__ (line 23) | def __init__(self, optim_wrapper_cfg, paramwise_cfg=None):
    method add_params (line 29) | def add_params(self, params, module, prefix='', lr=None):

FILE: mmpose/engine/schedulers/constant_lr.py
  class ConstantParamScheduler (line 11) | class ConstantParamScheduler(MMENGINE_ConstantParamScheduler):
    method __init__ (line 37) | def __init__(self,
  class ConstantLR (line 60) | class ConstantLR(LRSchedulerMixin, ConstantParamScheduler):

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

FILE: mmpose/evaluation/evaluators/mutli_dataset_evaluator.py
  class MultiDatasetEvaluator (line 14) | class MultiDatasetEvaluator(Evaluator):
    method __init__ (line 22) | def __init__(
    method dataset_meta (line 43) | def dataset_meta(self) -> Optional[dict]:
    method dataset_meta (line 48) | def dataset_meta(self, dataset_meta: dict) -> None:
    method process (line 52) | def process(self,

FILE: mmpose/evaluation/functional/keypoint_eval.py
  function _calc_distances (line 10) | def _calc_distances(preds: np.ndarray, gts: np.ndarray, mask: np.ndarray,
  function _distance_acc (line 45) | def _distance_acc(distances: np.ndarray, thr: float = 0.5) -> float:
  function keypoint_pck_accuracy (line 67) | def keypoint_pck_accuracy(pred: np.ndarray, gt: np.ndarray, mask: np.nda...
  function keypoint_auc (line 106) | def keypoint_auc(pred: np.ndarray,
  function keypoint_nme (line 142) | def keypoint_nme(pred: np.ndarray, gt: np.ndarray, mask: np.ndarray,
  function keypoint_epe (line 166) | def keypoint_epe(pred: np.ndarray, gt: np.ndarray, mask: np.ndarray) -> ...
  function pose_pck_accuracy (line 191) | def pose_pck_accuracy(output: np.ndarray,
  function simcc_pck_accuracy (line 238) | def simcc_pck_accuracy(output: Tuple[np.ndarray, np.ndarray],
  function multilabel_classification_accuracy (line 291) | def multilabel_classification_accuracy(pred: np.ndarray,
  function keypoint_mpjpe (line 324) | def keypoint_mpjpe(pred: np.ndarray,

FILE: mmpose/evaluation/functional/mesh_eval.py
  function compute_similarity_transform (line 9) | def compute_similarity_transform(source_points, target_points):

FILE: mmpose/evaluation/functional/nms.py
  function nms (line 16) | def nms(dets: np.ndarray, thr: float) -> List[int]:
  function oks_iou (line 58) | def oks_iou(g: np.ndarray,
  function oks_nms (line 115) | def oks_nms(kpts_db: List[dict],
  function _rescore (line 168) | def _rescore(overlap: np.ndarray,
  function soft_oks_nms (line 196) | def soft_oks_nms(kpts_db: List[dict],
  function nearby_joints_nms (line 259) | def nearby_joints_nms(
  function nms_torch (line 335) | def nms_torch(bboxes: Tensor,

FILE: mmpose/evaluation/functional/transforms.py
  function transform_sigmas (line 7) | def transform_sigmas(sigmas: Union[List, np.ndarray], num_keypoints: int,
  function transform_ann (line 30) | def transform_ann(ann_info: Union[dict, list], num_keypoints: int,
  function transform_pred (line 63) | def transform_pred(pred_info: Union[dict, list], num_keypoints: int,

FILE: mmpose/evaluation/metrics/coco_metric.py
  class CocoMetric (line 22) | class CocoMetric(BaseMetric):
    method __init__ (line 96) | def __init__(self,
    method dataset_meta (line 156) | def dataset_meta(self) -> Optional[dict]:
    method dataset_meta (line 161) | def dataset_meta(self, dataset_meta: dict) -> None:
    method process (line 182) | def process(self, data_batch: Sequence[dict],
    method gt_to_coco_json (line 266) | def gt_to_coco_json(self, gt_dicts: Sequence[dict],
    method compute_metrics (line 367) | def compute_metrics(self, results: list) -> Dict[str, float]:
    method results2json (line 507) | def results2json(self, keypoints: Dict[int, list],
    method _do_python_keypoint_eval (line 548) | def _do_python_keypoint_eval(self, outfile_prefix: str) -> list:
    method _sort_and_unique_bboxes (line 585) | def _sort_and_unique_bboxes(self,

FILE: mmpose/evaluation/metrics/coco_wholebody_metric.py
  class CocoWholeBodyMetric (line 14) | class CocoWholeBodyMetric(CocoMetric):
    method gt_to_coco_json (line 81) | def gt_to_coco_json(self, gt_dicts: Sequence[dict],
    method results2json (line 176) | def results2json(self, keypoints: Dict[int, list],
    method _do_python_keypoint_eval (line 222) | def _do_python_keypoint_eval(self, outfile_prefix: str) -> list:

FILE: mmpose/evaluation/metrics/hand_metric.py
  class InterHandMetric (line 14) | class InterHandMetric(BaseMetric):
    method __init__ (line 18) | def __init__(self,
    method process (line 30) | def process(self, data_batch: Sequence[dict],
    method compute_metrics (line 145) | def compute_metrics(self, results: list) -> Dict[str, float]:

FILE: mmpose/evaluation/metrics/keypoint_2d_metrics.py
  class PCKAccuracy (line 15) | class PCKAccuracy(BaseMetric):
    method __init__ (line 70) | def __init__(self,
    method process (line 88) | def process(self, data_batch: Sequence[dict],
    method compute_metrics (line 151) | def compute_metrics(self, results: list) -> Dict[str, float]:
  class MpiiPCKAccuracy (line 212) | class MpiiPCKAccuracy(PCKAccuracy):
    method __init__ (line 271) | def __init__(self,
    method compute_metrics (line 282) | def compute_metrics(self, results: list) -> Dict[str, float]:
  class JhmdbPCKAccuracy (line 374) | class JhmdbPCKAccuracy(PCKAccuracy):
    method __init__ (line 436) | def __init__(self,
    method compute_metrics (line 447) | def compute_metrics(self, results: list) -> Dict[str, float]:
  class AUC (line 539) | class AUC(BaseMetric):
    method __init__ (line 564) | def __init__(self,
    method process (line 573) | def process(self, data_batch: Sequence[dict],
    method compute_metrics (line 606) | def compute_metrics(self, results: list) -> Dict[str, float]:
  class EPE (line 638) | class EPE(BaseMetric):
    method process (line 658) | def process(self, data_batch: Sequence[dict],
    method compute_metrics (line 691) | def compute_metrics(self, results: list) -> Dict[str, float]:
  class NME (line 722) | class NME(BaseMetric):
    method __init__ (line 776) | def __init__(self,
    method process (line 797) | def process(self, data_batch: Sequence[dict],
    method compute_metrics (line 847) | def compute_metrics(self, results: list) -> Dict[str, float]:
    method _get_normalize_factor (line 906) | def _get_normalize_factor(self, gt_coords: np.ndarray) -> np.ndarray:

FILE: mmpose/evaluation/metrics/keypoint_3d_metrics.py
  class MPJPE (line 15) | class MPJPE(BaseMetric):
    method __init__ (line 47) | def __init__(self,
    method process (line 61) | def process(self, data_batch: Sequence[dict],
    method compute_metrics (line 104) | def compute_metrics(self, results: list) -> Dict[str, float]:

FILE: mmpose/evaluation/metrics/keypoint_partition_metric.py
  class KeypointPartitionMetric (line 14) | class KeypointPartitionMetric(BaseMetric):
    method __init__ (line 64) | def __init__(
    method dataset_meta (line 139) | def dataset_meta(self, dataset_meta: dict) -> None:
    method process (line 149) | def process(self, data_batch: Sequence[dict],
    method compute_metrics (line 191) | def compute_metrics(self, results: list) -> dict:
    method evaluate (line 194) | def evaluate(self, size: int) -> dict:

FILE: mmpose/evaluation/metrics/posetrack18_metric.py
  class PoseTrack18Metric (line 22) | class PoseTrack18Metric(CocoMetric):
    method __init__ (line 74) | def __init__(self,
    method results2json (line 100) | def results2json(self, keypoints: Dict[int, list],
    method _do_python_keypoint_eval (line 173) | def _do_python_keypoint_eval(self, outfile_prefix: str) -> List[tuple]:

FILE: mmpose/evaluation/metrics/simple_keypoint_3d_metrics.py
  class SimpleMPJPE (line 13) | class SimpleMPJPE(BaseMetric):
    method __init__ (line 45) | def __init__(self,
    method process (line 59) | def process(self, data_batch: Sequence[dict],
    method compute_metrics (line 92) | def compute_metrics(self, results: list) -> Dict[str, float]:

FILE: mmpose/models/backbones/alexnet.py
  class AlexNet (line 9) | class AlexNet(BaseBackbone):
    method __init__ (line 22) | def __init__(self, num_classes=-1, init_cfg=None):
    method forward (line 51) | def forward(self, x):

FILE: mmpose/models/backbones/base_backbone.py
  class BaseBackbone (line 7) | class BaseBackbone(BaseModule, metaclass=ABCMeta):
    method forward (line 15) | def forward(self, x):
    method train (line 23) | def train(self, mode=True):

FILE: mmpose/models/backbones/cpm.py
  class CpmBlock (line 13) | class CpmBlock(BaseModule):
    method __init__ (line 24) | def __init__(self,
    method forward (line 48) | def forward(self, x):
  class CPM (line 55) | class CPM(BaseBackbone):
    method __init__ (line 96) | def __init__(
    method forward (line 165) | def forward(self, x):

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

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

FILE: mmpose/models/backbones/dstformer.py
  class Attention (line 12) | class Attention(BaseModule):
    method __init__ (line 14) | def __init__(self,
    method forward (line 37) | def forward(self, x, seq_len=1):
    method forward_spatial (line 58) | def forward_spatial(self, q, k, v):
    method forward_temporal (line 68) | def forward_temporal(self, q, k, v, seq_len=8):
  class AttentionBlock (line 86) | class AttentionBlock(BaseModule):
    method __init__ (line 88) | def __init__(self,
    method forward (line 136) | def forward(self, x, seq_len=1):
  class DSTFormer (line 153) | class DSTFormer(BaseBackbone):
    method __init__ (line 189) | def __init__(self,
    method forward (line 257) | def forward(self, x):
    method init_weights (line 289) | def init_weights(self):

FILE: mmpose/models/backbones/hourglass.py
  class HourglassModule (line 13) | class HourglassModule(BaseModule):
    method __init__ (line 29) | def __init__(self,
    method forward (line 79) | def forward(self, x):
  class HourglassNet (line 90) | class HourglassNet(BaseBackbone):
    method __init__ (line 130) | def __init__(
    method forward (line 190) | def forward(self, x):

FILE: mmpose/models/backbones/hourglass_ae.py
  class HourglassAEModule (line 12) | class HourglassAEModule(BaseModule):
    method __init__ (line 26) | def __init__(self,
    method forward (line 59) | def forward(self, x):
  class HourglassAENet (line 71) | class HourglassAENet(BaseBackbone):
    method __init__ (line 112) | def __init__(
    method forward (line 191) | def forward(self, x):

FILE: mmpose/models/backbones/hrformer.py
  function nlc_to_nchw (line 16) | def nlc_to_nchw(x, hw_shape):
  function nchw_to_nlc (line 33) | def nchw_to_nlc(x):
  function build_drop_path (line 46) | def build_drop_path(drop_path_rate):
  class WindowMSA (line 51) | class WindowMSA(BaseModule):
    method __init__ (line 72) | def __init__(self,
    method init_weights (line 111) | def init_weights(self):
    method forward (line 114) | def forward(self, x, mask=None):
    method double_step_seq (line 155) | def double_step_seq(step1, len1, step2, len2):
  class LocalWindowSelfAttention (line 161) | class LocalWindowSelfAttention(BaseModule):
    method __init__ (line 186) | def __init__(self,
    method forward (line 213) | def forward(self, x, H, W, **kwargs):
  class CrossFFN (line 258) | class CrossFFN(BaseModule):
    method __init__ (line 275) | def __init__(self,
    method forward (line 302) | def forward(self, x, H, W):
  class HRFormerBlock (line 312) | class HRFormerBlock(BaseModule):
    method __init__ (line 335) | def __init__(self,
    method forward (line 373) | def forward(self, x):
    method extra_repr (line 384) | def extra_repr(self):
  class HRFomerModule (line 390) | class HRFomerModule(HRModule):
    method __init__ (line 425) | def __init__(self,
    method _make_one_branch (line 457) | def _make_one_branch(self,
    method _make_fuse_layers (line 500) | def _make_fuse_layers(self):
    method get_num_inchannels (line 570) | def get_num_inchannels(self):
  class HRFormer (line 576) | class HRFormer(HRNet):
    method __init__ (line 669) | def __init__(
    method _make_stage (line 713) | def _make_stage(self,

FILE: mmpose/models/backbones/hrnet.py
  class HRModule (line 14) | class HRModule(BaseModule):
    method __init__ (line 21) | def __init__(self,
    method _check_branches (line 54) | def _check_branches(num_branches, num_blocks, in_channels, num_channels):
    method _make_one_branch (line 71) | def _make_one_branch(self,
    method _make_branches (line 117) | def _make_branches(self, num_branches, block, num_blocks, num_channels):
    method _make_fuse_layers (line 127) | def _make_fuse_layers(self):
    method forward (line 194) | def forward(self, x):
  class HRNet (line 215) | class HRNet(BaseBackbone):
    method __init__ (line 284) | def __init__(
    method norm1 (line 401) | def norm1(self):
    method norm2 (line 406) | def norm2(self):
    method _make_transition_layer (line 410) | def _make_transition_layer(self, num_channels_pre_layer,
    method _make_layer (line 457) | def _make_layer(self, block, in_channels, out_channels, blocks, stride...
    method _make_stage (line 492) | def _make_stage(self, layer_config, in_channels, multiscale_output=True):
    method _freeze_stages (line 525) | def _freeze_stages(self):
    method init_weights (line 551) | def init_weights(self):
    method forward (line 567) | def forward(self, x):
    method train (line 603) | def train(self, mode=True):

FILE: mmpose/models/backbones/litehrnet.py
  class SpatialWeighting (line 21) | class SpatialWeighting(BaseModule):
    method __init__ (line 38) | def __init__(self,
    method forward (line 68) | def forward(self, x):
  class CrossResolutionWeighting (line 75) | class CrossResolutionWeighting(BaseModule):
    method __init__ (line 92) | def __init__(self,
    method forward (line 123) | def forward(self, x):
  class ConditionalChannelWeighting (line 137) | class ConditionalChannelWeighting(BaseModule):
    method __init__ (line 154) | def __init__(self,
    method forward (line 193) | def forward(self, x):
  class Stem (line 217) | class Stem(BaseModule):
    method __init__ (line 236) | def __init__(self,
    method forward (line 321) | def forward(self, x):
  class IterativeHead (line 345) | class IterativeHead(BaseModule):
    method __init__ (line 356) | def __init__(self, in_channels, norm_cfg=dict(type='BN'), init_cfg=None):
    method forward (line 389) | def forward(self, x):
  class ShuffleUnit (line 409) | class ShuffleUnit(BaseModule):
    method __init__ (line 428) | def __init__(self,
    method forward (line 506) | def forward(self, x):
  class LiteHRModule (line 527) | class LiteHRModule(BaseModule):
    method __init__ (line 550) | def __init__(self,
    method _check_branches (line 585) | def _check_branches(self, num_branches, in_channels):
    method _make_weighting_blocks (line 592) | def _make_weighting_blocks(self, num_blocks, reduce_ratio, stride=1):
    method _make_one_branch (line 607) | def _make_one_branch(self, branch_index, num_blocks, stride=1):
    method _make_naive_branches (line 632) | def _make_naive_branches(self, num_branches, num_blocks):
    method _make_fuse_layers (line 641) | def _make_fuse_layers(self):
    method forward (line 726) | def forward(self, x):
  class LiteHRNet (line 756) | class LiteHRNet(BaseBackbone):
    method __init__ (line 812) | def __init__(self,
    method _make_transition_layer (line 865) | def _make_transition_layer(self, num_channels_pre_layer,
    method _make_stage (line 933) | def _make_stage(self,
    method forward (line 969) | def forward(self, x):
    method train (line 993) | def train(self, mode=True):

FILE: mmpose/models/backbones/mobilenet_v2.py
  class InvertedResidual (line 15) | class InvertedResidual(BaseModule):
    method __init__ (line 36) | def __init__(self,
    method forward (line 88) | def forward(self, x):
  class MobileNetV2 (line 104) | class MobileNetV2(BaseBackbone):
    method __init__ (line 142) | def __init__(self,
    method make_layer (line 223) | def make_layer(self, out_channels, num_blocks, stride, expand_ratio):
    method forward (line 251) | def forward(self, x):
    method _freeze_stages (line 263) | def _freeze_stages(self):
    method train (line 273) | def train(self, mode=True):

FILE: mmpose/models/backbones/mobilenet_v3.py
  class MobileNetV3 (line 13) | class MobileNetV3(BaseBackbone):
    method __init__ (line 74) | def __init__(self,
    method _make_layer (line 123) | def _make_layer(self):
    method forward (line 156) | def forward(self, x):
    method _freeze_stages (line 169) | def _freeze_stages(self):
    method train (line 179) | def train(self, mode=True):

FILE: mmpose/models/backbones/mspn.py
  class Bottleneck (line 18) | class Bottleneck(_Bottleneck):
    method __init__ (line 34) | def __init__(self, in_channels, out_channels, **kwargs):
  class DownsampleModule (line 38) | class DownsampleModule(BaseModule):
    method __init__ (line 55) | def __init__(self,
    method _make_layer (line 80) | def _make_layer(self, block, out_channels, blocks, stride=1):
    method forward (line 107) | def forward(self, x, skip1, skip2):
  class UpsampleUnit (line 121) | class UpsampleUnit(BaseModule):
    method __init__ (line 145) | def __init__(self,
    method forward (line 214) | def forward(self, x, up_x):
  class UpsampleModule (line 240) | class UpsampleModule(BaseModule):
    method __init__ (line 259) | def __init__(self,
    method forward (line 293) | def forward(self, x):
  class SingleStageNetwork (line 315) | class SingleStageNetwork(BaseModule):
    method __init__ (line 337) | def __init__(self,
    method forward (line 365) | def forward(self, x, skip1, skip2):
  class ResNetTop (line 372) | class ResNetTop(BaseModule):
    method __init__ (line 383) | def __init__(self, norm_cfg=dict(type='BN'), channels=64, init_cfg=None):
    method forward (line 397) | def forward(self, img):
  class MSPN (line 402) | class MSPN(BaseBackbone):
    method __init__ (line 450) | def __init__(self,
    method forward (line 496) | def forward(self, x):
    method init_weights (line 508) | def init_weights(self):

FILE: mmpose/models/backbones/pvt.py
  class MixFFN (line 22) | class MixFFN(BaseModule):
    method __init__ (line 46) | def __init__(self,
    method forward (line 92) | def forward(self, x, hw_shape, identity=None):
  class SpatialReductionAttention (line 101) | class SpatialReductionAttention(MultiheadAttention):
    method __init__ (line 128) | def __init__(self,
    method forward (line 168) | def forward(self, x, hw_shape, identity=None):
    method legacy_forward (line 199) | def legacy_forward(self, x, hw_shape, identity=None):
  class PVTEncoderLayer (line 218) | class PVTEncoderLayer(BaseModule):
    method __init__ (line 244) | def __init__(self,
    method forward (line 283) | def forward(self, x, hw_shape):
  class AbsolutePositionEmbedding (line 290) | class AbsolutePositionEmbedding(BaseModule):
    method __init__ (line 302) | def __init__(self, pos_shape, pos_dim, drop_rate=0., init_cfg=None):
    method init_weights (line 320) | def init_weights(self):
    method resize_pos_embed (line 323) | def resize_pos_embed(self, pos_embed, input_shape, mode='bilinear'):
    method forward (line 352) | def forward(self, x, hw_shape, mode='bilinear'):
  class PyramidVisionTransformer (line 358) | class PyramidVisionTransformer(BaseModule):
    method __init__ (line 416) | def __init__(self,
    method init_weights (line 520) | def init_weights(self):
    method forward (line 541) | def forward(self, x):
  class PyramidVisionTransformerV2 (line 558) | class PyramidVisionTransformerV2(PyramidVisionTransformer):
    method __init__ (line 562) | def __init__(self, **kwargs):

FILE: mmpose/models/backbones/regnet.py
  class RegNet (line 14) | class RegNet(ResNet):
    method __init__ (line 97) | def __init__(self,
    method _make_stem_layer (line 213) | def _make_stem_layer(self, in_channels, base_channels):
    method generate_regnet (line 228) | def generate_regnet(initial_width,
    method quantize_float (line 260) | def quantize_float(number, divisor):
    method adjust_width_group (line 272) | def adjust_width_group(self, widths, bottleneck_ratio, groups):
    method get_stages_from_blocks (line 297) | def get_stages_from_blocks(self, widths):
    method forward (line 319) | def forward(self, x):

FILE: mmpose/models/backbones/resnest.py
  class RSoftmax (line 14) | class RSoftmax(nn.Module):
    method __init__ (line 22) | def __init__(self, radix, groups):
    method forward (line 27) | def forward(self, x):
  class SplitAttentionConv2d (line 38) | class SplitAttentionConv2d(BaseModule):
    method __init__ (line 59) | def __init__(self,
    method norm0 (line 101) | def norm0(self):
    method norm1 (line 105) | def norm1(self):
    method forward (line 108) | def forward(self, x):
  class Bottleneck (line 136) | class Bottleneck(_Bottleneck):
    method __init__ (line 168) | def __init__(self,
    method forward (line 231) | def forward(self, x):
  class ResNeSt (line 266) | class ResNeSt(ResNetV1d):
    method __init__ (line 330) | def __init__(self,
    method make_res_layer (line 345) | def make_res_layer(self, **kwargs):

FILE: mmpose/models/backbones/resnet.py
  class BasicBlock (line 14) | class BasicBlock(BaseModule):
    method __init__ (line 39) | def __init__(self,
    method norm1 (line 95) | def norm1(self):
    method norm2 (line 100) | def norm2(self):
    method forward (line 104) | def forward(self, x):
  class Bottleneck (line 134) | class Bottleneck(BaseModule):
    method __init__ (line 159) | def __init__(self,
    method norm1 (line 233) | def norm1(self):
    method norm2 (line 238) | def norm2(self):
    method norm3 (line 243) | def norm3(self):
    method forward (line 247) | def forward(self, x):
  function get_expansion (line 281) | def get_expansion(block, expansion=None):
  class ResLayer (line 316) | class ResLayer(nn.Sequential):
    method __init__ (line 340) | def __init__(self,
  class ResNet (line 430) | class ResNet(BaseBackbone):
    method __init__ (line 501) | def __init__(self,
    method make_res_layer (line 586) | def make_res_layer(self, **kwargs):
    method norm1 (line 591) | def norm1(self):
    method _make_stem_layer (line 595) | def _make_stem_layer(self, in_channels, stem_channels):
    method _freeze_stages (line 641) | def _freeze_stages(self):
    method init_weights (line 660) | def init_weights(self):
    method forward (line 676) | def forward(self, x):
    method train (line 693) | def train(self, mode=True):
  class ResNetV1d (line 705) | class ResNetV1d(ResNet):
    method __init__ (line 714) | def __init__(self, **kwargs):

FILE: mmpose/models/backbones/resnext.py
  class Bottleneck (line 9) | class Bottleneck(_Bottleneck):
    method __init__ (line 34) | def __init__(self,
  class ResNeXt (line 90) | class ResNeXt(ResNet):
    method __init__ (line 161) | def __init__(self, depth, groups=32, width_per_group=4, **kwargs):
    method make_res_layer (line 166) | def make_res_layer(self, **kwargs):

FILE: mmpose/models/backbones/rsn.py
  class RSB (line 14) | class RSB(BaseModule):
    method __init__ (line 37) | def __init__(self,
    method forward (line 93) | def forward(self, x):
  class Downsample_module (line 128) | class Downsample_module(BaseModule):
    method __init__ (line 148) | def __init__(self,
    method _make_layer (line 186) | def _make_layer(self,
    method forward (line 228) | def forward(self, x, skip1, skip2):
  class Upsample_unit (line 242) | class Upsample_unit(BaseModule):
    method __init__ (line 266) | def __init__(self,
    method forward (line 335) | def forward(self, x, up_x):
  class Upsample_module (line 361) | class Upsample_module(BaseModule):
    method __init__ (line 380) | def __init__(self,
    method forward (line 413) | def forward(self, x):
  class Single_stage_RSN (line 435) | class Single_stage_RSN(BaseModule):
    method __init__ (line 460) | def __init__(self,
    method forward (line 492) | def forward(self, x, skip1, skip2):
  class ResNet_top (line 499) | class ResNet_top(BaseModule):
    method __init__ (line 510) | def __init__(self, norm_cfg=dict(type='BN'), channels=64, init_cfg=None):
    method forward (line 524) | def forward(self, img):
  class RSN (line 529) | class RSN(BaseBackbone):
    method __init__ (line 579) | def __init__(self,
    method forward (line 630) | def forward(self, x):

FILE: mmpose/models/backbones/scnet.py
  class SCConv (line 15) | class SCConv(BaseModule):
    method __init__ (line 31) | def __init__(self,
    method forward (line 81) | def forward(self, x):
  class SCBottleneck (line 94) | class SCBottleneck(Bottleneck):
    method __init__ (line 104) | def __init__(self, in_channels, out_channels, **kwargs):
    method forward (line 157) | def forward(self, x):
  class SCNet (line 196) | class SCNet(ResNet):
    method __init__ (line 249) | def __init__(self, depth, **kwargs):

FILE: mmpose/models/backbones/seresnet.py
  class SEBottleneck (line 9) | class SEBottleneck(Bottleneck):
    method __init__ (line 18) | def __init__(self, in_channels, out_channels, se_ratio=16, **kwargs):
    method forward (line 22) | def forward(self, x):
  class SEResNet (line 58) | class SEResNet(ResNet):
    method __init__ (line 127) | def __init__(self, depth, se_ratio=16, **kwargs):
    method make_res_layer (line 133) | def make_res_layer(self, **kwargs):

FILE: mmpose/models/backbones/seresnext.py
  class SEBottleneck (line 10) | class SEBottleneck(_SEBottleneck):
    method __init__ (line 39) | def __init__(self,
  class SEResNeXt (line 97) | class SEResNeXt(SEResNet):
    method __init__ (line 169) | def __init__(self, depth, groups=32, width_per_group=4, **kwargs):
    method make_res_layer (line 174) | def make_res_layer(self, **kwargs):

FILE: mmpose/models/backbones/shufflenet_v1.py
  class ShuffleUnit (line 16) | class ShuffleUnit(BaseModule):
    method __init__ (line 48) | def __init__(self,
    method _add (line 119) | def _add(x, out):
    method _concat (line 124) | def _concat(x, out):
    method forward (line 128) | def forward(self, x):
  class ShuffleNetV1 (line 159) | class ShuffleNetV1(BaseBackbone):
    method __init__ (line 194) | def __init__(self,
    method _freeze_stages (line 270) | def _freeze_stages(self):
    method init_weights (line 280) | def init_weights(self, pretrained=None):
    method make_layer (line 291) | def make_layer(self, out_channels, num_blocks, first_block=False):
    method forward (line 320) | def forward(self, x):
    method train (line 332) | def train(self, mode=True):

FILE: mmpose/models/backbones/shufflenet_v2.py
  class InvertedResidual (line 15) | class InvertedResidual(BaseModule):
    method __init__ (line 34) | def __init__(self,
    method forward (line 115) | def forward(self, x):
  class ShuffleNetV2 (line 137) | class ShuffleNetV2(BaseBackbone):
    method __init__ (line 170) | def __init__(self,
    method _make_layer (line 248) | def _make_layer(self, out_channels, num_blocks):
    method _freeze_stages (line 271) | def _freeze_stages(self):
    method init_weights (line 282) | def init_weights(self):
    method forward (line 293) | def forward(self, x):
    method train (line 305) | def train(self, mode=True):

FILE: mmpose/models/backbones/swin.py
  class WindowMSA (line 23) | class WindowMSA(BaseModule):
    method __init__ (line 42) | def __init__(self,
    method init_weights (line 78) | def init_weights(self):
    method forward (line 81) | def forward(self, x, mask=None):
    method double_step_seq (line 122) | def double_step_seq(step1, len1, step2, len2):
  class ShiftWindowMSA (line 128) | class ShiftWindowMSA(BaseModule):
    method __init__ (line 151) | def __init__(self,
    method forward (line 179) | def forward(self, query, hw_shape):
    method window_reverse (line 255) | def window_reverse(self, windows, H, W):
    method window_partition (line 271) | def window_partition(self, x):
  class SwinBlock (line 287) | class SwinBlock(BaseModule):
    method __init__ (line 312) | def __init__(self,
    method forward (line 355) | def forward(self, x, hw_shape):
  class SwinBlockSequence (line 378) | class SwinBlockSequence(BaseModule):
    method __init__ (line 407) | def __init__(self,
    method forward (line 451) | def forward(self, x, hw_shape):
  class SwinTransformer (line 463) | class SwinTransformer(BaseBackbone):
    method __init__ (line 523) | def __init__(self,
    method train (line 632) | def train(self, mode=True):
    method _freeze_stages (line 637) | def _freeze_stages(self):
    method init_weights (line 659) | def init_weights(self, pretrained=None):
    method forward (line 721) | def forward(self, x):

FILE: mmpose/models/backbones/tcn.py
  class BasicTemporalBlock (line 13) | class BasicTemporalBlock(BaseModule):
    method __init__ (line 40) | def __init__(self,
    method forward (line 103) | def forward(self, x):
  class TCN (line 136) | class TCN(BaseBackbone):
    method __init__ (line 195) | def __init__(self,
    method forward (line 272) | def forward(self, x):

FILE: mmpose/models/backbones/utils/channel_shuffle.py
  function channel_shuffle (line 5) | def channel_shuffle(x, groups):

FILE: mmpose/models/backbones/utils/ckpt_convert.py
  function swin_converter (line 10) | def swin_converter(ckpt):

FILE: mmpose/models/backbones/utils/inverted_residual.py
  class InvertedResidual (line 11) | class InvertedResidual(nn.Module):
    method __init__ (line 41) | def __init__(self,
    method forward (line 104) | def forward(self, x):

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

FILE: mmpose/models/backbones/utils/se_layer.py
  class SELayer (line 7) | class SELayer(nn.Module):
    method __init__ (line 24) | def __init__(self,
    method forward (line 50) | def forward(self, x):

FILE: mmpose/models/backbones/utils/utils.py
  function load_checkpoint (line 7) | def load_checkpoint(model,
  function get_state_dict (line 55) | def get_state_dict(filename, map_location='cpu'):

FILE: mmpose/models/backbones/v2v_net.py
  class Basic3DBlock (line 17) | class Basic3DBlock(BaseModule):
    method __init__ (line 32) | def __init__(self,
    method forward (line 50) | def forward(self, x):
  class Res3DBlock (line 55) | class Res3DBlock(BaseModule):
    method __init__ (line 71) | def __init__(self,
    method forward (line 114) | def forward(self, x):
  class Pool3DBlock (line 121) | class Pool3DBlock(BaseModule):
    method __init__ (line 128) | def __init__(self, pool_size):
    method forward (line 132) | def forward(self, x):
  class Upsample3DBlock (line 138) | class Upsample3DBlock(BaseModule):
    method __init__ (line 152) | def __init__(self,
    method forward (line 170) | def forward(self, x):
  class EncoderDecorder (line 175) | class EncoderDecorder(BaseModule):
    method __init__ (line 184) | def __init__(self, in_channels=32, init_cfg=None):
    method forward (line 204) | def forward(self, x):
  class V2VNet (line 228) | class V2VNet(BaseBackbone):
    method __init__ (line 249) | def __init__(self,
    method forward (line 269) | def forward(self, x):

FILE: mmpose/models/backbones/vgg.py
  function make_vgg_layer (line 10) | def make_vgg_layer(in_channels,
  class VGG (line 39) | class VGG(BaseBackbone):
    method __init__ (line 90) | def __init__(self,
    method forward (line 169) | def forward(self, x):
    method _freeze_stages (line 185) | def _freeze_stages(self):
    method train (line 194) | def train(self, mode=True):

FILE: mmpose/models/backbones/vipnas_mbv3.py
  class ViPNAS_MobileNetV3 (line 13) | class ViPNAS_MobileNetV3(BaseBackbone):
    method __init__ (line 52) | def __init__(
    method _make_layer (line 101) | def _make_layer(self):
    method forward (line 148) | def forward(self, x):
    method _freeze_stages (line 157) | def _freeze_stages(self):
    method train (line 167) | def train(self, mode=True):

FILE: mmpose/models/backbones/vipnas_resnet.py
  class ViPNAS_Bottleneck (line 15) | class ViPNAS_Bottleneck(BaseModule):
    method __init__ (line 44) | def __init__(self,
    method norm1 (line 128) | def norm1(self):
    method norm2 (line 133) | def norm2(self):
    method norm3 (line 138) | def norm3(self):
    method forward (line 142) | def forward(self, x):
  function get_expansion (line 179) | def get_expansion(block, expansion=None):
  class ViPNAS_ResLayer (line 212) | class ViPNAS_ResLayer(Sequential):
    method __init__ (line 244) | def __init__(self,
  class ViPNAS_ResNet (line 350) | class ViPNAS_ResNet(BaseBackbone):
    method __init__ (line 408) | def __init__(self,
    method make_res_layer (line 497) | def make_res_layer(self, **kwargs):
    method norm1 (line 502) | def norm1(self):
    method _make_stem_layer (line 506) | def _make_stem_layer(self, in_channels, stem_channels, kernel_size):
    method _freeze_stages (line 552) | def _freeze_stages(self):
    method forward (line 571) | def forward(self, x):
    method train (line 588) | def train(self, mode=True):

FILE: mmpose/models/builder.py
  function build_backbone (line 13) | def build_backbone(cfg):
  function build_neck (line 18) | def build_neck(cfg):
  function build_head (line 23) | def build_head(cfg):
  function build_loss (line 28) | def build_loss(cfg):
  function build_pose_estimator (line 33) | def build_pose_estimator(cfg):
  function build_posenet (line 38) | def build_posenet(cfg):

FILE: mmpose/models/data_preprocessors/batch_augmentation.py
  class BatchSyncRandomResize (line 18) | class BatchSyncRandomResize(nn.Module):
    method __init__ (line 30) | def __init__(self,
    method forward (line 42) | def forward(self, inputs: Tensor, data_samples: List[PoseDataSample]
    method _get_random_size (line 101) | def _get_random_size(self, aspect_ratio: float,

FILE: mmpose/models/data_preprocessors/data_preprocessor.py
  class PoseDataPreprocessor (line 14) | class PoseDataPreprocessor(ImgDataPreprocessor):
    method __init__ (line 53) | def __init__(self,
    method forward (line 77) | def forward(self, data: dict, training: bool = False) -> dict:
    method _get_pad_shape (line 107) | def _get_pad_shape(self, data: dict) -> List[tuple]:

FILE: mmpose/models/distillers/dwpose_distiller.py
  class DWPoseDistiller (line 22) | class DWPoseDistiller(BaseModel, metaclass=ABCMeta):
    method __init__ (line 49) | def __init__(self,
    method init_weights (line 87) | def init_weights(self):
    method set_epoch (line 93) | def set_epoch(self):
    method forward (line 102) | def forward(self,
    method loss (line 120) | def loss(self, inputs: Tensor, data_samples: SampleList) -> dict:
    method predict (line 170) | def predict(self, inputs, data_samples):
    method extract_feat (line 218) | def extract_feat(self, inputs: Tensor) -> Tuple[Tensor]:
    method head_loss (line 231) | def head_loss(
    method _forward (line 280) | def _forward(self, inputs: Tensor):

FILE: mmpose/models/heads/base_head.py
  class BaseHead (line 14) | class BaseHead(BaseModule, metaclass=ABCMeta):
    method forward (line 23) | def forward(self, feats: Tuple[Tensor]):
    method predict (line 27) | def predict(self,
    method loss (line 34) | def loss(self,
    method decode (line 40) | def decode(self, batch_outputs: Union[Tensor,

FILE: mmpose/models/heads/coord_cls_heads/rtmcc_head.py
  class RTMCCHead (line 24) | class RTMCCHead(BaseHead):
    method __init__ (line 58) | def __init__(
    method forward (line 134) | def forward(self, feats: Tuple[Tensor]) -> Tuple[Tensor, Tensor]:
    method predict (line 163) | def predict(
    method loss (line 248) | def loss(
    method default_init_cfg (line 297) | def default_init_cfg(self):

FILE: mmpose/models/heads/coord_cls_heads/rtmw_head.py
  class RTMWHead (line 25) | class RTMWHead(BaseHead):
    method __init__ (line 56) | def __init__(
    method forward (line 159) | def forward(self, feats: Tuple[Tensor]) -> Tuple[Tensor, Tensor]:
    method predict (line 197) | def predict(
    method loss (line 282) | def loss(
    method default_init_cfg (line 331) | def default_init_cfg(self):

FILE: mmpose/models/heads/coord_cls_heads/simcc_head.py
  class SimCCHead (line 24) | class SimCCHead(BaseHead):
    method __init__ (line 73) | def __init__(
    method _make_deconv_head (line 161) | def _make_deconv_head(
    method forward (line 200) | def forward(self, feats: Tuple[Tensor]) -> Tuple[Tensor, Tensor]:
    method predict (line 228) | def predict(
    method loss (line 315) | def loss(
    method default_init_cfg (line 364) | def default_init_cfg(self):

FILE: mmpose/models/heads/heatmap_heads/ae_head.py
  class AssociativeEmbeddingHead (line 20) | class AssociativeEmbeddingHead(HeatmapHead):
    method __init__ (line 22) | def __init__(self,
    method predict (line 62) | def predict(self,
    method _flip_tags (line 197) | def _flip_tags(self,
    method decode (line 230) | def decode(self, batch_outputs: Union[Tensor,
    method forward (line 281) | def forward(self, feats: Tuple[Tensor]) -> Tuple[Tensor, Tensor]:
    method loss (line 299) | def loss(self,

FILE: mmpose/models/heads/heatmap_heads/cid_head.py
  function smooth_heatmaps (line 20) | def smooth_heatmaps(heatmaps: Tensor, blur_kernel_size: int) -> Tensor:
  class TruncSigmoid (line 36) | class TruncSigmoid(nn.Sigmoid):
    method __init__ (line 47) | def __init__(self, min: float = 0.0, max: float = 1.0):
    method forward (line 52) | def forward(self, input: Tensor) -> Tensor:
  class IIAModule (line 59) | class IIAModule(BaseModule):
    method __init__ (line 72) | def __init__(
    method forward (line 89) | def forward(self, feats: Tensor):
    method _sample_feats (line 94) | def _sample_feats(self, feats: Tensor, indices: Tensor) -> Tensor:
    method _hierarchical_pool (line 121) | def _hierarchical_pool(self, heatmaps: Tensor) -> Tensor:
    method forward_train (line 140) | def forward_train(self, feats: Tensor, instance_coords: Tensor,
    method forward_test (line 160) | def forward_test(
  class ChannelAttention (line 209) | class ChannelAttention(nn.Module):
    method __init__ (line 219) | def __init__(self, in_channels: int, out_channels: int):
    method forward (line 223) | def forward(self, global_feats: Tensor, instance_feats: Tensor) -> Ten...
  class SpatialAttention (line 230) | class SpatialAttention(nn.Module):
    method __init__ (line 240) | def __init__(self, in_channels, out_channels):
    method _get_pixel_coords (line 246) | def _get_pixel_coords(self, heatmap_size: Tuple, device: str = 'cpu'):
    method forward (line 263) | def forward(self, global_feats: Tensor, instance_feats: Tensor,
  class GFDModule (line 294) | class GFDModule(BaseModule):
    method __init__ (line 309) | def __init__(
    method forward (line 342) | def forward(
  class CIDHead (line 381) | class CIDHead(BaseHead):
    method __init__ (line 414) | def __init__(self,
    method default_init_cfg (line 483) | def default_init_cfg(self):
    method forward (line 490) | def forward(self, feats: Tuple[Tensor]) -> Tensor:
    method predict (line 510) | def predict(self,
    method loss (line 603) | def loss(self,
    method _load_state_dict_pre_hook (line 699) | def _load_state_dict_pre_hook(self, state_dict, prefix, local_meta, *a...

FILE: mmpose/models/heads/heatmap_heads/cpm_head.py
  class CPMHead (line 21) | class CPMHead(BaseHead):
    method __init__ (line 54) | def __init__(self,
    method default_init_cfg (line 128) | def default_init_cfg(self):
    method _make_deconv_layers (line 136) | def _make_deconv_layers(self, in_channels: int,
    method forward (line 173) | def forward(self, feats: Sequence[Tensor]) -> List[Tensor]:
    method predict (line 194) | def predict(self,
    method loss (line 254) | def loss(self,

FILE: mmpose/models/heads/heatmap_heads/heatmap_head.py
  class HeatmapHead (line 21) | class HeatmapHead(BaseHead):
    method __init__ (line 57) | def __init__(self,
    method _make_conv_layers (line 132) | def _make_conv_layers(self, in_channels: int,
    method _make_deconv_layers (line 155) | def _make_deconv_layers(self, in_channels: int,
    method default_init_cfg (line 193) | def default_init_cfg(self):
    method forward (line 201) | def forward(self, feats: Tuple[Tensor]) -> Tensor:
    method predict (line 219) | def predict(self,
    method loss (line 278) | def loss(self,
    method _load_state_dict_pre_hook (line 319) | def _load_state_dict_pre_hook(self, state_dict, prefix, local_meta, *a...

FILE: mmpose/models/heads/heatmap_heads/internet_head.py
  function make_linear_layers (line 23) | def make_linear_layers(feat_dims, relu_final=False):
  class Heatmap3DHead (line 34) | class Heatmap3DHead(HeatmapHead):
    method __init__ (line 56) | def __init__(self,
    method forward (line 76) | def forward(self, feats: Tensor) -> Tensor:
  class Heatmap1DHead (line 96) | class Heatmap1DHead(nn.Module):
    method __init__ (line 107) | def __init__(self,
    method soft_argmax_1d (line 120) | def soft_argmax_1d(self, heatmap1d):
    method forward (line 128) | def forward(self, feats: Tuple[Tensor]) -> Tensor:
    method init_weights (line 141) | def init_weights(self):
  class MultilabelClassificationHead (line 148) | class MultilabelClassificationHead(nn.Module):
    method __init__ (line 159) | def __init__(self,
    method init_weights (line 171) | def init_weights(self):
    method forward (line 176) | def forward(self, x):
  class InternetHead (line 183) | class InternetHead(BaseHead):
    method __init__ (line 209) | def __init__(self,
    method forward (line 241) | def forward(self, feats: Tuple[Tensor]) -> Tensor:
    method predict (line 262) | def predict(self,
    method loss (line 327) | def loss(self,
    method decode (line 393) | def decode(self, batch_outputs: Union[Tensor,

FILE: mmpose/models/heads/heatmap_heads/mspn_head.py
  class PRM (line 23) | class PRM(nn.Module):
    method __init__ (line 36) | def __init__(self,
    method forward (line 80) | def forward(self, x: Tensor) -> Tensor:
  class PredictHeatmap (line 104) | class PredictHeatmap(nn.Module):
    method __init__ (line 116) | def __init__(self,
    method forward (line 152) | def forward(self, feature: Tensor) -> Tensor:
  class MSPNHead (line 170) | class MSPNHead(BaseHead):
    method __init__ (line 203) | def __init__(self,
    method default_init_cfg (line 267) | def default_init_cfg(self):
    method forward (line 276) | def forward(self, feats: Sequence[Sequence[Tensor]]) -> List[Tensor]:
    method predict (line 307) | def predict(self,
    method loss (line 367) | def loss(self,

FILE: mmpose/models/heads/heatmap_heads/vipnas_head.py
  class ViPNASHead (line 15) | class ViPNASHead(HeatmapHead):
    method __init__ (line 57) | def __init__(self,
    method _make_deconv_layers (line 141) | def _make_deconv_layers(self, in_channels: int,

FILE: mmpose/models/heads/hybrid_heads/dekr_head.py
  class AdaptiveActivationBlock (line 27) | class AdaptiveActivationBlock(BaseModule):
    method __init__ (line 40) | def __init__(self,
    method forward (line 82) | def forward(self, x):
  class RescoreNet (line 100) | class RescoreNet(BaseModule):
    method __init__ (line 110) | def __init__(
    method make_feature (line 127) | def make_feature(self, keypoints, keypoint_scores, skeleton):
    method forward (line 160) | def forward(self, keypoints, keypoint_scores, skeleton):
  class DEKRHead (line 169) | class DEKRHead(BaseHead):
    method __init__ (line 200) | def __init__(self,
    method default_init_cfg (line 260) | def default_init_cfg(self):
    method _make_heatmap_conv_layers (line 268) | def _make_heatmap_conv_layers(self, in_channels: int, out_channels: int,
    method _make_displacement_conv_layers (line 288) | def _make_displacement_conv_layers(self, in_channels: int,
    method forward (line 311) | def forward(self, feats: Tuple[Tensor]) -> Tensor:
    method loss (line 328) | def loss(self,
    method predict (line 375) | def predict(self,
    method decode (line 476) | def decode(self,
    method _load_state_dict_pre_hook (line 548) | def _load_state_dict_pre_hook(self, state_dict, prefix, local_meta, *a...

FILE: mmpose/models/heads/hybrid_heads/rtmo_head.py
  class RTMOHeadModule (line 25) | class RTMOHeadModule(BaseModule):
    method __init__ (line 60) | def __init__(
    method _init_layers (line 99) | def _init_layers(self):
    method _init_cls_branch (line 104) | def _init_cls_branch(self):
    method _init_pose_branch (line 130) | def _init_pose_branch(self):
    method init_weights (line 169) | def init_weights(self):
    method forward (line 180) | def forward(self, x: Tuple[Tensor]) -> Tuple[List]:
  class DCC (line 222) | class DCC(BaseModule):
    method __init__ (line 238) | def __init__(
    method _build_layers (line 273) | def _build_layers(self):
    method _build_basic_bins (line 303) | def _build_basic_bins(self):
    method _apply_softmax (line 310) | def _apply_softmax(self, x_hms, y_hms):
    method _get_bin_enc (line 332) | def _get_bin_enc(self, bbox_cs, grids):
    method _pose_feats_to_heatmaps (line 367) | def _pose_feats_to_heatmaps(self, pose_feats, x_bins_enc, y_bins_enc):
    method _decode_xy_heatmaps (line 401) | def _decode_xy_heatmaps(self, x_hms, y_hms, bbox_cs):
    method generate_target_heatmap (line 431) | def generate_target_heatmap(self, kpt_targets, bbox_cs, sigmas, areas):
    method forward_train (line 471) | def forward_train(self, pose_feats, bbox_cs, grids):
    method forward_test (line 496) | def forward_test(self, pose_feats, bbox_cs, grids):
    method switch_to_deploy (line 518) | def switch_to_deploy(self, test_cfg: Optional[Dict] = None):
    method _convert_pose_to_kpts (line 529) | def _convert_pose_to_kpts(self):
    method _convert_gau (line 550) | def _convert_gau(self):
    method _convert_forward_test (line 599) | def _convert_forward_test(self):
  class RTMOHead (line 662) | class RTMOHead(YOLOXPoseHead):
    method __init__ (line 695) | def __init__(
    method loss (line 748) | def loss(self,
    method predict (line 889) | def predict(self,
    method switch_to_deploy (line 1016) | def switch_to_deploy(self, test_cfg: Optional[Dict]):

FILE: mmpose/models/heads/hybrid_heads/vis_head.py
  class VisPredictHead (line 16) | class VisPredictHead(BaseHead):
    method __init__ (line 30) | def __init__(self,
    method vis_forward (line 68) | def vis_forward(self, feats: Tuple[Tensor]):
    method forward (line 84) | def forward(self, feats: Tuple[Tensor]):
    method integrate (line 99) | def integrate(self, batch_vis: Tensor,
    method predict (line 119) | def predict(self,
    method vis_accuracy (line 179) | def vis_accuracy(self, vis_pred_outputs, vis_labels, vis_weights=None):
    method loss (line 193) | def loss(self,
    method default_init_cfg (line 239) | def default_init_cfg(self):

FILE: mmpose/models/heads/hybrid_heads/yoloxpose_head.py
  class YOLOXPoseHeadModule (line 22) | class YOLOXPoseHeadModule(BaseModule):
    method __init__ (line 58) | def __init__(
    method _init_layers (line 92) | def _init_layers(self):
    method _init_cls_branch (line 98) | def _init_cls_branch(self):
    method _init_reg_branch (line 125) | def _init_reg_branch(self):
    method _init_pose_branch (line 152) | def _init_pose_branch(self):
    method init_weights (line 181) | def init_weights(self):
    method forward (line 190) | def forward(self, x: Tuple[Tensor]) -> Tuple[List]:
  class YOLOXPoseHead (line 224) | class YOLOXPoseHead(BaseModule):
    method __init__ (line 226) | def __init__(
    method forward (line 272) | def forward(self, feats: Features):
    method loss (line 276) | def loss(self,
    method _get_targets (line 389) | def _get_targets(
    method _get_targets_single (line 450) | def _get_targets_single(
    method predict (line 593) | def predict(self,
    method decode_bbox (line 713) | def decode_bbox(self, pred_bboxes: torch.Tensor, priors: torch.Tensor,
    method decode_kpt_reg (line 750) | def decode_kpt_reg(self, pred_kpt_offsets: torch.Tensor,
    method _flatten_predictions (line 775) | def _flatten_predictions(self, preds: List[Tensor]):

FILE: mmpose/models/heads/regression_heads/dsnt_head.py
  class DSNTHead (line 19) | class DSNTHead(IntegralRegressionHead):
    method __init__ (line 65) | def __init__(self,
    method loss (line 103) | def loss(self,

FILE: mmpose/models/heads/regression_heads/integral_regression_head.py
  class IntegralRegressionHead (line 25) | class IntegralRegressionHead(BaseHead):
    method __init__ (line 69) | def __init__(self,
    method _linear_expectation (line 151) | def _linear_expectation(self, heatmaps: Tensor,
    method _flat_softmax (line 161) | def _flat_softmax(self, featmaps: Tensor) -> Tensor:
    method forward (line 171) | def forward(self, feats: Tuple[Tensor]) -> Union[Tensor, Tuple[Tensor]]:
    method predict (line 202) | def predict(self,
    method loss (line 274) | def loss(self,
    method default_init_cfg (line 309) | def default_init_cfg(self):
    method _load_state_dict_pre_hook (line 313) | def _load_state_dict_pre_hook(self, state_dict, prefix, local_meta, *a...

FILE: mmpose/models/heads/regression_heads/motion_regression_head.py
  class MotionRegressionHead (line 19) | class MotionRegressionHead(BaseHead):
    method __init__ (line 38) | def __init__(self,
    method forward (line 68) | def forward(self, feats: Tuple[Tensor]) -> Tensor:
    method predict (line 84) | def predict(self,
    method loss (line 155) | def loss(self,
    method default_init_cfg (line 192) | def default_init_cfg(self):

FILE: mmpose/models/heads/regression_heads/regression_head.py
  class RegressionHead (line 20) | class RegressionHead(BaseHead):
    method __init__ (line 40) | def __init__(self,
    method forward (line 64) | def forward(self, feats: Tuple[Tensor]) -> Tensor:
    method predict (line 81) | def predict(self,
    method loss (line 109) | def loss(self,
    method default_init_cfg (line 144) | def default_init_cfg(self):

FILE: mmpose/models/heads/regression_heads/rle_head.py
  class RLEHead (line 20) | class RLEHead(BaseHead):
    method __init__ (line 40) | def __init__(self,
    method forward (line 67) | def forward(self, feats: Tuple[Tensor]) -> Tensor:
    method predict (line 84) | def predict(self,
    method loss (line 118) | def loss(self,
    method _load_state_dict_pre_hook (line 155) | def _load_state_dict_pre_hook(self, state_dict, prefix, local_meta, *a...
    method default_init_cfg (line 185) | def default_init_cfg(self):

FILE: mmpose/models/heads/regression_heads/temporal_regression_head.py
  class TemporalRegressionHead (line 18) | class TemporalRegressionHead(BaseHead):
    method __init__ (line 36) | def __init__(self,
    method forward (line 60) | def forward(self, feats: Tuple[Tensor]) -> Tensor:
    method predict (line 76) | def predict(self,
    method loss (line 110) | def loss(self,
    method default_init_cfg (line 147) | def default_init_cfg(self):

FILE: mmpose/models/heads/regression_heads/trajectory_regression_head.py
  class TrajectoryRegressionHead (line 18) | class TrajectoryRegressionHead(BaseHead):
    method __init__ (line 36) | def __init__(self,
    method forward (line 60) | def forward(self, feats: Tuple[Tensor]) -> Tensor:
    method predict (line 76) | def predict(self,
    method loss (line 110) | def loss(self,
    method default_init_cfg (line 146) | def default_init_cfg(self):

FILE: mmpose/models/heads/transformer_heads/base_transformer_head.py
  class TransformerHead (line 15) | class TransformerHead(BaseHead):
    method __init__ (line 37) | def __init__(self,
    method forward (line 57) | def forward(self,
    method predict (line 70) | def predict(self,
    method loss (line 77) | def loss(self,
    method forward_encoder (line 85) | def forward_encoder(self, feat: Tensor, feat_mask: Tensor,
    method forward_decoder (line 90) | def forward_decoder(self, query: Tensor, query_pos: Tensor, memory: Te...
    method forward_out_head (line 95) | def forward_out_head(self, query: Tensor, query_pos: Tensor,
    method get_valid_ratio (line 100) | def get_valid_ratio(mask: Tensor) -> Tensor:

FILE: mmpose/models/heads/transformer_heads/edpose_head.py
  class EDPoseDecoder (line 30) | class EDPoseDecoder(BaseModule):
    method __init__ (line 49) | def __init__(self,
    method forward (line 103) | def forward(self, query: Tensor, value: Tensor, key_padding_mask: Tensor,
    method get_proposal_pos_embed (line 287) | def get_proposal_pos_embed(pos_tensor: Tensor,
  class EDPoseOutHead (line 343) | class EDPoseOutHead(BaseModule):
    method __init__ (line 369) | def __init__(self,
    method init_weights (line 457) | def init_weights(self) -> None:
    method forward (line 465) | def forward(self, hidden_states: List[Tensor], references: List[Tensor],
    method keypoint_xyzxyz_to_xyxyzz (line 581) | def keypoint_xyzxyz_to_xyxyzz(self, keypoints: torch.Tensor):
  class EDPoseHead (line 595) | class EDPoseHead(TransformerHead):
    method __init__ (line 634) | def __init__(self,
    method init_weights (line 716) | def init_weights(self) -> None:
    method pre_transformer (line 731) | def pre_transformer(self,
    method forward_encoder (line 842) | def forward_encoder(self,
    method pre_decoder (line 870) | def pre_decoder(self, memory: Tensor, memory_mask: Tensor,
    method forward_decoder (line 947) | def forward_decoder(self, memory: Tensor, memory_mask: Tensor,
    method forward_out_head (line 1003) | def forward_out_head(self, batch_data_samples: OptSampleList,
    method predict (line 1013) | def predict(self,
    method decode (line 1036) | def decode(self, input_shapes: np.ndarray, pred_logits: Tensor,
    method gen_encoder_output_proposals (line 1079) | def gen_encoder_output_proposals(self, memory: Tensor, memory_mask: Te...
    method default_init_cfg (line 1146) | def default_init_cfg(self):
    method prepare_for_denosing (line 1150) | def prepare_for_denosing(self, targets: OptSampleList, device):
    method loss (line 1338) | def loss(self,

FILE: mmpose/models/heads/transformer_heads/transformers/deformable_detr_layers.py
  class DeformableDetrTransformerEncoder (line 16) | class DeformableDetrTransformerEncoder(DetrTransformerEncoder):
    method _init_layers (line 19) | def _init_layers(self) -> None:
    method forward (line 27) | def forward(self, query: Tensor, query_pos: Tensor,
    method get_encoder_reference_points (line 68) | def get_encoder_reference_points(spatial_shapes: Tensor,
  class DeformableDetrTransformerDecoder (line 107) | class DeformableDetrTransformerDecoder(DetrTransformerDecoder):
    method _init_layers (line 110) | def _init_layers(self) -> None:
    method forward (line 121) | def forward(self,
  class DeformableDetrTransformerEncoderLayer (line 223) | class DeformableDetrTransformerEncoderLayer(DetrTransformerEncoderLayer):
    method _init_layers (line 226) | def _init_layers(self) -> None:
  class DeformableDetrTransformerDecoderLayer (line 238) | class DeformableDetrTransformerDecoderLayer(DetrTransformerDecoderLayer):
    method _init_layers (line 241) | def _init_layers(self) -> None:

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

FILE: mmpose/models/heads/transformer_heads/transformers/utils.py
  class FFN (line 11) | class FFN(BaseModule):
    method __init__ (line 22) | def __init__(self, input_dim: int, hidden_dim: int, output_dim: int,
    method forward (line 34) | def forward(self, x: Tensor) -> Tensor:
  class PositionEmbeddingSineHW (line 51) | class PositionEmbeddingSineHW(BaseModule):
    method __init__ (line 56) | def __init__(self,
    method forward (line 73) | def forward(self, mask: Tensor):

FILE: mmpose/models/losses/ae_loss.py
  class AssociativeEmbeddingLoss (line 14) | class AssociativeEmbeddingLoss(nn.Module):
    method __init__ (line 35) | def __init__(self,
    method _ae_loss_per_image (line 42) | def _ae_loss_per_image(self, tags: Tensor, keypoint_indices: Tensor):
    method forward (line 93) | def forward(self, tags: Tensor, keypoint_indices: Union[List[Tensor],

FILE: mmpose/models/losses/bbox_loss.py
  class IoULoss (line 12) | class IoULoss(nn.Module):
    method __init__ (line 23) | def __init__(self,
    method forward (line 44) | def forward(self, output, target, target_weight=None):

FILE: mmpose/models/losses/classification_loss.py
  class BCELoss (line 12) | class BCELoss(nn.Module):
    method __init__ (line 24) | def __init__(self,
    method forward (line 43) | def forward(self, output, target, target_weight=None):
  class JSDiscretLoss (line 75) | class JSDiscretLoss(nn.Module):
    method __init__ (line 87) | def __init__(
    method kl (line 97) | def kl(self, p, q):
    method js (line 104) | def js(self, pred_hm, gt_hm):
    method forward (line 111) | def forward(self, pred_hm, gt_hm, target_weight=None):
  class KLDiscretLoss (line 142) | class KLDiscretLoss(nn.Module):
    method __init__ (line 159) | def __init__(self,
    method criterion (line 177) | def criterion(self, dec_outs, labels):
    method forward (line 185) | def forward(self, pred_simcc, gt_simcc, target_weight):
  class InfoNCELoss (line 219) | class InfoNCELoss(nn.Module):
    method __init__ (line 234) | def __init__(self, temperature: float = 1.0, loss_weight=1.0) -> None:
    method forward (line 241) | def forward(self, features: torch.Tensor) -> torch.Tensor:
  class VariFocalLoss (line 260) | class VariFocalLoss(nn.Module):
    method __init__ (line 274) | def __init__(self,
    method criterion (line 292) | def criterion(self, output, target):
    method forward (line 302) | def forward(self, output, target, target_weight=None):

FILE: mmpose/models/losses/fea_dis_loss.py
  class FeaLoss (line 8) | class FeaLoss(nn.Module):
    method __init__ (line 19) | def __init__(
    method forward (line 40) | def forward(self, preds_S, preds_T):
    method get_dis_loss (line 57) | def get_dis_loss(self, preds_S, preds_T):

FILE: mmpose/models/losses/heatmap_loss.py
  class KeypointMSELoss (line 13) | class KeypointMSELoss(nn.Module):
    method __init__ (line 27) | def __init__(self,
    method forward (line 36) | def forward(self,
    method _get_mask (line 72) | def _get_mask(self, target: Tensor, target_weights: Optional[Tensor],
  class CombinedTargetMSELoss (line 122) | class CombinedTargetMSELoss(nn.Module):
    method __init__ (line 137) | def __init__(self,
    method forward (line 145) | def forward(self, output: Tensor, target: Tensor,
  class KeypointOHKMMSELoss (line 196) | class KeypointOHKMMSELoss(nn.Module):
    method __init__ (line 207) | def __init__(self,
    method _ohkm (line 218) | def _ohkm(self, losses: Tensor) -> Tensor:
    method forward (line 242) | def forward(self, output: Tensor, target: Tensor,
  class AdaptiveWingLoss (line 283) | class AdaptiveWingLoss(nn.Module):
    method __init__ (line 295) | def __init__(self,
    method criterion (line 310) | def criterion(self, pred, target):
    method forward (line 341) | def forward(self,
  class FocalHeatmapLoss (line 375) | class FocalHeatmapLoss(KeypointMSELoss):
    method __init__ (line 397) | def __init__(self,
    method forward (line 408) | def forward(self,
  class MLECCLoss (line 459) | class MLECCLoss(nn.Module):
    method __init__ (line 480) | def __init__(self,
    method forward (line 498) | def forward(self, outputs, targets, target_weight=None):

FILE: mmpose/models/losses/logit_dis_loss.py
  class KDLoss (line 10) | class KDLoss(nn.Module):
    method __init__ (line 19) | def __init__(
    method forward (line 31) | def forward(self, pred, pred_t, beta, target_weight):
    method loss (line 46) | def loss(self, logit_s, logit_t, beta, weight):

FILE: mmpose/models/losses/loss_wrappers.py
  class MultipleLossWrapper (line 11) | class MultipleLossWrapper(nn.Module):
    method __init__ (line 19) | def __init__(self, losses: list):
    method forward (line 29) | def forward(self, input_list, target_list, keypoint_weights=None):
  class CombinedLoss (line 59) | class CombinedLoss(nn.ModuleDict):
    method __init__ (line 79) | def __init__(self, losses: Dict[str, ConfigType]):

FILE: mmpose/models/losses/regression_loss.py
  class RLELoss (line 16) | class RLELoss(nn.Module):
    method __init__ (line 35) | def __init__(self,
    method forward (line 48) | def forward(self, pred, sigma, target, target_weight=None):
  class SmoothL1Loss (line 96) | class SmoothL1Loss(nn.Module):
    method __init__ (line 105) | def __init__(self, use_target_weight=False, loss_weight=1.):
    method forward (line 111) | def forward(self, output, target, target_weight=None):
  class SoftWeightSmoothL1Loss (line 142) | class SoftWeightSmoothL1Loss(nn.Module):
    method __init__ (line 155) | def __init__(self,
    method smooth_l1_loss (line 171) | def smooth_l1_loss(input, target, reduction='none', beta=1.0):
    method forward (line 189) | def forward(self, output, target, target_weight=None):
  class WingLoss (line 223) | class WingLoss(nn.Module):
    method __init__ (line 235) | def __init__(self,
    method criterion (line 250) | def criterion(self, pred, target):
    method forward (line 268) | def forward(self, output, target, target_weight=None):
  class SoftWingLoss (line 293) | class SoftWingLoss(nn.Module):
    method __init__ (line 310) | def __init__(self,
    method criterion (line 328) | def criterion(self, pred, target):
    method forward (line 346) | def forward(self, output, target, target_weight=None):
  class MPJPEVelocityJointLoss (line 371) | class MPJPEVelocityJointLoss(nn.Module):
    method __init__ (line 380) | def __init__(self,
    method forward (line 391) | def forward(self, output, target, target_weight=None):
  class MPJPELoss (line 449) | class MPJPELoss(nn.Module):
    method __init__ (line 458) | def __init__(self, use_target_weight=False, loss_weight=1.):
    method forward (line 463) | def forward(self, output, target, target_weight=None):
  class L1Loss (line 489) | class L1Loss(nn.Module):
    method __init__ (line 492) | def __init__(self,
    method forward (line 506) | def forward(self, output, target, target_weight=None):
  class MSELoss (line 532) | class MSELoss(nn.Module):
    method __init__ (line 535) | def __init__(self, use_target_weight=False, loss_weight=1.):
    method forward (line 541) | def forward(self, output, target, target_weight=None):
  class BoneLoss (line 566) | class BoneLoss(nn.Module):
    method __init__ (line 576) | def __init__(self,
    method forward (line 593) | def forward(self, output, target, target_weight=None):
    method loss_name (line 626) | def loss_name(self):
  class SemiSupervisionLoss (line 636) | class SemiSupervisionLoss(nn.Module):
    method __init__ (line 658) | def __init__(self,
    method project_joints (line 672) | def project_joints(x, intrinsics):
    method forward (line 700) | def forward(self, output, target):
  class OKSLoss (line 728) | class OKSLoss(nn.Module):
    method __init__ (line 754) | def __init__(self,
    method forward (line 783) | def forward(self, output, target, target_weight=None, areas=None):

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

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

FILE: mmpose/models/necks/fmap_proc_neck.py
  class FeatureMapProcessor (line 14) | class FeatureMapProcessor(nn.Module):
    method __init__ (line 32) | def __init__(
    method forward (line 55) | def forward(self, inputs: Union[Tensor, Sequence[Tensor]]
    method _concat (line 81) | def _concat(self, inputs: Sequence[Tensor]) -> List[Tensor]:
    method _rescale (line 92) | def _rescale(self, inputs: Sequence[Tensor]) -> List[Tensor]:

FILE: mmpose/models/necks/fpn.py
  class FPN (line 11) | class FPN(nn.Module):
    method __init__ (line 61) | def __init__(self,
    method init_weights (line 148) | def init_weights(self):
    method forward (line 154) | def forward(self, inputs):

FILE: mmpose/models/necks/gap_neck.py
  class GlobalAveragePooling (line 9) | class GlobalAveragePooling(nn.Module):
    method __init__ (line 17) | def __init__(self):
    method init_weights (line 21) | def init_weights(self):
    method forward (line 24) | def forward(self, inputs):

FILE: mmpose/models/necks/hybrid_encoder.py
  class CSPRepLayer (line 17) | class CSPRepLayer(BaseModule):
    method __init__ (line 35) | def __init__(self,
    method forward (line 71) | def forward(self, x: Tensor) -> Tensor:
  class HybridEncoder (line 87) | class HybridEncoder(BaseModule):
    method __init__ (line 124) | def __init__(self,
    method forward (line 224) | def forward(self, inputs: Tuple[Tensor]) -> Tuple[Tensor]:
    method switch_to_deploy (line 283) | def switch_to_deploy(self, test_cfg):

FILE: mmpose/models/necks/posewarper_neck.py
  class PoseWarperNeck (line 22) | class PoseWarperNeck(nn.Module):
    method __init__ (line 68) | def __init__(self,
    method freeze_layers (line 205) | def freeze_layers(self):
    method init_weights (line 212) | def init_weights(self):
    method _transform_inputs (line 238) | def _transform_inputs(self, inputs):
    method forward (line 267) | def forward(self, inputs, frame_weight):
    method train (line 322) | def train(self, mode=True):

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

FILE: mmpose/models/pose_estimators/base.py
  class BasePoseEstimator (line 19) | class BasePoseEstimator(BaseModel, metaclass=ABCMeta):
    method __init__ (line 37) | def __init__(self,
    method switch_to_deploy (line 76) | def switch_to_deploy(self):
    method with_neck (line 87) | def with_neck(self) -> bool:
    method with_head (line 92) | def with_head(self) -> bool:
    method _load_metainfo (line 97) | def _load_metainfo(metainfo: dict = None) -> dict:
    method forward (line 117) | def forward(self,
    method loss (line 169) | def loss(self, inputs: Tensor, data_samples: SampleList) -> dict:
    method predict (line 173) | def predict(self, inputs: Tensor, data_samples: SampleList) -> SampleL...
    method _forward (line 177) | def _forward(self,
    method extract_feat (line 197) | def extract_feat(self, inputs: Tensor) -> Tuple[Tensor]:
    method _load_state_dict_pre_hook (line 213) | def _load_state_dict_pre_hook(self, state_dict, prefix, local_meta, *a...

FILE: mmpose/models/pose_estimators/bottomup.py
  class BottomupPoseEstimator (line 15) | class BottomupPoseEstimator(BasePoseEstimator):
    method __init__ (line 34) | def __init__(self,
    method loss (line 53) | def loss(self, inputs: Tensor, data_samples: SampleList) -> dict:
    method predict (line 74) | def predict(self, inputs: Union[Tensor, List[Tensor]],
    method add_pred_to_datasample (line 143) | def add_pred_to_datasample(self, batch_pred_instances: InstanceList,

FILE: mmpose/models/pose_estimators/pose_lifter.py
  class PoseLifter (line 18) | class PoseLifter(BasePoseEstimator):
    method __init__ (line 50) | def __init__(self,
    method with_traj_backbone (line 100) | def with_traj_backbone(self):
    method with_traj_neck (line 106) | def with_traj_neck(self):
    method with_traj (line 111) | def with_traj(self):
    method causal (line 116) | def causal(self):
    method extract_feat (line 125) | def extract_feat(self, inputs: Tensor) -> Tuple[Tensor]:
    method _forward (line 154) | def _forward(self,
    method loss (line 184) | def loss(self, inputs: Tensor, data_samples: SampleList) -> dict:
    method predict (line 219) | def predict(self, inputs: Tensor, data_samples: SampleList) -> SampleL...
    method add_pred_to_datasample (line 296) | def add_pred_to_datasample(

FILE: mmpose/models/pose_estimators/topdown.py
  class TopdownPoseEstimator (line 14) | class TopdownPoseEstimator(BasePoseEstimator):
    method __init__ (line 38) | def __init__(self,
    method loss (line 57) | def loss(self, inputs: Tensor, data_samples: SampleList) -> dict:
    method predict (line 78) | def predict(self, inputs: Tensor, data_samples: SampleList) -> SampleL...
    method add_pred_to_datasample (line 122) | def add_pred_to_datasample(self, batch_pred_instances: InstanceList,

FILE: mmpose/models/task_modules/assigners/metric_calculators.py
  function cast_tensor_type (line 12) | def cast_tensor_type(x, scale=1., dtype=None):
  class BBoxOverlaps2D (line 20) | class BBoxOverlaps2D:
    method __init__ (line 23) | def __init__(self, scale=1., dtype=None):
    method __call__ (line 28) | def __call__(self, bboxes1, bboxes2, mode='iou', is_aligned=False):
    method __repr__ (line 67) | def __repr__(self):
  class PoseOKS (line 75) | class PoseOKS:
    method __init__ (line 78) | def __init__(self,
    method __call__ (line 88) | def __call__(self,

FILE: mmpose/models/task_modules/assigners/sim_ota_assigner.py
  class SimOTAAssigner (line 17) | class SimOTAAssigner:
    method __init__ (line 39) | def __init__(self,
    method assign (line 65) | def assign(self, pred_instances: InstanceData, gt_instances: InstanceD...
    method get_in_gt_and_in_center_info (line 210) | def get_in_gt_and_in_center_info(
    method dynamic_k_matching (line 271) | def dynamic_k_matching(self, cost: Tensor, pairwise_ious: Tensor,

FILE: mmpose/models/task_modules/prior_generators/mlvl_point_generator.py
  class MlvlPointGenerator (line 15) | class MlvlPointGenerator:
    method __init__ (line 28) | def __init__(self,
    method num_levels (line 37) | def num_levels(self) -> int:
    method num_base_priors (line 42) | def num_base_priors(self) -> List[int]:
    method _meshgrid (line 47) | def _meshgrid(self,
    method grid_priors (line 60) | def grid_priors(self,
    method single_level_grid_priors (line 100) | def single_level_grid_priors(self,
    method valid_flags (line 163) | def valid_flags(self,
    method single_level_valid_flags (line 195) | def single_level_valid_flags(self,
    method sparse_priors (line 224) | def sparse_priors(self,

FILE: mmpose/models/utils/check_and_update_config.py
  function process_input_transform (line 11) | def process_input_transform(input_transform: str, head: Dict, head_new: ...
  function process_extra_field (line 54) | def process_extra_field(extra: Dict, head_new: Dict, head_deleted_dict: ...
  function process_has_final_layer (line 83) | def process_has_final_layer(has_final_layer: bool, head_new: Dict,
  function check_and_update_config (line 94) | def check_and_update_config(neck: Optional[ConfigType],
  function display_modifications (line 148) | def display_modifications(head_deleted_dict: Dict, head_append_dict: Dict,
  function build_model_info (line 176) | def build_model_info(head_deleted_dict: Dict, head_append_dict: Dict,
  function build_head_info (line 198) | def build_head_info(head_dict: Dict) -> str:
  function build_neck_info (line 213) | def build_neck_info(neck: Dict) -> str:

FILE: mmpose/models/utils/ckpt_convert.py
  function pvt_convert (line 12) | def pvt_convert(ckpt):

FILE: mmpose/models/utils/csp_layer.py
  class ChannelAttention (line 12) | class ChannelAttention(BaseModule):
    method __init__ (line 21) | def __init__(self, channels: int, init_cfg: OptMultiConfig = None) -> ...
    method forward (line 30) | def forward(self, x: Tensor) -> Tensor:
  class DarknetBottleneck (line 39) | class DarknetBottleneck(BaseModule):
    method __init__ (line 64) | def __init__(self,
    method forward (line 97) | def forward(self, x: Tensor) -> Tensor:
  class CSPNeXtBlock (line 109) | class CSPNeXtBlock(BaseModule):
    method __init__ (line 133) | def __init__(self,
    method forward (line 168) | def forward(self, x: Tensor) -> Tensor:
  class CSPLayer (line 180) | class CSPLayer(BaseModule):
    method __init__ (line 208) | def __init__(self,
    method forward (line 262) | def forward(self, x: Tensor) -> Tensor:

FILE: mmpose/models/utils/geometry.py
  function rot6d_to_rotmat (line 6) | def rot6d_to_rotmat(x):
  function batch_rodrigues (line 25) | def batch_rodrigues(theta):
  function quat_to_rotmat (line 43) | def quat_to_rotmat(quat):

FILE: mmpose/models/utils/misc.py
  function multi_apply (line 8) | def multi_apply(func, *args, **kwargs):
  function filter_scores_and_topk (line 30) | def filter_scores_and_topk(scores, score_thr, topk, results=None):

FILE: mmpose/models/utils/ops.py
  function resize (line 12) | def resize(input: torch.Tensor,
  class FrozenBatchNorm2d (line 59) | class FrozenBatchNorm2d(torch.nn.Module):
    method __init__ (line 68) | def __init__(self, n, eps: int = 1e-5):
    method _load_from_state_dict (line 76) | def _load_from_state_dict(self, state_dict, prefix, local_metadata, st...
    method forward (line 87) | def forward(self, x):
  function inverse_sigmoid (line 97) | def inverse_sigmoid(x: Tensor, eps: float = 1e-3) -> Tensor:

FILE: mmpose/models/utils/realnvp.py
  class RealNVP (line 7) | class RealNVP(nn.Module):
    method get_scale_net (line 21) | def get_scale_net():
    method get_trans_net (line 28) | def get_trans_net():
    method prior (line 35) | def prior(self):
    method __init__ (line 39) | def __init__(self):
    method init_weights (line 53) | def init_weights(self):
    method backward_p (line 59) | def backward_p(self, x):
    method log_prob (line 72) | def log_prob(self, x):

FILE: mmpose/models/utils/regularizations.py
  class PytorchModuleHook (line 7) | class PytorchModuleHook(metaclass=ABCMeta):
    method hook (line 21) | def hook(self, *args, **kwargs):
    method hook_type (line 25) | def hook_type(self) -> str:
    method register (line 32) | def register(self, module):
  class WeightNormClipHook (line 56) | class WeightNormClipHook(PytorchModuleHook):
    method __init__ (line 68) | def __init__(self, max_norm=1.0, module_param_names='weight'):
    method hook_type (line 74) | def hook_type(self):
    method hook (line 77) | def hook(self, module, _input):

FILE: mmpose/models/utils/reparam_layers.py
  class RepVGGBlock (line 15) | class RepVGGBlock(BaseModule):
    method __init__ (line 39) | def __init__(self,
    method forward (line 90) | def forward(self, x: Tensor) -> Tensor:
    method _pad_1x1_to_3x3_tensor (line 115) | def _pad_1x1_to_3x3_tensor(self, kernel1x1):
    method _fuse_bn_tensor (line 128) | def _fuse_bn_tensor(self, branch: nn.Module) -> Tensor:
    method get_equivalent_kernel_bias (line 169) | def get_equivalent_kernel_bias(self):
    method switch_to_deploy (line 183) | def switch_to_deploy(self, test_cfg: Optional[Dict] = None):

FILE: mmpose/models/utils/rtmcc_block.py
  function rope (line 14) | def rope(x, dim):
  class Scale (line 60) | class Scale(nn.Module):
    method __init__ (line 71) | def __init__(self, dim, init_value=1., trainable=True):
    method forward (line 76) | def forward(self, x):
  class RTMCCBlock (line 82) | class RTMCCBlock(nn.Module):
    method __init__ (line 122) | def __init__(self,
    method rel_pos_bias (line 194) | def rel_pos_bias(self, seq_len, k_len=None):
    method _forward (line 208) | def _forward(self, inputs):
    method forward (line 266) | def forward(self, x):

FILE: mmpose/models/utils/transformer.py
  function nlc_to_nchw (line 24) | def nlc_to_nchw(x, hw_shape):
  function nchw_to_nlc (line 41) | def nchw_to_nlc(x):
  class AdaptivePadding (line 54) | class AdaptivePadding(nn.Module):
    method __init__ (line 85) | def __init__(self, kernel_size=1, stride=1, dilation=1, padding='corne...
    method get_pad_shape (line 101) | def get_pad_shape(self, input_shape):
    method forward (line 115) | def forward(self, x):
  class PatchEmbed (line 130) | class PatchEmbed(BaseModule):
    method __init__ (line 158) | def __init__(
    method forward (line 232) | def forward(self, x):
  class PatchMerging (line 256) | class PatchMerging(BaseModule):
    method __init__ (line 287) | def __init__(self,
    method forward (line 336) | def forward(self, x, input_size):
  class ScaleNorm (line 384) | class ScaleNorm(nn.Module):
    method __init__ (line 396) | def __init__(self, dim, eps=1e-5):
    method forward (line 402) | def forward(self, x):
  class SinePositionalEncoding (line 423) | class SinePositionalEncoding(nn.Module):
    method __init__ (line 443) | def __init__(
    method forward (line 479) | def forward(self, *args, **kwargs):
    method generate_pos_encoding (line 482) | def generate_pos_encoding(self,
    method apply_additional_pos_enc (line 540) | def apply_additional_pos_enc(feature: Tensor,
    method apply_rotary_pos_enc (line 560) | def apply_rotary_pos_enc(feature: Tensor,
  class ChannelWiseScale (line 592) | class ChannelWiseScale(nn.Module):
    method __init__ (line 603) | def __init__(self, dim, init_value=1., trainable=True):
    method forward (line 608) | def forward(self, x):
  class GAUEncoder (line 614) | class GAUEncoder(BaseModule):
    method __init__ (line 645) | def __init__(self,
    method _build_layers (line 696) | def _build_layers(self):
    method _forward (line 702) | def _forward(self, x, mask=None, pos_enc=None):
    method forward (line 752) | def forward(self, x, mask=None, pos_enc=None):
  class DetrTransformerEncoder (line 761) | class DetrTransformerEncoder(BaseModule):
    method __init__ (line 774) | def __init__(self,
    method _init_layers (line 787) | def _init_layers(self) -> None:
    method forward (line 805) | def forward(self, query: Tensor, query_pos: Tensor,
  class DetrTransformerEncoderLayer (line 826) | class DetrTransformerEncoderLayer(BaseModule):
    method __init__ (line 840) | def __init__(self,
    method _init_layers (line 866) | def _init_layers(self) -> None:
    method forward (line 877) | def forward(self, query: Tensor, query_pos: Tensor,

FILE: mmpose/models/utils/tta.py
  function flip_heatmaps (line 9) | def flip_heatmaps(heatmaps: Tensor,
  function flip_vectors (line 71) | def flip_vectors(x_labels: Tensor, y_labels: Tensor, flip_indices: List[...
  function flip_coordinates (line 91) | def flip_coordinates(coords: Tensor, flip_indices: List[int],
  function flip_visibility (line 117) | def flip_visibility(vis: Tensor, flip_indices: List[int]):
  function aggregate_heatmaps (line 132) | def aggregate_heatmaps(heatmaps: List[Tensor],

FILE: mmpose/structures/bbox/bbox_overlaps.py
  function fp16_clamp (line 5) | def fp16_clamp(x, min_val=None, max_val=None):
  function bbox_overlaps (line 11) | def bbox_overlaps(bboxes1,

FILE: mmpose/structures/bbox/transforms.py
  function bbox_xyxy2xywh (line 9) | def bbox_xyxy2xywh(bbox_xyxy: np.ndarray) -> np.ndarray:
  function bbox_xywh2xyxy (line 27) | def bbox_xywh2xyxy(bbox_xywh: np.ndarray) -> np.ndarray:
  function bbox_xyxy2cs (line 44) | def bbox_xyxy2cs(bbox: np.ndarray,
  function bbox_xywh2cs (line 76) | def bbox_xywh2cs(bbox: np.ndarray,
  function bbox_cs2xyxy (line 110) | def bbox_cs2xyxy(center: np.ndarray,
  function bbox_cs2xywh (line 142) | def bbox_cs2xywh(center: np.ndarray,
  function bbox_xyxy2corner (line 174) | def bbox_xyxy2corner(bbox: np.ndarray):
  function bbox_corner2xyxy (line 207) | def bbox_corner2xyxy(bbox: np.ndarray):
  function bbox_clip_border (line 242) | def bbox_clip_border(bbox: np.ndarray, shape: Tuple[int, int]) -> np.nda...
  function flip_bbox (line 271) | def flip_bbox(bbox: np.ndarray,
  function get_udp_warp_matrix (line 325) | def get_udp_warp_matrix(
  function get_warp_matrix (line 372) | def get_warp_matrix(
  function get_pers_warp_matrix (line 438) | def get_pers_warp_matrix(center: np.ndarray, translate: np.ndarray,
  function _rotate_point (line 493) | def _rotate_point(pt: np.ndarray, angle_rad: float) -> np.ndarray:
  function _get_3rd_point (line 509) | def _get_3rd_point(a: np.ndarray, b: np.ndarray):

FILE: mmpose/structures/keypoint/transforms.py
  function flip_keypoints (line 7) | def flip_keypoints(keypoints: np.ndarray,
  function flip_keypoints_custom_center (line 69) | def flip_keypoints_custom_center(keypoints: np.ndarray,
  function keypoint_clip_border (line 128) | def keypoint_clip_border(keypoints: np.ndarray, keypoints_visible: np.nd...

FILE: mmpose/structures/multilevel_pixel_data.py
  class MultilevelPixelData (line 15) | class MultilevelPixelData(BaseDataElement):
    method __init__ (line 53) | def __init__(self, *, metainfo: Optional[dict] = None, **kwargs) -> None:
    method nlevel (line 58) | def nlevel(self):
    method __getitem__ (line 67) | def __getitem__(self, item: Union[int, str, list,
    method levels (line 85) | def levels(self) -> List[PixelData]:
    method shape (line 91) | def shape(self) -> Optional[Tuple[Tuple]]:
    method set_data (line 103) | def set_data(self, data: dict) -> None:
    method set_field (line 116) | def set_field(self,
    method __delattr__ (line 176) | def __delattr__(self, item: str):
    method __getattr__ (line 193) | def __getattr__(self, name):
    method pop (line 202) | def pop(self, *args) -> Any:
    method _convert (line 222) | def _convert(self, apply_to: Type,
    method cpu (line 242) | def cpu(self) -> 'MultilevelPixelData':
    method cuda (line 246) | def cuda(self) -> 'MultilevelPixelData':
    method detach (line 250) | def detach(self) -> 'MultilevelPixelData':
    method numpy (line 254) | def numpy(self) -> 'MultilevelPixelData':
    method to_tensor (line 259) | def to_tensor(self) -> 'MultilevelPixelData':
    method to (line 265) | def to(self, *args, **kwargs) -> 'MultilevelPixelData':

FILE: mmpose/structures/pose_data_sample.py
  class PoseDataSample (line 9) | class PoseDataSample(BaseDataElement):
    method gt_instances (line 47) | def gt_instances(self) -> InstanceData:
    method gt_instances (line 51) | def gt_instances(self, value: InstanceData):
    method gt_instances (line 55) | def gt_instances(self):
    method gt_instance_labels (line 59) | def gt_instance_labels(self) -> InstanceData:
    method gt_instance_labels (line 63) | def gt_instance_labels(self, value: InstanceData):
    method gt_instance_labels (line 67) | def gt_instance_labels(self):
    method pred_instances (line 71) | def pred_instances(self) -> InstanceData:
    method pred_instances (line 75) | def pred_instances(self, value: InstanceData):
    method pred_instances (line 79) | def pred_instances(self):
    method gt_fields (line 83) | def gt_fields(self) -> Union[PixelData, MultilevelPixelData]:
    method gt_fields (line 87) | def gt_fields(self, value: Union[PixelData, MultilevelPixelData]):
    method gt_fields (line 91) | def gt_fields(self):
    method pred_fields (line 95) | def pred_fields(self) -> PixelData:
    method pred_fields (line 99) | def pred_fields(self, value: PixelData):
    method pred_fields (line 103) | def pred_fields(self):

FILE: mmpose/structures/utils.py
  function merge_data_samples (line 15) | def merge_data_samples(data_samples: List[PoseDataSample]) -> PoseDataSa...
  function revert_heatmap (line 80) | def revert_heatmap(heatmap, input_center, input_scale, img_shape):
  function split_instances (line 116) | def split_instances(instances: InstanceData) -> List[InstanceData]:

FILE: mmpose/testing/_utils.py
  function get_coco_sample (line 16) | def get_coco_sample(
  function get_packed_inputs (line 81) | def get_packed_inputs(batch_size=2,
  function _rand_keypoints (line 193) | def _rand_keypoints(rng, bboxes, num_keypoints):
  function _rand_simcc_label (line 202) | def _rand_simcc_label(rng, num_instances, num_keypoints, len_feats):
  function _rand_bboxes (line 207) | def _rand_bboxes(rng, num_instances, img_w, img_h):
  function get_repo_dir (line 220) | def get_repo_dir():
  function get_config_file (line 233) | def get_config_file(fn: str):
  function get_pose_estimator_cfg (line 247) | def get_pose_estimator_cfg(fn: str):

FILE: mmpose/utils/camera.py
  class SingleCameraBase (line 11) | class SingleCameraBase(metaclass=ABCMeta):
    method __init__ (line 29) | def __init__(self, param):
    method world_to_camera (line 32) | def world_to_camera(self, X):
    method camera_to_world (line 36) | def camera_to_world(self, X):
    method camera_to_pixel (line 40) | def camera_to_pixel(self, X):
    method world_to_pixel (line 44) | def world_to_pixel(self, X):
  class SimpleCamera (line 51) | class SimpleCamera(SingleCameraBase):
    method __init__ (line 84) | def __init__(self, param):
    method world_to_camera (line 128) | def world_to_camera(self, X):
    method camera_to_world (line 133) | def camera_to_world(self, X):
    method camera_to_pixel (line 138) | def camera_to_pixel(self, X):
    method pixel_to_camera (line 160) | def pixel_to_camera(self, X):
  class SimpleCameraTorch (line 170) | class SimpleCameraTorch(SingleCameraBase):
    method __init__ (line 203) | def __init__(self, param, device):
    method world_to_camera (line 250) | def world_to_camera(self, X):
    method camera_to_world (line 255) | def camera_to_world(self, X):
    method camera_to_pixel (line 260) | def camera_to_pixel(self, X):

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

FILE: mmpose/utils/config_utils.py
  function adapt_mmdet_pipeline (line 5) | def adapt_mmdet_pipeline(cfg: ConfigDict) -> ConfigDict:

FILE: mmpose/utils/dist_utils.py
  function reduce_mean (line 5) | def reduce_mean(tensor):

FILE: mmpose/utils/hooks.py
  class OutputHook (line 5) | class OutputHook:
    method __init__ (line 7) | def __init__(self, module, outputs=None, as_tensor=False):
    method register (line 13) | def register(self, module):
    method remove (line 42) | def remove(self):
    method __enter__ (line 46) | def __enter__(self):
    method __exit__ (line 49) | def __exit__(self, exc_type, exc_val, exc_tb):
  function rsetattr (line 55) | def rsetattr(obj, attr, val):
  function rgetattr (line 72) | def rgetattr(obj, attr, *args):

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

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

FILE: mmpose/utils/tensor_utils.py
  function to_numpy (line 11) | def to_numpy(x: Union[Tensor, Sequence[Tensor]],
  function to_tensor (line 56) | def to_tensor(x: Union[np.ndarray, Sequence[np.ndarray]],

FILE: mmpose/utils/timer.py
  class RunningAverage (line 10) | class RunningAverage():
    method __init__ (line 17) | def __init__(self, window: int = 1):
    method update (line 21) | def update(self, value):
    method average (line 26) | def average(self):
  class StopWatch (line 31) | class StopWatch:
    method __init__ (line 54) | def __init__(self, window=1):
    method timeit (line 60) | def timeit(self, timer_name='_FPS_'):
    method report (line 80) | def report(self, key=None):
    method report_strings (line 99) | def report_strings(self):
    method reset (line 115) | def reset(self):

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

FILE: mmpose/visualization/fast_visualizer.py
  class Instances (line 8) | class Instances:
  class FastVisualizer (line 13) | class FastVisualizer:
    method __init__ (line 29) | def __init__(self,
    method draw_pose (line 45) | def draw_pose(self, img: np.ndarray, instances: Instances):
    method draw_points (line 93) | def draw_points(self, img: np.ndarray, instances: Union[Instances, Dict,

FILE: mmpose/visualization/local_visualizer.py
  function _get_adaptive_scales (line 20) | def _get_adaptive_scales(areas: np.ndarray,
  class PoseLocalVisualizer (line 46) | class PoseLocalVisualizer(OpencvBackendVisualizer):
    method __init__ (line 105) | def __init__(self,
    method set_dataset_meta (line 148) | def set_dataset_meta(self,
    method _draw_instances_bbox (line 184) | def _draw_instances_bbox(self, image: np.ndarray,
    method _draw_instances_kpts (line 242) | def _draw_instances_kpts(self,
    method _draw_instances_kpts_openpose (line 366) | def _draw_instances_kpts_openpose(self,
    method _draw_instance_heatmap (line 516) | def _draw_instance_heatmap(
    method _draw_instance_xy_heatmap (line 542) | def _draw_instance_xy_heatmap(
    method add_datasample (line 571) | def add_datasample(self,

FILE: mmpose/visualization/local_visualizer_3d.py
  class Pose3dLocalVisualizer (line 19) | class Pose3dLocalVisualizer(PoseLocalVisualizer):
    method __init__ (line 50) | def __init__(
    method _draw_3d_data_samples (line 78) | def _draw_3d_data_samples(self,
    method _draw_instances_kpts (line 309) | def _draw_instances_kpts(self,
    method add_datasample (line 490) | def add_datasample(self,

FILE: mmpose/visualization/opencv_backend_visualizer.py
  class OpencvBackendVisualizer (line 12) | class OpencvBackendVisualizer(Visualizer):
    method __init__ (line 32) | def __init__(self,
    method set_image (line 44) | def set_image(self, image: np.ndarray) -> None:
    method get_image (line 73) | def get_image(self) -> np.ndarray:
    method draw_circles (line 86) | def draw_circles(self,
    method draw_texts (line 148) | def draw_texts(
    method draw_bboxes (line 269) | def draw_bboxes(self,
    method draw_lines (line 323) | def draw_lines(self,
    method draw_polygons (line 376) | def draw_polygons(self,
    method show (line 432) | def show(self,

FILE: mmpose/visualization/simcc_vis.py
  class SimCCVisualizer (line 10) | class SimCCVisualizer:
    method draw_instance_xy_heatmap (line 12) | def draw_instance_xy_heatmap(self,
    method split_simcc_xy (line 49) | def split_simcc_xy(self, heatmap: Union[np.ndarray, torch.Tensor]):
    method merge_maps (line 62) | def merge_maps(self, map_2d):
    method draw_1d_heatmaps (line 68) | def draw_1d_heatmaps(self, heatmap_1d):
    method creat_blank (line 81) | def creat_blank(self,
    method draw_2d_heatmaps (line 94) | def draw_2d_heatmaps(self, heatmap_2d):
    method image_cover (line 101) | def image_cover(self, background: np.ndarray, foreground: np.ndarray,
    method add_1d_heatmaps (line 108) | def add_1d_heatmaps(self,

FILE: projects/example_project/models/example_head.py
  class ExampleHead (line 7) | class ExampleHead(HeatmapHead):
    method __init__ (line 13) | def __init__(self, **kwargs) -> None:
    method forward (line 17) | def forward(self, feats):
    method predict (line 29) | def predict(self, feats, batch_data_samples, test_cfg={}):
    method loss (line 62) | def loss(self, feats, batch_data_samples, train_cfg={}) -> dict:

FILE: projects/example_project/models/example_loss.py
  class ExampleLoss (line 7) | class ExampleLoss(KeypointMSELoss):
    method __init__ (line 13) | def __init__(self, **kwargs) -> None:
    method forward (line 17) | def forward(self, output, target, target_weights=None, mask=None):

FILE: projects/just_dance/app.py
  function process_video (line 26) | def process_video(

FILE: projects/just_dance/calculate_similarity.py
  function _calculate_similarity (line 10) | def _calculate_similarity(tch_kpts: np.ndarray, stu_kpts: np.ndarray):
  function calculate_similarity (line 57) | def calculate_similarity(tch_kpts: np.ndarray, stu_kpts: np.ndarray):
  function select_piece_from_similarity (line 75) | def select_piece_from_similarity(similarity):

FILE: projects/just_dance/process_video.py
  class VideoProcessor (line 45) | class VideoProcessor:
    method __init__ (line 48) | def __init__(self):
    method _set_category (line 51) | def _set_category(self, category):
    method pose_estimator (line 56) | def pose_estimator(self) -> Pose2DInferencer:
    method visualizer (line 67) | def visualizer(self) -> PoseLocalVisualizer:
    method get_keypoints_from_frame (line 83) | def get_keypoints_from_frame(self, image: np.ndarray) -> np.ndarray:
    method get_keypoints_from_video (line 121) | def get_keypoints_from_video(self, video: str) -> np.ndarray:
    method run (line 150) | def run(self,
    method generate_output_video (line 173) | def generate_output_video(self, tch_video: str, stu_video: str,

FILE: projects/just_dance/utils.py
  function resize_image_to_fixed_height (line 9) | def resize_image_to_fixed_height(image: np.ndarray,
  function blend_images (line 30) | def blend_images(img1: np.ndarray,
  function convert_video_fps (line 60) | def convert_video_fps(video):
  function get_smoothed_kpt (line 75) | def get_smoothed_kpt(kpts, index, sigma=5):

FILE: projects/mmpose4aigc/openpose_visualization.py
  function mmpose_to_openpose_visualization (line 42) | def mmpose_to_openpose_visualization(args, img_path, detector, pose_esti...
  function main (line 117) | def main():

FILE: projects/pose_anything/datasets/builder.py
  function _concat_cfg (line 8) | def _concat_cfg(cfg):
  function _check_vaild (line 27) | def _check_vaild(cfg):
  function build_dataset (line 35) | def build_dataset(cfg, default_args=None):

FILE: projects/pose_anything/datasets/datasets/mp100/fewshot_base_dataset.py
  class FewShotBaseDataset (line 15) | class FewShotBaseDataset(Dataset, metaclass=ABCMeta):
    method __init__ (line 17) | def __init__(self,
    method _get_db (line 49) | def _get_db(self):
    method _select_kpt (line 54) | def _select_kpt(self, obj, kpt_id):
    method evaluate (line 59) | def evaluate(self, cfg, preds, output_dir, *args, **kwargs):
    method _write_keypoint_results (line 64) | def _write_keypoint_results(keypoints, res_file):
    method _report_metric (line 70) | def _report_metric(self,
    method _merge_obj (line 137) | def _merge_obj(self, Xs_list, Xq, idx):
    method __len__ (line 168) | def __len__(self):
    method __getitem__ (line 172) | def __getitem__(self, idx):
    method _sort_and_unique_bboxes (line 227) | def _sort_and_unique_bboxes(self, kpts, key='bbox_id'):

FILE: projects/pose_anything/datasets/datasets/mp100/fewshot_dataset.py
  class FewShotKeypointDataset (line 13) | class FewShotKeypointDataset(FewShotBaseDataset):
    method __init__ (line 15) | def __init__(self,
    method random_paired_samples (line 73) | def random_paired_samples(self):
    method make_paired_samples (line 91) | def make_paired_samples(self):
    method _select_kpt (line 107) | def _select_kpt(self, obj, kpt_id):
    method _get_mapping_id_name (line 115) | def _get_mapping_id_name(imgs):
    method _get_db (line 135) | def _get_db(self):
    method _load_coco_keypoint_annotation_kernel (line 148) | def _load_coco_keypoint_annotation_kernel(self, img_id):
    method _xywh2cs (line 238) | def _xywh2cs(self, x, y, w, h):
    method evaluate (line 269) | def evaluate(self, outputs, res_folder, metric='PCK', **kwargs):

FILE: projects/pose_anything/datasets/datasets/mp100/test_base_dataset.py
  class TestBaseDataset (line 17) | class TestBaseDataset(Dataset, metaclass=ABCMeta):
    method __init__ (line 19) | def __init__(self,
    method _get_db (line 53) | def _get_db(self):
    method _select_kpt (line 58) | def _select_kpt(self, obj, kpt_id):
    method evaluate (line 63) | def evaluate(self, cfg, preds, output_dir, *args, **kwargs):
    method _write_keypoint_results (line 68) | def _write_keypoint_results(keypoints, res_file):
    method _report_metric (line 74) | def _report_metric(self, res_file, metrics):
    method _merge_obj (line 175) | def _merge_obj(self, Xs_list, Xq, idx):
    method __len__ (line 206) | def __len__(self):
    method __getitem__ (line 210) | def __getitem__(self, idx):
    method _sort_and_unique_bboxes (line 240) | def _sort_and_unique_bboxes(self, kpts, key='bbox_id'):

FILE: projects/pose_anything/datasets/datasets/mp100/test_dataset.py
  class TestPoseDataset (line 13) | class TestPoseDataset(TestBaseDataset):
    method __init__ (line 15) | def __init__(self,
    method random_paired_samples (line 81) | def random_paired_samples(self):
    method make_paired_samples (line 99) | def make_paired_samples(self):
    method _select_kpt (line 115) | def _select_kpt(self, obj, kpt_id):
    method _get_mapping_id_name (line 123) | def _get_mapping_id_name(imgs):
    method _get_db (line 143) | def _get_db(self):
    method _load_coco_keypoint_annotation_kernel (line 156) | def _load_coco_keypoint_annotation_kernel(self, img_id):
    method _xywh2cs (line 251) | def _xywh2cs(self, x, y, w, h):
    method evaluate (line 282) | def evaluate(self, outputs, res_folder, metric='PCK', **kwargs):

FILE: projects/pose_anything/datasets/datasets/mp100/transformer_base_dataset.py
  class TransformerBaseDataset (line 15) | class TransformerBaseDataset(Dataset, metaclass=ABCMeta):
    method __init__ (line 17) | def __init__(self,
    method _get_db (line 49) | def _get_db(self):
    method _select_kpt (line 54) | def _select_kpt(self, obj, kpt_id):
    method evaluate (line 59) | def evaluate(self, cfg, preds, output_dir, *args, **kwargs):
    method _write_keypoint_results (line 64) | def _write_keypoint_results(keypoints, res_file):
    method _report_metric (line 70) | def _report_metric(self,
    method _merge_obj (line 137) | def _merge_obj(self, Xs_list, Xq, idx):
    method __len__ (line 168) | def __len__(self):
    method __getitem__ (line 172) | def __getitem__(self, idx):
    method _sort_and_unique_bboxes (line 201) | def _sort_and_unique_bboxes(self, kpts, key='bbox_id'):

FILE: projects/pose_anything/datasets/datasets/mp100/transformer_dataset.py
  class TransformerPoseDataset (line 13) | class TransformerPoseDataset(TransformerBaseDataset):
    method __init__ (line 15) | def __init__(self,
    method random_paired_samples (line 75) | def random_paired_samples(self):
    method make_paired_samples (line 93) | def make_paired_samples(self):
    method _select_kpt (line 109) | def _select_kpt(self, obj, kpt_id):
    method _get_mapping_id_name (line 117) | def _get_mapping_id_name(imgs):
    method _get_db (line 137) | def _get_db(self):
    method _load_coco_keypoint_annotation_kernel (line 151) | def _load_coco_keypoint_annotation_kernel(self, img_id):
    method _xywh2cs (line 246) | def _xywh2cs(self, x, y, w, h):
    method evaluate (line 277) | def evaluate(self, outputs, res_folder, metric='PCK', **kwargs):

FILE: projects/pose_anything/datasets/pipelines/top_down_transform.py
  class TopDownGenerateTargetFewShot (line 4) | class TopDownGenerateTargetFewShot:
    method __init__ (line 32) | def __init__(self,
    method _msra_generate_target (line 46) | def _msra_generate_target(self, cfg, joints_3d, joints_3d_visible, sig...
    method _udp_generate_target (line 134) | def _udp_generate_target(self, cfg, joints_3d, joints_3d_visible, factor,
    method __call__ (line 255) | def __call__(self, results):

FILE: projects/pose_anything/demo.py
  class ResizePad (line 20) | class ResizePad:
    method __init__ (line 22) | def __init__(self, w=256, h=256):
    method __call__ (line 26) | def __call__(self, image):
  function parse_args (line 47) | def parse_args():
  function merge_configs (line 75) | def merge_configs(cfg1, cfg2):
  function main (line 86) | def main():

FILE: projects/pose_anything/models/backbones/simmim.py
  function norm_targets (line 17) | def norm_targets(targets, patch_size):
  class SwinTransformerForSimMIM (line 54) | class SwinTransformerForSimMIM(SwinTransformer):
    method __init__ (line 56) | def __init__(self, **kwargs):
    method forward (line 64) | def forward(self, x, mask):
    method no_weight_decay (line 89) | def no_weight_decay(self):
  class SwinTransformerV2ForSimMIM (line 93) | class SwinTransformerV2ForSimMIM(SwinTransformerV2):
    method __init__ (line 95) | def __init__(self, **kwargs):
    method forward (line 103) | def forward(self, x, mask):
    method no_weight_decay (line 128) | def no_weight_decay(self):
  class SimMIM (line 132) | class SimMIM(nn.Module):
    method __init__ (line 134) | def __init__(self, config, encoder, encoder_stride, in_chans, patch_si...
    method forward (line 151) | def forward(self, x, mask):
    method no_weight_decay (line 167) | def no_weight_decay(self):
    method no_weight_decay_keywords (line 173) | def no_weight_decay_keywords(self):
  function build_simmim (line 182) | def build_simmim(config):

FILE: projects/pose_anything/models/backbones/swin_mlp.py
  class Mlp (line 15) | class Mlp(nn.Module):
    method __init__ (line 17) | def __init__(self,
    method forward (line 31) | def forward(self, x):
  function window_partition (line 40) | def window_partition(x, window_size):
  function window_reverse (line 57) | def window_reverse(windows, window_size, H, W):
  class SwinMLPBlock (line 75) | class SwinMLPBlock(nn.Module):
    method __init__ (line 88) | def __init__(self,
    method forward (line 137) | def forward(self, x):
    method extra_repr (line 197) | def extra_repr(self) -> str:
    method flops (line 204) | def flops(self):
  class PatchMerging (line 224) | class PatchMerging(nn.Module):
    method __init__ (line 234) | def __init__(self, input_resolution, dim, norm_layer=nn.LayerNorm):
    method forward (line 241) | def forward(self, x):
    method extra_repr (line 264) | def extra_repr(self) -> str:
    method flops (line 267) | def flops(self):
  class BasicLayer (line 274) | class BasicLayer(nn.Module):
    method __init__ (line 295) | def __init__(self,
    method forward (line 336) | def forward(self, x):
    method extra_repr (line 346) | def extra_repr(self) -> str:
    method flops (line 350) | def flops(self):
  class PatchEmbed (line 359) | class PatchEmbed(nn.Module):
    method __init__ (line 371) | def __init__(self,
    method forward (line 398) | def forward(self, x):
    method flops (line 409) | def flops(self):
  class SwinMLP (line 418) | class SwinMLP(nn.Module):
    method __init__ (line 443) | def __init__(self,
    method _init_weights (line 521) | def _init_weights(self, m):
    method no_weight_decay (line 531) | def no_weight_decay(self):
    method no_weight_decay_keywords (line 535) | def no_weight_decay_keywords(self):
    method forward_features (line 538) | def forward_features(self, x):
    method forward (line 552) | def forward(self, x):
    method flops (line 557) | def flops(self):

FILE: projects/pose_anything/models/backbones/swin_transformer.py
  class Mlp (line 30) | class Mlp(nn.Module):
    method __init__ (line 32) | def __init__(self,
    method forward (line 46) | def forward(self, x):
  function window_partition (line 55) | def window_partition(x, window_size):
  function window_reverse (line 72) | def window_reverse(windows, window_size, H, W):
  class WindowAttention (line 90) | class WindowAttention(nn.Module):
    method __init__ (line 103) | def __init__(self,
    method forward (line 149) | def forward(self, x, mask=None):
    method extra_repr (line 188) | def extra_repr(self) -> str:
    method flops (line 192) | def flops(self, N):
  class SwinTransformerBlock (line 206) | class SwinTransformerBlock(nn.Module):
    method __init__ (line 225) | def __init__(self,
    method forward (line 305) | def forward(self, x):
    method extra_repr (line 372) | def extra_repr(self) -> str:
    method flops (line 380) | def flops(self):
  class PatchMerging (line 395) | class PatchMerging(nn.Module):
    method __init__ (line 403) | def __init__(self, input_resolution, dim, norm_layer=nn.LayerNorm):
    method forward (line 410) | def forward(self, x):
    method extra_repr (line 433) | def extra_repr(self) -> str:
    method flops (line 436) | def flops(self):
  class BasicLayer (line 443) | class BasicLayer(nn.Module):
    method __init__ (line 464) | def __init__(self,
    method forward (line 514) | def forward(self, x):
    method extra_repr (line 524) | def extra_repr(self) -> str:
    method flops (line 528) | def flops(self):
  class PatchEmbed (line 537) | class PatchEmbed(nn.Module):
    method __init__ (line 547) | def __init__(self,
    method forward (line 574) | def forward(self, x):
    method flops (line 585) | def flops(self):
  class SwinTransformer (line 594) | class SwinTransformer(nn.Module):
    method __init__ (line 621) | def __init__(self,
    method _init_weights (line 707) | def _init_weights(self, m):
    method no_weight_decay (line 717) | def no_weight_decay(self):
    method no_weight_decay_keywords (line 721) | def no_weight_decay_keywords(self):
    method forward_features (line 724) | def forward_features(self, x):
    method forward (line 738) | def forward(self, x):
    method flops (line 743) | def flops(self):

FILE: projects/pose_anything/models/backbones/swin_transformer_moe.py
  class Mlp (line 25) | class Mlp(nn.Module):
    method __init__ (line 27) | def __init__(self,
    method forward (line 42) | def forward(self, x):
  class MoEMlp (line 51) | class MoEMlp(nn.Module):
    method __init__ (line 53) | def __init__(self,
    method forward (line 115) | def forward(self, x):
    method extra_repr (line 119) | def extra_repr(self) -> str:
    method _init_weights (line 129) | def _init_weights(self):
  function window_partition (line 139) | def window_partition(x, window_size):
  function window_reverse (line 156) | def window_reverse(windows, window_size, H, W):
  class WindowAttention (line 174) | class WindowAttention(nn.Module):
    method __init__ (line 194) | def __init__(self,
    method forward (line 267) | def forward(self, x, mask=None):
    method extra_repr (line 310) | def extra_repr(self) -> str:
    method flops (line 315) | def flops(self, N):
  class SwinTransformerBlock (line 329) | class SwinTransformerBlock(nn.Module):
    method __init__ (line 371) | def __init__(self,
    method forward (line 488) | def forward(self, x):
    method extra_repr (line 542) | def extra_repr(self) -> str:
    method flops (line 550) | def flops(self):
  class PatchMerging (line 569) | class PatchMerging(nn.Module):
    method __init__ (line 579) | def __init__(self, input_resolution, dim, norm_layer=nn.LayerNorm):
    method forward (line 586) | def forward(self, x):
    method extra_repr (line 609) | def extra_repr(self) -> str:
    method flops (line 612) | def flops(self):
  class BasicLayer (line 619) | class BasicLayer(nn.Module):
    method __init__ (line 665) | def __init__(self,
    method forward (line 742) | def forward(self, x):
    method extra_repr (line 760) | def extra_repr(self) -> str:
    method flops (line 764) | def flops(self):
  class PatchEmbed (line 773) | class PatchEmbed(nn.Module):
    method __init__ (line 785) | def __init__(self,
    method forward (line 812) | def forward(self, x):
    method flops (line 823) | def flops(self):
  class SwinTransformerMoE (line 832) | class SwinTransformerMoE(nn.Module):
    method __init__ (line 888) | def __init__(self,
    method _init_weights (line 1013) | def _init_weights(self, m):
    method no_weight_decay (line 1025) | def no_weight_decay(self):
    method no_weight_decay_keywords (line 1029) | def no_weight_decay_keywords(self):
    method forward_features (line 1035) | def forward_features(self, x):
    method forward (line 1050) | def forward(self, x):
    method add_param_to_skip_allreduce (line 1055) | def add_param_to_skip_allreduce(self, param_name):
    method flops (line 1058) | def flops(self):

FILE: projects/pose_anything/models/backbones/swin_transformer_v2.py
  class Mlp (line 18) | class Mlp(nn.Module):
    method __init__ (line 20) | def __init__(self,
    method forward (line 34) | def forward(self, x):
  function window_partition (line 43) | def window_partition(x, window_size):
  function window_reverse (line 60) | def window_reverse(windows, window_size, H, W):
  class WindowAttention (line 78) | class WindowAttention(nn.Module):
    method __init__ (line 91) | def __init__(self,
    method forward (line 171) | def forward(self, x, mask=None):
    method extra_repr (line 224) | def extra_repr(self) -> str:
    method flops (line 229) | def flops(self, N):
  class SwinTransformerBlock (line 243) | class SwinTransformerBlock(nn.Module):
    method __init__ (line 259) | def __init__(self,
    method forward (line 337) | def forward(self, x):
    method extra_repr (line 384) | def extra_repr(self) -> str:
    method flops (line 391) | def flops(self):
  class PatchMerging (line 406) | class PatchMerging(nn.Module):
    method __init__ (line 414) | def __init__(self, input_resolution, dim, norm_layer=nn.LayerNorm):
    method forward (line 421) | def forward(self, x):
    method extra_repr (line 444) | def extra_repr(self) -> str:
    method flops (line 447) | def flops(self):
  class BasicLayer (line 454) | class BasicLayer(nn.Module):
    method __init__ (line 472) | def __init__(self,
    method forward (line 520) | def forward(self, x):
    method extra_repr (line 530) | def extra_repr(self) -> str:
    method flops (line 534) | def flops(self):
    method _init_respostnorm (line 542) | def _init_respostnorm(self):
  class PatchEmbed (line 550) | class PatchEmbed(nn.Module):
    method __init__ (line 560) | def __init__(self,
    method forward (line 587) | def forward(self, x):
    method flops (line 598) | def flops(self):
  class SwinTransformerV2 (line 608) | class SwinTransformerV2(nn.Module):
    method __init__ (line 633) | def __init__(self,
    method _init_weights (line 762) | def _init_weights(self, m):
    method no_weight_decay (line 772) | def no_weight_decay(self):
    method no_weight_decay_keywords (line 776) | def no_weight_decay_keywords(self):
    method forward_features (line 779) | def forward_features(self, x):
    method forward (line 813) | def forward(self, x):
    method flops (line 818) | def flops(self):

FILE: projects/pose_anything/models/backbones/swin_utils.py
  function load_pretrained (line 14) | def load_pretrained(config, model, logger):
  function remap_pretrained_keys_swin (line 34) | def remap_pretrained_keys_swin(model, checkpoint_model, logger):

FILE: projects/pose_anything/models/detectors/pam.py
  class PoseAnythingModel (line 17) | class PoseAnythingModel(BaseModel, metaclass=ABCMeta):
    method __init__ (line 28) | def __init__(self,
    method init_backbone (line 44) | def init_backbone(self, pretrained, encoder_config):
    method with_keypoint (line 69) | def with_keypoint(self):
    method init_weights (line 73) | def init_weights(self, pretrained=None):
    method forward (line 79) | def forward(self,
    method forward_dummy (line 100) | def forward_dummy(self, img_s, target_s, target_weight_s, img_q, targe...
    method forward_train (line 104) | def forward_train(self, img_s, target_s, target_weight_s, img_q, targe...
    method forward_test (line 136) | def forward_test(self,
    method predict (line 168) | def predict(self, img_s, target_s, target_weight_s, img_q, img_metas=N...
    method extract_features (line 187) | def extract_features(self, img_s, img_q):
    method parse_keypoints_from_img_meta (line 218) | def parse_keypoints_from_img_meta(self, img_meta, device, keyword='que...
    method show_result (line 249) | def show_result(self,

FILE: projects/pose_anything/models/keypoint_heads/head.py
  function transform_preds (line 17) | def transform_preds(coords, center, scale, output_size, use_udp=False):
  function inverse_sigmoid (line 64) | def inverse_sigmoid(x, eps=1e-3):
  class TokenDecodeMLP (line 71) | class TokenDecodeMLP(nn.Module):
    method __init__ (line 75) | def __init__(self,
    method forward (line 92) | def forward(self, x):
  class PoseHead (line 97) | class PoseHead(nn.Module):
    method __init__ (line 105) | def __init__(self,
    method init_weights (line 168) | def init_weights(self):
    method forward (line 185) | def forward(self, x, feature_s, target_s, mask_s, skeleton):
    method get_loss (line 258) | def get_loss(self, output, initial_proposals, similarity_map, target,
    method get_max_coords (line 302) | def get_max_coords(self, heatmap, heatmap_size=64):
    method heatmap_loss (line 311) | def heatmap_loss(self, similarity_map, target_heatmap, target_weight,
    method get_accuracy (line 337) | def get_accuracy(self,
    method decode (line 373) | def decode(self, img_metas, output, img_size, **kwargs):

FILE: projects/pose_anything/models/utils/builder.py
  function build_positional_encoding (line 13) | def build_positional_encoding(cfg, default_args=None):
  function build_backbone (line 18) | def build_backbone(cfg, default_args=None):
  function build_transformer (line 23) | def build_transformer(cfg, default_args=None):
  function build_linear_layer (line 31) | def build_linear_layer(cfg, *args, **kwargs):

FILE: projects/pose_anything/models/utils/encoder_decoder.py
  function inverse_sigmoid (line 12) | def inverse_sigmoid(x, eps=1e-3):
  class MLP (line 19) | class MLP(nn.Module):
    method __init__ (line 22) | def __init__(self, input_dim, hidden_dim, output_dim, num_layers):
    method forward (line 29) | def forward(self, x):
  class ProposalGenerator (line 35) | class ProposalGenerator(nn.Module):
    method __init__ (line 37) | def __init__(self, hidden_dim, proj_dim, dynamic_proj_dim):
    method forward (line 46) | def forward(self, query_feat, support_feat, spatial_shape):
  class EncoderDecoder (line 126) | class EncoderDecoder(nn.Module):
    method __init__ (line 128) | def __init__(self,
    method init_weights (line 175) | def init_weights(self):
    method forward (line 181) | def forward(self,
  class GraphTransformerDecoder (line 233) | class GraphTransformerDecoder(nn.Module):
    method __init__ (line 235) | def __init__(self,
    method forward (line 252) | def forward(self,
    method update (line 340) | def update(self, query_coordinates, delta_unsig):
  class GraphTransformerDecoderLayer (line 347) | class GraphTransformerDecoderLayer(nn.Module):
    method __init__ (line 349) | def __init__(self,
    method with_pos_embed (line 389) | def with_pos_embed(self, tensor, pos: Optional[Tensor]):
    method forward (line 392) | def forward(self,
  class TransformerEncoder (line 464) | class TransformerEncoder(nn.Module):
    method __init__ (line 466) | def __init__(self, encoder_layer, num_layers, norm=None):
    method forward (line 472) | def forward(self,
  class TransformerEncoderLayer (line 512) | class TransformerEncoderLayer(nn.Module):
    method __init__ (line 514) | def __init__(self,
    method with_pos_embed (line 536) | def with_pos_embed(self, tensor, pos: Optional[Tensor]):
    method forward (line 539) | def forward(self,
  function adj_from_skeleton (line 563) | def adj_from_skeleton(num_pts, skeleton, mask, device='cuda'):
  class GCNLayer (line 580) | class GCNLayer(nn.Module):
    method __init__ (line 582) | def __init__(self,
    method forward (line 602) | def forward(self, x, adj):
  function _get_clones (line 621) | def _get_clones(module, N):
  function _get_activation_fn (line 625) | def _get_activation_fn(activation):
  function clones (line 636) | def clones(module, N):

FILE: projects/pose_anything/models/utils/positional_encoding.py
  class SinePositionalEncoding (line 12) | class SinePositionalEncoding(BaseModule):
    method __init__ (line 37) | def __init__(self,
    method forward (line 58) | def forward(self, mask):
    method forward_coordinates (line 99) | def forward_coordinates(self, coord):
    method __repr__ (line 127) | def __repr__(self):
  class LearnedPositionalEncoding (line 139) | class LearnedPositionalEncoding(BaseModule):
    method __init__ (line 153) | def __init__(self,
    method forward (line 165) | def forward(self, mask):
    method __repr__ (line 189) | def __repr__(self):

FILE: projects/pose_anything/models/utils/transformer.py
  class Transformer (line 12) | class Transformer(BaseModule):
    method __init__ (line 31) | def __init__(self, encoder=None, decoder=None, init_cfg=None):
    method init_weights (line 37) | def init_weights(self):
    method forward (line 44) | def forward(self, x, mask, query_embed, pos_embed, mask_query):
  class DetrTransformerDecoderLayer (line 109) | class DetrTransformerDecoderLayer(BaseTransformerLayer):
    method __init__ (line 131) | def __init__(self,
  class DetrTransformerEncoder (line 155) | class DetrTransformerEncoder(TransformerLayerSequence):
    method __init__ (line 163) | def __init__(self, *args, post_norm_cfg=dict(type='LN'), **kwargs):
    method forward (line 174) | def forward(self, *args, **kwargs):
  class DetrTransformerDecoder (line 187) | class DetrTransformerDecoder(TransformerLayerSequence):
    method __init__ (line 196) | def __init__(self,
    method forward (line 210) | def forward(self, query, *args, **kwargs):
  class DynamicConv (line 238) | class DynamicConv(BaseModule):
    method __init__ (line 264) | def __init__(self,
    method forward (line 298) | def forward(self, param_feature, input_feature):

FILE: projects/pose_anything/tools/visualization.py
  function plot_results (line 19) | def plot_results(support_img,
  function str_is_int (line 84) | def str_is_int(s):

FILE: projects/rtmpose/app.py
  function predict (line 38) | def predict(input,

FILE: projects/rtmpose/examples/RTMPose-Deploy/Windows/OnnxRumtime-CPU/src/RTMPoseOnnxRuntime/characterset_convert.h
  function namespace (line 17) | namespace stubbornhuang

FILE: projects/rtmpose/examples/RTMPose-Deploy/Windows/OnnxRumtime-CPU/src/RTMPoseOnnxRuntime/main.cpp
  function main (line 14) | int main()

FILE: projects/rtmpose/examples/RTMPose-Deploy/Windows/OnnxRumtime-CPU/src/RTMPoseOnnxRuntime/rtmdet_onnxruntime.cpp
  function DetectBox (line 35) | DetectBox RTMDetOnnxruntime::Inference(const cv::Mat& input_mat)

FILE: projects/rtmpose/examples/RTMPose-Deploy/Windows/OnnxRumtime-CPU/src/RTMPoseOnnxRuntime/rtmdet_onnxruntime.h
  function class (line 13) | class RTMDetOnnxruntime

FILE: projects/rtmpose/examples/RTMPose-Deploy/Windows/OnnxRumtime-CPU/src/RTMPoseOnnxRuntime/rtmpose_onnxruntime.h
  function class (line 13) | class RTMPoseOnnxruntime

FILE: projects/rtmpose/examples/RTMPose-Deploy/Windows/OnnxRumtime-CPU/src/RTMPoseOnnxRuntime/rtmpose_tracker_onnxruntime.h
  function class (line 10) | class RTMPoseTrackerOnnxruntime

FILE: projects/rtmpose/examples/RTMPose-Deploy/Windows/OnnxRumtime-CPU/src/RTMPoseOnnxRuntime/rtmpose_utils.h
  function std (line 6) | const std::vector<float> IMAGE_MEAN{ 123.675, 116.28, 103.53 };
  type PosePoint (line 54) | typedef PosePoint Vector2D;

FILE: projects/rtmpose/examples/RTMPose-Deploy/Windows/TensorRT/python/convert_rtmdet.py
  function build_model_from_cfg (line 9) | def build_model_from_cfg(config_path: str, checkpoint_path: str, device):
  class RTMDet (line 15) | class RTMDet(nn.Module):
    method __init__ (line 22) | def __init__(self, model: nn.Module) -> None:
    method forward (line 28) | def forward(self, inputs):
    method decode (line 40) | def decode(self, box: torch.Tensor, cls: torch.Tensor, stage: int):
  function parse_args (line 76) | def parse_args():

FILE: projects/rtmpose/examples/RTMPose-Deploy/Windows/TensorRT/src/RTMPoseTensorRT/inference.cpp
  function inference (line 11) | std::vector<std::vector<PosePoint>> inference(cv::Mat& image, RTMDet& de...

FILE: projects/rtmpose/examples/RTMPose-Deploy/Windows/TensorRT/src/RTMPoseTensorRT/main.cpp
  class Logger (line 18) | class Logger : public nvinfer1::ILogger
    method log (line 20) | void log(Severity severity, const char* msg) noexcept override
  function main (line 29) | int main()

FILE: projects/rtmpose/examples/RTMPose-Deploy/Windows/TensorRT/src/RTMPoseTensorRT/rtmdet.h
  function class (line 13) | class RTMDet

FILE: projects/rtmpose/examples/RTMPose-Deploy/Windows/TensorRT/src/RTMPoseTensorRT/rtmpose.h
  function class (line 15) | class RTMPose

FILE: projects/rtmpose/examples/RTMPose-Deploy/Windows/TensorRT/src/RTMPoseTensorRT/utils.cpp
  function MixImage (line 18) | bool MixImage(cv::Mat& srcImage, cv::Mat mixImage, cv::Point startPoint)
  function resize (line 47) | std::tuple<cv::Mat, int, int> resize(cv::Mat& img, int w, int h)
  function compare_boxes (line 82) | bool compare_boxes(const Box& b1, const Box& b2)
  function intersection_over_union (line 94) | float intersection_over_union(const Box& b1, const Box& b2)
  function non_maximum_suppression (line 122) | std::vector<Box> non_maximum_suppression(std::vector<Box> boxes, float i...
  function img_cut (line 157) | cv::Mat img_cut(cv::Mat& image, int x1, int y1, int x2, int y2)
  function isEqual (line 171) | bool isEqual(float a, float b)
  function draw_pose (line 182) | void draw_pose(cv::Mat& image, std::vector<std::vector<PosePoint>> points)

FILE: projects/rtmpose/examples/RTMPose-Deploy/Windows/TensorRT/src/RTMPoseTensorRT/utils.h
  type PosePoint (line 12) | struct PosePoint

FILE: projects/rtmpose/examples/onnxruntime/main.py
  function parse_args (line 14) | def parse_args():
  function preprocess (line 29) | def preprocess(
  function build_session (line 62) | def build_session(onnx_file: str, device: str = 'cpu') -> ort.InferenceS...
  function inference (line 79) | def inference(sess: ort.InferenceSession, img: np.ndarray) -> np.ndarray:
  function postprocess (line 104) | def postprocess(outputs: List[np.ndarray],
  function visualize (line 134) | def visualize(img: np.ndarray,
  function bbox_xyxy2cs (line 198) | def bbox_xyxy2cs(bbox: np.ndarray,
  function _fix_aspect_ratio (line 232) | def _fix_aspect_ratio(bbox_scale: np.ndarray,
  function _rotate_point (line 250) | def _rotate_point(pt: np.ndarray, angle_rad: float) -> np.ndarray:
  function _get_3rd_point (line 265) | def _get_3rd_point(a: np.ndarray, b: np.ndarray) -> np.ndarray:
  function get_warp_matrix (line 284) | def get_warp_matrix(center: np.ndarray,
  function top_down_affine (line 338) | def top_down_affine(input_size: dict, bbox_scale: dict, bbox_center: dict,
  function get_simcc_maximum (line 371) | def get_simcc_maximum(simcc_x: np.ndarray,
  function decode (line 416) | def decode(simcc_x: np.ndarray, simcc_y: np.ndarray,
  function main (line 436) | def main():

FILE: projects/rtmpose3d/demo/body3d_img2pose_demo.py
  function parse_args (line 32) | def parse_args():
  function process_one_image (line 127) | def process_one_image(args, detector, frame: np.ndarray, frame_idx: int,
  function main (line 261) | def main():

FILE: projects/rtmpose3d/rtmpose3d/loss.py
  class KLDiscretLossWithWeight (line 6) | class KLDiscretLossWithWeight(KLDiscretLoss):
    method __init__ (line 8) | def __init__(self, **kwargs):
    method forward (line 12) | def forward(self, pred_simcc, gt_simcc, target_weight):
    method loss_name (line 32) | def loss_name(self):

FILE: projects/rtmpose3d/rtmpose3d/pose_estimator.py
  class TopdownPoseEstimator3D (line 12) | class TopdownPoseEstimator3D(TopdownPoseEstimator):
    method __init__ (line 14) | def __init__(self, **kwargs):
    method add_pred_to_datasample (line 23) | def add_pred_to_datasample(self, batch_pred_instances: InstanceList,

FILE: projects/rtmpose3d/rtmpose3d/rtmw3d_head.py
  class RTMW3DHead (line 24) | class RTMW3DHead(BaseHead):
    method __init__ (line 55) | def __init__(
    method forward (line 169) | def forward(self, feats: Tuple[Tensor,
    method decode (line 209) | def decode(self, batch_outputs: Union[Tensor,
    method predict (line 256) | def predict(
    method loss (line 294) | def loss(
    method default_init_cfg (line 369) | def default_init_cfg(self):
  function simcc_mpjpe (line 378) | def simcc_mpjpe(output: Tuple[np.ndarray, np.ndarray, np.ndarray],
  function get_3d_coord (line 428) | def get_3d_coord(simcc_x, simcc_y, simcc_z, with_z_labels):

FILE: projects/rtmpose3d/rtmpose3d/simcc_3d_label.py
  class SimCC3DLabel (line 15) | class SimCC3DLabel(BaseKeypointCodec):
    method __init__ (line 74) | def __init__(self,
    method encode (line 102) | def encode(self,
    method decode (line 152) | def decode(self, x: np.ndarray, y: np.ndarray, z: np.ndarray):
    method _map_coordinates (line 195) | def _map_coordinates(
    method _generate_gaussian (line 209) | def _generate_gaussian(

FILE: projects/rtmpose3d/rtmpose3d/utils.py
  function get_simcc_maximum (line 6) | def get_simcc_maximum(simcc_x: np.ndarray,

FILE: projects/skps/custom_codecs/skps_heatmap.py
  class SKPSHeatmap (line 14) | class SKPSHeatmap(BaseKeypointCodec):
    method __init__ (line 42) | def __init__(self, input_size: Tuple[int, int],
    method encode (line 56) | def encode(self,
    method generate_offset_map (line 103) | def generate_offset_map(self, heatmap_size: Tuple[int, int],
    method decode (line 123) | def decode(self, encoded: np.ndarray,

FILE: projects/skps/models/skps_head.py
  class SKPSHead (line 24) | class SKPSHead(BaseHead):
    method __init__ (line 55) | def __init__(self,
    method default_init_cfg (line 122) | def default_init_cfg(self):
    method _make_conv_layers (line 129) | def _make_conv_layers(self, in_channels: int,
    method forward (line 152) | def forward(self, feats: Tuple[Tensor]) -> Tensor:
    method loss (line 170) | def loss(self,
    method predict (line 227) | def predict(self,
    method decode (line 307) | def decode(self,
    method _load_state_dict_pre_hook (line 351) | def _load_state_dict_pre_hook(self, state_dict, prefix, local_meta, *a...

FILE: projects/uniformer/models/uniformer.py
  class Mlp (line 19) | class Mlp(BaseModule):
    method __init__ (line 33) | def __init__(self,
    method forward (line 47) | def forward(self, x):
  class CMlp (line 54) | class CMlp(BaseModule):
    method __init__ (line 68) | def __init__(self,
    method forward (line 82) | def forward(self, x):
  class CBlock (line 89) | class CBlock(BaseModule):
    method __init__ (line 104) | def __init__(self,
    method forward (line 130) | def forward(self, x):
  class Attention (line 138) | class Attention(BaseModule):
    method __init__ (line 159) | def __init__(self,
    method forward (line 179) | def forward(self, x):
  class PatchEmbed (line 196) | class PatchEmbed(BaseModule):
    method __init__ (line 212) | def __init__(self,
    method forward (line 230) | def forward(self, x):
  class SABlock (line 240) | class SABlock(BaseModule):
    method __init__ (line 260) | def __init__(self,
    method forward (line 294) | def forward(self, x):
  class WindowSABlock (line 304) | class WindowSABlock(BaseModule):
    method __init__ (line 325) | def __init__(self,
    method window_reverse (line 361) | def window_reverse(self, windows, H, W):
    method window_partition (line 377) | def window_partition(self, x):
    method forward (line 393) | def forward(self, x):
  class UniFormer (line 430) | class UniFormer(BaseBackbone):
    method __init__ (line 468) | def __init__(
    method init_weights (line 634) | def init_weights(self):
    method _init_weights (line 652) | def _init_weights(self, m):
    method no_weight_decay (line 662) | def no_weight_decay(self):
    method get_classifier (line 665) | def get_classifier(self):
    method reset_classifier (line 668) | def reset_classifier(self, num_classes, global_pool=''):
    method forward (line 674) | def forward(self, x):

FILE: projects/yolox_pose/datasets/bbox_keypoint_structure.py
  class BBoxKeypoints (line 16) | class BBoxKeypoints(HorizontalBoxes):
    method __init__ (line 42) | def __init__(self,
    method flip_ (line 80) | def flip_(self,
    method translate_ (line 96) | def translate_(self, distances: Tuple[float, float]) -> None:
    method rescale_ (line 109) | def rescale_(self, scale_factor: Tuple[float, float]) -> None:
    method clip_ (line 129) | def clip_(self, img_shape: Tuple[int, int]) -> None:
    method project_ (line 147) | def project_(self, homography_matrix: Union[Tensor, np.ndarray]) -> None:
    method cat (line 193) | def cat(cls: Type[T], box_list: Sequence[T], dim: int = 0) -> T:
    method __getitem__ (line 225) | def __getitem__(self: T, index: IndexType) -> T:
    method num_keypoints (line 254) | def num_keypoints(self) -> Tensor:
    method __deepcopy__ (line 258) | def __deepcopy__(self, memo):
    method clone (line 269) | def clone(self: T) -> T:
    method to (line 278) | def to(self: T, *args, **kwargs) -> T:

FILE: projects/yolox_pose/datasets/coco_dataset.py
  class CocoDataset (line 11) | class CocoDataset(MMPoseCocoDataset):
    method prepare_data (line 14) | def prepare_data(self, idx) -> Any:

FILE: projects/yolox_pose/datasets/transforms.py
  class PoseToDetConverter (line 15) | class PoseToDetConverter(BaseTransform):
    method transform (line 19) | def transform(self, results: dict) -> dict:
  class PackDetPoseInputs (line 49) | class PackDetPoseInputs(PackDetInputs):
    method __init__ (line 58) | def __init__(self,
    method transform (line 65) | def transform(self, results: dict) -> dict:
  class FilterDetPoseAnnotations (line 81) | class FilterDetPoseAnnotations(FilterDetAnnotations):
    method transform (line 90) | def transform(self, results: dict) -> Union[dict, None]:

FILE: projects/yolox_pose/models/assigner.py
  class PoseSimOTAAssigner (line 17) | class PoseSimOTAAssigner(SimOTAAssigner):
    method __init__ (line 19) | def __init__(self,
    method assign (line 38) | def assign(self,
    method dynamic_k_matching (line 177) | def dynamic_k_matching(self, cost: Tensor, pairwise_ious: Tensor,

FILE: projects/yolox_pose/models/data_preprocessor.py
  class PoseBatchSyncRandomResize (line 12) | class PoseBatchSyncRandomResize(BatchSyncRandomResize):
    method forward (line 19) | def forward(self, inputs: Tensor, data_samples: List[PoseDataSample]

FILE: projects/yolox_pose/models/oks_loss.py
  class OksLoss (line 13) | class OksLoss(nn.Module):
    method __init__ (line 33) | def __init__(self,
    method forward (line 45) | def forward(self,
    method compute_oks (line 54) | def compute_oks(self,

FILE: projects/yolox_pose/models/utils.py
  class OutputSaveObjectWrapper (line 7) | class OutputSaveObjectWrapper:
    method __init__ (line 10) | def __init__(self, obj: Any) -> None:
    method __getattr__ (line 14) | def __getattr__(self, attr: str) -> Any:
    method clear (line 37) | def clear(self):
    method __deepcopy__ (line 41) | def __deepcopy__(self, memo):
  class OutputSaveFunctionWrapper (line 48) | class OutputSaveFunctionWrapper:
    method __init__ (line 62) | def __init__(self, func: Callable, spec: Optional[Dict]) -> None:
    method __call__ (line 76) | def __call__(self, *args, **kwargs) -> Any:
    method __enter__ (line 83) | def __enter__(self) -> None:
    method __exit__ (line 89) | def __exit__(self, exc_type, exc_val, exc_tb) -> None:

FILE: projects/yolox_pose/models/yolox_pose_head.py
  class YOLOXPoseHeadModule (line 21) | class YOLOXPoseHeadModule(YOLOXHeadModule):
    method __init__ (line 28) | def __init__(self, num_keypoints: int, *args, **kwargs):
    method _init_layers (line 32) | def _init_layers(self):
    method init_weights (line 52) | def init_weights(self):
    method forward (line 61) | def forward(self, x: Tuple[Tensor]) -> Tuple[List]:
  class YOLOXPoseHead (line 73) | class YOLOXPoseHead(YOLOXHead):
    method __init__ (line 82) | def __init__(
    method _clear (line 103) | def _clear(self):
    method loss_by_feat (line 108) | def loss_by_feat(self,
    method _get_targets_single (line 201) | def _get_targets_single(self,
    method predict_by_feat (line 233) | def predict_by_feat(self,
    method predict (line 323) | def predict(self,
    method decode_pose (line 333) | def decode_pose(self, grids: torch.Tensor, offsets: torch.Tensor,
    method gt_instances_preprocess (line 357) | def gt_instances_preprocess(batch_gt_instances: List[InstanceData], *a...

FILE: setup.py
  function readme (line 16) | def readme():
  function get_version (line 25) | def get_version():
  function parse_requirements (line 37) | def parse_requirements(fname='requirements.txt', with_version=True):
  function add_mim_extension (line 125) | def add_mim_extension():

FILE: tests/test_apis/test_inference.py
  class TestInference (line 19) | class TestInference(TestCase):
    method setUp (line 21) | def setUp(self) -> None:
    method test_init_model (line 27) | def test_init_model(self, config, devices):
    method test_inference_topdown (line 50) | def test_inference_topdown(self, config, devices):
    method test_inference_bottomup (line 95) | def test_inference_bottomup(self, config, devices):

FILE: tests/test_apis/test_inferencers/test_hand3d_inferencer.py
  class TestHand3DInferencer (line 16) | class TestHand3DInferencer(TestCase):
    method tearDown (line 18) | def tearDown(self) -> None:
    method test_init (line 22) | def test_init(self):
    method test_call (line 27) | def test_call(self):

FILE: tests/test_apis/test_inferencers/test_mmpose_inferencer.py
  class TestMMPoseInferencer (line 17) | class TestMMPoseInferencer(TestCase):
    method tearDown (line 19) | def tearDown(self) -> None:
    method test_pose2d_call (line 23) | def test_pose2d_call(self):
    method test_pose3d_call (line 97) | def test_pose3d_call(self):
    method test_hand3d_call (line 131) | def test_hand3d_call(self):

FILE: tests/test_apis/test_inferencers/test_pose2d_inferencer.py
  class TestPose2DInferencer (line 19) | class TestPose2DInferencer(TestCase):
    method tearDown (line 21) | def tearDown(self) -> None:
    method _get_det_model_weights (line 25) | def _get_det_model_weights(self):
    method test_init (line 38) | def test_init(self):
    method test_call (line 94) | def test_call(self):

FILE: tests/test_apis/test_inferencers/test_pose3d_inferencer.py
  class TestPose3DInferencer (line 18) | class TestPose3DInferencer(TestCase):
    method tearDown (line 20) | def tearDown(self) -> None:
    method _get_det_model_weights (line 24) | def _get_det_model_weights(self):
    method test_init (line 37) | def test_init(self):
    method test_call (line 84) | def test_call(self):

FILE: tests/test_codecs/test_annotation_processors.py
  class TestYOLOXPoseAnnotationProcessor (line 10) | class TestYOLOXPoseAnnotationProcessor(TestCase):
    method test_encode (line 12) | def test_encode(self):
    method test_decode (line 32) | def test_decode(self):

FILE: tests/test_codecs/test_associative_embedding.py
  class TestAssociativeEmbedding (line 14) | class TestAssociativeEmbedding(TestCase):
    method setUp (line 16) | def setUp(self) -> None:
    method test_build (line 21) | def test_build(self):
    method test_encode (line 32) | def test_encode(self):
    method _get_tags (line 79) | def _get_tags(self,
    method _sort_preds (line 102) | def _sort_preds(self, keypoints_pred, scores_pred, keypoints_gt):
    method test_decode (line 126) | def test_decode(self):

FILE: tests/test_codecs/test_decoupled_heatmap.py
  class TestDecoupledHeatmap (line 11) | class TestDecoupledHeatmap(TestCase):
    method setUp (line 13) | def setUp(self) -> None:
    method _make_multi_instance_data (line 16) | def _make_multi_instance_data(self, data):
    method test_build (line 47) | def test_build(self):
    method test_encode (line 56) | def test_encode(self):
    method test_decode (line 126) | def test_decode(self):
    method test_cicular_verification (line 148) | def test_cicular_verification(self):

FILE: tests/test_codecs/test_edpose_label.py
  class TestEDPoseLabel (line 10) | class TestEDPoseLabel(TestCase):
    method setUp (line 12) | def setUp(self):
    method test_encode (line 19) | def test_encode(self):
    method test_decode (line 39) | def test_decode(self):

FILE: tests/test_codecs/test_hand_3d_heatmap.py
  class TestHand3DHeatmap (line 9) | class TestHand3DHeatmap(TestCase):
    method build_hand_3d_heatmap (line 11) | def build_hand_3d_heatmap(self, **kwargs):
    method setUp (line 16) | def setUp(self) -> None:
    method test_encode (line 32) | def test_encode(self):
    method test_decode (line 94) | def test_decode(self):
    method test_cicular_verification (line 106) | def test_cicular_verification(self):

FILE: tests/test_codecs/test_image_pose_lifting.py
  class TestImagePoseLifting (line 10) | class TestImagePoseLifting(TestCase):
    method setUp (line 12) | def setUp(self) -> None:
    method build_pose_lifting_label (line 36) | def build_pose_lifting_label(self, **kwargs):
    method test_build (line 45) | def test_build(self):
    method test_encode (line 49) | def test_encode(self):
    method test_decode (line 106) | def test_decode(self):
    method test_cicular_verification (line 126) | def test_cicular_verification(self):

FILE: tests/test_codecs/test_integral_regression_label.py
  class TestRegressionLabel (line 10) | class TestRegressionLabel(TestCase):
    method setUp (line 13) | def setUp(self) -> None:
    method test_encode (line 38) | def test_encode(self):
    method test_decode (line 57) | def test_decode(self):
    method test_cicular_verification (line 69) | def test_cicular_verification(self):

FILE: tests/test_codecs/test_megvii_heatmap.py
  class TestMegviiHeatmap (line 10) | class TestMegviiHeatmap(TestCase):
    method setUp (line 12) | def setUp(self) -> None:
    method test_encode (line 36) | def test_encode(self):
    method test_decode (line 50) | def test_decode(self):
    method test_cicular_verification (line 62) | def test_cicular_verification(self):
    method test_errors (line 76) | def test_errors(self):

FILE: tests/test_codecs/test_motionbert_label.py
  class TestMotionBERTLabel (line 12) | class TestMotionBERTLabel(TestCase):
    method get_camera_param (line 14) | def get_camera_param(self, imgname, camera_param) -> dict:
    method build_pose_lifting_label (line 21) | def build_pose_lifting_label(self, **kwargs):
    method setUp (line 26) | def setUp(self) -> None:
    method test_build (line 53) | def test_build(self):
    method test_encode (line 57) | def test_encode(self):
    method test_decode (line 85) | def test_decode(self):
    method test_cicular_verification (line 117) | def test_cicular_verification(self):

FILE: tests/test_codecs/test_msra_heatmap.py
  class TestMSRAHeatmap (line 10) | class TestMSRAHeatmap(TestCase):
    method setUp (line 12) | def setUp(self) -> None:
    method test_encode (line 45) | def test_encode(self):
    method test_decode (line 59) | def test_decode(self):
    method test_cicular_verification (line 71) | def test_cicular_verification(self):
    method test_errors (line 85) | def test_errors(self):

FILE: tests/test_codecs/test_regression_label.py
  class TestRegressionLabel (line 10) | class TestRegressionLabel(TestCase):
    method setUp (line 13) | def setUp(self) -> None:
    method test_encode (line 37) | def test_encode(self):
    method test_decode (line 51) | def test_decode(self):
    method test_cicular_verification (line 68) | def test_cicular_verification(self):

FILE: tests/test_codecs/test_simcc_label.py
  class TestSimCCLabel (line 10) | class TestSimCCLabel(TestCase):
    method setUp (line 13) | def setUp(self) -> None:
    method test_encode (line 72) | def test_encode(self):
    method test_decode (line 90) | def test_decode(self):
    method test_cicular_verification (line 120) | def test_cicular_verification(self):
    method test_errors (line 137) | def test_errors(self):

FILE: tests/test_codecs/test_spr.py
  class TestSPR (line 12) | class TestSPR(TestCase):
    method setUp (line 14) | def setUp(self) -> None:
    method _make_multi_instance_data (line 17) | def _make_multi_instance_data(self, data):
    method test_build (line 40) | def test_build(self):
    method test_encode (line 50) | def test_encode(self):
    method test_decode (line 131) | def test_decode(self):
    method test_cicular_verification (line 171) | def test_cicular_verification(self):

FILE: tests/test_codecs/test_udp_heatmap.py
  class TestUDPHeatmap (line 10) | class TestUDPHeatmap(TestCase):
    method setUp (line 12) | def setUp(self) -> None:
    method test_encode (line 42) | def test_encode(self):
    method test_decode (line 62) | def test_decode(self):
    method test_cicular_verification (line 80) | def test_cicular_verification(self):
    method test_errors (line 94) | def test_errors(self):

FILE: tests/test_codecs/test_video_pose_lifting.py
  class TestVideoPoseLifting (line 12) | class TestVideoPoseLifting(TestCase):
    method get_camera_param (line 14) | def get_camera_param(self, imgname, camera_param) -> dict:
    method build_pose_lifting_label (line 21) | def build_pose_lifting_label(self, **kwargs):
    method setUp (line 27) | def setUp(self) -> None:
    method test_build (line 52) | def test_build(self):
    method test_encode (line 56) | def test_encode(self):
    method test_decode (line 176) | def test_decode(self):
    method test_cicular_verification (line 196) | def test_cicular_verification(self):

FILE: tests/test_datasets/test_datasets/test_animal_datasets/test_animalkingdom_dataset.py
  class TestAnimalKingdomDataset (line 9) | class TestAnimalKingdomDataset(TestCase):
    method build_ak_dataset (line 11) | def build_ak_dataset(self, **kwargs):
    method check_data_info_keys (line 24) | def check_data_info_keys(self,
    method check_metainfo_keys (line 53) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 73) | def test_metainfo(self):
    method test_topdown (line 94) | def test_topdown(self):
    method test_bottomup (line 109) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 120) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_animal_datasets/test_animalpose_dataset.py
  class TestAnimalPoseDataset (line 9) | class TestAnimalPoseDataset(TestCase):
    method build_animalpose_dataset (line 11) | def build_animalpose_dataset(self, **kwargs):
    method check_data_info_keys (line 24) | def check_data_info_keys(self,
    method check_metainfo_keys (line 53) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 73) | def test_metainfo(self):
    method test_topdown (line 94) | def test_topdown(self):
    method test_bottomup (line 110) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 122) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_animal_datasets/test_ap10k_dataset.py
  class TestAP10KDataset (line 9) | class TestAP10KDataset(TestCase):
    method build_ap10k_dataset (line 11) | def build_ap10k_dataset(self, **kwargs):
    method check_data_info_keys (line 24) | def check_data_info_keys(self,
    method check_metainfo_keys (line 53) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 73) | def test_metainfo(self):
    method test_topdown (line 94) | def test_topdown(self):
    method test_bottomup (line 110) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 122) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_animal_datasets/test_atrw_dataset.py
  class TestATRWDataset (line 9) | class TestATRWDataset(TestCase):
    method build_atrw_dataset (line 11) | def build_atrw_dataset(self, **kwargs):
    method check_data_info_keys (line 24) | def check_data_info_keys(self,
    method check_metainfo_keys (line 53) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 73) | def test_metainfo(self):
    method test_topdown (line 94) | def test_topdown(self):
    method test_bottomup (line 109) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 120) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_animal_datasets/test_fly_dataset.py
  class TestFlyDataset (line 9) | class TestFlyDataset(TestCase):
    method build_fly_dataset (line 11) | def build_fly_dataset(self, **kwargs):
    method check_data_info_keys (line 24) | def check_data_info_keys(self,
    method check_metainfo_keys (line 53) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 73) | def test_metainfo(self):
    method test_topdown (line 92) | def test_topdown(self):
    method test_bottomup (line 107) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 118) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_animal_datasets/test_horse10_dataset.py
  class TestHorse10Dataset (line 9) | class TestHorse10Dataset(TestCase):
    method build_horse10_dataset (line 11) | def build_horse10_dataset(self, **kwargs):
    method check_data_info_keys (line 24) | def check_data_info_keys(self,
    method check_metainfo_keys (line 53) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 73) | def test_metainfo(self):
    method test_topdown (line 92) | def test_topdown(self):
    method test_bottomup (line 108) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 120) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_animal_datasets/test_locust_dataset.py
  class TestLocustDataset (line 9) | class TestLocustDataset(TestCase):
    method build_locust_dataset (line 11) | def build_locust_dataset(self, **kwargs):
    method check_data_info_keys (line 24) | def check_data_info_keys(self,
    method check_metainfo_keys (line 53) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 73) | def test_metainfo(self):
    method test_topdown (line 92) | def test_topdown(self):
    method test_bottomup (line 108) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 120) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_animal_datasets/test_macaque_dataset.py
  class TestMacaqueDataset (line 9) | class TestMacaqueDataset(TestCase):
    method build_macaque_dataset (line 11) | def build_macaque_dataset(self, **kwargs):
    method check_data_info_keys (line 24) | def check_data_info_keys(self,
    method check_metainfo_keys (line 53) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 73) | def test_metainfo(self):
    method test_topdown (line 94) | def test_topdown(self):
    method test_bottomup (line 110) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 122) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_animal_datasets/test_zebra_dataset.py
  class TestZebraDataset (line 9) | class TestZebraDataset(TestCase):
    method build_zebra_dataset (line 11) | def build_zebra_dataset(self, **kwargs):
    method check_data_info_keys (line 24) | def check_data_info_keys(self,
    method check_metainfo_keys (line 53) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 73) | def test_metainfo(self):
    method test_topdown (line 92) | def test_topdown(self):
    method test_bottomup (line 107) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 119) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_body_datasets/test_aic_dataset.py
  class TestAicDataset (line 9) | class TestAicDataset(TestCase):
    method build_aic_dataset (line 11) | def build_aic_dataset(self, **kwargs):
    method check_data_info_keys (line 24) | def check_data_info_keys(self,
    method check_metainfo_keys (line 54) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 74) | def test_metainfo(self):
    method test_topdown (line 95) | def test_topdown(self):
    method test_bottomup (line 108) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 119) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_body_datasets/test_coco_dataset.py
  class TestCocoDataset (line 9) | class TestCocoDataset(TestCase):
    method build_coco_dataset (line 11) | def build_coco_dataset(self, **kwargs):
    method check_data_info_keys (line 24) | def check_data_info_keys(self,
    method check_metainfo_keys (line 54) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 74) | def test_metainfo(self):
    method test_topdown (line 95) | def test_topdown(self):
    method test_bottomup (line 122) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 133) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_body_datasets/test_crowdpose_dataset.py
  class TestCrowdPoseDataset (line 9) | class TestCrowdPoseDataset(TestCase):
    method build_crowdpose_dataset (line 11) | def build_crowdpose_dataset(self, **kwargs):
    method check_data_info_keys (line 24) | def check_data_info_keys(self,
    method check_metainfo_keys (line 54) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 74) | def test_metainfo(self):
    method test_topdown (line 95) | def test_topdown(self):
    method test_bottomup (line 125) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 137) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_body_datasets/test_exlpose_dataset.py
  class TestExlposeDataset (line 9) | class TestExlposeDataset(TestCase):
    method build_exlpose_dataset (line 11) | def build_exlpose_dataset(self, **kwargs):
    method check_data_info_keys (line 24) | def check_data_info_keys(self,
    method check_metainfo_keys (line 54) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 74) | def test_metainfo(self):
    method test_topdown (line 95) | def test_topdown(self):
    method test_bottomup (line 109) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 121) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_body_datasets/test_h36m_dataset.py
  class TestH36MDataset (line 9) | class TestH36MDataset(TestCase):
    method build_h36m_dataset (line 11) | def build_h36m_dataset(self, **kwargs):
    method check_data_info_keys (line 23) | def check_data_info_keys(self,
    method check_metainfo_keys (line 52) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 72) | def test_metainfo(self):
    method test_topdown (line 91) | def test_topdown(self):
    method test_bottomup (line 144) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 165) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_body_datasets/test_humanart21_dataset.py
  class TestHumanart21Dataset (line 9) | class TestHumanart21Dataset(TestCase):
    method build_humanart_dataset (line 11) | def build_humanart_dataset(self, **kwargs):
    method check_data_info_keys (line 24) | def check_data_info_keys(self,
    method check_metainfo_keys (line 53) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 73) | def test_metainfo(self):
    method test_topdown (line 94) | def test_topdown(self):
    method test_bottomup (line 122) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 134) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_body_datasets/test_humanart_dataset.py
  class TestHumanartDataset (line 9) | class TestHumanartDataset(TestCase):
    method build_humanart_dataset (line 11) | def build_humanart_dataset(self, **kwargs):
    method check_data_info_keys (line 24) | def check_data_info_keys(self,
    method check_metainfo_keys (line 53) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 73) | def test_metainfo(self):
    method test_topdown (line 94) | def test_topdown(self):
    method test_bottomup (line 122) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 134) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_body_datasets/test_jhmdb_dataset.py
  class TestJhmdbDataset (line 9) | class TestJhmdbDataset(TestCase):
    method build_jhmdb_dataset (line 11) | def build_jhmdb_dataset(self, **kwargs):
    method check_data_info_keys (line 24) | def check_data_info_keys(self,
    method check_metainfo_keys (line 54) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 74) | def test_metainfo(self):
    method test_topdown (line 95) | def test_topdown(self):
    method test_bottomup (line 108) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 120) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_body_datasets/test_mhp_dataset.py
  class TestMhpDataset (line 9) | class TestMhpDataset(TestCase):
    method build_mhp_dataset (line 11) | def build_mhp_dataset(self, **kwargs):
    method check_data_info_keys (line 24) | def check_data_info_keys(self,
    method check_metainfo_keys (line 57) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 77) | def test_metainfo(self):
    method test_topdown (line 98) | def test_topdown(self):
    method test_bottomup (line 111) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 122) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_body_datasets/test_mpii_dataset.py
  class TestMpiiDataset (line 9) | class TestMpiiDataset(TestCase):
    method build_mpii_dataset (line 11) | def build_mpii_dataset(self, **kwargs):
    method check_data_info_keys (line 24) | def check_data_info_keys(self,
    method check_metainfo_keys (line 56) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 76) | def test_metainfo(self):
    method test_topdown (line 97) | def test_topdown(self):
    method test_bottomup (line 108) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 119) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_body_datasets/test_mpii_trb_dataset.py
  class TestMpiiTrbDataset (line 9) | class TestMpiiTrbDataset(TestCase):
    method build_mpii_trb_dataset (line 11) | def build_mpii_trb_dataset(self, **kwargs):
    method check_data_info_keys (line 24) | def check_data_info_keys(self,
    method check_metainfo_keys (line 55) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 75) | def test_metainfo(self):
    method test_topdown (line 94) | def test_topdown(self):
    method test_bottomup (line 106) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 118) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_body_datasets/test_ochuman_dataset.py
  class TestOCHumanDataset (line 9) | class TestOCHumanDataset(TestCase):
    method build_ochuman_dataset (line 11) | def build_ochuman_dataset(self, **kwargs):
    method check_data_info_keys (line 24) | def check_data_info_keys(self,
    method check_metainfo_keys (line 53) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 73) | def test_metainfo(self):
    method test_topdown (line 94) | def test_topdown(self):
    method test_bottomup (line 106) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 118) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_body_datasets/test_posetrack18_dataset.py
  class TestPoseTrack18Dataset (line 9) | class TestPoseTrack18Dataset(TestCase):
    method build_posetrack18_dataset (line 11) | def build_posetrack18_dataset(self, **kwargs):
    method check_data_info_keys (line 24) | def check_data_info_keys(self,
    method check_metainfo_keys (line 54) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 74) | def test_metainfo(self):
    method test_topdown (line 95) | def test_topdown(self):
    method test_bottomup (line 123) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 135) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_body_datasets/test_posetrack18_video_dataset.py
  class TestPoseTrack18VideoDataset (line 9) | class TestPoseTrack18VideoDataset(TestCase):
    method build_posetrack18_video_dataset (line 11) | def build_posetrack18_video_dataset(self, **kwargs):
    method check_data_info_keys (line 30) | def check_data_info_keys(self,
    method check_metainfo_keys (line 63) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 83) | def test_metainfo(self):
    method test_topdown (line 104) | def test_topdown(self):
    method test_bottomup (line 167) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 183) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_dataset_wrappers/test_combined_dataset.py
  class TestCombinedDataset (line 9) | class TestCombinedDataset(TestCase):
    method build_combined_dataset (line 11) | def build_combined_dataset(self, **kwargs):
    method check_data_info_keys (line 38) | def check_data_info_keys(self,
    method test_get_subset_index (line 67) | def test_get_subset_index(self):
    method test_prepare_data (line 107) | def test_prepare_data(self):

FILE: tests/test_datasets/test_datasets/test_face_datasets/test_aflw_dataset.py
  class TestAFLWDataset (line 9) | class TestAFLWDataset(TestCase):
    method build_aflw_dataset (line 11) | def build_aflw_dataset(self, **kwargs):
    method check_data_info_keys (line 24) | def check_data_info_keys(self,
    method check_metainfo_keys (line 55) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 75) | def test_metainfo(self):
    method test_topdown (line 89) | def test_topdown(self):
    method test_bottomup (line 104) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 115) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_face_datasets/test_coco_wholebody_face_dataset.py
  class TestCocoWholeBodyFaceDataset (line 9) | class TestCocoWholeBodyFaceDataset(TestCase):
    method build_coco_wholebody_face_dataset (line 11) | def build_coco_wholebody_face_dataset(self, **kwargs):
    method check_data_info_keys (line 24) | def check_data_info_keys(self,
    method check_metainfo_keys (line 53) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 73) | def test_metainfo(self):
    method test_topdown (line 90) | def test_topdown(self):
    method test_bottomup (line 107) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 121) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_face_datasets/test_cofw_dataset.py
  class TestCOFWDataset (line 9) | class TestCOFWDataset(TestCase):
    method build_cofw_dataset (line 11) | def build_cofw_dataset(self, **kwargs):
    method check_data_info_keys (line 24) | def check_data_info_keys(self,
    method check_metainfo_keys (line 53) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 73) | def test_metainfo(self):
    method test_topdown (line 87) | def test_topdown(self):
    method test_bottomup (line 102) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 113) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_face_datasets/test_face_300vw_dataset.py
  class TestFace300VWDataset (line 9) | class TestFace300VWDataset(TestCase):
    method build_face_300vw_dataset (line 11) | def build_face_300vw_dataset(self, **kwargs):
    method check_data_info_keys (line 24) | def check_data_info_keys(self,
    method check_metainfo_keys (line 55) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 75) | def test_metainfo(self):
    method test_topdown (line 89) | def test_topdown(self):
    method test_bottomup (line 105) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 117) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_face_datasets/test_face_300w_dataset.py
  class TestFace300WDataset (line 9) | class TestFace300WDataset(TestCase):
    method build_face_300w_dataset (line 11) | def build_face_300w_dataset(self, **kwargs):
    method check_data_info_keys (line 24) | def check_data_info_keys(self,
    method check_metainfo_keys (line 55) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 75) | def test_metainfo(self):
    method test_topdown (line 89) | def test_topdown(self):
    method test_bottomup (line 105) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 117) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_face_datasets/test_face_300wlp_dataset.py
  class TestFace300WLPDataset (line 9) | class TestFace300WLPDataset(TestCase):
    method build_face_300wlp_dataset (line 11) | def build_face_300wlp_dataset(self, **kwargs):
    method check_data_info_keys (line 24) | def check_data_info_keys(self,
    method check_metainfo_keys (line 51) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 71) | def test_metainfo(self):
    method test_topdown (line 85) | def test_topdown(self):
    method test_bottomup (line 101) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 113) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_face_datasets/test_lapa_dataset.py
  class TestLaPaDataset (line 9) | class TestLaPaDataset(TestCase):
    method build_lapa_dataset (line 11) | def build_lapa_dataset(self, **kwargs):
    method check_data_info_keys (line 24) | def check_data_info_keys(self,
    method check_metainfo_keys (line 43) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 63) | def test_metainfo(self):
    method test_topdown (line 79) | def test_topdown(self):

FILE: tests/test_datasets/test_datasets/test_face_datasets/test_wflw_dataset.py
  class TestWFLWDataset (line 9) | class TestWFLWDataset(TestCase):
    method build_wflw_dataset (line 11) | def build_wflw_dataset(self, **kwargs):
    method check_data_info_keys (line 24) | def check_data_info_keys(self,
    method check_metainfo_keys (line 55) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 75) | def test_metainfo(self):
    method test_topdown (line 89) | def test_topdown(self):
    method test_bottomup (line 104) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 115) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_fashion_datasets/test_deepfashion_dataset.py
  class TestDeepFashionDataset (line 9) | class TestDeepFashionDataset(TestCase):
    method build_deepfashion_dataset (line 11) | def build_deepfashion_dataset(self, **kwargs):
    method check_data_info_keys (line 25) | def check_data_info_keys(self,
    method check_metainfo_keys (line 53) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 73) | def test_metainfo(self):
    method test_topdown (line 114) | def test_topdown(self):
    method test_bottomup (line 130) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 142) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_hand_datasets/test_coco_wholebody_hand_dataset.py
  class TestCocoWholeBodyHandDataset (line 9) | class TestCocoWholeBodyHandDataset(TestCase):
    method build_coco_wholebody_hand_dataset (line 11) | def build_coco_wholebody_hand_dataset(self, **kwargs):
    method check_data_info_keys (line 24) | def check_data_info_keys(self,
    method check_metainfo_keys (line 53) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 73) | def test_metainfo(self):
    method test_topdown (line 95) | def test_topdown(self):
    method test_bottomup (line 113) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 127) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_hand_datasets/test_freihand_dataset.py
  class TestFreiHandDataset (line 9) | class TestFreiHandDataset(TestCase):
    method build_freihand_dataset (line 11) | def build_freihand_dataset(self, **kwargs):
    method check_data_info_keys (line 24) | def check_data_info_keys(self,
    method check_metainfo_keys (line 53) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 73) | def test_metainfo(self):
    method test_topdown (line 92) | def test_topdown(self):
    method test_bottomup (line 108) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 120) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_hand_datasets/test_interhand2d_double_dataset.py
  class TestInterHand2DDoubleDataset (line 9) | class TestInterHand2DDoubleDataset(TestCase):
    method build_interhand2d_dataset (line 11) | def build_interhand2d_dataset(self, **kwargs):
    method check_metainfo_keys (line 25) | def check_metainfo_keys(self, metainfo: dict):
    method check_data_info_keys (line 45) | def check_data_info_keys(self,
    method test_metainfo (line 82) | def test_metainfo(self):
    method test_topdown (line 101) | def test_topdown(self):
    method test_bottomup (line 117) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 129) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_hand_datasets/test_interhand3d_dataset.py
  class TestInterHand3DDataset (line 9) | class TestInterHand3DDataset(TestCase):
    method build_interhand3d_dataset (line 11) | def build_interhand3d_dataset(self, **kwargs):
    method check_metainfo_keys (line 25) | def check_metainfo_keys(self, metainfo: dict):
    method check_data_info_keys (line 45) | def check_data_info_keys(self,
    method test_metainfo (line 94) | def test_metainfo(self):
    method test_topdown (line 113) | def test_topdown(self):
    method test_bottomup (line 129) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 141) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_hand_datasets/test_onehand10k_dataset.py
  class TestOneHand10KDataset (line 9) | class TestOneHand10KDataset(TestCase):
    method build_onehand10k_dataset (line 11) | def build_onehand10k_dataset(self, **kwargs):
    method check_data_info_keys (line 24) | def check_data_info_keys(self,
    method check_metainfo_keys (line 53) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 73) | def test_metainfo(self):
    method test_topdown (line 92) | def test_topdown(self):
    method test_bottomup (line 108) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 120) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_hand_datasets/test_panoptic_hand2d_dataset.py
  class TestPanopticHand2DDataset (line 9) | class TestPanopticHand2DDataset(TestCase):
    method build_panoptic_hand2d_dataset (line 11) | def build_panoptic_hand2d_dataset(self, **kwargs):
    method check_data_info_keys (line 24) | def check_data_info_keys(self,
    method check_metainfo_keys (line 58) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 78) | def test_metainfo(self):
    method test_topdown (line 97) | def test_topdown(self):
    method test_bottomup (line 113) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 125) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_hand_datasets/test_rhd2d_dataset.py
  class TestRhd2DDataset (line 9) | class TestRhd2DDataset(TestCase):
    method build_rhd2d_dataset (line 11) | def build_rhd2d_dataset(self, **kwargs):
    method check_data_info_keys (line 24) | def check_data_info_keys(self,
    method check_metainfo_keys (line 52) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 72) | def test_metainfo(self):
    method test_topdown (line 91) | def test_topdown(self):
    method test_bottomup (line 106) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 118) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_wholebody_datasets/test_coco_wholebody_dataset.py
  class TestCocoWholeBodyDataset (line 9) | class TestCocoWholeBodyDataset(TestCase):
    method build_coco_wholebody_dataset (line 11) | def build_coco_wholebody_dataset(self, **kwargs):
    method check_data_info_keys (line 24) | def check_data_info_keys(self,
    method check_metainfo_keys (line 53) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 73) | def test_metainfo(self):
    method test_topdown (line 94) | def test_topdown(self):
    method test_bottomup (line 123) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 135) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_wholebody_datasets/test_h3wb_dataset.py
  class TestH36MWholeBodyDataset (line 9) | class TestH36MWholeBodyDataset(TestCase):
    method build_h3wb_dataset (line 11) | def build_h3wb_dataset(self, **kwargs):
    method check_data_info_keys (line 22) | def check_data_info_keys(self, data_info: dict):
    method test_metainfo (line 35) | def test_metainfo(self):
    method test_topdown (line 53) | def test_topdown(self):

FILE: tests/test_datasets/test_datasets/test_wholebody_datasets/test_halpe_dataset.py
  class TestHalpeDataset (line 9) | class TestHalpeDataset(TestCase):
    method build_halpe_dataset (line 11) | def build_halpe_dataset(self, **kwargs):
    method check_data_info_keys (line 23) | def check_data_info_keys(self,
    method check_metainfo_keys (line 52) | def check_metainfo_keys(self, metainfo: dict):
    method test_metainfo (line 72) | def test_metainfo(self):
    method test_topdown (line 93) | def test_topdown(self):
    method test_bottomup (line 124) | def test_bottomup(self):
    method test_exceptions_and_warnings (line 136) | def test_exceptions_and_warnings(self):

FILE: tests/test_datasets/test_datasets/test_wholebody_datasets/test_ubody_dataset.py
  class TestUBody3dDataset (line 9) | class TestUBody3dDataset(TestCase):
    method build_ubody3d_dataset (line 11) | def build_ubody3d_dataset(self, **kwargs):
    method check_data_info_keys (line 23) | def check_data_info_keys(self, data_info: dict):
    method test_metainfo (line 36) | def test_metainfo(self):
    method test_topdown (line 54) | def test_topdown(self):

FILE: tests/test_datasets/test_transforms/test_bottomup_transforms.py
  class TestBottomupRandomAffine (line 16) | class TestBottomupRandomAffine(TestCase):
    method setUp (line 18) | def setUp(self):
    method test_transform (line 23) | def test_transform(self):
  class TestBottomupGetHeatmapMask (line 42) | class TestBottomupGetHeatmapMask(TestCase):
    method setUp (line 44) | def setUp(self):
    method test_transform (line 49) | def test_transform(self):
  class TestBottomupResize (line 100) | class TestBottomupResize(TestCase):
    method setUp (line 102) | def setUp(self):
    method test_transform (line 110) | def test_transform(self):
  class TestBottomupRandomCrop (line 152) | class TestBottomupRandomCrop(TestCase):
    method setUp (line 154) | def setUp(self):
    method test_transform (line 186) | def test_transform(self):
  class TestBottomupRandomChoiceResize (line 263) | class TestBottomupRandomChoiceResize(TestCase):
    method setUp (line 265) | def setUp(self):
    method test_transform (line 268) | def test_transform(self):

FILE: tests/test_datasets/test_transforms/test_common_transforms.py
  class TestGetBBoxCenterScale (line 21) | class TestGetBBoxCenterScale(TestCase):
    method setUp (line 23) | def setUp(self):
    method test_transform (line 33) | def test_transform(self):
    method test_repr (line 56) | def test_repr(self):
  class TestRandomFlip (line 61) | class TestRandomFlip(TestCase):
    method setUp (line 63) | def setUp(self):
    method test_init (line 72) | def test_init(self):
    method test_transform (line 82) | def test_transform(self):
    method test_errors (line 154) | def test_errors(self):
    method test_repr (line 170) | def test_repr(self):
  class TestRandomHalfBody (line 176) | class TestRandomHalfBody(TestCase):
    method setUp (line 178) | def setUp(self):
    method test_transform (line 186) | def test_transform(self):
    method test_repr (line 261) | def test_repr(self):
  class TestRandomBBoxTransform (line 276) | class TestRandomBBoxTransform(TestCase):
    method setUp (line 278) | def setUp(self):
    method test_transform (line 286) | def test_transform(self):
    method test_repr (line 382) | def test_repr(self):
  class TestAlbumentation (line 398) | class TestAlbumentation(TestCase):
    method setUp (line 400) | def setUp(self):
    method test_transform (line 411) | def test_transform(self):
    method test_repr (line 420) | def test_repr(self):
  class TestPhotometricDistortion (line 432) | class TestPhotometricDistortion(TestCase):
    method setUp (line 434) | def setUp(self):
    method test_transform (line 445) | def test_transform(self):
    method test_repr (line 450) | def test_repr(self):
  class TestGenerateTarget (line 460) | class TestGenerateTarget(TestCase):
    method setUp (line 462) | def setUp(self):
    method test_generate_single_target (line 470) | def test_generate_single_target(self):
    method test_generate_multilevel_target (line 504) | def test_generate_multilevel_target(self):
    method test_generate_combined_target (line 528) | def test_generate_combined_target(self):
    method test_errors (line 551) | def test_errors(self):
  class TestFilterAnnotations (line 607) | class TestFilterAnnotations(TestCase):
    method setUp (line 609) | def setUp(self):
    method test_transform (line 630) | def test_transform(self):
  class TestYOLOXHSVRandomAug (line 698) | class TestYOLOXHSVRandomAug(TestCase):
    method setUp (line 700) | def setUp(self):
    method test_transform (line 721) | def test_transform(self):
    method test_repr (line 730) | def test_repr(self):

FILE: tests/test_datasets/test_transforms/test_converting.py
  class TestKeypointConverter (line 11) | class TestKeypointConverter(TestCase):
    method setUp (line 13) | def setUp(self):
    method test_transform (line 18) | def test_transform(self):

FILE: tests/test_datasets/test_transforms/test_formatting.py
  class TestPackPoseInputs (line 13) | class TestPackPoseInputs(TestCase):
    method setUp (line 15) | def setUp(self):
    method test_transform (line 69) | def test_transform(self):
    method test_repr (line 105) | def test_repr(self):

FILE: tests/test_datasets/test_transforms/test_loading.py
  class TestLoadImage (line 10) | class TestLoadImage(TestCase):
    method test_load_image (line 12) | def test_load_image(self):
    method test_with_input_image (line 21) | def test_with_input_image(self):

FILE: tests/test_datasets/test_transforms/test_mix_img_transform.py
  class TestMosaic (line 10) | class TestMosaic(TestCase):
    method setUp (line 12) | def setUp(self):
    method test_apply_mix (line 29) | def test_apply_mix(self):
    method test_create_mosaic_image (line 43) | def test_create_mosaic_image(self):
    method test_mosaic_combine (line 57) | def test_mosaic_combine(self):
  class TestYOLOXMixUp (line 69) | class TestYOLOXMixUp(TestCase):
    method setUp (line 71) | def setUp(self):
    method test_apply_mix (line 89) | def test_apply_mix(self):
    method test_create_mixup_image (line 103) | def test_create_mixup_image(self):

FILE: tests/test_datasets/test_transforms/test_pose3d_transforms.py
  function get_h36m_sample (line 12) | def get_h36m_sample():
  class TestRandomFlipAroundRoot (line 79) | class TestRandomFlipAroundRoot(TestCase):
    method setUp (line 81) | def setUp(self):
    method test_init (line 86) | def test_init(self):
    method test_transform (line 93) | def test_transform(self):

FILE: tests/test_datasets/test_transforms/test_topdown_transforms.py
  class TestTopdownAffine (line 9) | class TestTopdownAffine(TestCase):
    method setUp (line 11) | def setUp(self):
    method test_transform (line 15) | def test_transform(self):
    method test_repr (line 30) | def test_repr(self):

FILE: tests/test_engine/test_hooks/test_badcase_hook.py
  function _rand_poses (line 18) | def _rand_poses(num_boxes, kpt_num, h, w):
  class TestBadCaseHook (line 29) | class TestBadCaseHook(TestCase):
    method setUp (line 31) | def setUp(self) -> None:
    method test_after_test_iter (line 56) | def test_after_test_iter(self):

FILE: tests/test_engine/test_hooks/test_mode_switch_hooks.py
  class DummyDataset (line 14) | class DummyDataset(Dataset):
    method metainfo (line 20) | def metainfo(self):
    method __len__ (line 23) | def __len__(self):
    method __getitem__ (line 26) | def __getitem__(self, index):
  class TestYOLOXPoseModeSwitchHook (line 40) | class TestYOLOXPoseModeSwitchHook(TestCase):
    method test (line 42) | def test(self):
  class TestRTMOModeSwitchHook (line 70) | class TestRTMOModeSwitchHook(TestCase):
    method test (line 72) | def test(self):

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

FILE: tests/test_engine/test_hooks/test_visualization_hook.py
  function _rand_poses (line 16) | def _rand_poses(num_boxes, h, w):
  class TestVisualizationHook (line 27) | class TestVisualizationHook(TestCase):
    method setUp (line 29) | def setUp(self) -> None:
    method test_after_val_iter (line 47) | def test_after_val_iter(self):
    method test_after_test_iter (line 54) | def test_after_test_iter(self):

FILE: tests/test_engine/test_schedulers/test_lr_scheduler.py
  class ToyModel (line 13) | class ToyModel(torch.nn.Module):
    method __init__ (line 15) | def __init__(self):
    method forward (line 20) | def forward(self, x):
  class TestLRScheduler (line 24) | class TestLRScheduler(TestCase):
    method setUp (line 26) | def setUp(self):
    method _test_scheduler_value (line 45) | def _test_scheduler_value(self,
    method test_constant_scheduler (line 75) | def test_constant_scheduler(self):

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

FILE: tests/test_evaluation/test_evaluator/test_multi_dataset_evaluator.py
  class TestMultiDatasetEvaluator (line 11) | class TestMultiDatasetEvaluator(TestCase):
    method setUp (line 13) | def setUp(self) -> None:
    method test_init (line 87) | def test_init(self):
    method test_process (line 95) | def test_process(self):

FILE: tests/test_evaluation/test_functional/test_keypoint_eval.py
  class TestKeypointEval (line 14) | class TestKeypointEval(TestCase):
    method test_keypoint_pck_accuracy (line 16) | def test_keypoint_pck_accuracy(self):
    method test_keypoint_auc (line 61) | def test_keypoint_auc(self):
    method test_keypoint_epe (line 84) | def test_keypoint_epe(self):
    method test_keypoint_nme (line 107) | def test_keypoint_nme(self):
    method test_pose_pck_accuracy (line 132) | def test_pose_pck_accuracy(self):
    method test_multilabel_classification_accuracy (line 149) | def test_multilabel_classification_accuracy(self):
    method test_keypoint_mpjpe (line 170) | def test_keypoint_mpjpe(self):

FILE: tests/test_evaluation/test_functional/test_nms.py
  class TestNearbyJointsNMS (line 10) | class TestNearbyJointsNMS(TestCase):
    method test_nearby_joints_nms (line 12) | def test_nearby_joints_nms(self):
  class TestNMSTorch (line 44) | class TestNMSTorch(TestCase):
    method test_nms_torch (line 46) | def test_nms_torch(self):

FILE: tests/test_evaluation/test_functional/test_transforms.py
  class TestKeypointEval (line 11) | class TestKeypointEval(TestCase):
    method test_transform_sigmas (line 13) | def test_transform_sigmas(self):
    method test_transform_ann (line 23) | def test_transform_ann(self):
    method test_transform_pred (line 40) | def test_transform_pred(self):

FILE: tests/test_evaluation/test_metrics/test_coco_metric.py
  class TestCocoMetric (line 18) | class TestCocoMetric(TestCase):
    method setUp (line 20) | def setUp(self):
    method _convert_ann_to_topdown_batch_data (line 118) | def _convert_ann_to_topdown_batch_data(self,
    method _convert_ann_to_bottomup_batch_data (line 173) | def _convert_ann_to_bottomup_batch_data(self, ann_file):
    method tearDown (line 208) | def tearDown(self):
    method test_init (line 211) | def test_init(self):
    method test_other_methods (line 231) | def test_other_methods(self):
    method test_format_only (line 248) | def test_format_only(self):
    method test_bottomup_evaluate (line 275) | def test_bottomup_evaluate(self):
    method test_topdown_alignment (line 294) | def test_topdown_alignment(self):
    method test_topdown_evaluate (line 499) | def test_topdown_evaluate(self):
    method test_gt_converter (line 634) | def test_gt_converter(self):
    method test_get_ann_file_from_dataset (line 676) | def test_get_ann_file_from_dataset(self):

FILE: tests/test_evaluation/test_metrics/test_coco_wholebody_metric.py
  class TestCocoWholeBodyMetric (line 17) | class TestCocoWholeBodyMetric(TestCase):
    method setUp (line 19) | def setUp(self):
    method _convert_ann_to_topdown_batch_data (line 61) | def _convert_ann_to_topdown_batch_data(self, ann_file):
    method _convert_ann_to_bottomup_batch_data (line 106) | def _convert_ann_to_bottomup_batch_data(self, ann_file):
    method tearDown (line 145) | def tearDown(self):
    method test_init (line 148) | def test_init(self):
    method test_other_methods (line 170) | def test_other_methods(self):
    method test_format_only (line 187) | def test_format_only(self):
    method test_bottomup_evaluate (line 214) | def test_bottomup_evaluate(self):
    method test_topdown_evaluate (line 233) | def test_topdown_evaluate(self):

FILE: tests/test_evaluation/test_metrics/test_hand_metric.py
  class TestInterHandMetric (line 15) | class TestInterHandMetric(TestCase):
    method setUp (line 17) | def setUp(self):
    method encode_handtype (line 51) | def encode_handtype(self, hand_type):
    method _convert_ann_to_topdown_batch_data (line 61) | def _convert_ann_to_topdown_batch_data(self, ann_file):
    method tearDown (line 153) | def tearDown(self):
    method test_init (line 156) | def test_init(self):
    method test_topdown_evaluate (line 162) | def test_topdown_evaluate(self):

FILE: tests/test_evaluation/test_metrics/test_keypoint_2d_metrics.py
  class TestPCKAccuracy (line 12) | class TestPCKAccuracy(TestCase):
    method setUp (line 14) | def setUp(self):
    method test_init (line 48) | def test_init(self):
    method test_evaluate (line 55) | def test_evaluate(self):
  class TestMpiiPCKAccuracy (line 83) | class TestMpiiPCKAccuracy(TestCase):
    method setUp (line 85) | def setUp(self):
    method test_init (line 119) | def test_init(self):
    method test_evaluate (line 126) | def test_evaluate(self):
  class TestJhmdbPCKAccuracy (line 146) | class TestJhmdbPCKAccuracy(TestCase):
    method setUp (line 148) | def setUp(self):
    method test_init (line 182) | def test_init(self):
    method test_evaluate (line 189) | def test_evaluate(self):
  class TestAUCandEPE (line 224) | class TestAUCandEPE(TestCase):
    method setUp (line 226) | def setUp(self):
    method test_auc_evaluate (line 267) | def test_auc_evaluate(self):
    method test_epe_evaluate (line 275) | def test_epe_evaluate(self):
  class TestNME (line 283) | class TestNME(TestCase):
    method _generate_data (line 285) | def _generate_data(self,
    method test_nme_evaluate (line 317) | def test_nme_evaluate(self):
    method test_exceptions_and_warnings (line 368) | def test_exceptions_and_warnings(self):

FILE: tests/test_evaluation/test_metrics/test_keypoint_3d_metrics.py
  class TestMPJPE (line 11) | class TestMPJPE(TestCase):
    method setUp (line 13) | def setUp(self):
    method test_init (line 44) | def test_init(self):
    method test_evaluate (line 52) | def test_evaluate(self):

FILE: tests/test_evaluation/test_metrics/test_keypoint_partition_metric.py
  class TestKeypointPartitionMetricWrappingCocoMetric (line 18) | class TestKeypointPartitionMetricWrappingCocoMetric(TestCase):
    method setUp (line 20) | def setUp(self):
    method _convert_ann_to_topdown_batch_data (line 73) | def _convert_ann_to_topdown_batch_data(self, ann_file):
    method _convert_ann_to_bottomup_batch_data (line 129) | def _convert_ann_to_bottomup_batch_data(self, ann_file):
    method _assert_outfiles (line 175) | def _assert_outfiles(self, prefix):
    method tearDown (line 182) | def tearDown(self):
    method test_init (line 185) | def test_init(self):
    method test_bottomup_evaluate (line 225) | def test_bottomup_evaluate(self):
    method test_topdown_evaluate (line 253) | def test_topdown_evaluate(self):
  class TestKeypointPartitionMetricWrappingPCKAccuracy (line 282) | class TestKeypointPartitionMetricWrappingPCKAccuracy(TestCase):
    method setUp (line 284) | def setUp(self):
    method test_init (line 323) | def test_init(self):
    method test_evaluate (line 332) | def test_evaluate(self):
  class TestKeypointPartitionMetricWrappingAUCandEPE (line 383) | class TestKeypointPartitionMetricWrappingAUCandEPE(TestCase):
    method setUp (line 385) | def setUp(self):
    method test_auc_evaluate (line 426) | def test_auc_evaluate(self):
    method test_epe_evaluate (line 440) | def test_epe_evaluate(self):
  class TestKeypointPartitionMetricWrappingNME (line 459) | class TestKeypointPartitionMetricWrappingNME(TestCase):
    method setUp (line 461) | def setUp(self):
    method test_init (line 500) | def test_init(self):
    method test_nme_evaluate (line 513) | def test_nme_evaluate(self):

FILE: tests/test_evaluation/test_metrics/test_posetrack18_metric.py
  class TestPoseTrack18Metric (line 14) | class TestPoseTrack18Metric(TestCase):
    method setUp (line 16) | def setUp(self):
    method _convert_ann_to_topdown_batch_data (line 47) | def _convert_ann_to_topdown_batch_data(self):
    method _convert_ann_to_bottomup_batch_data (line 80) | def _convert_ann_to_bottomup_batch_data(self):
    method tearDown (line 113) | def tearDown(self):
    method test_init (line 116) | def test_init(self):
    method test_topdown_evaluate (line 134) | def test_topdown_evaluate(self):
    method test_bottomup_evaluate (line 190) | def test_bottomup_evaluate(self):
    method test_other_methods (line 207) | def test_other_methods(self):
    method test_format_only (line 223) | def test_format_only(self):
    method test_topdown_alignment (line 248) | def test_topdown_alignment(self):

FILE: tests/test_external/test_mim.py
  class TestMIM (line 9) | class TestMIM(TestCase):
    method test_download (line 11) | def test_download(self):

FILE: tests/test_models/test_backbones/test_alexnet.py
  class TestAlexNet (line 9) | class TestAlexNet(TestCase):
    method test_alexnet_backbone (line 11) | def test_alexnet_backbone(self):

FILE: tests/test_models/test_backbones/test_backbones_utils.py
  class TestBackboneUtils (line 12) | class TestBackboneUtils(TestCase):
    method is_norm (line 15) | def is_norm(modules):
    method test_make_divisible (line 21) | def test_make_divisible(self):
    method test_channel_shuffle (line 34) | def test_channel_shuffle(self):
    method test_inverted_residual (line 53) | def test_inverted_residual(self):

FILE: tests/test_models/test_backbones/test_cpm.py
  class TestCPM (line 10) | class TestCPM(TestCase):
    method test_cpm_block (line 12) | def test_cpm_block(self):
    method test_cpm_backbone (line 28) | def test_cpm_backbone(self):

FILE: tests/test_models/test_backbones/test_csp_darknet.py
  function is_norm (line 11) | def is_norm(modules):
  function check_norm_state (line 18) | def check_norm_state(modules, train_state):
  class TestCSPDarknetBackbone (line 27) | class TestCSPDarknetBackbone(unittest.TestCase):
    method test_invalid_frozen_stages (line 29) | def test_invalid_frozen_stages(self):
    method test_invalid_out_indices (line 33) | def test_invalid_out_indices(self):
    method test_frozen_stages (line 37) | def test_frozen_stages(self):
    method test_norm_eval (line 53) | def test_norm_eval(self):
    method test_csp_darknet_p5_forward (line 59) | def test_csp_darknet_p5_forward(self):
    method test_csp_darknet_p6_forward (line 73) | def test_csp_darknet_p6_forward(self):
    method test_csp_darknet_custom_arch_forward (line 90) | def test_csp_darknet_custom_arch_forward(self):
    method test_csp_darknet_custom_arch_norm (line 107) | def test_csp_darknet_custom_arch_norm(self):

FILE: tests/test_models/test_backbones/test_dstformer.py
  class TestDSTFormer (line 10) | class TestDSTFormer(TestCase):
    method test_attention_block (line 12) | def test_attention_block(self):
    method test_DSTFormer (line 19) | def test_DSTFormer(self):

FILE: tests/test_models/test_backbones/test_hourglass.py
  class TestHourglass (line 9) | class TestHourglass(TestCase):
    method test_hourglass_backbone (line 11) | def test_hourglass_backbone(self):
    method test_hourglass_ae_backbone (line 50) | def test_hourglass_ae_backbone(self):

FILE: tests/test_models/test_backbones/test_hrformer.py
  class TestHrformer (line 10) | class TestHrformer(TestCase):
    method test_hrformer_module (line 12) | def test_hrformer_module(self):
    method test_hrformer_backbone (line 125) | def test_hrformer_backbone(self):

FILE: tests/test_models/test_backbones/test_hrnet.py
  class TestHrnet (line 12) | class TestHrnet(TestCase):
    method is_block (line 15) | def is_block(modules):
    method is_norm (line 22) | def is_norm(modules):
    method all_zeros (line 29) | def all_zeros(modules):
    method test_hrmodule (line 41) | def test_hrmodule(self):
    method test_hrnet_backbone (line 56) | def test_hrnet_backbone(self):

FILE: tests/test_models/test_backbones/test_litehrnet.py
  class TestLiteHrnet (line 12) | class TestLiteHrnet(TestCase):
    method is_norm (line 15) | def is_norm(modules):
    method all_zeros (line 22) | def all_zeros(modules):
    method test_litehrmodule (line 34) | def test_litehrmodule(self):
    method test_litehrnet_backbone (line 72) | def test_litehrnet_backbone(self):

FILE: tests/test_models/test_backbones/test_mobilenet_v2.py
  class TestMobilenetV2 (line 12) | class TestMobilenetV2(TestCase):
    method is_block (line 15) | def is_block(modules):
    method is_norm (line 22) | def is_norm(modules):
    method check_norm_state (line 29) | def check_norm_state(modules, train_state):
    method test_mobilenetv2_invertedresidual (line 37) | def test_mobilenetv2_invertedresidual(self):
    method test_mobilenetv2_backbone (line 81) | def test_mobilenetv2_backbone(self):

FILE: tests/test_models/test_backbones/test_mobilenet_v3.py
  class TestMobilenetV3 (line 12) | class TestMobilenetV3(TestCase):
    method is_norm (line 15) | def is_norm(modules):
    method check_norm_state (line 22) | def check_norm_state(modules, train_state):
    method test_mobilenetv3_backbone (line 30) | def test_mobilenetv3_backbone(self):

FILE: tests/test_models/test_backbones/test_mspn.py
  class TestMSPN (line 9) | class TestMSPN(TestCase):
    method test_mspn_backbone (line 11) | def test_mspn_backbone(self):

FILE: tests/test_models/test_backbones/test_pvt.py
  class TestPVT (line 11) | class TestPVT(TestCase):
    method test_pvt_block (line 13) | def test_pvt_block(self):
    method test_pvt (line 24) | def test_pvt(self):
    method test_pvtv2 (line 75) | def test_pvtv2(self):

FILE: tests/test_models/test_backbones/test_regnet.py
  class TestRegnet (line 9) | class TestRegnet(TestCase):
    method _test_regnet_backbone (line 38) | def _test_regnet_backbone(self, arch_name, arch, out_channels):
    method test_regnet_backbone (line 66) | def test_regnet_backbone(self):
    method _test_custom_arch (line 72) | def _test_custom_arch(self, arch_name, arch, out_channels):
    method test_custom_arch (line 94) | def test_custom_arch(self):
    method test_exception (line 100) | def test_exception(self):

FILE: tests/test_models/test_backbones/test_resnest.py
  class TestResnest (line 10) | class TestResnest(TestCase):
    method test_bottleneck (line 12) | def test_bottleneck(self):
    method test_resnest (line 30) | def test_resnest(self):

FILE: tests/test_models/test_backbones/test_resnet.py
  class TestResnet (line 14) | class TestResnet(TestCase):
    method is_block (line 17) | def is_block(modules):
    method all_zeros (line 24) | def all_zeros(modules):
    method check_norm_state (line 37) | def check_norm_state(modules, train_state):
    method test_get_expansion (line 45) | def test_get_expansion(self):
    method test_basic_block (line 68) | def test_basic_block(self):
    method test_bottleneck (line 133) | def test_bottleneck(self):
    method test_basicblock_reslayer (line 223) | def test_basicblock_reslayer(self):
    method test_bottleneck_reslayer (line 290) | def test_bottleneck_reslayer(self):
    method test_resnet (line 378) | def test_resnet(self):
    method test_resnet_v1d (line 511) | def test_resnet_v1d(self):
    method test_resnet_half_channel (line 549) | def test_resnet_half_channel(self):

FILE: tests/test_models/test_backbones/test_resnext.py
  class TestResnext (line 10) | class TestResnext(TestCase):
    method test_bottleneck (line 12) | def test_bottleneck(self):
    method test_resnext (line 32) | def test_resnext(self):

FILE: tests/test_models/test_backbones/test_rsn.py
  class TestRSN (line 9) | class TestRSN(TestCase):
    method test_rsn_backbone (line 11) | def test_rsn_backbone(self):

FILE: tests/test_models/test_backbones/test_scnet.py
  class TestSCnet (line 11) | class TestSCnet(TestCase):
    method is_block (line 14) | def is_block(modules):
    method is_norm (line 21) | def is_norm(modules):
    method all_zeros (line 28) | def all_zeros(modules):
    method check_norm_state (line 41) | def check_norm_state(modules, train_state):
    method test_scnet_scconv (line 49) | def test_scnet_scconv(self):
    method test_scnet_bottleneck (line 56) | def test_scnet_bottleneck(self):
    method test_scnet_backbone (line 63) | def test_scnet_backbone(self):

FILE: tests/test_models/test_backbones/test_seresnet.py
  class TestSEResnet (line 13) | class TestSEResnet(TestCase):
    method all_zeros (line 16) | def all_zeros(modules):
    method check_norm_state (line 29) | def check_norm_state(modules, train_state):
    method test_selayer (line 37) | def test_selayer(self):
    method test_bottleneck (line 50) | def test_bottleneck(self):
    method test_res_layer (line 77) | def test_res_layer(self):
    method test_seresnet (line 123) | def test_seresnet(self):

FILE: tests/test_models/test_backbones/test_seresnext.py
  class TestSEResnext (line 10) | class TestSEResnext(TestCase):
    method test_bottleneck (line 12) | def test_bottleneck(self):
    method test_seresnext (line 43) | def test_seresnext(self):

FILE: tests/test_models/test_backbones/test_shufflenet_v1.py
  class TestShufflenetV1 (line 12) | class TestShufflenetV1(TestCase):
    method is_block (line 15) | def is_block(modules):
    method is_norm (line 22) | def is_norm(modules):
    method check_norm_state (line 29) | def check_norm_state(modules, train_state):
    method test_shufflenetv1_shuffleuint (line 37) | def test_shufflenetv1_shuffleuint(self):
    method test_shufflenetv1_backbone (line 69) | def test_shufflenetv1_backbone(self):

FILE: tests/test_models/test_backbones/test_shufflenet_v2.py
  class TestShufflenetV2 (line 12) | class TestShufflenetV2(TestCase):
    method is_block (line 15) | def is_block(modules):
    method is_norm (line 22) | def is_norm(modules):
    method check_norm_state (line 29) | def check_norm_state(modules, train_state):
    method test_shufflenetv2_invertedresidual (line 37) | def test_shufflenetv2_invertedresidual(self):
    method test_shufflenetv2_backbone (line 63) | def test_shufflenetv2_backbone(self):

FILE: tests/test_models/test_backbones/test_swin.py
  class TestSwin (line 9) | class TestSwin(TestCase):
    method test_swin_block (line 11) | def test_swin_block(self):
    method test_swin_transformer (line 29) | def test_swin_transformer(self):

FILE: tests/test_models/test_backbones/test_tcn.py
  class TestTCN (line 12) | class TestTCN(TestCase):
    method test_basic_temporal_block (line 14) | def test_basic_temporal_block(self):
    method test_tcn_backbone (line 60) | def test_tcn_backbone(self):

FILE: tests/test_models/test_backbones/test_v2v_net.py
  class TestV2Vnet (line 9) | class TestV2Vnet(TestCase):
    method test_v2v_net (line 11) | def test_v2v_net(self):

FILE: tests/test_models/test_backbones/test_vgg.py
  class TestVGG (line 10) | class TestVGG(TestCase):
    method check_norm_state (line 13) | def check_norm_state(modules, train_state):
    method test_vgg (line 21) | def test_vgg(self):

FILE: tests/test_models/test_backbones/test_vipnas_mbv3.py
  class TestVipnasMbv3 (line 12) | class TestVipnasMbv3(TestCase):
    method is_norm (line 15) | def is_norm(modules):
    method check_norm_state (line 22) | def check_norm_state(modules, train_state):
    method test_mobilenetv3_backbone (line 30) | def test_mobilenetv3_backbone(self):

FILE: tests/test_models/test_backbones/test_vipnas_resnet.py
  class TestVipnasResnet (line 14) | class TestVipnasResnet(TestCase):
    method is_block (line 17) | def is_block(modules):
    method all_zeros (line 24) | def all_zeros(modules):
    method check_norm_state (line 37) | def check_norm_state(modules, train_state):
    method test_get_expansion (line 45) | def test_get_expansion(self):
    method test_vipnas_bottleneck (line 67) | def test_vipnas_bottleneck(self):
    method test_vipnas_bottleneck_reslayer (line 158) | def test_vipnas_bottleneck_reslayer(self):
    method test_resnet (line 247) | def test_resnet(self):

FILE: tests/test_models/test_data_preprocessors/test_data_preprocessor.py
  class TestPoseDataPreprocessor (line 12) | class TestPoseDataPreprocessor(TestCase):
    method test_init (line 14) | def test_init(self):
    method test_forward (line 34) | def test_forward(self):
    method test_batch_sync_random_resize (line 92) | def test_batch_sync_random_resize(self):

FILE: tests/test_models/test_distillers/test_dwpose_distiller.py
  class TestDWPoseDistiller (line 27) | class TestDWPoseDistiller(TestCase):
    method setUp (line 29) | def setUp(self) -> None:
    method test_init (line 33) | def test_init(self, config):
    method test_forward_loss (line 47) | def test_forward_loss(self, config, devices):
    method test_forward_predict (line 69) | def test_forward_predict(self, config, devices):
    method test_forward_tensor (line 94) | def test_forward_tensor(self, config, devices):

FILE: tests/test_models/test_heads/test_heatmap_heads/test_ae_head.py
  class TestAssociativeEmbeddingHead (line 17) | class TestAssociativeEmbeddingHead(TestCase):
    method _get_tags (line 19) | def _get_tags(self, heatmaps, keypoint_indices, tag_per_keypoint: bool):
    method test_forward (line 38) | def test_forward(self):
    method test_predict (line 53) | def test_predict(self):
    method test_loss (line 98) | def test_loss(self):

FILE: tests/test_models/test_heads/test_heatmap_heads/test_cid_head.py
  class TestCIDHead (line 13) | class TestCIDHead(TestCase):
    method _get_feats (line 15) | def _get_feats(
    method _get_data_samples (line 31) | def _get_data_samples(self):
    method test_forward (line 39) | def test_forward(self):
    method test_predict (line 49) | def test_predict(self):
    method test_loss (line 85) | def test_loss(self):

FILE: tests/test_models/test_heads/test_heatmap_heads/test_cpm_head.py
  class TestCPMHead (line 13) | class TestCPMHead(TestCase):
    method _get_feats (line 15) | def _get_feats(self,
    method _get_data_samples (line 25) | def _get_data_samples(self, batch_size: int = 2):
    method test_init (line 37) | def test_init(self):
    method test_predict (line 97) | def test_predict(self):
    method test_tta (line 148) | def test_tta(self):
    method test_loss (line 178) | def test_loss(self):
    method test_errors (line 219) | def test_errors(self):

FILE: tests/test_models/test_heads/test_heatmap_heads/test_heatmap_head.py
  class TestHeatmapHead (line 14) | class TestHeatmapHead(TestCase):
    method _get_feats (line 16) | def _get_feats(self,
    method test_init (line 26) | def test_init(self):
    method test_predict (line 67) | def test_predict(self):
    method test_tta (line 103) | def test_tta(self):
    method test_loss (line 151) | def test_loss(self):
    method test_errors (line 161) | def test_errors(self):
    method test_state_dict_compatible (line 181) | def test_state_dict_compatible(self):

FILE: tests/test_models/test_heads/test_heatmap_heads/test_mspn_head.py
  class TestMSPNHead (line 13) | class TestMSPNHead(TestCase):
    method _get_feats (line 15) | def _get_feats(
    method _get_data_samples (line 33) | def _get_data_samples(self,
    method test_init (line 50) | def test_init(self):
    method test_loss (line 97) | def test_loss(self):
    method test_predict (line 207) | def test_predict(self):
    method test_tta (line 309) | def test_tta(self):
    method test_errors (line 347) | def test_errors(self):

FILE: tests/test_models/test_heads/test_heatmap_heads/test_rtmcc_head.py
  class TestRTMCCHead (line 17) | class TestRTMCCHead(TestCase):
    method _get_feats (line 19) | def _get_feats(self,
    method test_init (line 29) | def test_init(self):
    method test_predict (line 158) | def test_predict(self):
    method test_tta (line 513) | def test_tta(self):
    method test_loss (line 556) | def test_loss(self):

FILE: tests/test_models/test_heads/test_heatmap_heads/test_simcc_head.py
  class TestSimCCHead (line 13) | class TestSimCCHead(TestCase):
    method _get_feats (line 15) | def _get_feats(self,
    method test_init (line 25) | def test_init(self):
    method test_predict (line 73) | def test_predict(self):
    method test_tta (line 141) | def test_tta(self):
    method test_loss (line 170) | def test_loss(self):
    method test_errors (line 212) | def test_errors(self):

FILE: tests/test_models/test_heads/test_heatmap_heads/test_vipnas_head.py
  class TestViPNASHead (line 13) | class TestViPNASHead(TestCase):
    method _get_feats (line 15) | def _get_feats(self,
    method test_init (line 25) | def test_init(self):
    method test_predict (line 68) | def test_predict(self):
    method test_tta (line 104) | def test_tta(self):
    method test_loss (line 129) | def test_loss(self):
    method test_errors (line 139) | def test_errors(self):
    method test_state_dict_compatible (line 170) | def test_state_dict_compatible(self):

FILE: tests/test_models/test_heads/test_hybrid_heads/test_dekr_head.py
  class TestDEKRHead (line 13) | class TestDEKRHead(TestCase):
    method _get_feats (line 15) | def _get_feats(
    method _get_data_samples (line 31) | def _get_data_samples(self):
    method test_forward (line 39) | def test_forward(self):
    method test_predict (line 49) | def test_predict(self):
    method test_loss (line 101) | def test_loss(self):

FILE: tests/test_models/test_heads/test_hybrid_heads/test_vis_head.py
  class TestVisPredictHead (line 14) | class TestVisPredictHead(TestCase):
    method _get_feats (line 16) | def _get_feats(
    method test_init (line 27) | def test_init(self):
    method test_forward (line 47) | def test_forward(self):
    method test_predict (line 73) | def test_predict(self):
    method test_tta (line 118) | def test_tta(self):
    method test_loss (line 151) | def test_loss(self):

FILE: tests/test_models/test_heads/test_regression_heads/test_dsnt_head.py
  class TestDSNTHead (line 13) | class TestDSNTHead(TestCase):
    method _get_feats (line 15) | def _get_feats(
    method test_init (line 28) | def test_init(self):
    method test_predict (line 111) | def test_predict(self):
    method test_tta (line 153) | def test_tta(self):
    method test_loss (line 180) | def test_loss(self):

FILE: tests/test_models/test_heads/test_regression_heads/test_integral_regression_head.py
  class TestIntegralRegressionHead (line 13) | class TestIntegralRegressionHead(TestCase):
    method _get_feats (line 15) | def _get_feats(
    method test_init (line 28) | def test_init(self):
    method test_predict (line 107) | def test_predict(self):
    method test_tta (line 145) | def test_tta(self):
    method test_loss (line 171) | def test_loss(self):

FILE: tests/test_models/test_heads/test_regression_heads/test_regression_head.py
  class TestRegressionHead (line 13) | class TestRegressionHead(TestCase):
    method _get_feats (line 15) | def _get_feats(
    method test_init (line 28) | def test_init(self):
    method test_predict (line 42) | def test_predict(self):
    method test_tta (line 61) | def test_tta(self):
    method test_loss (line 83) | def test_loss(self):

FILE: tests/test_models/test_heads/test_regression_heads/test_rle_head.py
  class TestRLEHead (line 13) | class TestRLEHead(TestCase):
    method _get_feats (line 15) | def _get_feats(
    method test_init (line 28) | def test_init(self):
    method test_predict (line 43) | def test_predict(self):
    method test_tta (line 62) | def test_tta(self):
    method test_loss (line 83) | def test_loss(self):
    method test_state_dict_compatible (line 98) | def test_state_dict_compatible(self):

FILE: tests/test_models/test_losses/test_ae_loss.py
  class AELoss (line 16) | class AELoss(nn.Module):
    method __init__ (line 19) | def __init__(self, loss_type):
    method _make_input (line 24) | def _make_input(t, requires_grad=False, device=torch.device('cpu')):
    method singleTagLoss (line 40) | def singleTagLoss(self, pred_tag, joints):
    method forward (line 100) | def forward(self, tags, keypoint_indices):
  class TestAssociativeEmbeddingLoss (line 115) | class TestAssociativeEmbeddingLoss(TestCase):
    method _make_input (line 117) | def _make_input(self, num_instance: int) -> Tuple[Tensor, Tensor]:
    method _get_tags (line 136) | def _get_tags(self,
    method test_loss (line 162) | def test_loss(self):

FILE: tests/test_models/test_losses/test_classification_losses.py
  class TestInfoNCELoss (line 9) | class TestInfoNCELoss(TestCase):
    method test_loss (line 11) | def test_loss(self):
  class TestVariFocalLoss (line 25) | class TestVariFocalLoss(TestCase):
    method test_forward_no_target_weight_mean_reduction (line 27) | def test_forward_no_target_weight_mean_reduction(self):
    method test_forward_with_target_weight_sum_reduction (line 39) | def test_forward_with_target_weight_sum_reduction(self):
    method test_inf_nan_handling (line 52) | def test_inf_nan_handling(self):

FILE: tests/test_models/test_losses/test_heatmap_losses.py
  class TestAdaptiveWingLoss (line 11) | class TestAdaptiveWingLoss(TestCase):
    method test_loss (line 13) | def test_loss(self):
  class TestFocalHeatmapLoss (line 40) | class TestFocalHeatmapLoss(TestCase):
    method test_loss (line 42) | def test_loss(self):
  class TestKeypointMSELoss (line 69) | class TestKeypointMSELoss(TestCase):
    method test_loss (line 71) | def test_loss(self):
  class TestMLECCLoss (line 122) | class TestMLECCLoss(TestCase):
    method setUp (line 124) | def setUp(self):
    method test_mean_reduction_log_mode (line 128) | def test_mean_reduction_log_mode(self):
    method test_sum_reduction_linear_mode (line 133) | def test_sum_reduction_linear_mode(self):
    method test_none_reduction_square_mode (line 138) | def test_none_reduction_square_mode(self):
    method test_target_weight (line 143) | def test_target_weight(self):
    method test_invalid_reduction (line 149) | def test_invalid_reduction(self):
    method test_invalid_mode (line 153) | def test_invalid_mode(self):

FILE: tests/test_models/test_losses/test_regression_losses.py
  class TestSoftWeightSmoothL1Loss (line 9) | class TestSoftWeightSmoothL1Loss(TestCase):
    method test_loss (line 11) | def test_loss(self):

FILE: tests/test_models/test_necks/test_fmap_proc_neck.py
  class TestFeatureMapProcessor (line 10) | class TestFeatureMapProcessor(TestCase):
    method _get_feats (line 12) | def _get_feats(
    method test_init (line 25) | def test_init(self):
    method test_call (line 33) | def test_call(self):

FILE: tests/test_models/test_necks/test_yolox_pafpn.py
  class TestYOLOXPAFPN (line 9) | class TestYOLOXPAFPN(TestCase):
    method test_forward (line 11) | def test_forward(self):

FILE: tests/test_models/test_pose_estimators/test_bottomup.py
  class TestTopdownPoseEstimator (line 19) | class TestTopdownPoseEstimator(TestCase):
    method setUp (line 21) | def setUp(self) -> None:
    method test_init (line 25) | def test_init(self, config):
    method test_forward_tensor (line 37) | def test_forward_tensor(self, config, devices):

FILE: tests/test_models/test_pose_estimators/test_topdown.py
  class TestTopdownPoseEstimator (line 24) | class TestTopdownPoseEstimator(TestCase):
    method setUp (line 26) | def setUp(self) -> None:
    method test_init (line 30) | def test_init(self, config):
    method test_forward_loss (line 42) | def test_forward_loss(self, config, devices):
    method test_forward_predict (line 62) | def test_forward_predict(self, config, devices):
    method test_forward_tensor (line 85) | def test_forward_tensor(self, config, devices):

FILE: tests/test_models/test_utils/test_check_and_update_config.py
  class TestCheckAndUpdateConfig (line 7) | class TestCheckAndUpdateConfig(unittest.TestCase):
    method test_case_1 (line 9) | def test_case_1(self):
    method test_case_2 (line 38) | def test_case_2(self):
    method test_case_3 (line 66) | def test_case_3(self):
    method test_case_4 (line 89) | def test_case_4(self):

FILE: tests/test_models/test_utils/test_transformers.py
  class TestSinePositionalEncoding (line 9) | class TestSinePositionalEncoding(TestCase):
    method test_init (line 11) | def test_init(self):
    method test_generate_speoding (line 31) | def test_generate_speoding(self):
    method test_apply_additional_pos_enc (line 63) | def test_apply_additional_pos_enc(self):
    method test_apply_rotary_pos_enc (line 81) | def test_apply_rotary_pos_enc(self):
  class TestGAUEncoder (line 100) | class TestGAUEncoder(TestCase):
    method test_init (line 102) | def test_init(self):
    method test_forward (line 109) | def test_forward(self):

FILE: tests/test_structures/test_bbox/test_bbox_overlaps.py
  class TestBBoxOverlaps (line 9) | class TestBBoxOverlaps(TestCase):
    method test_bbox_overlaps_iou (line 11) | def test_bbox_overlaps_iou(self):
    method test_bbox_overlaps_iof (line 33) | def test_bbox_overlaps_iof(self):
    method test_bbox_overlaps_giou (line 55) | def test_bbox_overlaps_giou(self):

FILE: tests/test_structures/test_bbox/test_bbox_transforms.py
  class TestBBoxClipBorder (line 11) | class TestBBoxClipBorder(TestCase):
    method test_bbox_clip_border_2D (line 13) | def test_bbox_clip_border_2D(self):
    method test_bbox_clip_border_4D (line 22) | def test_bbox_clip_border_4D(self):
  class TestBBoxXYXY2Corner (line 38) | class TestBBoxXYXY2Corner(TestCase):
    method test_bbox_xyxy2corner_single (line 40) | def test_bbox_xyxy2corner_single(self):
    method test_bbox_xyxy2corner_multiple (line 48) | def test_bbox_xyxy2corner_multiple(self):
  class TestBBoxCorner2XYXY (line 59) | class TestBBoxCorner2XYXY(TestCase):
    method test_bbox_corner2xyxy_single (line 61) | def test_bbox_corner2xyxy_single(self):
    method test_bbox_corner2xyxy_multiple (line 69) | def test_bbox_corner2xyxy_multiple(self):
  class TestGetPersWarpMatrix (line 79) | class TestGetPersWarpMatrix(TestCase):
    method test_get_pers_warp_matrix_identity (line 81) | def test_get_pers_warp_matrix_identity(self):
    method test_get_pers_warp_matrix_translation (line 95) | def test_get_pers_warp_matrix_translation(self):
    method test_get_pers_warp_matrix_scale_rotation_shear (line 109) | def test_get_pers_warp_matrix_scale_rotation_shear(self):
  class TestGetWarpMatrix (line 130) | class TestGetWarpMatrix(TestCase):
    method test_basic_transformation (line 132) | def test_basic_transformation(self):
    method test_rotation (line 142) | def test_rotation(self):
    method test_shift (line 153) | def test_shift(self):
    method test_inverse (line 165) | def test_inverse(self):
    method test_aspect_ratio (line 176) | def test_aspect_ratio(self):

FILE: tests/test_structures/test_keypoint/test_keypoint_transforms.py
  class TestKeypointClipBorder (line 9) | class TestKeypointClipBorder(TestCase):
    method test_keypoint_clip_border (line 11) | def test_keypoint_clip_border(self):

FILE: tests/test_structures/test_multilevel_pixel_data.py
  class TestMultilevelPixelData (line 11) | class TestMultilevelPixelData(TestCase):
    method get_multi_level_pixel_data (line 13) | def get_multi_level_pixel_data(self):
    method test_init (line 23) | def test_init(self):
    method test_setter (line 31) | def test_setter(self):
    method test_deleter (line 65) | def test_deleter(self):

FILE: tests/test_structures/test_pose_data_sample.py
  class TestPoseDataSample (line 11) | class TestPoseDataSample(TestCase):
    method get_pose_data_sample (line 13) | def get_pose_data_sample(self, multilevel: bool = False):
    method _equal (line 58) | def _equal(x, y):
    method test_init (line 68) | def test_init(self):
    method test_setter (line 74) | def test_setter(self):
    method test_deleter (line 114) | def test_deleter(self):

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

FILE: tests/test_visualization/test_fast_visualizer.py
  class TestFastVisualizer (line 9) | class TestFastVisualizer(TestCase):
    method setUp (line 11) | def setUp(self):
    method test_init (line 30) | def test_init(self):
    method test_draw_pose (line 45) | def test_draw_pose(self):
    method test_draw_pose_with_none_instances (line 64) | def test_draw_pose_with_none_instances(self):

FILE: tests/test_visualization/test_pose_visualizer.py
  class TestPoseLocalVisualizer (line 14) | class TestPoseLocalVisualizer(TestCase):
    method setUp (line 16) | def setUp(self):
    method _get_dataset_meta (line 19) | def _get_dataset_meta(self):
    method test_set_dataset_meta (line 30) | def test_set_dataset_meta(self):
    method test_add_datasample (line 41) | def test_add_datasample(self):
    method test_simcc_visualization (line 100) | def test_simcc_visualization(self):
    method _assert_image_and_shape (line 107) | def _assert_image_and_shape(self, out_file, out_shape):

FILE: tools/analysis_tools/analyze_logs.py
  function cal_train_time (line 11) | def cal_train_time(log_dicts, args):
  function plot_curve (line 34) | def plot_curve(log_dicts, args):
  function add_plot_parser (line 76) | def add_plot_parser(subparsers):
  function add_time_parser (line 104) | def add_time_parser(subparsers):
  function parse_args (line 120) | def parse_args():
  function load_json_logs (line 130) | def load_json_logs(json_logs):
  function main (line 150) | def main():

FILE: tools/analysis_tools/get_flops.py
  function parse_args (line 18) | def parse_args():
  function batch_constructor (line 55) | def batch_constructor(flops_model, batch_size, input_shape):
  function inference (line 68) | def inference(args, input_shape, logger):
  function main (line 111) | def main():

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

FILE: tools/dataset_converters/300vw2coco.py
  function extract_frames (line 14) | def extract_frames(video_path):
  class Base300VW (line 40) | class Base300VW:
    method __init__ (line 42) | def __init__(self):
  class Preprocess300VW (line 91) | class Preprocess300VW(Base300VW):
    method __init__ (line 93) | def __init__(self, dataset_root):
    method _init_json_data (line 99) | def _init_json_data(self):
    method _extract_frames (line 110) | def _extract_frames(self):
    method _extract_keypoints_from_pts (line 116) | def _extract_keypoints_from_pts(self, file_path):
    method _get_video_list (line 134) | def _get_video_list(self, video_list):
    method _process_image (line 148) | def _process_image(self, img_path):
    method _process_annotation (line 159) | def _process_annotation(self, annot_path, image_id, anno_id):
    method _calculate_annotation_properties (line 180) | def _calculate_annotation_properties(self, annotation, keypoints):
    method convert_annotations (line 200) | def convert_annotations(self,
    method _save_json_data (line 246) | def _save_json_data(self, json_save_name):

FILE: tools/dataset_converters/300wlp2coco.py
  function move_img (line 14) | def move_img(img_path, save_img):
  function split_data (line 31) | def split_data(file_img,
  function default_dump (line 56) | def default_dump(obj):
  function convert_300WLP_to_coco (line 66) | def convert_300WLP_to_coco(root_path, img_pathDir, out_file):

FILE: tools/dataset_converters/h36m_to_coco.py
  function _keypoint_camera_to_world (line 13) | def _keypoint_camera_to_world(keypoints,
  function _get_bbox_xywh (line 41) | def _get_bbox_xywh(center, scale, w=200, h=200):
  function mmcv_track_func (line 49) | def mmcv_track_func(func):
  function _get_img_info (line 59) | def _get_img_info(img_idx, img_name, img_root):
  function _get_ann (line 76) | def _get_ann(idx, kpt_2d, kpt_3d, center, scale, imgname, camera_params):
  function main (line 95) | def main():

FILE: tools/dataset_converters/labelstudio2coco.py
  function parse_args (line 19) | def parse_args():
  class LSConverter (line 29) | class LSConverter:
    method __init__ (line 31) | def __init__(self, config: str):
    method convert_to_coco (line 77) | def convert_to_coco(self, input_json: str, output_json: str):
  function main (line 239) | def main():

FILE: tools/dataset_converters/lapa2coco.py
  function default_dump (line 12) | def default_dump(obj):
  function convert_labpa_to_coco (line 22) | def convert_labpa_to_coco(ann_dir, out_file):

FILE: tools/dataset_converters/mat2json.py
  function parse_args (line 9) | def parse_args():
  function save_json (line 22) | def save_json(list_file, path):
  function convert_mat (line 28) | def convert_mat(pred_mat_file, gt_json_file, output_json_file):
  function main (line 54) | def main():

FILE: tools/dataset_converters/parse_animalpose_dataset.py
  function list_all_files (line 16) | def list_all_files(root_dir, ext='.xml'):
  function get_anno_info (line 35) | def get_anno_info():
  function xml2coco_trainval (line 73) | def xml2coco_trainval(file_list, img_root, save_path, start_ann_id=0):
  function xml2coco_test (line 195) | def xml2coco_test(file_list, img_root, save_path, start_ann_id=0):
  function split_train_val (line 323) | def split_train_val(work_dir, trainval_file, train_file, val_file,

FILE: tools/dataset_converters/parse_deepposekit_dataset.py
  function save_coco_anno (line 13) | def save_coco_anno(keypoints_all,

FILE: tools/dataset_converters/parse_macaquepose_dataset.py
  function get_poly_area (line 13) | def get_poly_area(x, y):
  function get_seg_area (line 24) | def get_seg_area(segmentations):
  function save_coco_anno (line 31) | def save_coco_anno(data_annotation,

FILE: tools/dataset_converters/preprocess_h36m.py
  class PreprocessH36m (line 18) | class PreprocessH36m:
    method __init__ (line 33) | def __init__(self,
    method extract_tgz (line 92) | def extract_tgz(self):
    method generate_cameras_file (line 104) | def generate_cameras_file(self):
    method generate_annotations (line 118) | def generate_annotations(self):
    method _get_pose_stats (line 205) | def _get_pose_stats(kps):
    method _load_metadata (line 221) | def _load_metadata(self):
    method _get_base_filename (line 250) | def _get_base_filename(self, subject, action, subaction, camera):
    method _get_camera_params (line 255) | def _get_camera_params(self, camera, subject):
    method _load_annotations (line 299) | def _load_annotations(self, subject, action, subaction, camera):
  function parse_args (line 374) | def parse_args():

FILE: tools/dataset_converters/preprocess_mpi_inf_3dhp.py
  function get_pose_stats (line 42) | def get_pose_stats(kps):
  function get_annotations (line 59) | def get_annotations(joints_2d, joints_3d, scale_factor=1.2):
  function load_trainset (line 99) | def load_trainset(data_root, out_dir):
  function load_testset (line 249) | def load_testset(data_root, out_dir, valid_only=True):

FILE: tools/dataset_converters/ubody_kpts_to_coco.py
  function findAllFile (line 12) | def findAllFile(base):
  function convert (line 21) | def convert(video_path: str):
  function split_dataset (line 34) | def split_dataset(annotation_path: str, split_path: str):

FILE: tools/dataset_converters/ubody_smplx_to_coco.py
  class SMPLX (line 16) | class SMPLX(object):
    method __init__ (line 18) | def __init__(self, human_model_path):
  function read_annotation_file (line 203) | def read_annotation_file(annotation_file: str) -> List[Dict]:
  function cam2pixel (line 209) | def cam2pixel(cam_coord, f, c):
  function process_scene_anno (line 216) | def process_scene_anno(scene: str, annotation_root: str, splits: np.array,

FILE: tools/dataset_converters/wflw2coco.py
  function default_dump (line 11) | def default_dump(obj):
  function convert_wflw_to_coco (line 21) | def convert_wflw_to_coco(ann_file, out_file):

FILE: tools/misc/browse_dataset.py
  function parse_args (line 19) | def parse_args():
  function generate_dup_file_name (line 68) | def generate_dup_file_name(out_file):
  function main (line 84) | def main():

FILE: tools/misc/generate_bbox_file.py
  function main (line 21) | def main():

FILE: tools/misc/keypoints2coco_without_mmdet.py
  function main (line 13) | def main():

FILE: tools/misc/pth_transfer.py
  function change_model (line 8) | def change_model(args):

FILE: tools/misc/publish_model.py
  function parse_args (line 12) | def parse_args():
  function process_checkpoint (line 27) | def process_checkpoint(in_file, out_file, save_keys=['meta', 'state_dict...
  function main (line 59) | def main():

FILE: tools/test.py
  function parse_args (line 12) | def parse_args():
  function merge_args (line 68) | def merge_args(cfg, args):
  function main (line 141) | def main():

FILE: tools/torchserve/mmpose2torchserve.py
  function mmpose2torchserve (line 18) | def mmpose2torchserve(config_file: str,
  function parse_args (line 83) | def parse_args():

FILE: tools/torchserve/mmpose_handler.py
  class MMPoseHandler (line 18) | class MMPoseHandler(BaseHandler):
    method initialize (line 20) | def initialize(self, context):
    method preprocess (line 36) | def preprocess(self, data):
    method inference (line 48) | def inference(self, data, *args, **kwargs):
    method _inference_top_down_pose_model (line 59) | def _inference_top_down_pose_model(self, data):
    method _inference_bottom_up_pose_model (line 68) | def _inference_bottom_up_pose_model(self, data):
    method postprocess (line 75) | def postprocess(self, data):

FILE: tools/torchserve/test_torchserver.py
  function parse_args (line 15) | def parse_args():
  function main (line 33) | def main(args):

FILE: tools/train.py
  function parse_args (line 10) | def parse_args():
  function merge_args (line 79) | def merge_args(cfg, args):
  function main (line 140) | def main():