def main():
# capture the config path from the run arguments
# then process the json configuration file
config = fetch_args()
# create the experiments dirs
create_dirs([config.tensorboard_log_dir, config.checkpoint_dir])
print('Create the data generator.')
train_data_loader = DataLoader(config, 'train')
valid_data_loader = DataLoader(config, 'valid')
print('Create the model.')
model = Model(config)
if config.pretrained_model_checkpoint is not None:
model.load(config.pretrained_model_checkpoint)
if config.evaluate:
print('Predicting on test set.')
test_data_loader = DataLoader(config, 'test')
evaluator = Evaluator(model.model, test_data_loader, config)
evaluator.evaluate()
exit(0)
print('Create the trainer')
trainer = Trainer(model.model, train_data_loader, valid_data_loader, config)
print('Start training the model.')
trainer.train()
def main():
# capture the config path from the run arguments
# then process the JSON config file
try:
args = get_args()
config = process_config_file(args.config)
except:
print("missing or invalid arguments")
exit(0)
# create the experiment dirs
create_dirs([config.summary_dir, config.checkpoints_dir])
# create tf session
sess = tf.Session()
# create data loader
data = DataLoader(config)
# create an instance of the model
model = Model(config)
# create tensorboard logger
logger = Logger(sess, config)
# create trainer and pass all the components to it
trainer = Trainer(sess, model, data, logger, config)
# load model if it exists
model.load(sess)
# train the model
trainer.train()
def eval():
try:
args = get_args()
config = process_config(args.config)
except:
print("missing or invalid arguments")
exit(0)
# Get Model
model_types = import_module('models.' + config.architecture + '_model')
Model = getattr(model_types, 'Model')
# create tensorflow session
sess = tf.Session()
# create your data generator
data_loader = DataGenerator(config, eval_phase=True, eval_on_test_data=True)
# create instance of the model you want
model = Model(data_loader, config)
# create trainer and path all previous components to it
trainer = Trainer(sess, model, config, None, data_loader, load_best=True)
# here we evaluate on the test dataset
test_loss, test_cer = trainer.test(tqdm_enable=True)
print('\nTest set Loss:', test_loss)
print('Test set CER:', round(test_cer*100, 2), '%')
def init() -> None:
"""
The main function of the project used to initialise all the required classes
used when training the model
"""
# get input arguments
args = get_args()
# get static config information
config = process_config()
# combine both into dictionary
config = {**config, **args}
# initialise model
model = VGG16(config)
# create your data generators for each mode
train_data = TFRecordShardLoader(config, mode="train")
val_data = TFRecordShardLoader(config, mode="val")
test_data = TFRecordShardLoader(config, mode="test")
# initialise the estimator
trainer = Trainer(config, model, train_data, val_data, test_data)
# start training
trainer.run()
def __init__(self, params, session, name="GAN", mode="train"):
self.generator = tf.make_template(name + '/generator', Generator)
self.discriminator = tf.make_template(name + '/discriminator', Discriminator)
Trainer.__init__(self, session, params, name=name, mode=mode)
self.build_eval_graph()
self.train_X = np.transpose(self.train_X, (0, 3, 1, 2))
self.test_X = np.transpose(self.test_X, (0, 3, 1, 2))
def main():
# capture the config path from the run arguments
# then process the json configuration file
try:
args = get_args()
config = process_config(args.config)
except Exception as e:
print("missing or invalid arguments %s" % e)
exit(0)
os.environ["CUDA_VISIBLE_devices"] = config.gpu
import tensorflow as tf
# create the experiments dirs
create_dirs([config.summary_dir, config.checkpoint_dir])
# create tensorflow session
gpuconfig = tf.ConfigProto(allow_soft_placement=True,
log_device_placement=False)
gpuconfig.gpu_options.visible_device_list = config.gpu
sess = tf.Session(config=gpuconfig)
# create your data generator
data = DataGenerator(config)
# create an instance of the model you want
model = invariant_basic(config, data)
# create trainer and pass all the previous components to it
trainer = Trainer(sess, model, data, config)
# load model if exists
model.load(sess)
# here you train your model
trainer.train()
def main():
# capture the config path from the run arguments
# then process the json configration file
# try:
# args = get_args()
# config = process_config(args.config)
# except:
# print("missing or invalid arguments")
# exit(0)
config = get_config_from_json('configs/config.json')
pdb.set_trace()
# create the experiments dirs
create_dirs([config.summary_dir, config.checkpoint_dir])
# create tensorflow session
sess = tf.Session()
# create instance of the model you want
model = Model(config)
# create your data generator
data = DataGenerator(config)
# create tensorboard logger
logger = Logger(sess, config)
# create trainer and path all previous components to it
trainer = Trainer(sess, model, data, config, logger)
# here you train your model
trainer.train()
def main():
# capture the config path from the run arguments
# then process the json configration file
# try:
# args = get_args()
# config = process_config(args.config)
# except:
# print("missing or invalid arguments")
# exit(0)
config, _ = get_config_from_json('configs/config.json')
# create the experiments dirs
# create_dirs([config.summary_dir, config.checkpoint_dir])
# create tensorflow session
sess = tf.Session()
# create instance of the model you want
model = Model(config)
# create your data generator
data = DataGenerator(config)
# create tensorboard logger
# logger = Logger(sess, config)
# create trainer and path all previous components to it
trainer = Trainer(sess, config, model, data)
for epoch in range(150):
losses, samples, likelihood, diversity = trainer.train_epoch()
print(likelihood, diversity)
def __init__(self, args, worker_id, tasks, par_list):
super().__init__()
self.tasks = tasks
if type(args.gpu_number) == list:
args.device = torch.device(
'cuda', args.gpu_number[worker_id % len(args.gpu_number)])
else:
args.device = torch.device('cuda', args.gpu_number)
self.trainer = Trainer(args, worker_id=worker_id)
self.par_list = par_list
def main(args):
export_root, args = setup_experiments(args)
device = args.device
model_checkpoint_path = os.path.join(export_root, 'models')
dataloaders = dataloaders_factory(args)
model = model_factory(args)
writer = SummaryWriter(os.path.join(export_root, 'logs'))
train_loggers = [
MetricGraphPrinter(writer,
key='ce_loss',
graph_name='ce_loss',
group_name='Train'),
MetricGraphPrinter(writer,
key='epoch',
graph_name='Epoch',
group_name='Train')
]
val_loggers = [
MetricGraphPrinter(writer,
key='mean_iou',
graph_name='mIOU',
group_name='Validation'),
MetricGraphPrinter(writer,
key='acc',
graph_name='Accuracy',
group_name='Validation'),
RecentModelLogger(model_checkpoint_path),
BestModelLogger(model_checkpoint_path, metric_key='mean_iou'),
]
# criterion = nn.CrossEntropyLoss(ignore_index=IGNORE_LABEL, weight=torch.Tensor(CLASS_WEIGHT).to(device))
criterion = nn.CrossEntropyLoss()
optimizer = create_optimizer(model, args)
scheduler = optim.lr_scheduler.StepLR(optimizer,
step_size=args.decay_step,
gamma=args.gamma)
trainer = Trainer(model,
dataloaders,
optimizer,
criterion,
args.epoch,
args,
num_classes=42,
log_period_as_iter=args.log_period_as_iter,
train_loggers=train_loggers,
val_loggers=val_loggers,
lr_scheduler=scheduler,
device=device)
trainer.train()
writer.close()
def train(cfg):
# output
output_dir = cfg.OUTPUT_DIR
if os.path.exists(output_dir):
raise KeyError("Existing path: ", output_dir)
else:
os.makedirs(output_dir)
with open(os.path.join(output_dir, 'config.yaml'), 'w') as f_out:
print(cfg, file=f_out)
# logger
logger = make_logger("project", output_dir, 'log')
# device
num_gpus = 0
if cfg.DEVICE == 'cuda':
os.environ['CUDA_VISIBLE_DEVICES'] = cfg.DEVICE_ID
num_gpus = len(cfg.DEVICE_ID.split(','))
logger.info("Using {} GPUs.\n".format(num_gpus))
cudnn.benchmark = True
device = torch.device(cfg.DEVICE)
# data
train_loader, query_loader, gallery_loader, num_classes = make_loader(cfg)
# model
model = make_model(cfg, num_classes=num_classes)
if num_gpus > 1:
model = nn.DataParallel(model)
# solver
criterion = make_loss(cfg, num_classes)
optimizer = make_optimizer(cfg, model)
scheduler = make_scheduler(cfg, optimizer)
# do_train
trainer = Trainer(model=model,
optimizer=optimizer,
criterion=criterion,
logger=logger,
scheduler=scheduler,
device=device)
trainer.run(start_epoch=0,
total_epoch=cfg.SOLVER.MAX_EPOCHS,
train_loader=train_loader,
query_loader=query_loader,
gallery_loader=gallery_loader,
print_freq=cfg.SOLVER.PRINT_FREQ,
eval_period=cfg.SOLVER.EVAL_PERIOD,
out_dir=output_dir)
print('Done.')
def train_all():
print("Training all!")
deep_dog = DeepDog()
Trainer(deep_dog)
cnn = CNN()
Trainer(cnn)
cnn_pool = CNNPool()
Trainer(cnn_pool)
cnn_dropout = CNNDropout()
Trainer(cnn_dropout)
def main(unused_argv):
tf.logging.set_verbosity(3)
try:
config = process_config()
except:
exit(0)
create_dirs(config, [config.checkpoint_dir, config.evaluate_dir, config.presentation_dir, config.summary_dir])
session = tf.Session()
K.set_session(session)
if config.mode == "evaluate":
model = Unet(config, is_evaluating=True)
trainer = Trainer(config, None, None, model, session)
sat_data = [Aracati.load_data(file, is_grayscale=False) for file in
sorted(glob.glob("./datasets/aracati/test/input/*.png"))]
sat_data = [sat_data[i:i+1] for i in range(len(sat_data))]
model.load(session)
trainer.evaluate_data(sat_data, Aracati.save_data)
else:
data = Aracati(config)
model = Unet(config)
logger = Logger(config, session)
trainer = Trainer(config, data, logger, model, session)
if config.mode == "restore":
model.load(session)
trainer.train()
def main():
#%%directories and configs
model_name = "RNN_points_256units_residual_preFCNN_GRID"
SAVEDIR = os.getcwd() + "\\TEST\\" +model_name + "\\saved_model\\"
LOGDIR = os.getcwd() + "\\TEST\\" +model_name + "\\"
data_opts = cfg.default_data_opts()
model_config = cfg.default_model_config(data_opts, SAVEDIR)
trainer_cfg = cfg.default_trainer_config(LOGDIR)
#%% Load training and eval data
train_path = os.getcwd() + "\\DATA\\Training.mat"
test_path = os.getcwd() + "\\DATA\\Testing.mat"
umx_path = os.getcwd() + "\\DATA\\UMX_spectra.mat""
training_data = DataHandler(data_opts, trainer_cfg, train_path, umx_path, train_flag = True)
test_val_data = DataHandler(data_opts, trainer_cfg, test_path, umx_path, train_flag = False, split = 0.1)
#%%TRAIN AND VALIDATE==========================================================
sess = tf.Session()
model = RNN_Model(model_config)
trainer = Trainer(sess, model, training_data, test_val_data, trainer_cfg)
trainer.train()
#%% RESTORE THE BEST MODEL AND TEST
model.load(sess)
features_batch, labels_batch, sp_batch, so2_batch = test_val_data.get_test_data()
input_dict = {model.NN_input_features: features_batch,
model.NN_input_labels: labels_batch,
model.NN_input_train: False}
eig_out_dict = sess.run(model.predictions, feed_dict=input_dict)
#flatten the output and the data
eig_out = eig_out_dict['eigenparams']
out_flat = ut.flatten_data(eig_out, model_config)
spectra_flat = ut.flatten_data(sp_batch, model_config)
so2_labels_flat = ut.flatten_data(so2_batch, model_config)
# convert to so2 and calculate error values
so2 = ut.eigenparams_to_so2(spectra_flat, out_flat, test_val_data.umx_sp)
abs_err_so2 = np.abs(so2 - so2_labels_flat)
mean_abs_err_so2 = np.mean(abs_err_so2)
std_abs_err_so2 = np.std(abs_err_so2)
print('mean so2 TEST error: %f' % mean_abs_err_so2)
def __init__(self, args, worker_id, iter, best_iter, best_score,
population, finish_tasks):
super().__init__()
self.iter = iter
self.best_iter = best_iter
self.verbose = args.verbose
self.best_score = best_score
self.population = population
self.finish_tasks = finish_tasks
if type(args.gpu_number) == list:
args.device = torch.device(
'cuda', args.gpu_number[worker_id % len(args.gpu_number)])
else:
args.device = torch.device('cuda', args.gpu_number)
self.trainer = Trainer(args, worker_id=worker_id)
def main():
# capture the config path from the run arguments
# then process the json configuration file
try:
args = get_args()
config = process_config(args.config)
except:
print("missing or invalid arguments")
exit(0)
# Get Model
model_types = import_module('models.' + config.architecture + '_model')
Model = getattr(model_types, 'Model')
# create the experiments dirs
if config.train_from_start:
if os.path.exists(config.summary_dir):
shutil.rmtree(config.summary_dir)
if os.path.exists(config.checkpoint_dir):
shutil.rmtree(config.checkpoint_dir)
if os.path.exists(config.best_model_dir):
shutil.rmtree(config.best_model_dir)
create_dirs(
[config.summary_dir, config.checkpoint_dir, config.best_model_dir])
# create tensorflow session
sess = tf.Session()
# create your data generator
data_loader = DataGenerator(config)
# create instance of the model you want
model = Model(data_loader, config)
# create tensorboard logger
logger = DefinedSummarizer(sess,
summary_dir=config.summary_dir,
scalar_tags=[
'train/loss_per_epoch',
'train/cer_per_epoch',
'test/loss_per_epoch', 'test/cer_per_epoch'
])
# create trainer and path all previous components to it
trainer = Trainer(sess, model, config, logger, data_loader)
# here we train our model
trainer.train()
def main(args):
logger = Logger()
if args.dataset != 'func':
loss = cross_entropy_loss
metrics = [accuracy]
if args.arch[:6] == 'deeper':
model = eval(args.arch[:6].title() + args.dataset.title() + 'CNN')(
int(args.arch[6:]))
identifier = type(
model).__name__ + args.arch[6:] + '_' + args.dataset + '_'
else:
model = eval(args.arch.title() + args.dataset.title() + 'CNN')()
identifier = type(model).__name__ + '_' + args.dataset + '_'
data_loader = eval(args.dataset.title() + 'Loader')(args.batch_size,
args.rand_label,
args.noise)
else:
loss = mse_loss
metrics = []
model = eval(args.arch.title() + 'FC')()
data_loader = FunctionDataLoader(args.target_func,
batch_size=args.batch_size,
n_sample=1024,
x_range=(0, 1))
identifier = type(model).__name__ + '_' + args.target_func + '_'
model.summary()
optimizer = optim.Adam(model.parameters())
data_loader, valid_data_loader = split_validation(data_loader,
args.validation_split)
trainer = Trainer(model,
loss,
metrics,
data_loader=data_loader,
valid_data_loader=valid_data_loader,
optimizer=optimizer,
epochs=args.epochs,
logger=logger,
save_dir=args.save_dir,
save_freq=args.save_freq,
resume=args.resume,
verbosity=args.verbosity,
identifier=identifier,
with_cuda=not args.no_cuda,
save_grad=args.save_grad)
trainer.train()
print(logger)
def main():
# capture the config path from the run arguments
# then process the json configuration file
try:
args = get_args()
config = process_config(args.config)
except Exception as e:
print("missing or invalid arguments %s" % e)
exit(0)
os.environ["CUDA_VISIBLE_devices"] = config.gpu
import tensorflow as tf
import numpy as np
tf.set_random_seed(100)
np.random.seed(100)
base_summary_folder = config.summary_dir
base_exp_name = config.exp_name
# create the experiments dirs
create_dirs([config.summary_dir, config.checkpoint_dir])
for lr in [0.00008 * (2**i) for i in range(8)]:
for decay in [0.6, 0.7, 0.8, 0.9]:
config.learning_rate = lr
config.decay_rate = decay
config.exp_name = base_exp_name + " lr={0}_decay={1}".format(
lr, decay)
curr_dir = os.path.join(base_summary_folder,
"lr={0}_decay={1}".format(lr, decay))
config.summary_dir = curr_dir
create_dirs([curr_dir])
# create your data generator
data = DataGenerator(config)
gpuconfig = tf.ConfigProto(allow_soft_placement=True,
log_device_placement=False)
gpuconfig.gpu_options.visible_device_list = config.gpu
sess = tf.Session(config=gpuconfig)
# create an instance of the model you want
model = invariant_basic(config, data)
# create trainer and pass all the previous components to it
trainer = Trainer(sess, model, data, config)
# here you train your model
acc, loss = trainer.train()
sess.close()
tf.reset_default_graph()
doc_utils.summary_10fold_results(config.summary_dir)
def main():
# capture the config path from the run arguments
# then process the json configuration file
try:
args = get_args()
config = process_config(args.config)
except Exception as e:
print("missing or invalid arguments %s" % e)
exit(0)
os.environ["CUDA_VISIBLE_DEVICES"] = config.gpu
# import tensorflow as tf
import torch
# create the experiments dirs
create_dirs([config.summary_dir, config.checkpoint_dir])
# create tensorflow session
# gpuconfig = tf.ConfigProto(allow_soft_placement=True, log_device_placement=False)
# gpuconfig.gpu_options.visible_device_list = config.gpus_list
# gpuconfig.gpu_options.allow_growth = True
# sess = tf.Session(config=gpuconfig)
if config.cuda:
print(f'Using GPU : {torch.cuda.get_device_name(int(config.gpu))}')
else:
print(f'Using CPU')
# create your data generator
data = DataGenerator(config)
# data = torch.from_numpy(data)
# create an instance of the model you want
model = invariant_basic(config, data)
if config.cuda:
model = model.cuda()
for name, param in model.named_parameters():
# if param.device.type != 'cuda':
print(f'{name}, device type {param.device.type}')
# create trainer and pass all the previous components to it
# trainer = Trainer(sess, model, data, config)
trainer = Trainer(model, data, config)
# load model if exists
# model.load(sess)
# here you train your model
trainer.train()
def main():
# capture the config path from the run arguments
# then process the json configuration file
try:
args = get_args()
config = process_config(args.config, dataset_name='QM9')
except Exception as e:
print("missing or invalid arguments %s" % e)
exit(0)
os.environ["CUDA_VISIBLE_DEVICES"] = config.gpu
import tensorflow as tf
import numpy as np
tf.set_random_seed(100)
np.random.seed(100)
print("lr = {0}".format(config.hyperparams.learning_rate))
print("decay = {0}".format(config.hyperparams.decay_rate))
if config.target_param is not False: # (0 == False) while (0 is not False)
print("target parameter: {0}".format(config.target_param))
print(config.architecture)
# create the experiments dirs
create_dirs([config.summary_dir, config.checkpoint_dir])
doc_utils.doc_used_config(config)
# create your data generator
data = DataGenerator(config)
gpuconfig = tf.ConfigProto(allow_soft_placement=True,
log_device_placement=False)
gpuconfig.gpu_options.visible_device_list = config.gpus_list
gpuconfig.gpu_options.allow_growth = True
sess = tf.Session(config=gpuconfig)
# create an instance of the model you want
model = invariant_basic(config, data)
# create trainer and pass all the previous components to it
trainer = Trainer(sess, model, data, config)
# here you train your model
trainer.train()
# test model, restore best model
test_dists, test_loss = trainer.test(load_best_model=True)
sess.close()
tf.reset_default_graph()
doc_utils.summary_qm9_results(config.summary_dir, test_dists, test_loss,
trainer.best_epoch)
def main():
# capture the config path from the run arguments
# then process the json configuration file
try:
args = get_args()
config = process_config(args.config)
except Exception as e:
print("missing or invalid arguments %s" % e)
exit(0)
os.environ["CUDA_VISIBLE_DEVICES"] = config.gpu
import tensorflow as tf
import numpy as np
tf.set_random_seed(100)
np.random.seed(100)
print("lr = {0}".format(config.learning_rate))
print("decay = {0}".format(config.decay_rate))
print(config.architecture)
# create the experiments dirs
create_dirs([config.summary_dir, config.checkpoint_dir])
for exp in range(1, config.num_exp + 1):
for fold in range(1, 11):
print("Experiment num = {0}\nFold num = {1}".format(exp, fold))
# create your data generator
config.num_fold = fold
data = DataGenerator(config)
gpuconfig = tf.ConfigProto(allow_soft_placement=True,
log_device_placement=False)
gpuconfig.gpu_options.visible_device_list = config.gpus_list
gpuconfig.gpu_options.allow_growth = True
sess = tf.Session(config=gpuconfig)
# create an instance of the model you want
model = invariant_basic(config, data)
# create trainer and pass all the previous components to it
trainer = Trainer(sess, model, data, config)
# here you train your model
acc, loss = trainer.train()
doc_utils.doc_results(acc, loss, exp, fold, config.summary_dir)
sess.close()
tf.reset_default_graph()
doc_utils.summary_10fold_results(config.summary_dir)
def __init__(self,
sess,
model,
wgan,
params,
name="classifier",
mode="train"):
'''
Init:
sess: tf.Session()
model: function that takes in input placeholder, is_training placeholder and params dictionary,
wgan: trainer for adversarial generator.
params: dictionary of hyperparameters for the model and training.
'''
self.model = model
self.gan = wgan
Trainer.__init__(self, sess, params, name, mode)
self.adversarial_dir = os.path.join(self.checkpoint_dir, "adversarial")
check_folder(self.adversarial_dir)
def main(args):
#Train using the PBT algorithm
if args.pbt_training:
Pbt_trainer(args)
#Train SVM or RF
elif args.SVM:
SVM(args)
elif args.RF:
RF(args)
#Get trainer and train model
elif args.is_train:
trainer = Trainer(args)
trainer.train()
else:
#Best performing model is loaded and evaluated on the test set
evalObj = Eval_obj(args)
evalObj.demo()
def main():
try:
args = get_args()
config = process_config(args.config)
except:
print("Missing or invalid arguments")
exit(0)
create_dirs([config.summary_dir, config.checkpoint_dir])
#sess = tf.Session()
print("Loading dataset")
data = DataLoader(config, args.preprocess)
print("Finished loading dataset")
data.next_batch()
model = Biaxial(config)
logger = Logger(sess, config)
trainer = Trainer(sess, model, data, config, logger)
model.load(sess)
trainer.train()
def __init__(self,
sess,
model,
generator,
params,
name="classifier",
mode="train"):
'''
Init:
sess: tf.Session()
model: function that takes in input placeholder, is_training placeholder and params dictionary,
adv_trainer: trainer for adversarial generator, must be not None is adversarial_mode == "gan"
returns a tensor containing the logits.
params: dictionary of hyperparameters for the model and training.
'''
self.model = model
self.generator = generator
Trainer.__init__(self, sess, params, name, mode)
self.adversarial_dir = os.path.join(self.checkpoint_dir, "adversarial")
check_folder(self.adversarial_dir)
def build_model_and_trainer(config, data_loader):
network_builder = get_network_builder(config=config)
backbone = network_builder.define_backbone(model_name="backbone")
full_model = network_builder.build_full(backbone=backbone,
model_name="full")
# TODO: Finish implementing the trainer
data_loader = Dataloader(config=config)
trainer = Trainer(data_loader=data_loader,
config=config,
backbone=backbone,
full=full_model)
return backbone, full_model, trainer
def train(args):
config_path = args.conf
with open(config_path) as f:
config = yaml.load(f, Loader=yaml.FullLoader)
config['network']['use_cuda'] = config['network'][
'use_cuda'] and torch.cuda.is_available()
config['checkname'] = 'deeplab-' + str(config['network']['backbone'])
# torch.manual_seed(config['seed'])
trainer = Trainer(config)
print('Starting Epoch:', trainer.config['training']['start_epoch'])
print('Total Epoches:', trainer.config['training']['epochs'])
for epoch in range(trainer.config['training']['start_epoch'],
trainer.config['training']['epochs']):
trainer.training(epoch)
if not trainer.config['training'][
'no_val'] and epoch % config['training']['val_interval'] == (
config['training']['val_interval'] - 1):
trainer.validation(epoch)
trainer.writer.close()
def main():
# capture the config path from the run arguments
# then process the json configuration file
try:
args = get_args()
config = process_config(args.config, args.dataset_name)
except Exception as e:
print("missing or invalid arguments {}".format(e))
exit(0)
# os.environ['CUDA_LAUNCH_BLOCKING'] = "1" # TODO uncomment only for CUDA error debugging
os.environ["CUDA_VISIBLE_DEVICES"] = config.gpu
torch.manual_seed(100)
np.random.seed(100)
# torch.backends.cudnn.deterministic = True # can impact performance
# torch.backends.cudnn.benchmark = False # can impact performance
print("lr = {0}".format(config.hyperparams.learning_rate))
print("decay = {0}".format(config.hyperparams.decay_rate))
print(config.architecture)
# create the experiments dirs
create_dirs([config.summary_dir, config.checkpoint_dir])
doc_utils.doc_used_config(config)
for exp in range(1, config.num_exp + 1):
for fold in range(1, 11):
print("Experiment num = {0}\nFold num = {1}".format(exp, fold))
# create your data generator
config.num_fold = fold
data = DataGenerator(config)
# create an instance of the model you want
model_wrapper = ModelWrapper(config, data)
# create trainer and pass all the previous components to it
trainer = Trainer(model_wrapper, data, config)
# here you train your model
trainer.train()
doc_utils.summary_10fold_results(config.summary_dir)
def main():
# capture the config path from the run arguments
# then process the json configuration file
try:
args = get_args()
config = process_config(args.config, dataset_name='QM9')
except Exception as e:
print("missing or invalid arguments %s" % e)
exit(0)
os.environ["CUDA_VISIBLE_DEVICES"] = config.gpu
torch.manual_seed(100)
np.random.seed(100)
# torch.backends.cudnn.deterministic = True # can impact performance
# torch.backends.cudnn.benchmark = False # can impact performance
print("lr = {0}".format(config.hyperparams.learning_rate))
print("decay = {0}".format(config.hyperparams.decay_rate))
if config.target_param is not False: # (0 == False) while (0 is not False)
print("target parameter: {0}".format(config.target_param))
print(config.architecture)
# create the experiments dirs
create_dirs([config.summary_dir, config.checkpoint_dir])
doc_utils.doc_used_config(config)
data = DataGenerator(config)
# create an instance of the model you want
model_wrapper = ModelWrapper(config, data)
# create trainer and pass all the previous components to it
trainer = Trainer(model_wrapper, data, config)
# here you train your model
trainer.train()
# test model, restore best model
test_dists, test_loss = trainer.test(load_best_model=True)
doc_utils.summary_qm9_results(config.summary_dir, test_dists, test_loss,
trainer.best_epoch)
def main():
parser = ArgumentParser()
parser.add_argument("-m", "--model", dest="model")
parser.add_argument("-a", "--all", action="store_true", dest="all")
args = parser.parse_args()
print(args)
if args.all:
train_all()
model = None
if args.model:
model = retrieve_option_model(args.model)
else:
print("No Model specified!")
model = retrieve_option_model("")
Trainer(model)
