def main(arguments): model_parameters = { 'scale': arguments['scale'], 'learning_rate': 1e-5, 'D': arguments['D'], 'C': arguments['C'], 'G': arguments['G'], 'kernel_size': 3, 'c_dim': 3, 'G0': arguments['G0'], } model = load_model(model_parameters, arguments['vgg'], verbose=arguments['verbose']) if arguments['summary'] is True: model.rdn.summary() if arguments['train'] is True: from trainer.train import Trainer trainer = Trainer(train_arguments=arguments) trainer.train_model(model) if arguments['test'] is True: from predict import Predictor predictor = Predictor(test_arguments=arguments) predictor.get_predictions(model)
def test_if_trainable_weights_update_with_one_step(self): self.scale = self.model_params['scale'] self.img_size = {'HR': 10 * self.scale, 'LR': 10} self.dataset_size = 8 self.create_random_dataset(type='correct') before_step = [] for layer in self.model.rdn.layers: if len(layer.trainable_weights) > 0: before_step.append(layer.get_weights()[0]) train_arguments = { 'validation_labels': self.dataset_folder['correct']['HR'], 'validation_input': self.dataset_folder['correct']['LR'], 'training_labels': self.dataset_folder['correct']['HR'], 'training_input': self.dataset_folder['correct']['LR'], } cl_args = ['--pytest', '--no_verbose'] parser = get_parser() cl_args = parser.parse_args(cl_args) cl_args = vars(cl_args) load_configuration(cl_args, '../config.json') cl_args.update(train_arguments) trainer = Trainer(train_arguments=cl_args) i = 0 for layer in self.model.rdn.layers: if len(layer.trainable_weights) > 0: self.assertTrue( np.all(before_step[i] == layer.get_weights()[0])) i += 1 trainer.train_model(self.model) i = 0 for layer in self.model.rdn.layers: if len(layer.trainable_weights) > 0: self.assertFalse( np.all(before_step[i] == layer.get_weights()[0])) i += 1
def load_model(self, dataset, rc, experiment_name, iteration): loss = LossCombiner(4, dataset.class_weights, NllLoss) if self.produce_baseline: iteration = 0 if iteration == 0: self.current_transformer = TransformerEncoder( dataset.source_embedding, hyperparameters=rc) model = JointAspectTagger(self.current_transformer, rc, 4, 20, dataset.target_names, initialize_params=True) else: model = JointAspectTagger(self.current_transformer, rc, 4, 20, dataset.target_names, initialize_params=False) optimizer = get_optimizer(model, rc) trainer = Trainer(model, loss, optimizer, rc, dataset, experiment_name, enable_tensorboard=True, verbose=True) # see if we might be able to restore the source model if iteration == 0 and self.load_model_path is not None: model, optimizer, epoch = trainer.load_model( custom_path=self.load_model_path) self.skip_source_training = True return trainer
def load_model(dataset, rc, experiment_name): loss = LossCombiner(4, dataset.class_weights, NllLoss) transformer = TransformerEncoder(dataset.source_embedding, hyperparameters=rc) model = JointAspectTagger(transformer, rc, 4, 20, dataset.target_names) optimizer = get_optimizer(model, rc) trainer = Trainer(model, loss, optimizer, rc, dataset, experiment_name, enable_tensorboard=False, verbose=False) return trainer
def load_model(self, dataset, rc, experiment_name): transformer = TransformerEncoder(dataset.source_embedding, hyperparameters=rc) if rc.use_random_classifier: from models.random_model import RandomModel model = RandomModel(rc, dataset.target_size, len(dataset.target_names), dataset.target_names) loss = NllLoss(dataset.target_size, dataset.class_weights[0]) else: # NER or ABSA-task? if rc.task == 'ner': from models.transformer_tagger import TransformerTagger from models.output_layers import SoftmaxOutputLayer loss = NllLoss(dataset.target_size, dataset.class_weights[0]) softmax = SoftmaxOutputLayer(rc.model_size, dataset.target_size) model = TransformerTagger(transformer, softmax) else: from models.jointAspectTagger import JointAspectTagger loss = LossCombiner(dataset.target_size, dataset.class_weights, NllLoss) model = JointAspectTagger(transformer, rc, dataset.target_size, len(dataset.target_names), dataset.target_names) optimizer = get_optimizer(model, rc) trainer = Trainer( model, loss, optimizer, rc, dataset, experiment_name, enable_tensorboard=False, verbose=False) return trainer
parser.add_argument('--eval_batch_size', default=128, type=int) parser.add_argument('--base_lr1', default=0.1, type=float) parser.add_argument('--base_lr2', default=0.1, type=float) parser.add_argument('--lr_factor', default=0.1, type=float) parser.add_argument('--custom_weight_decay', default=5e-4, type=float) parser.add_argument('--custom_momentum', default=0.9, type=float) parser.add_argument('--load_ckpt_prefix', type=str, default='-') parser.add_argument('--load_order', type=str, default='-') parser.add_argument('--add_str', default=None, type=str) the_args = parser.parse_args() assert (the_args.nb_cl_fg % the_args.nb_cl == 0) assert (the_args.nb_cl_fg >= the_args.nb_cl) print(the_args) np.random.seed(the_args.random_seed) if not os.path.exists('./logs/cifar100_nfg50_ncls2_nproto20_mtl_exp01'): print('Download checkpoints from Google Drive.') os.system('sh ./script/download_ckpt.sh') os.environ['CUDA_VISIBLE_DEVICES'] = the_args.gpu print('Using gpu:', the_args.gpu) occupy_memory(the_args.gpu) print('Occupy GPU memory in advance.') trainer = Trainer(the_args) trainer.eval()
def main(): # Setup the log log_filename = config.LOG_FILENAME log = setup_log(log_filename) # Setup datasets instruments = config.INSTRUMENTS musdbwav_path = config.MUSDB18_WAV_PATH # sample_time_frames = config.SAMPLE_TIME_FRAMES audio_samples_per_chunk = config.AUDIO_SAMPLES_PER_CHUNK batch_size = config.BATCH_SIZE prefetch_factor = config.PREFETCH_FACTOR train_dataset = TrainMUSDB18Dataset(musdbwav_path, instruments, sample_length=audio_samples_per_chunk) validation_dataset = TestMUSDB18Dataset( musdbwav_path, instruments, sample_length=audio_samples_per_chunk, subset_split='valid') # Setup model model_config_path = config.MODEL_CONFIG_YAML_PATH model_config_name = config.MODEL_CONFIGURATION with open(model_config_path, 'r') as file: model_configurations = yaml.load(file, Loader=yaml.FullLoader) train_model_config = model_configurations[model_config_name] train_model_class = train_model_config.pop('class') model = eval(train_model_class)(**train_model_config) # Setup trainer checkpoint_folder_path = config.CHECKPOINT_FOLDER_PATH epochs = config.EPOCHS checkpoint_frequency = config.CHECKPOINT_FREQUENCY logging_frequency = config.LOGGING_FREQUENCY optimizer_class = get_optimizer_class(config.OPTIMIZER) optimizer_params = config.OPTIMIZER_PARAMS optimizer = optimizer_class(model.parameters(), **optimizer_params) lr_scheduler_class = get_lr_scheduler_class(config.LR_SCHEDULER) lr_scheduler_params = config.LR_SCHEDULER_PARAMS lr_scheduler = lr_scheduler_class(optimizer, **lr_scheduler_params) loss_function = get_loss_function(config.LOSS_FUNCTION) gpu = config.GPU gpu_device = config.GPU_DEVICE device = get_device(gpu, gpu_device) if not os.path.isdir(checkpoint_folder_path): os.mkdir(checkpoint_folder_path) # Setup the spectrogram spectrogram_type = config.SPECTROGRAM_TYPE n_fft = config.N_FFT hop_length = config.HOP_LENGTH window = config.WINDOW window_length = config.WINDOW_LENGTH spectrogramer = Spectrogramer(spectrogram_type, n_fft, hop_length, window, window_length, device) # Initialize traininer trainer = Trainer(model, spectrogramer, optimizer, loss_function, lr_scheduler, train_dataset, validation_dataset, log, checkpoint_folder_path, epochs, logging_frequency, checkpoint_frequency, batch_size, prefetch_factor, instruments, train_model_class, device) # Start trainer/evaluation trainer.train()
for i, sample in enumerate(self): target = sample[1] pred = predictions[str(i)] if target == pred: TP += 1 return {'score': TP / len(self)} if __name__ == '__main__': from torchvision import transforms from trainer.data import Subset from trainer.train import ArgumentParser, Trainer parser = ArgumentParser() args = parser.parse_args() net = Net() mnist_root = 'data/mnist' transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,)) ]) datasets = dict(train=MyMNIST(mnist_root, True, download=True, transform=transform), valid=MyMNIST(mnist_root, False, download=True, transform=transform), test=MyMNIST(mnist_root, False, download=True, transform=transform) ) datasets = {k: Subset(d, slice(0, len(d), 10)) for k, d in datasets.items()} criterion = F.nll_loss trainer = Trainer(net, datasets, criterion, args) trainer.run()
parser.add_argument('--load_order', type=str, default='-') parser.add_argument('--maml_lr', default=0.1, type=float) parser.add_argument('--maml_epoch', default=50, type=int) parser.add_argument('--mnemonics_images_per_class_per_step', default=1, type=int) parser.add_argument('--mnemonics_steps', default=20, type=int) parser.add_argument('--mnemonics_epochs', default=5, type=int) parser.add_argument('--mnemonics_lr', type=float, default=0.01) parser.add_argument('--mnemonics_decay_factor', type=float, default=0.5) parser.add_argument('--mnemonics_outer_lr', type=float, default=1e-6) parser.add_argument('--mnemonics_total_epochs', type=int, default=10) parser.add_argument('--mnemonics_decay_epochs', type=int, default=40) the_args = parser.parse_args() assert(the_args.nb_cl_fg % the_args.nb_cl == 0) assert(the_args.nb_cl_fg >= the_args.nb_cl) print(the_args) np.random.seed(the_args.random_seed) os.environ['CUDA_VISIBLE_DEVICES'] = the_args.gpu print('Using gpu:', the_args.gpu) occupy_memory(the_args.gpu) print('Occupy GPU memory in advance') trainer = Trainer(the_args) trainer.train()