|
|
| import os.path as osp
|
|
|
| import mmengine
|
| import numpy as np
|
| import torch
|
| from mmengine.utils.dl_utils.parrots_wrapper import _BatchNorm
|
|
|
|
|
| def check_norm_state(modules, train_state):
|
| """Check if norm layer is in correct train state."""
|
| for mod in modules:
|
| if isinstance(mod, _BatchNorm):
|
| if mod.training != train_state:
|
| return False
|
| return True
|
|
|
|
|
| def generate_backbone_demo_inputs(input_shape=(1, 3, 64, 64)):
|
| """Create a superset of inputs needed to run backbone.
|
|
|
| Args:
|
| input_shape (tuple): input batch dimensions.
|
| Defaults to ``(1, 3, 64, 64)``.
|
| """
|
| imgs = np.random.random(input_shape)
|
| imgs = torch.FloatTensor(imgs)
|
|
|
| return imgs
|
|
|
|
|
|
|
| def generate_recognizer_demo_inputs(
|
| input_shape=(1, 3, 3, 224, 224), model_type='2D'):
|
| """Create a superset of inputs needed to run test or train batches.
|
|
|
| Args:
|
| input_shape (tuple): input batch dimensions.
|
| Default: (1, 250, 3, 224, 224).
|
| model_type (str): Model type for data generation, from {'2D', '3D'}.
|
| Default:'2D'
|
| """
|
| if len(input_shape) == 5:
|
| (N, L, _, _, _) = input_shape
|
| elif len(input_shape) == 6:
|
| (N, M, _, L, _, _) = input_shape
|
|
|
| imgs = np.random.random(input_shape)
|
|
|
| if model_type == '2D' or model_type == 'skeleton':
|
| gt_labels = torch.LongTensor([2] * N)
|
| elif model_type == '3D':
|
| gt_labels = torch.LongTensor([2] * M)
|
| elif model_type == 'audio':
|
| gt_labels = torch.LongTensor([2] * L)
|
| else:
|
| raise ValueError(f'Data type {model_type} is not available')
|
|
|
| inputs = {'imgs': torch.FloatTensor(imgs), 'gt_labels': gt_labels}
|
| return inputs
|
|
|
|
|
| def generate_detector_demo_inputs(
|
| input_shape=(1, 3, 4, 224, 224), num_classes=81, train=True,
|
| device='cpu'):
|
| num_samples = input_shape[0]
|
| if not train:
|
| assert num_samples == 1
|
|
|
| def random_box(n):
|
| box = torch.rand(n, 4) * 0.5
|
| box[:, 2:] += 0.5
|
| box[:, 0::2] *= input_shape[3]
|
| box[:, 1::2] *= input_shape[4]
|
| if device == 'cuda':
|
| box = box.cuda()
|
| return box
|
|
|
| def random_label(n):
|
| label = torch.randn(n, num_classes)
|
| label = (label > 0.8).type(torch.float32)
|
| label[:, 0] = 0
|
| if device == 'cuda':
|
| label = label.cuda()
|
| return label
|
|
|
| img = torch.FloatTensor(np.random.random(input_shape))
|
| if device == 'cuda':
|
| img = img.cuda()
|
|
|
| proposals = [random_box(2) for i in range(num_samples)]
|
| gt_bboxes = [random_box(2) for i in range(num_samples)]
|
| gt_labels = [random_label(2) for i in range(num_samples)]
|
| img_metas = [dict(img_shape=input_shape[-2:]) for i in range(num_samples)]
|
|
|
| if train:
|
| return dict(
|
| img=img,
|
| proposals=proposals,
|
| gt_bboxes=gt_bboxes,
|
| gt_labels=gt_labels,
|
| img_metas=img_metas)
|
|
|
| return dict(img=[img], proposals=[proposals], img_metas=[img_metas])
|
|
|
|
|
| def get_cfg(config_type, fname):
|
| """Grab configs necessary to create a recognizer.
|
|
|
| These are deep copied to allow for safe modification of parameters without
|
| influencing other tests.
|
| """
|
| config_types = ('recognition', 'recognition_audio', 'localization',
|
| 'detection', 'skeleton', 'retrieval')
|
| assert config_type in config_types
|
|
|
| repo_dpath = osp.dirname(osp.dirname(osp.dirname(__file__)))
|
| config_dpath = osp.join(repo_dpath, 'configs/' + config_type)
|
| config_fpath = osp.join(config_dpath, fname)
|
| if not osp.exists(config_dpath):
|
| raise Exception('Cannot find config path')
|
| config = mmengine.Config.fromfile(config_fpath)
|
| return config
|
|
|
|
|
| def get_recognizer_cfg(fname):
|
| return get_cfg('recognition', fname)
|
|
|
|
|
| def get_audio_recognizer_cfg(fname):
|
| return get_cfg('recognition_audio', fname)
|
|
|
|
|
| def get_localizer_cfg(fname):
|
| return get_cfg('localization', fname)
|
|
|
|
|
| def get_detector_cfg(fname):
|
| return get_cfg('detection', fname)
|
|
|
|
|
| def get_skeletongcn_cfg(fname):
|
| return get_cfg('skeleton', fname)
|
|
|
|
|
| def get_similarity_cfg(fname):
|
| return get_cfg('retrieval', fname)
|
|
|
