def main(cfg): OmegaConf.set_struct(cfg, False) # Get device device = torch.device("cuda" if (torch.cuda.is_available() and cfg.training.cuda) else "cpu") log.info("DEVICE : {}".format(device)) # Enable CUDNN BACKEND torch.backends.cudnn.enabled = cfg.training.enable_cudnn # Checkpoint checkpoint = ModelCheckpoint(cfg.training.checkpoint_dir, cfg.model_name, cfg.training.weight_name, strict=True) # Setup the dataset config # Generic config dataset = instantiate_dataset(cfg.data) model = checkpoint.create_model(dataset, weight_name=cfg.training.weight_name) log.info(model) log.info("Model size = %i", sum(param.numel() for param in model.parameters() if param.requires_grad)) log.info(dataset) model.eval() if cfg.enable_dropout: model.enable_dropout_in_eval() model = model.to(device) # Run training / evaluation output_path = os.path.join(cfg.training.checkpoint_dir, cfg.data.name, "features") if not os.path.exists(output_path): os.makedirs(output_path, exist_ok=True) run(model, dataset, device, output_path, cfg)
def main(cfg): OmegaConf.set_struct(cfg, False) # Get device device = torch.device("cuda" if (torch.cuda.is_available() and cfg.training.cuda) else "cpu") log.info("DEVICE : {}".format(device)) # Enable CUDNN BACKEND torch.backends.cudnn.enabled = cfg.training.enable_cudnn # Checkpoint checkpoint = ModelCheckpoint(cfg.training.checkpoint_dir, cfg.model_name, cfg.training.weight_name, strict=True) # Setup the dataset config # Generic config dataset = instantiate_dataset(cfg.data) if not checkpoint.is_empty: model = checkpoint.create_model(dataset, weight_name=cfg.training.weight_name) else: log.info("No Checkpoint for this model") model = instantiate_model(copy.deepcopy(cfg), dataset) model.set_pretrained_weights() log.info(model) log.info("Model size = %i", sum(param.numel() for param in model.parameters() if param.requires_grad)) log.info(dataset) model.eval() if cfg.enable_dropout: model.enable_dropout_in_eval() model = model.to(device) run(model, dataset, device, cfg)
def main(cfg): OmegaConf.set_struct(cfg, False) # Get device device = torch.device("cuda" if ( torch.cuda.is_available() and cfg.cuda) else "cpu") log.info("DEVICE : {}".format(device)) # Enable CUDNN BACKEND torch.backends.cudnn.enabled = cfg.enable_cudnn # Checkpoint checkpoint = ModelCheckpoint(cfg.checkpoint_dir, cfg.model_name, cfg.weight_name, strict=True) # Setup the dataset config # Generic config train_dataset_cls = get_dataset_class(checkpoint.data_config) setattr(checkpoint.data_config, "class", train_dataset_cls.FORWARD_CLASS) setattr(checkpoint.data_config, "dataroot", cfg.input_path) # Datset specific configs if cfg.data: for key, value in cfg.data.items(): checkpoint.data_config.update(key, value) # Create dataset and mdoel dataset = instantiate_dataset(checkpoint.data_config) model = checkpoint.create_model(dataset, weight_name=cfg.weight_name) log.info(model) log.info( "Model size = %i", sum(param.numel() for param in model.parameters() if param.requires_grad)) # Set dataloaders dataset.create_dataloaders( model, cfg.batch_size, cfg.shuffle, cfg.num_workers, False, ) log.info(dataset) model.eval() if cfg.enable_dropout: model.enable_dropout_in_eval() model = model.to(device) # Run training / evaluation if not os.path.exists(cfg.output_path): os.makedirs(cfg.output_path) run(model, dataset, device, cfg.output_path)
def main(cfg): OmegaConf.set_struct(cfg, False) # Get device device = torch.device("cuda" if ( torch.cuda.is_available() and cfg.cuda) else "cpu") log.info("DEVICE : {}".format(device)) # Enable CUDNN BACKEND torch.backends.cudnn.enabled = cfg.enable_cudnn # Checkpoint checkpoint = ModelCheckpoint(cfg.checkpoint_dir, cfg.model_name, cfg.weight_name, strict=True) # Create model and datasets dataset = instantiate_dataset(checkpoint.data_config) model = checkpoint.create_model(dataset, weight_name=cfg.weight_name) log.info(model) log.info( "Model size = %i", sum(param.numel() for param in model.parameters() if param.requires_grad)) # Set dataloaders dataset.create_dataloaders( model, cfg.batch_size, cfg.shuffle, cfg.num_workers, cfg.precompute_multi_scale, ) log.info(dataset) model.eval() if cfg.enable_dropout: model.enable_dropout_in_eval() model = model.to(device) tracker: BaseTracker = dataset.get_tracker(model, dataset, False, False) # Run training / evaluation run( cfg, model, dataset, device, tracker, checkpoint, voting_runs=cfg.voting_runs, tracker_options=cfg.tracker_options, )
def __init__(self, checkpoint_dir, model_name, weight_name, feat_name, num_classes=None, mock_dataset=True): # Checkpoint from torch_points3d.datasets.base_dataset import BaseDataset from torch_points3d.datasets.dataset_factory import instantiate_dataset from torch_points3d.utils.mock import MockDataset import torch_points3d.metrics.model_checkpoint as model_checkpoint checkpoint = model_checkpoint.ModelCheckpoint(checkpoint_dir, model_name, weight_name, strict=True) if mock_dataset: dataset = MockDataset(num_classes) dataset.num_classes = num_classes else: dataset = instantiate_dataset(checkpoint.data_config) BaseDataset.set_transform(self, checkpoint.data_config) self.model = checkpoint.create_model(dataset, weight_name=weight_name) self.model.eval()
def from_pretrained(model_tag, download=True, out_file=None, weight_name="latest", mock_dataset=True): # Convert inputs to registry format if PretainedRegistry.MODELS.get(model_tag) is not None: url = PretainedRegistry.MODELS.get(model_tag) else: raise Exception( "model_tag {} doesn't exist within available models. Here is the list of pre-trained models {}" .format(model_tag, PretainedRegistry.available_models())) checkpoint_name = model_tag + ".pt" out_file = os.path.join(CHECKPOINT_DIR, checkpoint_name) if download: download_file(url, out_file) weight_name = weight_name if weight_name is not None else "latest" checkpoint: ModelCheckpoint = ModelCheckpoint( CHECKPOINT_DIR, model_tag, weight_name if weight_name is not None else "latest", resume=False, ) if mock_dataset: dataset = checkpoint.dataset_properties.copy() if PretainedRegistry.MOCK_USED_PROPERTIES.get( model_tag) is not None: for k, v in PretainedRegistry.MOCK_USED_PROPERTIES.get( model_tag).items(): dataset[k] = v else: dataset = instantiate_dataset(checkpoint.data_config) model: BaseModel = checkpoint.create_model(dataset, weight_name=weight_name) Wandb.set_urls_to_model(model, url) BaseDataset.set_transform(model, checkpoint.data_config) return model
def main(cfg): OmegaConf.set_struct( cfg, False) # This allows getattr and hasattr methods to function correctly if cfg.pretty_print: print(cfg.pretty()) set_debugging_vars_to_global(cfg.debugging) # Get device device = torch.device("cuda" if ( torch.cuda.is_available() and cfg.training.cuda) else "cpu") log.info("DEVICE : {}".format(device)) # Enable CUDNN BACKEND torch.backends.cudnn.enabled = cfg.training.enable_cudnn dataset = instantiate_dataset(cfg.data) model = instantiate_model(cfg, dataset) log.info(model) log.info( "Model size = %i", sum(param.numel() for param in model.parameters() if param.requires_grad)) # Set dataloaders dataset.create_dataloaders( model, cfg.training.batch_size, cfg.training.shuffle, cfg.training.num_workers, cfg.training.precompute_multi_scale, ) log.info(dataset) # Run training / evaluation model = model.to(device) measurement_name = "{}_{}".format(cfg.model_name, dataset.__class__.__name__) run(cfg, model, dataset, device, measurement_name)
def from_file(path, weight_name="latest", mock_property=None): """ Load a pretrained model trained with torch-points3d from file. return a pretrained model Parameters ---------- path: str path of a pretrained model weight_name: str, optional name of the weight mock_property: dict, optional mock dataset """ weight_name = weight_name if weight_name is not None else "latest" path_dir, name = os.path.split(path) name = name.split(".")[0] # ModelCheckpoint will add the extension checkpoint: ModelCheckpoint = ModelCheckpoint( path_dir, name, weight_name if weight_name is not None else "latest", resume=False, ) dataset = checkpoint.data_config if mock_property is not None: for k, v in mock_property.items(): dataset[k] = v else: dataset = instantiate_dataset(checkpoint.data_config) model: BaseModel = checkpoint.create_model(dataset, weight_name=weight_name) BaseDataset.set_transform(model, checkpoint.data_config) return model
def _initialize_trainer(self): # Enable CUDNN BACKEND torch.backends.cudnn.enabled = self.enable_cudnn if not self.has_training: self._cfg.training = self._cfg resume = bool(self._cfg.checkpoint_dir) else: resume = bool(self._cfg.training.checkpoint_dir) # Get device if self._cfg.training.cuda > -1 and torch.cuda.is_available(): device = "cuda" torch.cuda.set_device(self._cfg.training.cuda) else: device = "cpu" self._device = torch.device(device) log.info("DEVICE : {}".format(self._device)) # Profiling if self.profiling: # Set the num_workers as torch.utils.bottleneck doesn't work well with it self._cfg.training.num_workers = 0 # Start Wandb if public if self.wandb_log: Wandb.launch(self._cfg, self._cfg.wandb.public and self.wandb_log) # Checkpoint self._checkpoint: ModelCheckpoint = ModelCheckpoint( self._cfg.training.checkpoint_dir, self._cfg.model_name, self._cfg.training.weight_name, run_config=self._cfg, resume=resume, ) # Create model and datasets if not self._checkpoint.is_empty: self._dataset: BaseDataset = instantiate_dataset( self._checkpoint.data_config) self._model: BaseModel = self._checkpoint.create_model( self._dataset, weight_name=self._cfg.training.weight_name) else: self._dataset: BaseDataset = instantiate_dataset(self._cfg.data) self._model: BaseModel = instantiate_model( copy.deepcopy(self._cfg), self._dataset) self._model.instantiate_optimizers(self._cfg, "cuda" in device) self._model.set_pretrained_weights() if not self._checkpoint.validate(self._dataset.used_properties): log.warning( "The model will not be able to be used from pretrained weights without the corresponding dataset. Current properties are {}" .format(self._dataset.used_properties)) self._checkpoint.dataset_properties = self._dataset.used_properties log.info(self._model) self._model.log_optimizers() log.info( "Model size = %i", sum(param.numel() for param in self._model.parameters() if param.requires_grad)) # Set dataloaders self._dataset.create_dataloaders( self._model, self._cfg.training.batch_size, self._cfg.training.shuffle, self._cfg.training.num_workers, self.precompute_multi_scale, ) log.info(self._dataset) # Verify attributes in dataset self._model.verify_data(self._dataset.train_dataset[0]) # Choose selection stage selection_stage = getattr(self._cfg, "selection_stage", "") self._checkpoint.selection_stage = self._dataset.resolve_saving_stage( selection_stage) self._tracker: BaseTracker = self._dataset.get_tracker( self.wandb_log, self.tensorboard_log) if self.wandb_log: Wandb.launch(self._cfg, not self._cfg.wandb.public and self.wandb_log) # Run training / evaluation self._model = self._model.to(self._device) if self.has_visualization: self._visualizer = Visualizer(self._cfg.visualization, self._dataset.num_batches, self._dataset.batch_size, os.getcwd())
def main(cfg): OmegaConf.set_struct( cfg, False) # This allows getattr and hasattr methods to function correctly if cfg.pretty_print: print(cfg.pretty()) # Get device device = torch.device("cuda" if ( torch.cuda.is_available() and cfg.training.cuda) else "cpu") log.info("DEVICE : {}".format(device)) # Enable CUDNN BACKEND torch.backends.cudnn.enabled = cfg.training.enable_cudnn # Profiling profiling = getattr(cfg.debugging, "profiling", False) if profiling: # Set the num_workers as torch.utils.bottleneck doesn't work well with it cfg.training.num_workers = 0 # Start Wandb if public launch_wandb(cfg, cfg.wandb.public and cfg.wandb.log) # Checkpoint checkpoint = ModelCheckpoint( cfg.training.checkpoint_dir, cfg.model_name, cfg.training.weight_name, run_config=cfg, resume=bool(cfg.training.checkpoint_dir), ) # Create model and datasets if not checkpoint.is_empty: dataset = instantiate_dataset(checkpoint.data_config) model = checkpoint.create_model(dataset, weight_name=cfg.training.weight_name) else: dataset = instantiate_dataset(cfg.data) model = instantiate_model(cfg, dataset) model.instantiate_optimizers(cfg) log.info(model) model.log_optimizers() log.info( "Model size = %i", sum(param.numel() for param in model.parameters() if param.requires_grad)) # Set dataloaders dataset.create_dataloaders( model, cfg.training.batch_size, cfg.training.shuffle, cfg.training.num_workers, cfg.training.precompute_multi_scale, ) log.info(dataset) # Choose selection stage selection_stage = getattr(cfg, "selection_stage", "") checkpoint.selection_stage = dataset.resolve_saving_stage(selection_stage) tracker: BaseTracker = dataset.get_tracker(model, dataset, cfg.wandb.log, cfg.tensorboard.log) launch_wandb(cfg, not cfg.wandb.public and cfg.wandb.log) # Run training / evaluation model = model.to(device) visualizer = Visualizer(cfg.visualization, dataset.num_batches, dataset.batch_size, os.getcwd()) run(cfg, model, dataset, device, tracker, checkpoint, visualizer) # https://github.com/facebookresearch/hydra/issues/440 hydra._internal.hydra.GlobalHydra.get_state().clear() return 0