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}')