def main(args):
# load config
cfg = mmcv.Config.fromfile(args.config)
if args.update_config is not None:
cfg.merge_from_dict(args.update_config)
cfg = update_config(cfg, args)
cfg = propagate_root_dir(cfg, args.data_dir)
if cfg.get('seed'):
print(f'Set random seed to {cfg.seed}')
set_random_seed(cfg.seed)
# build the dataset
dataset = build_dataset(cfg.data, 'test', dict(test_mode=True))
print(f'Test datasets:\n{str(dataset)}')
# build the dataloader
data_loader = build_dataloader(
dataset,
videos_per_gpu=20,
workers_per_gpu=cfg.data.workers_per_gpu,
dist=False,
shuffle=False
)
# collect results
mean_data, std_data = collect_stat(data_loader)
# filter data
mean_data, std_data = filter_stat(mean_data, std_data, min_value=1.0)
# dump stat
dump_stat(mean_data, std_data, args.out)
def main(args):
cfg = mmcv.Config.fromfile(args.config)
if args.update_config is not None:
cfg.merge_from_dict(args.update_config)
cfg.data.videos_per_gpu = 1
if cfg.get('seed'):
print(f'Set random seed to {cfg.seed}')
set_random_seed(cfg.seed)
class_maps = None
if cfg.get('classes'):
class_maps = {0: {k: v for k, v in enumerate(sorted(cfg.classes))}}
model = build_recognizer(cfg.model,
train_cfg=None,
test_cfg=cfg.test_cfg,
class_maps=class_maps)
model.eval()
load_checkpoint(model, args.checkpoint, force_matching=True)
if hasattr(model, 'forward_inference'):
model.forward = model.forward_inference
input_time_size = cfg.input_clip_length
input_image_size = (tuple(cfg.input_img_size) if isinstance(
cfg.input_img_size, (list, tuple)) else
(cfg.input_img_size, cfg.input_img_size))
input_size = (3, input_time_size) + input_image_size
onnx_model_path = join(args.output_dir,
splitext(basename(args.config))[0] + '.onnx')
base_output_dir = dirname(onnx_model_path)
if not exists(base_output_dir):
makedirs(base_output_dir)
convert_to_onnx(model,
input_size,
onnx_model_path,
opset=args.opset,
check=True)
if args.target == 'openvino':
input_shape = (1, ) + input_size
export_to_openvino(cfg, onnx_model_path, args.output_dir, input_shape,
args.input_format)
meta = {'model_classes': model.CLASSES[0]}
with open(args.meta_info, 'w') as output_meta_stream:
json.dump(meta, output_meta_stream)
def test_set_random_seed():
set_random_seed(0)
a_random = random.randint(0, 10)
a_np_random = np.random.rand(2, 2)
a_torch_random = torch.rand(2, 2)
assert torch.backends.cudnn.deterministic is False
assert torch.backends.cudnn.benchmark is False
assert os.environ['PYTHONHASHSEED'] == str(0)
set_random_seed(0, True)
b_random = random.randint(0, 10)
b_np_random = np.random.rand(2, 2)
b_torch_random = torch.rand(2, 2)
assert torch.backends.cudnn.deterministic is True
assert torch.backends.cudnn.benchmark is False
assert a_random == b_random
assert np.equal(a_np_random, b_np_random).all()
assert torch.equal(a_torch_random, b_torch_random)
def main():
args = parse_args()
cfg = Config.fromfile(args.config)
if args.options is not None:
cfg.merge_from_dict(args.options)
# set cudnn_benchmark
if cfg.get('cudnn_benchmark', False):
torch.backends.cudnn.benchmark = True
# work_dir is determined in this priority: CLI > segment in file > filename
if args.work_dir is not None:
# update configs according to CLI args if args.work_dir is not None
cfg.work_dir = args.work_dir
elif cfg.get('work_dir', None) is None:
# use config filename as default work_dir if cfg.work_dir is None
cfg.work_dir = osp.join('./work_dirs',
osp.splitext(osp.basename(args.config))[0])
if args.resume_from is not None:
cfg.resume_from = args.resume_from
if args.gpu_ids is not None:
cfg.gpu_ids = args.gpu_ids
else:
cfg.gpu_ids = range(1) if args.gpus is None else range(args.gpus)
if args.autoscale_lr:
# apply the linear scaling rule (https://arxiv.org/abs/1706.02677)
cfg.optimizer['lr'] = cfg.optimizer['lr'] * len(cfg.gpu_ids) / 8
# init distributed env first, since logger depends on the dist info.
if args.launcher == 'none':
distributed = False
else:
distributed = True
init_dist(args.launcher, **cfg.dist_params)
# create work_dir
mmcv.mkdir_or_exist(osp.abspath(cfg.work_dir))
# init the logger before other steps
timestamp = time.strftime('%Y%m%d_%H%M%S', time.localtime())
log_file = osp.join(cfg.work_dir, f'{timestamp}.log')
logger = get_root_logger(log_file=log_file, log_level=cfg.log_level)
# init the meta dict to record some important information such as
# environment info and seed, which will be logged
meta = dict()
# log env info
env_info_dict = collect_env()
env_info = '\n'.join([(f'{k}: {v}') for k, v in env_info_dict.items()])
dash_line = '-' * 60 + '\n'
logger.info('Environment info:\n' + dash_line + env_info + '\n' +
dash_line)
meta['env_info'] = env_info
# log some basic info
logger.info(f'Distributed training: {distributed}')
logger.info(f'Config:\n{cfg.pretty_text}')
# set random seeds
if args.seed is not None:
logger.info(f'Set random seed to {args.seed}, '
f'deterministic: {args.deterministic}')
set_random_seed(args.seed, deterministic=args.deterministic)
cfg.seed = args.seed
meta['seed'] = args.seed
model = build_posenet(cfg.model)
datasets = [build_dataset(cfg.data.train)]
if len(cfg.workflow) == 2:
val_dataset = copy.deepcopy(cfg.data.val)
val_dataset.pipeline = cfg.data.train.pipeline
datasets.append(build_dataset(val_dataset))
if cfg.checkpoint_config is not None:
# save mmpose version, config file content
# checkpoints as meta data
cfg.checkpoint_config.meta = dict(
mmpose_version=__version__ + get_git_hash(digits=7),
config=cfg.pretty_text,
)
train_model(
model,
datasets,
cfg,
distributed=distributed,
validate=(not args.no_validate),
timestamp=timestamp,
meta=meta)
def main():
args = parse_args()
cfg = Config.fromfile(args.config)
cfg.merge_from_dict(args.cfg_options)
# set cudnn_benchmark
if cfg.get('cudnn_benchmark', False):
torch.backends.cudnn.benchmark = True
# work_dir is determined in this priority:
# CLI > config file > default (base filename)
if args.work_dir is not None:
# update configs according to CLI args if args.work_dir is not None
cfg.work_dir = args.work_dir
elif cfg.get('work_dir', None) is None:
# use config filename as default work_dir if cfg.work_dir is None
cfg.work_dir = osp.join('./work_dirs',
osp.splitext(osp.basename(args.config))[0])
if args.resume_from is not None:
cfg.resume_from = args.resume_from
if args.gpu_ids is not None:
cfg.gpu_ids = args.gpu_ids
else:
cfg.gpu_ids = range(1) if args.gpus is None else range(args.gpus)
# init distributed env first, since logger depends on the dist info.
if args.launcher == 'none':
distributed = False
else:
distributed = True
init_dist(args.launcher, **cfg.dist_params)
# The flag is used to determine whether it is omnisource training
cfg.setdefault('omnisource', False)
# The flag is used to register module's hooks
cfg.setdefault('module_hooks', [])
# create work_dir
mmcv.mkdir_or_exist(osp.abspath(cfg.work_dir))
# dump config
cfg.dump(osp.join(cfg.work_dir, osp.basename(args.config)))
# init logger before other steps
timestamp = time.strftime('%Y%m%d_%H%M%S', time.localtime())
log_file = osp.join(cfg.work_dir, f'{timestamp}.log')
logger = get_root_logger(log_file=log_file, log_level=cfg.log_level)
# init the meta dict to record some important information such as
# environment info and seed, which will be logged
meta = dict()
# log env info
env_info_dict = collect_env()
env_info = '\n'.join([f'{k}: {v}' for k, v in env_info_dict.items()])
dash_line = '-' * 60 + '\n'
logger.info('Environment info:\n' + dash_line + env_info + '\n' +
dash_line)
meta['env_info'] = env_info
# log some basic info
logger.info(f'Distributed training: {distributed}')
logger.info(f'Config: {cfg.text}')
# set random seeds
if args.seed is not None:
logger.info(f'Set random seed to {args.seed}, '
f'deterministic: {args.deterministic}')
set_random_seed(args.seed, deterministic=args.deterministic)
cfg.seed = args.seed
meta['seed'] = args.seed
meta['config_name'] = osp.basename(args.config)
meta['work_dir'] = osp.basename(cfg.work_dir.rstrip('/\\'))
model = build_model(cfg.model,
train_cfg=cfg.get('train_cfg'),
test_cfg=cfg.get('test_cfg'))
register_module_hooks(model.backbone, cfg.module_hooks)
if cfg.omnisource:
# If omnisource flag is set, cfg.data.train should be a list
assert type(cfg.data.train) is list
datasets = [build_dataset(dataset) for dataset in cfg.data.train]
else:
datasets = [build_dataset(cfg.data.train)]
if len(cfg.workflow) == 2:
# For simplicity, omnisource is not compatiable with val workflow,
# we recommend you to use `--validate`
assert not cfg.omnisource
if args.validate:
warnings.warn('val workflow is duplicated with `--validate`, '
'it is recommended to use `--validate`. see '
'https://github.com/open-mmlab/mmaction2/pull/123')
val_dataset = copy.deepcopy(cfg.data.val)
datasets.append(build_dataset(val_dataset))
if cfg.checkpoint_config is not None:
# save mmaction version, config file content and class names in
# checkpoints as meta data
cfg.checkpoint_config.meta = dict(mmaction_version=__version__ +
get_git_hash(digits=7),
config=cfg.text)
train_model(model,
datasets,
cfg,
distributed=distributed,
validate=args.validate,
timestamp=timestamp,
meta=meta)
def change_config(config_path):
cfg = Config.fromfile(config_path)
# print(cfg.pretty_text)
#set model parameters
cfg.model.generator.num_blocks = args.num_blocks
cfg.model.pixel_loss.type = args.loss
# Training folders
cfg.data.train.dataset.lq_folder = './data/Mini-DIV2K/Train/LR_x4/'
cfg.data.train.dataset.gt_folder = './data/Mini-DIV2K/Train/HR/'
cfg.data.train.dataset.ann_file = './data/training_ann.txt'
# Validation folders
cfg.data.val.lq_folder = './data/Mini-DIV2K/Val/LR_x4/'
cfg.data.val.gt_folder = './data/Mini-DIV2K/Val/HR/'
# TEST folders #which folder is used for calculating metrics?
cfg.data.test.lq_folder = './data/test/'
cfg.data.test.gt_folder = './data/fake/'
#Resume from checkpoint
if args.resume or args.inference:
cfg.resume_from = args.work_dir + args.checkpoint
else:
cfg.resume_from = None
# Set up working dir to save files and logs
cfg.work_dir = args.work_dir
# Use smaller batch size for training
cfg.data.samples_per_gpu = args.bs #DEFAULT 16 takes 1hr/1k iter
cfg.data.workers_per_gpu = args.worker
cfg.data.val_workers_per_gpu = args.worker
# Reduce the number of iterations
cfg.total_iters = args.iter
# Training scheme change to step
if args.lr_step:
cfg.lr_config = {}
cfg.lr_config.policy = 'Step'
cfg.lr_config.by_epoch = False
cfg.lr_config.step = [args.iter / 2]
cfg.lr_config.gamma = 0.5
else:
#update lr cosinestart schedule
period = 300000
cfg.lr_config.periods = [period, period, period, period]
cfg.lr_config.restart_weights = [0.1, 0.1, 0.1, 0.1]
cfg.lr_config.min_lr = 1e-06
# Evaluate every 1000 iterations
cfg.evaluation.interval = args.log_eva_interval
if cfg.evaluation.get('gpu_collect', None):
cfg.evaluation.pop('gpu_collect')
# Save the checkpoints every N iterations
cfg.checkpoint_config.interval = args.checkpoint_interval
# Print out the log every N iterations
cfg.log_config.interval = args.log_eva_interval
# Set seed thus the results are reproducible
cfg.seed = 0
set_random_seed(0, deterministic=False)
cfg.gpus = 1
cfg.dump('restoration_config.py')
return cfg
def update_config(self):
cfg = Config.fromfile(self.system_dict["params"]["config_file"]);
# Modify dataset type and path
cfg.dataset_type = 'VideoDataset'
cfg.data_root = self.system_dict["params"]["train_img_folder"]
cfg.data_root_val = self.system_dict["params"]["val_img_folder"]
cfg.ann_file_train = self.system_dict["params"]["train_anno_file"]
cfg.ann_file_val = self.system_dict["params"]["val_anno_file"]
cfg.ann_file_test = self.system_dict["params"]["val_anno_file"]
cfg.data.test.type = 'VideoDataset'
cfg.data.test.ann_file = self.system_dict["params"]["val_anno_file"]
cfg.data.test.data_prefix = self.system_dict["params"]["val_img_folder"]
cfg.data.train.type = 'VideoDataset'
cfg.data.train.ann_file = self.system_dict["params"]["train_anno_file"]
cfg.data.train.data_prefix = self.system_dict["params"]["train_img_folder"]
cfg.data.val.type = 'VideoDataset'
cfg.data.val.ann_file = self.system_dict["params"]["val_anno_file"]
cfg.data.val.data_prefix = self.system_dict["params"]["val_img_folder"]
# Modify num classes of the model in cls_head
cfg.model.cls_head.num_classes = self.system_dict["params"]["num_classes"]
# We can use the pre-trained TSN model
cfg.load_from = self.system_dict["params"]["load_from"]
# Set up working dir to save files and logs.
cfg.work_dir = './work_dirs'
# The original learning rate (LR) is set for 8-GPU training.
# We divide it by 8 since we only use one GPU.
cfg.data.videos_per_gpu = self.system_dict["params"]["batch_size"]
cfg.data.workers_per_gpu = self.system_dict["params"]["num_workers"]
cfg.optimizer.lr = self.system_dict["params"]["lr"];
cfg.optimizer.momentum = self.system_dict["params"]["momentum"];
cfg.optimizer.weight_decay = self.system_dict["params"]["weight_decay"];
cfg.total_epochs = self.system_dict["params"]["num_epochs"]
if(self.system_dict["params"]["model_name"] != "r2plus1d_r34_video_8x8x1_180e_kinetics400_rgb"
and self.system_dict["params"]["model_name"] != "slowonly_r50_video_4x16x1_256e_kinetics400_rgb"
and self.system_dict["params"]["model_name"] != "slowfast_r50_video_4x16x1_256e_kinetics400_rgb"
):
if(self.system_dict["params"]["num_epochs"] > 2):
cfg.lr_config.step = [self.system_dict["params"]["num_epochs"]//3,
2*self.system_dict["params"]["num_epochs"]//3];
else:
cfg.lr_config.step = [1];
# We can set the checkpoint saving interval to reduce the storage cost
cfg.checkpoint_config.interval = self.system_dict["params"]["val_interval"]
cfg.evaluation.interval = self.system_dict["params"]["val_interval"]
# We can set the log print interval to reduce the the times of printing log
cfg.log_config.interval = self.system_dict["params"]["val_interval"]
# Set seed thus the results are more reproducible
cfg.seed = 0
set_random_seed(0, deterministic=False)
cfg.gpu_ids = self.system_dict["params"]["gpu_ids"]
return cfg;
def main():
args = parse_args()
cfg = Config.fromfile(args.config)
if args.cfg_options is not None:
cfg.merge_from_dict(args.cfg_options)
# update mc config
if args.mc_config:
mc = Config.fromfile(args.mc_config)
if isinstance(cfg.data.train, list):
for i in range(len(cfg.data.train)):
cfg.data.train[i].pipeline[0].update(
file_client_args=mc['mc_file_client_args'])
else:
cfg.data.train.pipeline[0].update(
file_client_args=mc['mc_file_client_args'])
# set cudnn_benchmark
if cfg.get('cudnn_benchmark', False):
torch.backends.cudnn.benchmark = True
# work_dir is determined in this priority: CLI > segment in file > filename
if args.work_dir is not None:
# update configs according to CLI args if args.work_dir is not None
cfg.work_dir = args.work_dir
elif cfg.get('work_dir', None) is None:
# use config filename as default work_dir if cfg.work_dir is None
cfg.work_dir = osp.join('./work_dirs',
osp.splitext(osp.basename(args.config))[0])
if args.load_from is not None:
cfg.load_from = args.load_from
if args.resume_from is not None:
cfg.resume_from = args.resume_from
if args.gpu_ids is not None:
cfg.gpu_ids = args.gpu_ids
else:
cfg.gpu_ids = range(1) if args.gpus is None else range(args.gpus)
# init distributed env first, since logger depends on the dist info.
if args.launcher == 'none':
distributed = False
else:
distributed = True
init_dist(args.launcher, **cfg.dist_params)
# re-set gpu_ids with distributed training mode
_, world_size = get_dist_info()
cfg.gpu_ids = range(world_size)
# create work_dir
mmcv.mkdir_or_exist(osp.abspath(cfg.work_dir))
# dump config
cfg.dump(osp.join(cfg.work_dir, osp.basename(args.config)))
# init the logger before other steps
timestamp = time.strftime('%Y%m%d_%H%M%S', time.localtime())
log_file = osp.join(cfg.work_dir, f'{timestamp}.log')
logger = get_root_logger(log_file=log_file, log_level=cfg.log_level)
# init the meta dict to record some important information such as
# environment info and seed, which will be logged
meta = dict()
# log env info
env_info_dict = collect_env()
env_info = '\n'.join([(f'{k}: {v}') for k, v in env_info_dict.items()])
dash_line = '-' * 60 + '\n'
logger.info('Environment info:\n' + dash_line + env_info + '\n' +
dash_line)
meta['env_info'] = env_info
meta['config'] = cfg.pretty_text
# log some basic info
logger.info(f'Distributed training: {distributed}')
logger.info(f'Config:\n{cfg.pretty_text}')
# set random seeds
seed = init_random_seed(args.seed)
logger.info(f'Set random seed to {seed}, '
f'deterministic: {args.deterministic}')
set_random_seed(seed, deterministic=args.deterministic)
cfg.seed = seed
meta['seed'] = seed
meta['exp_name'] = osp.basename(args.config)
model = build_detector(cfg.model,
train_cfg=cfg.get('train_cfg'),
test_cfg=cfg.get('test_cfg'))
model.init_weights()
datasets = [build_dataset(cfg.data.train)]
if len(cfg.workflow) == 2:
val_dataset = copy.deepcopy(cfg.data.val)
if cfg.data.train['type'] == 'ConcatDataset':
train_pipeline = cfg.data.train['datasets'][0].pipeline
else:
train_pipeline = cfg.data.train.pipeline
if val_dataset['type'] == 'ConcatDataset':
for dataset in val_dataset['datasets']:
dataset.pipeline = train_pipeline
else:
val_dataset.pipeline = train_pipeline
datasets.append(build_dataset(val_dataset))
if cfg.checkpoint_config is not None:
# save mmdet version, config file content and class names in
# checkpoints as meta data
cfg.checkpoint_config.meta = dict(mmocr_version=__version__ +
get_git_hash()[:7],
CLASSES=datasets[0].CLASSES)
# add an attribute for visualization convenience
model.CLASSES = datasets[0].CLASSES
train_detector(model,
datasets,
cfg,
distributed=distributed,
validate=(not args.no_validate),
timestamp=timestamp,
meta=meta)
def main():
args = parse_args()
if args.seed is not None:
print(f'Set random seed to {args.seed}')
set_random_seed(args.seed)
if args.format == 'rawframes':
frame_info = parse_directory(args.src_folder,
rgb_prefix=args.rgb_prefix,
flow_x_prefix=args.flow_x_prefix,
flow_y_prefix=args.flow_y_prefix,
level=args.level)
elif args.format == 'videos':
if args.level == 1:
# search for one-level directory
video_list = glob.glob(osp.join(args.src_folder, '*'))
elif args.level == 2:
# search for two-level directory
video_list = glob.glob(osp.join(args.src_folder, '*', '*'))
else:
raise ValueError(f'level must be 1 or 2, but got {args.level}')
frame_info = {}
for video in video_list:
video_path = osp.relpath(video, args.src_folder)
# video_id: (video_relative_path, -1, -1)
frame_info[osp.splitext(video_path)[0]] = (video_path, -1, -1)
else:
raise NotImplementedError('only rawframes and videos are supported')
if args.dataset == 'ucf101':
splits = parse_ucf101_splits(args.level)
elif args.dataset == 'sthv1':
splits = parse_sthv1_splits(args.level)
elif args.dataset == 'sthv2':
splits = parse_sthv2_splits(args.level)
elif args.dataset == 'mit':
splits = parse_mit_splits()
elif args.dataset == 'mmit':
splits = parse_mmit_splits()
elif args.dataset in ['kinetics400', 'kinetics600', 'kinetics700']:
splits = parse_kinetics_splits(args.level, args.dataset)
elif args.dataset == 'hmdb51':
splits = parse_hmdb51_split(args.level)
elif args.dataset == 'jester':
splits = parse_jester_splits(args.level)
elif args.dataset == 'diving48':
splits = parse_diving48_splits()
else:
raise ValueError(
f"Supported datasets are 'ucf101, sthv1, sthv2', 'jester', "
f"'mmit', 'mit', 'kinetics400', 'kinetics600', 'kinetics700', but "
f'got {args.dataset}')
assert len(splits) == args.num_split
out_path = args.out_root_path + args.dataset
if len(splits) > 1:
for i, split in enumerate(splits):
file_lists = build_file_list(split,
frame_info,
shuffle=args.shuffle)
train_name = f'{args.dataset}_train_split_{i+1}_{args.format}.txt'
val_name = f'{args.dataset}_val_split_{i+1}_{args.format}.txt'
if args.output_format == 'txt':
with open(osp.join(out_path, train_name), 'w') as f:
f.writelines(file_lists[0][0])
with open(osp.join(out_path, val_name), 'w') as f:
f.writelines(file_lists[0][1])
elif args.output_format == 'json':
train_list = lines2dictlist(file_lists[0][0], args.format)
val_list = lines2dictlist(file_lists[0][1], args.format)
train_name = train_name.replace('.txt', '.json')
val_name = val_name.replace('.txt', '.json')
with open(osp.join(out_path, train_name), 'w') as f:
json.dump(train_list, f)
with open(osp.join(out_path, val_name), 'w') as f:
json.dump(val_list, f)
else:
lists = build_file_list(splits[0], frame_info, shuffle=args.shuffle)
if args.subset == 'train':
ind = 0
elif args.subset == 'val':
ind = 1
elif args.subset == 'test':
ind = 2
else:
raise ValueError(f"subset must be in ['train', 'val', 'test'], "
f'but got {args.subset}.')
filename = f'{args.dataset}_{args.subset}_list_{args.format}.txt'
if args.output_format == 'txt':
with open(osp.join(out_path, filename), 'w') as f:
f.writelines(lists[0][ind])
elif args.output_format == 'json':
data_list = lines2dictlist(lists[0][ind], args.format)
filename = filename.replace('.txt', '.json')
with open(osp.join(out_path, filename), 'w') as f:
json.dump(data_list, f)
def main():
# parse arguments
args = parse_args()
# load config
cfg = Config.fromfile(args.config)
if args.update_config is not None:
cfg.merge_from_dict(args.update_config)
cfg = update_config(cfg, args)
cfg = propagate_root_dir(cfg, args.data_dir)
# init distributed env first, since logger depends on the dist info.
distributed = args.launcher != 'none'
if distributed:
init_dist(args.launcher, **cfg.dist_params)
# create work_dir
mmcv.mkdir_or_exist(osp.abspath(cfg.work_dir))
# init logger before other steps
timestamp = time.strftime('%Y%m%d_%H%M%S', time.localtime())
log_file = osp.join(cfg.work_dir, f'{timestamp}.log')
logger = get_root_logger(log_file=log_file, log_level=cfg.log_level)
# init the meta dict to record some important information such as
# environment info and seed, which will be logged
meta = dict()
# log env info
env_info_dict = collect_env()
env_info = '\n'.join([f'{k}: {v}' for k, v in env_info_dict.items()])
dash_line = '-' * 60 + '\n'
logger.info('Environment info:\n' + dash_line + env_info + '\n' + dash_line)
meta['env_info'] = env_info
# log some basic info
logger.info(f'Distributed training: {distributed}')
logger.info(f'Config: {cfg.text}')
if cfg.get('nncf_config'):
check_nncf_is_enabled()
logger.info('NNCF config: {}'.format(cfg.nncf_config))
meta.update(get_nncf_metadata())
# set random seeds
cfg.seed = args.seed
meta['seed'] = args.seed
if cfg.get('seed'):
logger.info(f'Set random seed to {cfg.seed}, deterministic: {args.deterministic}')
set_random_seed(cfg.seed, deterministic=args.deterministic)
# build datasets
datasets = [build_dataset(cfg.data, 'train', dict(logger=logger))]
logger.info(f'Train datasets:\n{str(datasets[0])}')
if len(cfg.workflow) == 2:
if not args.no_validate:
warnings.warn('val workflow is duplicated with `--validate`, '
'it is recommended to use `--validate`. see '
'https://github.com/open-mmlab/mmaction2/pull/123')
datasets.append(build_dataset(copy.deepcopy(cfg.data), 'val', dict(logger=logger)))
logger.info(f'Val datasets:\n{str(datasets[-1])}')
# filter dataset labels
if cfg.get('classes'):
datasets = [dataset.filter(cfg.classes) for dataset in datasets]
# build model
model = build_model(
cfg.model,
train_cfg=cfg.train_cfg,
test_cfg=cfg.test_cfg,
class_sizes=datasets[0].class_sizes,
class_maps=datasets[0].class_maps
)
# define ignore layers
ignore_prefixes = []
if hasattr(cfg, 'reset_layer_prefixes') and isinstance(cfg.reset_layer_prefixes, (list, tuple)):
ignore_prefixes += cfg.reset_layer_prefixes
ignore_suffixes = ['num_batches_tracked']
if hasattr(cfg, 'reset_layer_suffixes') and isinstance(cfg.reset_layer_suffixes, (list, tuple)):
ignore_suffixes += cfg.reset_layer_suffixes
# train model
train_model(
model,
datasets,
cfg,
distributed=distributed,
validate=(not args.no_validate),
timestamp=timestamp,
meta=meta,
ignore_prefixes=tuple(ignore_prefixes),
ignore_suffixes=tuple(ignore_suffixes)
)
def main():
args = parse_args()
cfg = mmcv.Config.fromfile(args.config)
if args.update_config is not None:
cfg.merge_from_dict(args.update_config)
cfg = update_config(cfg, args)
cfg = propagate_root_dir(cfg, args.data_dir)
# Load output_config from cfg
output_config = cfg.get('output_config', {})
# Overwrite output_config from args.out
output_config = merge_configs(output_config, dict(out=args.out))
# Load eval_config from cfg
eval_config = cfg.get('eval_config', {})
# Overwrite eval_config from args.eval
eval_config = merge_configs(eval_config, dict(metrics=args.eval))
# Add options from args.option
eval_config = merge_configs(eval_config, args.options)
assert output_config or eval_config, \
('Please specify at least one operation (save or eval the '
'results) with the argument "--out" or "--eval"')
# init distributed env first, since logger depends on the dist info.
distributed = args.launcher != 'none'
if distributed:
init_dist(args.launcher, **cfg.dist_params)
# get rank
rank, _ = get_dist_info()
if cfg.get('seed'):
print(f'Set random seed to {cfg.seed}')
set_random_seed(cfg.seed)
# build the dataset
dataset = build_dataset(cfg.data, 'test', dict(test_mode=True))
if cfg.get('classes'):
dataset = dataset.filter(cfg.classes)
if rank == 0:
print(f'Test datasets:\n{str(dataset)}')
# build the dataloader
data_loader = build_dataloader(dataset,
videos_per_gpu=1,
workers_per_gpu=cfg.data.workers_per_gpu,
dist=distributed,
shuffle=False)
# build the model and load checkpoint
model = build_model(cfg.model,
train_cfg=None,
test_cfg=cfg.test_cfg,
class_sizes=dataset.class_sizes,
class_maps=dataset.class_maps)
# nncf model wrapper
if is_checkpoint_nncf(args.checkpoint) and not cfg.get('nncf_config'):
# reading NNCF config from checkpoint
nncf_part = get_nncf_config_from_meta(args.checkpoint)
for k, v in nncf_part.items():
cfg[k] = v
if cfg.get('nncf_config'):
check_nncf_is_enabled()
if not is_checkpoint_nncf(args.checkpoint):
raise RuntimeError(
'Trying to make testing with NNCF compression a model snapshot that was NOT trained with NNCF'
)
cfg.load_from = args.checkpoint
cfg.resume_from = None
if torch.cuda.is_available():
model = model.cuda()
_, model = wrap_nncf_model(model, cfg, None, get_fake_input)
else:
fp16_cfg = cfg.get('fp16', None)
if fp16_cfg is not None:
wrap_fp16_model(model)
# load model weights
load_checkpoint(model,
args.checkpoint,
map_location='cpu',
force_matching=True)
if args.fuse_conv_bn:
model = fuse_conv_bn(model)
if not distributed:
model = MMDataParallel(model, device_ids=[0])
outputs = single_gpu_test(model, data_loader)
else:
model = MMDistributedDataParallel(
model.cuda(),
device_ids=[torch.cuda.current_device()],
broadcast_buffers=False)
outputs = multi_gpu_test(model, data_loader, args.tmpdir,
args.gpu_collect)
if rank == 0:
if output_config:
out = output_config['out']
print(f'\nwriting results to {out}')
dataset.dump_results(outputs, **output_config)
if eval_config:
eval_res = dataset.evaluate(outputs, **eval_config)
print('\nFinal metrics:')
for name, val in eval_res.items():
if 'invalid_info' in name:
continue
if isinstance(val, float):
print(f'{name}: {val:.04f}')
elif isinstance(val, str):
print(f'{name}:\n{val}')
else:
print(f'{name}: {val}')
invalid_info = {
name: val
for name, val in eval_res.items() if 'invalid_info' in name
}
if len(invalid_info) > 0:
assert args.out_invalid is not None and args.out_invalid != ''
if os.path.exists(args.out_invalid):
shutil.rmtree(args.out_invalid)
if not os.path.exists(args.out_invalid):
os.makedirs(args.out_invalid)
for name, invalid_record in invalid_info.items():
out_invalid_dir = os.path.join(args.out_invalid, name)
item_gen = zip(invalid_record['ids'],
invalid_record['conf'],
invalid_record['pred'])
for invalid_idx, pred_conf, pred_label in item_gen:
record_info = dataset.get_info(invalid_idx)
gt_label = record_info['label']
if 'filename' in record_info:
src_data_path = record_info['filename']
in_record_name, record_extension = os.path.basename(
src_data_path).split('.')
out_record_name = f'{in_record_name}_gt{gt_label}_pred{pred_label}_conf{pred_conf:.3f}'
trg_data_path = os.path.join(
out_invalid_dir,
f'{out_record_name}.{record_extension}')
shutil.copyfile(src_data_path, trg_data_path)
else:
src_data_path = record_info['frame_dir']
in_record_name = os.path.basename(src_data_path)
out_record_name = f'{in_record_name}_gt{gt_label}_pred{pred_label}_conf{pred_conf:.3f}'
trg_data_path = os.path.join(
out_invalid_dir, out_record_name)
os.makedirs(trg_data_path)
start_frame_id = record_info[
'clip_start'] + dataset.start_index
end_frame_id = record_info[
'clip_end'] + dataset.start_index
for frame_id in range(start_frame_id,
end_frame_id):
img_name = f'{frame_id:05}.jpg'
shutil.copyfile(
os.path.join(src_data_path, img_name),
os.path.join(trg_data_path, img_name))
def main():
args = parse_args()
cfg = Config.fromfile(args.config)
# set cudnn_benchmark
if cfg.get('cudnn_benchmark', False):
torch.backends.cudnn.benchmark = True
# work_dir is determined in this priority:
# CLI > config file > default (base filename)
if args.work_dir is not None:
# update configs according to CLI args if args.work_dir is not None
cfg.work_dir = args.work_dir
elif cfg.get('work_dir', None) is None:
# use config filename as default work_dir if cfg.work_dir is None
cfg.work_dir = osp.join('./work_dirs',
osp.splitext(osp.basename(args.config))[0])
if args.resume_from is not None:
cfg.resume_from = args.resume_from
if args.gpu_ids is not None:
cfg.gpu_ids = args.gpu_ids
else:
cfg.gpu_ids = range(1) if args.gpus is None else range(args.gpus)
# init distributed env first, since logger depends on the dist info.
if args.launcher == 'none':
distributed = False
else:
distributed = True
init_dist(args.launcher, **cfg.dist_params)
# create work_dir
mmcv.mkdir_or_exist(osp.abspath(cfg.work_dir))
# dump config
cfg.dump(osp.join(cfg.work_dir, osp.basename(args.config)))
# init logger before other steps
timestamp = time.strftime('%Y%m%d_%H%M%S', time.localtime())
log_file = osp.join(cfg.work_dir, f'{timestamp}.log')
logger = get_root_logger(log_file=log_file, log_level=cfg.log_level)
# init the meta dict to record some important information such as
# environment info and seed, which will be logged
meta = dict()
# log env info
env_info_dict = collect_env()
env_info = '\n'.join([f'{k}: {v}' for k, v in env_info_dict.items()])
dash_line = '-' * 60 + '\n'
logger.info('Environment info:\n' + dash_line + env_info + '\n' +
dash_line)
meta['env_info'] = env_info
# log some basic info
logger.info(f'Distributed training: {distributed}')
logger.info(f'Config: {cfg.text}')
# set random seeds
if args.seed is not None:
logger.info('Set random seed to {}, deterministic: {}'.format(
args.seed, args.deterministic))
set_random_seed(args.seed, deterministic=args.deterministic)
cfg.seed = args.seed
meta['seed'] = args.seed
model = build_model(cfg.model,
train_cfg=cfg.train_cfg,
test_cfg=cfg.test_cfg)
datasets = [build_dataset(cfg.data.train)]
if len(cfg.workflow) == 2:
val_dataset = copy.deepcopy(cfg.data.val)
datasets.append(build_dataset(val_dataset))
if cfg.checkpoint_config is not None:
# save mmaction version, config file content and class names in
# checkpoints as meta data
cfg.checkpoint_config.meta = dict(mmaction_version=__version__,
config=cfg.text)
train_model(model,
datasets,
cfg,
distributed=distributed,
validate=args.validate,
timestamp=timestamp,
meta=meta)
cfg.work_dir = './tutorial_exps'
# The original learning rate (LR) is set for 8-GPU training.
# We divide it by 8 since we only use one GPU.
cfg.optimizer.lr = cfg.optimizer.lr / 8 / 16
cfg.total_epochs = 15
# We can set the checkpoint saving interval to reduce the storage cost
cfg.checkpoint_config.interval = 10
# We can set the log print interval to reduce the the times of printing log
cfg.log_config.interval = 5
# Set seed thus the results are more reproducible
cfg.seed = 0
set_random_seed(0, deterministic=False)
cfg.gpu_ids = range(1)
# We can initialize the logger for training and have a look
# at the final config used for training
print(f'Config:\n{cfg.pretty_text}')
# Build the dataset
datasets = [build_dataset(cfg.data.train)]
# Build the recognizer
model = build_model(cfg.model, train_cfg=cfg.train_cfg, test_cfg=cfg.test_cfg)
# Create work_dir
mmcv.mkdir_or_exist(osp.abspath(cfg.work_dir))
train_model(model, datasets, cfg, distributed=False, validate=True)
def main(args):
cfg = mmcv.Config.fromfile(args.config)
if args.update_config is not None:
cfg.merge_from_dict(args.update_config)
cfg.data.videos_per_gpu = 1
if cfg.get('seed'):
print(f'Set random seed to {cfg.seed}')
set_random_seed(cfg.seed)
class_maps = None
if cfg.get('classes'):
class_maps = {0: {k: v for k, v in enumerate(sorted(cfg.classes))}}
model = build_recognizer(
cfg.model,
train_cfg=None,
test_cfg=cfg.test_cfg,
class_maps=class_maps
)
model.eval()
load_checkpoint(model, args.checkpoint, force_matching=True)
if hasattr(model, 'forward_inference'):
model.forward = model.forward_inference
input_time_size = cfg.input_clip_length
input_image_size = (tuple(cfg.input_img_size)
if isinstance(cfg.input_img_size, (list, tuple))
else (cfg.input_img_size, cfg.input_img_size))
input_size = (3, input_time_size) + input_image_size
# BEGIN nncf part
was_model_compressed = is_checkpoint_nncf(args.checkpoint)
cfg_contains_nncf = cfg.get('nncf_config')
if cfg_contains_nncf and not was_model_compressed:
raise RuntimeError('Trying to make export with NNCF compression '
'a model snapshot that was NOT trained with NNCF')
if was_model_compressed and not cfg_contains_nncf:
# reading NNCF config from checkpoint
nncf_part = get_nncf_config_from_meta(args.checkpoint)
for k, v, in nncf_part.items():
cfg[k] = v
if cfg.get('nncf_config'):
if torch.cuda.is_available():
model.cuda()
check_nncf_is_enabled()
cfg.load_from = args.checkpoint
cfg.resume_from = None
compression_ctrl, model = wrap_nncf_model(model, cfg, None, get_fake_input, export=True)
compression_ctrl.prepare_for_export()
# END nncf part
onnx_model_path = join(args.output_dir, splitext(basename(args.config))[0] + '.onnx')
base_output_dir = dirname(onnx_model_path)
if not exists(base_output_dir):
makedirs(base_output_dir)
convert_to_onnx(model, input_size, onnx_model_path, opset=args.opset, check=True)
if args.target == 'openvino':
input_shape = (1,) + input_size
export_to_openvino(cfg, onnx_model_path, args.output_dir, input_shape, args.input_format)
meta = {'model_classes': model.CLASSES[0]}
with open(args.meta_info, 'w') as output_meta_stream:
json.dump(meta, output_meta_stream)
def main():
args = parse_args()
cfg = mmcv.Config.fromfile(args.config)
if args.update_config is not None:
cfg.merge_from_dict(args.update_config)
cfg = update_config(cfg, args)
cfg = propagate_root_dir(cfg, args.data_dir)
# Load output_config from cfg
output_config = cfg.get('output_config', {})
# Overwrite output_config from args.out
output_config = merge_configs(output_config, dict(out=args.out))
# Load eval_config from cfg
eval_config = cfg.get('eval_config', {})
# Overwrite eval_config from args.eval
eval_config = merge_configs(eval_config, dict(metrics=args.eval))
# Add options from args.option
eval_config = merge_configs(eval_config, args.options)
assert output_config or eval_config, \
('Please specify at least one operation (save or eval the '
'results) with the argument "--out" or "--eval"')
# init distributed env first, since logger depends on the dist info.
distributed = args.launcher != 'none'
if distributed:
init_dist(args.launcher, **cfg.dist_params)
# get rank
rank, _ = get_dist_info()
if cfg.get('seed'):
print(f'Set random seed to {cfg.seed}')
set_random_seed(cfg.seed)
# build the dataset
dataset = build_dataset(cfg.data, 'test', dict(test_mode=True))
if cfg.get('classes'):
dataset = dataset.filter(cfg.classes)
if rank == 0:
print(f'Test datasets:\n{str(dataset)}')
# build the dataloader
data_loader = build_dataloader(
dataset,
videos_per_gpu=1,
workers_per_gpu=cfg.data.workers_per_gpu,
dist=distributed,
shuffle=False
)
# build the model and load checkpoint
model = build_model(
cfg.model,
train_cfg=None,
test_cfg=cfg.test_cfg,
class_sizes=dataset.class_sizes,
class_maps=dataset.class_maps
)
fp16_cfg = cfg.get('fp16', None)
if fp16_cfg is not None:
wrap_fp16_model(model)
# load model weights
load_checkpoint(model, args.checkpoint, map_location='cpu', force_matching=True)
if args.fuse_conv_bn:
model = fuse_conv_bn(model)
if not distributed:
model = MMDataParallel(model, device_ids=[0])
outputs = single_gpu_test(model, data_loader)
else:
model = MMDistributedDataParallel(
model.cuda(),
device_ids=[torch.cuda.current_device()],
broadcast_buffers=False)
outputs = multi_gpu_test(model, data_loader, args.tmpdir, args.gpu_collect)
if rank == 0:
if output_config:
out = output_config['out']
print(f'\nwriting results to {out}')
dataset.dump_results(outputs, **output_config)
if eval_config:
eval_res = dataset.evaluate(outputs, **eval_config)
print('\nFinal metrics:')
for name, val in eval_res.items():
print(f'{name}: {val:.04f}')
