def run(args):
dataset = AlderleyWrapper()
save_args(args) # save command line to a file for reference
train_loader = alderley_cgan_data_loader(args, dataset=dataset) # get the data
model = CGANModel(
args,
discriminators=[PixelDiscriminator(), patchCDiscriminatorNetwork(args)],
generator=UnetUpsample())
# Build trainer
trainer = Trainer(model)
trainer.build_criterion(CWGANDiscriminatorLoss(penalty_weight=args.penalty_weight, model=model))
trainer.build_optimizer('Adam', [parameter for discriminator in model.discriminators for parameter in discriminator.parameters()], lr=args.discriminator_lr)
trainer.save_every((1, 'epochs'))
trainer.save_to_directory(args.save_directory)
trainer.set_max_num_epochs(args.epochs)
trainer.register_callback(CGenerateDataCallback(args, dataset=dataset))
trainer.register_callback(CGeneratorTrainingCallback(
args,
parameters=model.generator.parameters(),
criterion=WGANGeneratorLoss(), dataset=dataset))
trainer.bind_loader('train', train_loader, num_inputs=2)
# Custom logging configuration so it knows to log our images
if args.cuda:
trainer.cuda()
# Go!
trainer.fit()
def task(env):
dataset_name = 'MNIST'
dataset_path = env.dataset(dataset_name)
batch_size = 128
transform = transforms.Compose(
[
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
mnist_set = torchvision.datasets.MNIST(str(dataset_path), train=True, download=True, transform=transform)
train_loader = torch.utils.data.DataLoader(mnist_set, batch_size=batch_size,
shuffle=True, num_workers=2)
mnist_test_set = torchvision.datasets.MNIST(str(dataset_path), train=False, download=True, transform=transform)
test_loader = torch.utils.data.DataLoader(mnist_test_set, batch_size=512,
shuffle=True, num_workers=2)
model = Model(n_classes=10, in_channels=1, layers=4)
exp = TrainLog(env, dataset_name,model,log_time=True)
logging.info(' saving to %s', exp.save_directory)
logging.info(' logging to %s', exp.log_directory)
# Load loaders
# train_loader, validate_loader = get_cifar10_loaders(DATASET_DIRECTORY,
# download=DOWNLOAD_CIFAR)
# Build trainer
iterations = 5000
trainer = Trainer(model) \
.build_criterion('NLLLoss') \
.build_metric('CategoricalError') \
.build_optimizer('Adam', lr=0.001) \
.save_every((1, 'epochs')) \
.save_to_directory(str(exp.save_directory)) \
.validate_every((1, 'epochs'))\
.set_max_num_iterations(iterations) \
.build_logger(TensorboardLogger(log_scalars_every=(1, 'iteration'),
log_images_every='never'),
log_directory=str(exp.log_directory))
# Bind loaders
trainer.bind_loader('train', train_loader)
trainer.bind_loader('validate', test_loader)
trainer.cuda()
# Go!
logging.info('start training')
trainer.fit()
trainer.set_max_num_iterations(trainer.iteration_count + iterations)
trainer.build_optimizer('Adam',lr=0.0001)
logging.info('slower lr')
trainer.fit()
def my_train(load, folder):
click.echo('starting training')
os.makedirs(folder, exist_ok=True)
# joint_transform = Compose(
# RandomRotate(),
# RandomTranspose(),
# RandomFlip()
# )
# setup logger
os.makedirs('derived_data/log', exist_ok=True)
Logger.instance().setup('derived_data/log')
vae = Vae()
ds = HemoDataset(root_folder=root_folder, image_transform=None, training=True)
train_loader = torch.utils.data.DataLoader(ds, batch_size=1536, num_workers=8)
# Build trainer
trainer = Trainer(vae)
trainer.save_to_directory(folder)
if load:
trainer.load()
# trainer.cuda(devices=[0, 1])
trainer.cuda()
trainer.build_criterion(vae.loss_function())
trainer.build_optimizer('Adam', lr=0.001)
# trainer.validate_every((2, 'epochs'))
trainer.save_every((1, 'epochs'))
trainer.set_max_num_epochs(100)
trainer.build_logger(TensorboardLogger(log_scalars_every=(1, 'iteration'),
log_images_every='never',
# log_images_every=(1, 'iteration'),
log_directory=folder))
# Bind loaders
trainer.bind_loader('train', train_loader, num_inputs=1, num_targets=1)
# bind callbacks
trainer.register_callback(GarbageCollection(), trigger='end_of_training_iteration')
trainer.register_callback(ShowMinimalConsoleInfo(), trigger='end_of_training_iteration')
# trainer.bind_loader('train', train_loader, num_inputs=3, num_targets=1)
trainer.fit()
pushover_notification.send('embeddings generated')
def run(args):
dataset = RorschachWrapper()
save_args(args) # save command line to a file for reference
train_loader = rorschach_cgan_data_loader(args,
dataset=dataset) # get the data
# todo
model = patchCWGANModel(args,
discriminator=patchCDiscriminatorNetwork(args),
generator=CGeneratorNetwork(args))
# Build trainer
trainer = Trainer(model)
trainer.build_criterion(
CWGANDiscriminatorLoss(penalty_weight=args.penalty_weight,
model=model))
trainer.build_optimizer('Adam',
model.discriminator.parameters(),
lr=args.discriminator_lr)
trainer.save_every((1, 'epochs'))
trainer.save_to_directory(args.save_directory)
trainer.set_max_num_epochs(args.epochs)
trainer.register_callback(CGenerateDataCallback(args, dataset=dataset))
trainer.register_callback(
CGeneratorTrainingCallback(args,
parameters=model.generator.parameters(),
criterion=WGANGeneratorLoss(),
dataset=dataset))
trainer.bind_loader('train', train_loader, num_inputs=2)
# Custom logging configuration so it knows to log our images
logger = TensorboardLogger(log_scalars_every=(1, 'iteration'),
log_images_every=(args.log_image_frequency,
'iteration'))
trainer.build_logger(logger, log_directory=args.save_directory)
logger.observe_state('generated_images')
logger.observe_state('real_images')
logger._trainer_states_being_observed_while_training.remove(
'training_inputs')
if args.cuda:
trainer.cuda()
# Go!
trainer.fit()
def train_model(args):
"""
Perform training then call prediction
"""
model = all_cnn_module()
model.apply(initializer)
train_loader, validate_loader, test_loader = make_loaders(args)
# Build trainer
savepath = os.path.join(args.save_directory,
Trainer()._checkpoint_filename)
if os.path.exists(savepath):
trainer = Trainer().load(from_directory=args.save_directory)
if args.cuda:
trainer.cuda()
else:
trainer = Trainer(model) \
.build_criterion('CrossEntropyLoss') \
.build_metric('CategoricalError') \
.save_every((1, 'epochs')) \
.validate_every((1, 'epochs')) \
.save_to_directory(args.save_directory) \
.set_max_num_epochs(args.epochs) \
.build_logger(TensorboardLogger(log_scalars_every=(1, 'iteration'),
log_images_every='never'),
log_directory=args.save_directory)
# These are the params from the paper
trainer.build_optimizer('SGD',
lr=0.01,
momentum=0.9,
weight_decay=0.001)
# Also works with Adam and default settings
# trainer.build_optimizer('Adam')
trainer.bind_loader('train', train_loader)
trainer.bind_loader('validate', validate_loader)
if args.cuda:
trainer.cuda()
# Go!
trainer.fit()
trainer.save()
write_predictions(args, trainer.model, test_loader)
def run(args):
save_args(args) # save command line to a file for reference
train_loader = mnist_data_loader(args) # get the data
model = GANModel(args,
discriminator=DiscriminatorNetwork(args),
generator=GeneratorNetwork(args))
# Build trainer
trainer = Trainer(model)
trainer.build_criterion(
WGANDiscriminatorLoss(penalty_weight=args.penalty_weight, model=model))
trainer.build_optimizer('Adam',
model.discriminator.parameters(),
lr=args.discriminator_lr)
trainer.save_every((1, 'epochs'))
trainer.save_to_directory(args.save_directory)
trainer.set_max_num_epochs(args.epochs)
trainer.register_callback(GenerateDataCallback(args))
trainer.register_callback(
GeneratorTrainingCallback(args,
parameters=model.generator.parameters(),
criterion=WGANGeneratorLoss()))
trainer.bind_loader('train', train_loader)
# Custom logging configuration so it knows to log our images
logger = TensorboardLogger(log_scalars_every=(1, 'iteration'),
log_images_every=(args.log_image_frequency,
'iteration'))
trainer.build_logger(logger, log_directory=args.save_directory)
logger.observe_state('generated_images')
logger.observe_state('real_images')
logger._trainer_states_being_observed_while_training.remove(
'training_inputs')
if args.cuda:
trainer.cuda()
# Go!
trainer.fit()
# Generate video from saved images
if not args.no_ffmpeg:
generate_video(args.save_directory)
# data loaders
from inferno.io.box.cifar import get_cifar10_loaders
train_loader, validate_loader = get_cifar10_loaders(DATASET_DIRECTORY,
download=DOWNLOAD_CIFAR)
logger = TensorboardLogger(log_scalars_every=(1, 'iteration'),
log_images_every='never')
##################################################
# Build trainer
from inferno.trainers.basic import Trainer
trainer = Trainer(model)
trainer.build_criterion('CrossEntropyLoss')
trainer.build_metric('CategoricalError')
trainer.build_optimizer('Adam')
trainer.validate_every((2, 'epochs'))
trainer.save_every((5, 'epochs'))
trainer.save_to_directory(SAVE_DIRECTORY)
trainer.set_max_num_epochs(10)
trainer.build_logger(logger, log_directory=LOG_DIRECTORY)
trainer.set_log_directory(LOG_DIRECTORY)
##################################################
# Bind loaders
trainer.bind_loader('train', train_loader)
trainer.bind_loader('validate', validate_loader)
##################################################
p0, p1 = (0.86, 0.14)
print("class p ", p0, p1)
bsd_val = Bsd500Sp(bsd_root=bsd_root,
pmap_root=pmap_root,
split='val',
joint_transformation=joint_transformation)
model = ConvNet() #.double()
smoothness = 0.001
trainer = Trainer(model)
trainer.build_criterion(LossWrapper(p0=p0, p1=p1))
trainer.build_optimizer('Adam') #, lr=0.0001)
trainer.validate_every((1, 'epochs'))
#trainer.save_every((4, 'epochs'))
trainer.save_to_directory(SAVE_DIRECTORY)
trainer.set_max_num_epochs(200)
trainer.register_callback(
SaveAtBestValidationScore(smoothness=smoothness, verbose=True))
trainer.register_callback(
AutoLR(factor=0.5,
patience='1 epochs',
monitor_while='validating',
monitor='validation_loss',
monitor_momentum=smoothness,
consider_improvement_with_respect_to='previous',
verbose=True))
trainer = Trainer(net)
trainer.bind_loader('train', trainloader)
trainer.bind_loader('validate', valloader)
trainer.save_to_directory('./checkpoints')
trainer.save_every((200, 'iterations'))
trainer.build_logger(TensorboardLogger(log_scalars_every=(1, 'iteration'),
log_images_every='never'), log_directory=LOG_DIRECTORY)
trainer.validate_every((200, 'iterations'), for_num_iterations=50)
#trainer.build_metric()
trainer.build_criterion(nn.L1Loss)
trainer.build_optimizer(optim.Adam, lr=1e-4, weight_decay=0.0005)
trainer.set_max_num_iterations(20000)
if torch.cuda.is_available():
trainer.cuda()
print('starting training')
trainer.fit()
print('finished training')
