def from_config(cls, config: Dict[str, Any]) -> "ClassificationTask": """Instantiates a ClassificationTask from a configuration. Args: config: A configuration for a ClassificationTask. See :func:`__init__` for parameters expected in the config. Returns: A ClassificationTask instance. """ optimizer_config = config["optimizer"] optimizer_config["num_epochs"] = config["num_epochs"] datasets = {} phase_types = ["train", "test"] for phase_type in phase_types: datasets[phase_type] = build_dataset(config["dataset"][phase_type]) loss = build_loss(config["loss"]) test_only = config.get("test_only", False) amp_opt_level = config.get("amp_opt_level") meters = build_meters(config.get("meters", {})) model = build_model(config["model"]) # put model in eval mode in case any hooks modify model states, it'll # be reset to train mode before training model.eval() optimizer = build_optimizer(optimizer_config) task = (cls().set_num_epochs( config["num_epochs"]).set_loss(loss).set_test_only(test_only). set_model(model).set_optimizer(optimizer).set_meters(meters). set_amp_opt_level(amp_opt_level).set_distributed_options( BroadcastBuffersMode[config.get("broadcast_buffers", "DISABLED")])) for phase_type in phase_types: task.set_dataset(datasets[phase_type], phase_type) return task
def test_get_set_head_states(self): config = copy.deepcopy(self._get_config(self.model_configs[0])) head_configs = config["model"]["heads"] config["model"]["heads"] = [] model = build_model(config["model"]) trunk_state = model.get_classy_state() heads = defaultdict(dict) for head_config in head_configs: head = build_head(head_config) heads[head_config["fork_block"]][head.unique_id] = head model.set_heads(heads) model_state = model.get_classy_state() # the heads should be the same as we set self.assertEqual(len(heads), len(model.get_heads())) for block_name, hs in model.get_heads().items(): self.assertEqual(hs, heads[block_name]) model._clear_heads() self._compare_model_state(model.get_classy_state(), trunk_state) model.set_heads(heads) self._compare_model_state(model.get_classy_state(), model_state)
def test_build_model(self): for model_config in self.model_configs: model = build_model(model_config) self.assertTrue(isinstance(model, ClassyModel))
def from_config(cls, config: Dict[str, Any]) -> "ClassificationTask": """Instantiates a ClassificationTask from a configuration. Args: config: A configuration for a ClassificationTask. See :func:`__init__` for parameters expected in the config. Returns: A ClassificationTask instance. """ test_only = config.get("test_only", False) if not test_only: # TODO Make distinction between epochs and phases in optimizer clear train_phases_per_epoch = config["dataset"]["train"].get( "phases_per_epoch", 1) optimizer_config = config["optimizer"] optimizer_config["num_epochs"] = (config["num_epochs"] * train_phases_per_epoch) optimizer = build_optimizer(optimizer_config) param_schedulers = build_optimizer_schedulers(optimizer_config) datasets = {} phase_types = ["train", "test"] for phase_type in phase_types: if phase_type in config["dataset"]: datasets[phase_type] = build_dataset( config["dataset"][phase_type]) loss = build_loss(config["loss"]) amp_args = config.get("amp_args") meters = build_meters(config.get("meters", {})) model = build_model(config["model"]) mixup_transform = None if config.get("mixup") is not None: assert "alpha" in config[ "mixup"], "key alpha is missing in mixup dict" mixup_transform = MixupTransform( config["mixup"]["alpha"], config["mixup"].get("num_classes")) # hooks config is optional hooks_config = config.get("hooks") hooks = [] if hooks_config is not None: hooks = build_hooks(hooks_config) distributed_config = config.get("distributed", {}) distributed_options = { "broadcast_buffers_mode": BroadcastBuffersMode[distributed_config.get( "broadcast_buffers", "before_eval").upper()], "batch_norm_sync_mode": BatchNormSyncMode[distributed_config.get("batch_norm_sync_mode", "disabled").upper()], "batch_norm_sync_group_size": distributed_config.get("batch_norm_sync_group_size", 0), "find_unused_parameters": distributed_config.get("find_unused_parameters", True), } task = ( cls().set_num_epochs(config["num_epochs"]).set_test_phase_period( config.get( "test_phase_period", 1)).set_loss(loss).set_test_only(test_only).set_model( model).set_meters(meters).set_amp_args(amp_args). set_mixup_transform(mixup_transform).set_distributed_options( **distributed_options).set_hooks(hooks).set_bn_weight_decay( config.get("bn_weight_decay", False))) if not test_only: task.set_optimizer(optimizer) task.set_optimizer_schedulers(param_schedulers) use_gpu = config.get("use_gpu") if use_gpu is not None: task.set_use_gpu(use_gpu) for phase_type in datasets: task.set_dataset(datasets[phase_type], phase_type) # NOTE: this is a private member and only meant to be used for # logging/debugging purposes. See __repr__ implementation task._config = config return task
def _get_classy_model(self): config = get_test_task_config() model_config = config["model"] return build_model(model_config)
def from_config(cls, config: Dict[str, Any]) -> "ClassificationTask": """Instantiates a ClassificationTask from a configuration. Args: config: A configuration for a ClassificationTask. See :func:`__init__` for parameters expected in the config. Returns: A ClassificationTask instance. """ optimizer_config = config["optimizer"] # TODO Make distinction between epochs and phases in optimizer clear train_phases_per_epoch = config["dataset"]["train"].get( "phases_per_epoch", 1) optimizer_config[ "num_epochs"] = config["num_epochs"] * train_phases_per_epoch datasets = {} phase_types = ["train", "test"] for phase_type in phase_types: datasets[phase_type] = build_dataset(config["dataset"][phase_type]) loss = build_loss(config["loss"]) test_only = config.get("test_only", False) amp_args = config.get("amp_args") meters = build_meters(config.get("meters", {})) model = build_model(config["model"]) mixup_transform = None if config.get("mixup") is not None: assert "alpha" in config[ "mixup"], "key alpha is missing in mixup dict" mixup_transform = MixupTransform( config["mixup"]["alpha"], config["mixup"].get("num_classes")) # hooks config is optional hooks_config = config.get("hooks") hooks = [] if hooks_config is not None: hooks = build_hooks(hooks_config) optimizer = build_optimizer(optimizer_config) task = (cls().set_num_epochs( config["num_epochs"]).set_test_phase_period( config.get( "test_phase_period", 1)).set_loss(loss).set_test_only(test_only).set_model( model).set_optimizer(optimizer).set_meters( meters).set_amp_args(amp_args). set_mixup_transform(mixup_transform).set_distributed_options( broadcast_buffers_mode=BroadcastBuffersMode[config.get( "broadcast_buffers", "disabled").upper()], batch_norm_sync_mode=BatchNormSyncMode[config.get( "batch_norm_sync_mode", "disabled").upper()], find_unused_parameters=config.get("find_unused_parameters", True), ).set_hooks(hooks)) use_gpu = config.get("use_gpu") if use_gpu is not None: task.set_use_gpu(use_gpu) for phase_type in phase_types: task.set_dataset(datasets[phase_type], phase_type) return task
def main(): args = parser.parse_args() print(args) args.cuda = not args.no_cuda and torch.cuda.is_available() if args.cuda and args.mkldnn: assert False, "We can not runing this work on GPU backend and MKLDNN backend \ please set one backend.\n" if args.cuda: print("Using GPU backend to do this work.\n") elif args.mkldnn: print("Using MKLDNN backend to do this work.\n") else: print("Using native CPU backend to do this work.\n") # set it to the folder where video files are saved video_dir = args.video_dir + "/UCF-101" # set it to the folder where dataset splitting files are saved splits_dir = args.video_dir + "/ucfTrainTestlist" # set it to the file path for saving the metadata metadata_file = args.video_dir + "/metadata.pth" resnext3d_configs =model_config.ResNeXt3D_Config(video_dir, splits_dir, metadata_file, args.num_epochs) resnext3d_configs.setUp() datasets = {} dataset_train_configs = resnext3d_configs.dataset_configs["train"] dataset_test_configs = resnext3d_configs.dataset_configs["test"] dataset_train_configs["batchsize_per_replica"] = args.batch_size_train # For testing, batchsize per replica should be equal to clips_per_video dataset_test_configs["batchsize_per_replica"] = args.batch_size_eval dataset_test_configs["clips_per_video"] = args.batch_size_eval datasets["train"] = build_dataset(dataset_train_configs) datasets["test"] = build_dataset(dataset_test_configs) model = build_model(resnext3d_configs.model_configs) meters = build_meters(resnext3d_configs.meters_configs) loss = build_loss({"name": "CrossEntropyLoss"}) optimizer = build_optimizer(resnext3d_configs.optimizer_configs) # there some ops are not supported by MKLDNN, so convert input to CPU tensor if args.mkldnn: heads_configs = resnext3d_configs.model_configs['heads'][0] in_plane = heads_configs['in_plane'] num_classes = heads_configs['num_classes'] act_func = heads_configs['activation_func'] mkldnn_head_fcl = MkldnnFullyConvolutionalLinear(in_plane, num_classes, act_func) if args.evaluate: model = model.eval() model = mkldnn_utils.to_mkldnn(model) model._heads['pathway0-stage4-block2']['default_head'].head_fcl = mkldnn_head_fcl.eval() else: model._heads['pathway0-stage4-block2']['default_head'].head_fcl = mkldnn_head_fc # print(model) if args.evaluate: validata(datasets, model, loss, meters, args) return train(datasets, model, loss, optimizer, meters, args)
def test_model_forward(self): image_shape = (3, 260, 260) num_images = (10, ) input = torch.randn(num_images + image_shape) model = build_model(self.get_model_config()) model(input)
def test_build_preset_model(self): configs = [{"name": f"efficientnet_b{i}" for i in range(8)}] for config in configs: model = build_model(config) self.assertIsInstance(model, EfficientNet)