def main(args):
if cuda.is_available():
cuda.set_device(int(args.gpu_num))
cudnn.benchmark = True
start_time = time.time()
dp = DataProcessor(args.src_lang, args.trg_lang)
train_dataset, valid_dataset, test_dataset, vocabs = dp.load_data(
'fra.txt', 'english_french.pkl')
print("Elapsed Time: %1.3f \n" % (time.time() - start_time))
print("=========== Data Stat ===========")
print("Train: ", len(train_dataset))
print("Valid: ", len(valid_dataset))
print("Test: ", len(test_dataset))
print("=================================")
train_loader = data.BucketIterator(dataset=train_dataset,
batch_size=args.batch_size,
repeat=False,
shuffle=True,
sort_within_batch=True,
sort_key=lambda x: len(x.src))
val_loader = data.BucketIterator(dataset=valid_dataset,
batch_size=args.batch_size,
repeat=False,
shuffle=True,
sort_within_batch=True,
sort_key=lambda x: len(x.src))
trainer = Trainer(train_loader, val_loader, vocabs, args)
trainer.train()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--epoches', '-e', type=int, default=10, help='Number of training epoches')
parser.add_argument('--batch', '-b', type=int, default=16, help='Size of batches')
parser.add_argument('--samples', '-s', type=int, default=1000, help='Number of samples')
parser.add_argument('--lr', '-l', type=float, default=0.001, help='Learning rate')
args = parser.parse_args()
if not os.path.exists('save/'):
os.mkdir('save/')
if args.batch > args.samples:
raise Exception("Batch size cannot be larger than total number of samples in dataset")
if type(args.epoches) != int:
raise Exception("Epoches number be an integer. Given "+str(type(args.epoches)))
if args.samples < 1000:
raise Exception("Insufficient training data. Sample size %d < 1000"%args.samples)
train_config = {'epochs': args.epoches, 'batchs': args.batch, 'samples':args.samples, 'lr': args.lr}
model = FullyConnected()
t = Trainer(model, train_config)
t.train()
def main(config):
data = data_loader(config)
data_len, X, y, X_val, y_Val = data.preprocess()
trainer = Trainer(config, data_len, X, y, X_val, y_Val)
trainer.train()
trainer.show_result()
def __init__(self):
"""
constructor
"""
self.__pre_processor = PreProcessor()
self.__trainer = Trainer()
self.__predictor = Predictor()
def main():
if flag.MARIO_ENV:
env = mario_env.make_train_0()
if flag.TRAIN:
new_trainer = Trainer(num_training_steps=200000,
num_epoch=3,
batch_size=16,
learning_rate=0.0001,
discount_factor=0.99,
env=env,
num_action=7,
save_interval=100,
log_interval=50,
decay_rate=0.001,
num_steps=16,
memory_size=10000,
update_target_net_interval=5)
new_trainer.collect_experience_and_train()
elif flag.PLAY:
new_player = Player(env=env,
load_path='./step5500-20191027-162213/train')
new_player.play()
def process(self):
"""
Trains different model based on a csv-data containing the hyper_params.
If a model is trained, results, parameters of model, coefficient mask and the hyperparaemters are saved
in analysis_folder. Models are numbered in the same ordered as they are in the hyper_params.csv.
"""
rng = jax.random.PRNGKey(-1)
rng_batch = npr.RandomState(5)
for j, hyper_params in self.hyper_params_df.iterrows():
hyper_params = hyper_params.to_dict()
path_save = self.analysis_folder + '/' + str(j)
if os.path.isfile(path_save):
continue
else:
loader = Loader(hyper_params)
train_set = hyper_params['training_set']
X, dX, X_eval, dX_eval, t = self.data[train_set]
loader.hyper_params['num_batches'], _ = divmod(
X.shape[0], loader.hyper_params['batch_size'])
loader.hyper_params['x_dim'] = X.shape[1]
model, hyper_params = loader.create_model(rng)
trainer = Trainer(X, dX, X_eval, dX_eval, t, model,
hyper_params)
results, params, coeff_mask = trainer.fit(rng_batch)
with open(path_save, 'wb') as fp:
pickle.dump([results, params, coeff_mask, hyper_params],
fp)
def main():
config = None
try:
args = get_args()
config = process_config(args.config)
if config is None:
raise Exception()
except:
print("Add a config file using \'--config file_name.json\'")
exit(1)
makedirs(config.summary_dir)
makedirs(config.checkpoint_dir)
logger = get_logger('log',
logpath=config.summary_dir,
filepath=os.path.abspath(__file__))
train_loader, test_loader = load_pytorch(config)
model = PolyGNN(state_dim=128,
n_adj=4,
coarse_to_fine_steps=config.coarse_to_fine_steps,
get_point_annotation=False)
trainer = Trainer(model, train_loader, test_loader, config, logger)
if config.train:
trainer.train()
if config.validation:
trainer.resume(os.path.join(config.checkpoint_dir, 'model.pth'))
trainer.test_epoch(cur_epoch=999, plot=True)
def main():
# Create Model, Criterion and State
model, criterion, state = create_model(args)
print("=> Model and criterion are ready")
# Create Dataloader
if not args.test_only:
train_loader = get_train_loader(args)
val_loader = get_test_loader(args)
print("=> Dataloaders are ready")
# Create Logger
logger = Logger(args, state)
print("=> Logger is ready") # Create Trainer
trainer = Trainer(args, model, criterion, logger)
print("=> Trainer is ready")
if args.test_only:
test_summary = trainer.test(0, val_loader)
print("- Test: Acc %6.3f " % (test_summary['acc']))
else:
start_epoch = logger.state['epoch'] + 1
print("=> Start training")
# test_summary = trainer.test(0, val_loader)
for epoch in range(start_epoch, args.n_epochs + 1):
train_summary = trainer.train(epoch, train_loader)
test_summary = trainer.test(epoch, val_loader)
logger.record(epoch, train_summary, test_summary, model)
logger.final_print()
def train(opt, trial):
model = getattr(models, opt.netType)(opt.nClasses)
model.to_gpu()
optimizer = chainer.optimizers.NesterovAG(lr=opt.LR, momentum=opt.momentum)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(opt.weightDecay))
train_iter, val_iter = dataset.setup(opt)
trainer = Trainer(model, optimizer, train_iter, val_iter, opt)
for epoch in range(1, opt.nEpochs + 1):
train_loss, train_top1 = trainer.train(epoch)
val_top1 = trainer.val()
sys.stderr.write('\r\033[K')
sys.stdout.write(
'| Epoch: {}/{} | Train: LR {} Loss {:.3f} top1 {:.2f} | Val: top1 {:.2f}\n'
.format(epoch, opt.nEpochs, trainer.optimizer.lr, train_loss,
train_top1, val_top1))
sys.stdout.flush()
if opt.save != 'None':
chainer.serializers.save_npz(
os.path.join(opt.save, 'model_trial{}.npz'.format(trial)), model)
chainer.serializers.save_npz(
os.path.join(opt.save, 'optimizer_trial{}.npz'.format(trial)),
optimizer)
def main():
config = None
try:
args = get_args()
config = process_config(args.config)
if config is None:
raise Exception()
except:
print("Add a config file using \'--config file_name.json\'")
exit(1)
makedirs(config.summary_dir)
makedirs(config.checkpoint_dir)
logger = get_logger('log', logpath=config.summary_dir, filepath=os.path.abspath(__file__))
train_labelled_data_loader, train_unlabelled_data_loader, test_loader = load_pytorch(config)
model = SDNet(config.image_size, config.num_anatomical_factors, config.num_modality_factors, config.num_classes)
print(model)
trainer = Trainer(model, train_labelled_data_loader, train_unlabelled_data_loader, test_loader, config, logger)
if config.train:
trainer.train()
if config.validation:
trainer.resume(os.path.join(config.checkpoint_dir, 'model.pth'))
trainer.test_epoch(debug=False)
def main():
index = 0
args = sys.argv
if len(args) > 1:
if args[1].replace(',', '').replace('.', '').replace('-', '').isdigit():
index = int(args[1])
else:
print("----------------------------------")
print("")
print("Argument is not digit")
print("Set index to 0")
print("")
print("----------------------------------")
else:
print("----------------------------------")
print("")
print("Arguments are too short")
print("Set index to 0")
print("")
print("----------------------------------")
setting_csv_path = "./setting.csv"
trainer = Trainer(setting_csv_path=setting_csv_path, index=index)
if not os.path.isfile(os.path.join(trainer.log_path, trainer.model_name, trainer.model_name)):
print("Trained weight file does not exist")
trainer.train()
def training():
train_dataset = TrainDataset(
image_dir=args.train_data_dir,
csv_path_train=
f'data/dataset_csv/list_combined_{args.train_type}_small_train.tsv',
csv_path_val=
f'data/dataset_csv/list_combined_{args.train_type}_small_val.tsv',
train_type=args.train_type,
batch_size=16,
shuffle=True,
random_seed=60,
image_shape=args.input_shape)
fm = FashionModel()
fm.create_model(num_classes=train_dataset.num_classes,
input_shape=[args.input_shape[0], args.input_shape[1], 3])
if args.checkpoint is not None:
fm.model.load_weights(args.checkpoint)
fm.model.summary()
trainer = Trainer(model=fm.model,
train_gen=train_dataset.train_generator,
val_gen=train_dataset.validation_generator,
epoch=args.epoch,
step=args.step)
trainer.train(log_dir=args.log_dir)
def train_func(config):
# Hyperparameters
bindings = []
for key, value in config.items():
bindings.append(f'{key}={value}')
# generate folder structures
run_paths = utils_params.gen_run_folder(bindings[2])
# set loggers
utils_misc.set_loggers(run_paths['path_logs_train'], logging.INFO)
# gin-config
# gin dir should be replaced by your own dir
gin.parse_config_files_and_bindings([r'D:\Uni Stuttgart\Deep learning lab\Diabetic Retinopathy Detection\dl-lab-2020-team08\diabetic_retinopathy\configs\config.gin'],
bindings)
utils_params.save_config(run_paths['path_gin'], gin.config_str())
# setup pipeline
train_ds, valid_ds, test_ds = datasets.load()
# model
model = DenseNet121(IMG_SIZE=256)
trainer = Trainer(model=model, ds_train=train_ds, ds_val=test_ds, run_paths=run_paths)
for val_accuracy in trainer.train():
tune.report(val_accuracy=val_accuracy)
def train_func(config):
# Hyperparameters
bindings = []
for key, value in config.items():
bindings.append(f'{key}={value}')
# generate folder structures
run_paths = utils_params.gen_run_folder(','.join(bindings))
# set loggers
utils_misc.set_loggers(run_paths['path_logs_train'], logging.INFO)
# gin-config
gin.parse_config_files_and_bindings(['/mnt/home/repos/dl-lab-skeleton/diabetic_retinopathy/configs/config.gin'], bindings)
utils_params.save_config(run_paths['path_gin'], gin.config_str())
# setup pipeline
ds_train, ds_val, ds_test, ds_info = load()
# model
model = vgg_like(input_shape=ds_info.features["image"].shape, n_classes=ds_info.features["label"].num_classes)
trainer = Trainer(model, ds_train, ds_val, ds_info, run_paths)
for val_accuracy in trainer.train():
tune.report(val_accuracy=val_accuracy)
def addPerson():
conn = sqlite3.connect('database.db')
if not os.path.exists('./dataset'):
os.makedirs('./dataset')
c = conn.cursor()
uname = e1.get() #Get value from name entry
c.execute('INSERT INTO users (name) VALUES (?)', (uname, ))
uid = c.lastrowid
sampleNum = 0
while True:
img = getFrame()
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
face_cascade = cv2.CascadeClassifier(
'haarcascade_frontalface_default.xml')
faces = face_cascade.detectMultiScale(gray, 1.3, 5)
for (x, y, w, h) in faces:
sampleNum = sampleNum + 1
cv2.imwrite(
'dataset/User.' + str(uid) + '.' + str(sampleNum) + '.jpg',
gray[y:y + h, x:x + w])
if sampleNum > 20:
break
conn.commit()
conn.close()
write('%s added' % (e1.get()))
Trainer()
def build_trainer(cfg, experiment_name, tensorboard_in_subdir=True):
global is_first_trainer
cfg = deepcopy(cfg)
name = datetime.now().strftime("%Y-%m-%d_%H-%M-%S") + cfg["general"]["tag"]
run_id = experiment_name + "_" + datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
base_log_dir = cfg['training']['log_path']
log_dir = f"{base_log_dir}/{experiment_name}/"
os.makedirs(log_dir, exist_ok=True)
cfg["name"] = name
cfg["training"]["log_path"] = log_dir
cfg['training']['disable_depth_estimator'] = not is_first_trainer or cfg['training'].get('disable_depth_estimator', False)
if tensorboard_in_subdir:
writer = SummaryWriter(log_dir=log_dir, filename_suffix=f'{experiment_name}.metrics')
img_writer = SummaryWriter(log_dir=log_dir, filename_suffix=f'{experiment_name}.tensorboardimgs')
else:
writer = SummaryWriter(log_dir=base_log_dir, filename_suffix=f'{experiment_name}.metrics')
img_writer = SummaryWriter(log_dir=base_log_dir, filename_suffix=f'{experiment_name}.tensorboardimgs')
logger = get_logger(log_dir)
with open(log_dir + "/cfg.yml", 'w') as fp:
yaml.dump(cfg, fp)
is_first_trainer = False
return Trainer(cfg, writer, img_writer, logger, os.path.join(name, str(run_id)))
def base_hyperparameter_order_picking(dataset, key, values):
for train_filepath, val_filepath in getattr(
config, f"{dataset}_TRAIN_VAL_SET_FILEPATHS"):
subject = subject_re.findall(val_filepath)[0]
for model in ["Simple_CNN", "CNN_IMU"]:
results = []
name = f"{dataset}-{subject}-{model}-{key}"
for value in values:
config_dict = getattr(config, dataset).copy()
config_dict["TRAIN_SET_FILEPATH"] = train_filepath
config_dict["VAL_SET_FILEPATH"] = val_filepath
config_dict["NAME"] = f"{name}-{value}"
config_dict["MODEL"] = model
config_dict[key] = value
trainer = Trainer(config_dict)
eval_dict = trainer.train()
results.append(eval_dict)
eval_dict_acc, eval_dict_wf1 = eval_dict
print(
"ACC: ", eval_dict_acc["best_val"],
f"epoch: {eval_dict_acc['best_epoch']}, iteration: {eval_dict_acc['best_iteration']}\n"
)
print(
"WF1: ", eval_dict_wf1["best_val"],
f"epoch: {eval_dict_wf1['best_epoch']}, iteration: {eval_dict_wf1['best_iteration']}\n"
)
save_best_result(results)
def simple_cnn_layer_num(source_dataset, target_dataset):
for train_filepath, val_filepath in getattr(
config, f"{target_dataset}_TRAIN_VAL_SET_FILEPATHS"):
subject = subject_re.findall(val_filepath)[0]
results = []
for layer_num in range(1, 4):
name = f"{source_dataset}-{target_dataset}-Simple_CNN-{subject}-LAYER_NUM"
config_dict = getattr(config, target_dataset).copy()
config_dict["NAME"] = f"{name}-{layer_num}"
config_dict["MODEL"] = "Simple_CNN"
config_dict["TRAIN_SET_FILEPATH"] = train_filepath
config_dict["VAL_SET_FILEPATH"] = val_filepath
config_dict["LEARNING_RATE"] = config_dict[
"Simple_CNN_LEARNING_RATE"]
config_dict["LAYER_NUM"] = layer_num
state_dict, freeze_idx = base_transfer(source_dataset,
target_dataset,
"Simple_CNN",
layer_num=layer_num)
print(f"-----{config_dict['NAME']}-----")
trainer = Trainer(config_dict, state_dict, freeze_idx)
eval_dict = trainer.train()
results.append(eval_dict)
eval_dict_acc, eval_dict_wf1 = eval_dict
print(
"ACC: ", eval_dict_acc["best_val"],
f"epoch: {eval_dict_acc['best_epoch']}, iteration: {eval_dict_acc['best_iteration']}\n"
)
print(
"WF1: ", eval_dict_wf1["best_val"],
f"epoch: {eval_dict_wf1['best_epoch']}, iteration: {eval_dict_wf1['best_iteration']}\n"
)
save_best_result(results)
def _run(FLAGS, model_cls):
logger = logging.getLogger('Trainer_%s' % model_cls.__name__)
logger.setLevel(logging.INFO)
file_handler = logging.FileHandler('%s.log' % model_cls.__name__)
file_handler.setLevel(logging.INFO)
stream_handler = logging.StreamHandler()
stream_handler.setLevel(logging.INFO)
formatter = logging.Formatter('[%(asctime)s] ## %(message)s')
file_handler.setFormatter(formatter)
stream_handler.setFormatter(formatter)
logger.addHandler(file_handler)
logger.addHandler(stream_handler)
hparams = tf.contrib.training.HParams(**COMMON_HPARAMS.values())
hparams.set_hparam('batch_size', FLAGS.bs)
hparams.set_hparam('n_steps', FLAGS.stp)
hparams.set_hparam('n_dims', FLAGS.dims)
hparams.set_hparam('n_info_dims', FLAGS.info_dims)
hparams.set_hparam('n_att_dims', FLAGS.att_dims)
hparams.set_hparam('max_epochs', FLAGS.epochs)
hparams.set_hparam('checkpoint', FLAGS.ckpt)
hparams.set_hparam('n_heads', FLAGS.heads)
hparams.set_hparam('n_selfatt_dims', FLAGS.selfatt_dims)
assert hparams.n_dims == hparams.n_info_dims + hparams.n_att_dims, "`n_dims` should be equal to the sum of `n_info_dims` and `n_att_dims`"
assert hparams.n_dims == hparams.n_heads * hparams.n_selfatt_dims, "`n_dims` should be equal to the product of `n_heads` and `n_selfatt_dims`"
name_size = 'SZ%d-STP%d' % (FLAGS.sz, FLAGS.stp)
config_size = Config(size=FLAGS.sz, max_steps=FLAGS.stp)
for name_std, config_std in CONFIG_STDS.iteritems():
for name_drop, config_drop in CONFIG_DROPS.iteritems():
for name_direction, config_direction in CONFIG_DIRECTIONS.iteritems(
):
config = Config()
config.add('base', 'base', CONFIG_BASE)
config.add('size', name_size, config_size)
config.add('direction', name_direction, config_direction)
config.add('drop', name_drop, config_drop)
config.add('std', name_std, config_std)
gridworld = GridWorld(name=config.get_name(),
**config.get_kwargs())
for seed in GRIDWORLD_SEEDS:
data_dir = '%s-SEED%d' % (config.get_name(), seed)
gridworld.load(data_dir,
seed=seed,
splitting_seed=SPLITTING_SEED)
dataset_name = config.get_name()
for shuffling_seed in SHUFFLING_SEEDS:
dataset = Dataset(dataset_name,
os.path.join(BASE_DIR, data_dir),
shuffling_seed=shuffling_seed)
model = model_cls(dataset,
hparams,
gridworld,
seed=MODEL_SEED)
Trainer(model, logger)()
def main():
from model.voxel2mesh import Voxel2Mesh as network
exp_id = 2
# Initialize
cfg = load_config(exp_id)
trial_path, trial_id = init(cfg)
print('Experiment ID: {}, Trial ID: {}'.format(cfg.experiment_idx,
trial_id))
print("Create network")
classifier = network(cfg)
classifier.cuda()
wandb.init(name='Experiment_{}/trial_{}'.format(cfg.experiment_idx,
trial_id),
project="vm-net",
dir='/cvlabdata1/cvlab/datasets_udaranga/experiments/wanb')
print("Initialize optimizer")
optimizer = optim.Adam(filter(lambda p: p.requires_grad,
classifier.parameters()),
lr=cfg.learning_rate)
print("Load data")
data_obj = Chaos()
# During the first run use load_data function. It will do the necessary preprocessing and save the files to disk.
# data = data_obj.pre_process_dataset(cfg, trial_id)
data = data_obj.quick_load_data(cfg, trial_id)
loader = DataLoader(data[DataModes.TRAINING],
batch_size=classifier.config.batch_size,
shuffle=True)
print("Trainset length: {}".format(loader.__len__()))
print("Initialize evaluator")
evaluator = Evaluator(classifier, optimizer, data, trial_path, cfg,
data_obj)
print("Initialize trainer")
trainer = Trainer(classifier, loader, optimizer, cfg.numb_of_itrs,
cfg.eval_every, trial_path, evaluator)
if cfg.trial_id is not None:
print("Loading pretrained network")
save_path = trial_path + '/best_performance/model.pth'
checkpoint = torch.load(save_path)
classifier.load_state_dict(checkpoint['model_state_dict'])
optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
epoch = checkpoint['epoch']
else:
epoch = 0
trainer.train(start_iteration=epoch)
def __init__(self, name="seq256_batch16_epoch30_gpu_lr2e_5_train"):
logging.info("Loading the weights of the model..")
trainer = Trainer()
self.device = trainer.device
self.tokenizer = trainer.train_data.tokenizer
self.id_product2class = trainer.train_data.id_product2class
self.max_seq_len = trainer.max_seq_len
self.model = trainer.model
self.name = name
def main(args):
"""main
calls Trainer to train and validate a character-level language model
inputs are the passed in cli args
"""
dmm = Trainer(args)
dmm.train()
def main(args):
assert args.alg in ['sourceonly', 'dann', 'wasserstein', 'NW']
trainer = Trainer(args)
trainer.train()
print('Final accuracy')
trainer.test()
def run(batch_size, loss, optimizer, base_lr, n_epochs, schedule, dataset, model):
# load the dataset
dataset_train_meta, dataset_test_meta = load_dataset(dataset)
exporter = Exporter(depth=-1, module_filter=[torch.nn.Conv2d, torch.nn.Linear],)
# instantiate model
from ikkuna.models import get_model
model = get_model(model, dataset_train_meta.shape[1:],
num_classes=dataset_train_meta.num_classes, exporter=exporter)
loss_fn = getattr(torch.nn, loss)()
# set up the trainer
trainer = Trainer(dataset_train_meta, batch_size=batch_size, loss=loss_fn, exporter=exporter)
trainer.set_model(model)
trainer.optimize(name=optimizer, lr=base_lr)
trainer.add_subscriber(RatioSubscriber(['weight_updates', 'weights']))
trainer.add_subscriber(NormSubscriber('layer_gradients'))
trainer.add_subscriber(NormSubscriber('weight_gradients'))
trainer.add_subscriber(VarianceSubscriber('weight_updates'))
trainer.add_subscriber(VarianceSubscriber('layer_gradients'))
trainer.add_subscriber(VarianceSubscriber('weight_gradients'))
trainer.add_subscriber(TrainAccuracySubscriber())
trainer.add_subscriber(TestAccuracySubscriber(dataset_test_meta, trainer.model.forward,
frequency=trainer.batches_per_epoch,
batch_size=batch_size))
trainer.add_subscriber(MessageMeanSubscriber('weight_updates_weights_ratio'))
logged_metrics = ['weight_updates_weights_ratio',
'loss',
'test_accuracy',
'train_accuracy',
'layer_gradients_norm2',
'weight_gradients_norm2',
'weight_gradients_variance',
'layer_gradients_variance',
'weight_gradients_variance']
if schedule == 'ratio_adaptive_schedule_fn':
from experiments.subscribers import RatioLRSubscriber
lr_sub = RatioLRSubscriber(base_lr)
trainer.add_subscriber(lr_sub)
trainer.set_schedule(torch.optim.lr_scheduler.LambdaLR, lr_sub)
logged_metrics.append('learning_rate')
trainer.add_subscriber(SacredLoggingSubscriber(ex, logged_metrics))
# do n epochs of training
batches_per_epoch = trainer.batches_per_epoch
epochs = n_epochs
for i in range(epochs):
for b in range(batches_per_epoch):
trainer.train_batch()
# we return a result so we can use it for filtering aborted experiments in mongodb
return 0
def main(args):
if os.path.exists(args.model_dir) and len(os.listdir(args.model_dir)) > 0:
print("The model output path '%s' already exists and is not empty." %
args.model_dir)
return
init_logger(args)
set_seed(args)
tokenizer = load_tokenizer(args.model_name_or_path)
logger.info("******* Running with the following arguments *********")
for a in vars(args):
logger.info(a + " = " + str(getattr(args, a)))
logger.info("***********************************************")
train_dataset, train_examples = load_and_cache_examples(args,
tokenizer,
mode="train")
train_examples = dict([(example.guid, example)
for example in train_examples])
dev_dataset, dev_examples = load_and_cache_examples(args,
tokenizer,
mode="dev")
dev_examples = dict([(example.guid, example) for example in dev_examples])
test_dataset, test_examples = load_and_cache_examples(args,
tokenizer,
mode="test")
test_examples = dict([(example.guid, example)
for example in test_examples])
if args.align_languages:
alignment_dataset = generate_alignment_pairs(args=args)
else:
alignment_dataset = None
trainer = Trainer(args, train_dataset, dev_dataset, test_dataset,
train_examples, dev_examples, test_examples, tokenizer,
alignment_dataset)
if args.do_train:
trainer.load_model(final_eval=False)
logger.info(trainer.model)
trainer.train()
if args.task == Tasks.PAWS_X.value:
trainer.evaluate_pair("dev", exp_name=args.model_dir)
else:
trainer.evaluate_xnlu("dev", exp_name=args.model_dir)
if args.save_model:
trainer.save_model()
if args.do_eval:
if not args.do_train:
trainer.load_model(final_eval=True)
if args.task == Tasks.PAWS_X.value:
trainer.evaluate_pair("dev", exp_name=args.model_dir)
trainer.evaluate_pair("test", exp_name=args.model_dir)
else:
trainer.evaluate_xnlu("dev", exp_name=args.model_dir)
trainer.evaluate_xnlu("test", exp_name=args.model_dir)
def main():
dataCor = Corpus(config.conv_path, config.wiki_path, config.save_dir)
dataCor.load()
trainData = dataCor.create_batches(config.batch_size, 'train')
validData = dataCor.create_batches(config.batch_size, 'valid')
testData = dataCor.create_batches(config.batch_size, 'test')
model = Copy_seq2seq(vocab_size=dataCor.vocab.num_words,
embedding_size=config.embedding_size,
hidden_size=config.hidden_size,
encoder_num_layers=config.encoder_num_layers,
decoder_num_layers=config.decoder_num_layers,
dropout=config.dropout)
if config.use_cuda:
model.cuda(config.device)
# Optimizer definition
optimizer = getattr(torch.optim, config.optimizer)(model.parameters(),
lr=config.lr)
# Run training iterations
print("Starting Training!")
save_dir = os.path.join(config.save_dir, 'model')
if not os.path.exists(save_dir):
os.makedirs(save_dir)
generator = GreedySearchDecoder(model)
print("Training starts ...")
trainer = Trainer(model=model,
optimizer=optimizer,
trainData=trainData,
validData=validData,
vocab=dataCor.vocab,
generator=generator,
num_epochs=config.num_epochs,
save_dir=save_dir,
log_steps=config.log_steps,
valid_steps=config.valid_steps,
grad_clip=config.grad_clip)
if config.ckpt is not None:
trainer.load(file_prefix=config.ckpt)
trainer.train()
result_file = os.path.join(config.save_dir, 'greedy.txt')
evaluate_generation(generator=generator,
data_iter=testData,
vocab=dataCor.vocab,
save_file=result_file)
result_file = os.path.join(config.save_dir, 'beamSearch.txt')
generator = BeamSearchDecoder(model)
evaluate_generation(generator=generator,
data_iter=testData,
vocab=dataCor.vocab,
save_file=result_file)
def run(args):
print('----Setting up hyperparams----:')
print(args)
print('-------------------------------')
trainer = Trainer(args)
if args.mode == 'train':
trainer.train()
elif args.mode == 'test':
trainer.test()
def run(batch_size, loss, optimizer, base_lr, n_epochs, dataset, model, freeze_at):
# load the dataset
transforms = [ToTensor()]
dataset_train_meta, dataset_test_meta = load_dataset(dataset, train_transforms=transforms,
test_transforms=transforms)
exporter = Exporter(depth=-1, module_filter=[torch.nn.Conv2d, torch.nn.Linear],)
# instantiate model
model = get_model(model, dataset_train_meta.shape[1:],
num_classes=dataset_train_meta.num_classes, exporter=exporter)
loss_fn = getattr(torch.nn, loss)()
backend = None
# set up the trainer
trainer = Trainer(dataset_train_meta, batch_size=batch_size, loss=loss_fn,
exporter=exporter)
trainer.set_model(model)
trainer.optimize(name=optimizer, lr=base_lr)
svcca = SVCCASubscriber(dataset_test_meta, 500,
trainer.model.forward, freeze_at=freeze_at,
subsample=trainer.batches_per_epoch, backend=backend)
trainer.add_subscriber(svcca)
trainer.add_subscriber(RatioSubscriber(['weight_updates', 'weights'], backend=backend))
trainer.add_subscriber(NormSubscriber('weight_gradients', backend=backend))
trainer.add_subscriber(TrainAccuracySubscriber(backend=backend))
trainer.add_subscriber(TestAccuracySubscriber(dataset_test_meta, trainer.model.forward,
frequency=trainer.batches_per_epoch,
batch_size=batch_size, backend=backend))
logged_metrics = ['test_accuracy',
'train_accuracy',
'weight_gradients_norm2',
'weight_updates_weights_ratio',
'self_similarity',
]
trainer.add_subscriber(SacredLoggingSubscriber(ex, logged_metrics))
if freeze_at == 'percentage':
modules = exporter.modules
n_modules = len(modules)
step = n_epochs // n_modules
# do n epochs of training
batches_per_epoch = trainer.batches_per_epoch
for i in range(n_epochs):
for b in range(batches_per_epoch):
trainer.train_batch()
if freeze_at == 'percentage':
freeze_idx = i // step - 1
if freeze_idx >= 0:
svcca._freeze_module(modules[freeze_idx])
# we return a result so we can use it for filtering aborted experiments in mongodb
return 0
def main():
generator = make_generator()
discriminator = make_discriminator()
args = parser_with_default_args().parse_args()
dataset = MNISTDataset(args.batch_size)
gan = LSGAN(generator, discriminator, **vars(args))
trainer = Trainer(dataset, gan, **vars(args))
trainer.train()
def main(config):
trainer = Trainer(config)
if config['train']:
trainer.train()
else:
if config.pretrained_path is None:
raise Exception(
"[!] You should specify `pretrained_path` to load a pretrained model"
)
trainer.test()
