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()
