def main(config):
# Uncomment to see device placement
# tf.debugging.set_log_device_placement(True)
gpus = tf.config.experimental.list_physical_devices('GPU')
if gpus:
try:
# Currently, memory growth needs to be the same across GPUs
for gpu in gpus:
tf.config.experimental.set_memory_growth(gpu, True)
logical_gpus = tf.config.experimental.list_logical_devices('GPU')
print(len(gpus), "Physical GPUs,", len(logical_gpus),
"Logical GPUs")
except RuntimeError as e:
# Memory growth must be set before GPUs have been initialized
print(e)
# Prepare directories for saving data
prepare_dirs(config)
# Load data on CPU
with tf.device("/cpu:0"):
data_loader = DataLoader(config)
dataset = data_loader.load()
smpl_loader = data_loader.get_smpl_loader()
val_dataset = data_loader.load_val_dataset()
trainer = Trainer(config, dataset, smpl_loader, val_dataset)
save_config(config)
trainer.train()
def main():
args = parser.parse_args()
args, logging, writer = utils.parse_args(args)
logging.info('# Start Re-training #')
criterion = LOSS_FACTORY[args.task](args, args.loss_scaling)
if args.model_type == "stochastic":
model_temp = STOCHASTIC_FACTORY[args.model]
else:
raise NotImplementedError("Other models have not been implemented!")
model = model_temp(args.input_size, args.output_size, args.layers,
args.activation, args, True)
logging.info('## Model created: ##')
logging.info(model.__repr__())
logging.info("### Param size = %f MB, Total number of params = %d ###" %
utils.count_parameters_in_MB(model, args))
logging.info('### Loading model to parallel GPUs ###')
utils.profile(model, args, logging)
model = utils.model_to_gpus(model, args)
logging.info('### Preparing schedulers and optimizers ###')
optimizer = SGLD(model.parameters(),
args.learning_rate,
norm_sigma=args.weight_decay)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
optimizer, args.epochs)
logging.info('## Downloading and preparing data ##')
train_loader, valid_loader = get_train_loaders(args)
logging.info('## Beginning Training ##')
train = Trainer(model, criterion, optimizer, scheduler, args)
best_error, train_time, val_time = train.train_loop(
train_loader, valid_loader, logging, writer)
logging.info(
'## Finished training, the best observed validation error: {}, total training time: {}, total validation time: {} ##'
.format(best_error, timedelta(seconds=train_time),
timedelta(seconds=val_time)))
logging.info('## Beginning Plotting ##')
del model
with torch.no_grad():
args.samples = 100
args.model_path = args.save
model = model_temp(args.input_size, args.output_size, args.layers,
args.activation, args, False)
model = utils.model_to_gpus(model, args)
model.eval()
plot_regression_uncertainty(model, PLT, train_loader, args)
logging.info('# Finished #')
def train(experiment, parameters, method, joint, run_on_test=False):
experiment_summary = get_experiment_summary(parameters.embedding_size,
parameters.neg_ratio,
parameters.batch_size,
parameters.learning_rate,
parameters.loss_ratio,
parameters.type_ratios)
module = create_module(experiment, method, joint, parameters)
logger.info(" \n------------------ \n")
logger.info("Running model with:\n")
logger.info(experiment_summary)
trainer = Trainer(module)
valid_result = trainer.fit(experiment, parameters)
print(experiment_summary)
print_results('validation set', valid_result)
if run_on_test:
test_results = trainer.test(experiment, parameters.checkpoint_file)
print_results('test set', test_results)
else:
test_results = None
return valid_result, test_results
def __init__(self, params):
self.params = params
# check parameters
assert not params.cuda or torch.cuda.is_available()
assert params.dico_train in ["identical_char", "default"
] or os.path.isfile(params.dico_train)
assert params.dico_build in ["S2T", "T2S", "S2T|T2S", "S2T&T2S"]
assert params.dico_max_size == 0 or params.dico_max_size < params.dico_max_rank
assert params.dico_max_size == 0 or params.dico_max_size > params.dico_min_size
assert os.path.isfile(params.src_emb)
assert os.path.isfile(params.tgt_emb)
assert params.dico_eval == 'default' or os.path.isfile(
params.dico_eval)
assert params.export in ["", "txt", "pth"]
# build self.logger / model / self.trainer / evaluator
self.logger = initialize_exp(params)
src_emb, tgt_emb, mapping, _ = build_supervised_model(params, False)
self.trainer = Trainer(src_emb, tgt_emb, mapping, None, params)
evaluator = Evaluator(self.trainer)
# load a training dictionary. if a dictionary path is not provided, use a default
# one ("default") or create one based on identical character strings ("identical_char")
self.trainer.load_training_dico(params.dico_train)
def main():
"""
takes 2 args
train.py
$config.json5
"""
argv = sys.argv
if len(argv) == 2:
arg_groups = params.parse(sys.argv[1]) # list of tuples of obj and dict
for args, config in arg_groups:
trainer = Trainer(args)
# pdb.set_trace()
states = trainer.train()
with open('models/log.jsonl', 'a') as f:
f.write(json5.dump({
'data': os.path.basename(args.data_dir),
'params': config,
'state': states
}))
f.write('\n')
elif len(argv) == 3 and '--dry' in argv:
argv.remove('--dry')
arg_groups = params.parse(sys.argv[1])
pprint([args.__dict__ for args, _ in arg_groups])
else:
print('Usage: "python train.py configs/xxx.json5"')
def train_attention_seq2seq():
train, test = sequence.load_data('date.txt')
x_train, t_train = train
x_test, t_test = test
char_to_id, id_to_char = sequence.get_vocab()
x_train, x_test = x_train[:, ::-1], x_test[:, ::-1]
vocab_size = len(char_to_id)
wordvec_size = 16
hidden_size = 256
batch_size = 128
max_epoch = 10
max_grad = 5.0
model = AttentionSeq2Seq(vocab_size, wordvec_size, hidden_size)
optimizer = Adam()
trainer = Trainer(model, optimizer)
acc_list = []
for epoch in range(max_epoch):
trainer.fit(x_train, t_train, 1, batch_size, max_grad)
correct_num = 0
for i in range(len(x_test)):
question, correct = x_test[[i]], t_test[[i]]
verbose = i < 10
correct_num += eval_seq2seq(model, question, correct, id_to_char,
verbose, True)
acc = float(correct_num) / len(x_test)
acc_list.append(acc)
print(f'val acc {100*acc:.3f}%')
def setUp(self):
transform = self._get_transforms()
self.val_set, self.train_set = self._get_val_train_sets(transform)
device_type = 'cuda' if torch.cuda.is_available() else 'cpu'
device = torch.device('cpu')
net = ConvNet()
net.to(device)
optimizer = torch.optim.SGD(net.parameters(), lr=StateAndBackupTests.LEARNING_RATE)
random_int = randrange(1000000000, 9999999999)
self.custom_back_up_path = path.join( \
path.dirname(__file__), '../backups-{}/'.format(random_int))
print("Find backups in: {}".format(self.custom_back_up_path))
backup_interval = 5
self.epochs = 5
self.trainer = Trainer(net, optimizer, net.criterion, \
self.train_dataloader_creator, self.val_dataloader_creator,
backup_interval, device=device, \
final_eval_fn=ClassificationAccuracy,\
custom_back_up_path = self.custom_back_up_path)
self.trainer.train(self.epochs)
def main(config):
# Uncomment to see device placement
# tf.debugging.set_log_device_placement(True)
gpus = tf.config.experimental.list_physical_devices('GPU')
if gpus:
try:
# Currently, memory growth needs to be the same across GPUs
for gpu in gpus:
tf.config.experimental.set_memory_growth(gpu, True)
logical_gpus = tf.config.experimental.list_logical_devices('GPU')
print(len(gpus), "Physical GPUs,", len(logical_gpus),
"Logical GPUs")
except RuntimeError as e:
# Memory growth must be set before GPUs have been initialized
print(e)
# Load data on CPU
with tf.device("/cpu:0"):
data_loader = DataLoader(config)
val_dataset = data_loader.load_val_dataset()
# Make sure that everything is validated both on mr and kp loss
config.use_mesh_repro_loss = True
config.use_kp_loss = True
trainer = Trainer(config, None, None, val_dataset, validation_only=True)
trainer.validate_checkpoint()
def main(config):
config_proto = tf.ConfigProto()
config_proto.gpu_options.allow_growth = True
sess = tf.InteractiveSession(config=config_proto)
dataloader = Dataloader(sess, config, prefetch_buffer_size=10)
model = Model(sess, dataloader, config)
model.build_model()
logger = Logger(sess, config)
trainer = Trainer(sess, model, dataloader, logger, config)
trainer.train()
def build_trainer(self):
self.trainer = Trainer(
optimizer=self.optimizer,
scheduler=self.scheduler,
model=self.model,
train_iterator=self.train_iterator,
val_iterator=self.val_iterator,
ipu_options=self.ipu_options,
wandb=self.wandb,
logger=self.logger,
args=self.args,
checkpoint=self.checkpoint,
)
def main():
args = parse_args()
config = get_config(args.config_dir)
set_global_seeds(456)
for fold in range(4):
config['train_params']['fold'] = fold
netname = f'{args.netname}/fold{fold}'
log_save_dir = Path(
config['dumps']['path']) / config['dumps']['logs'] / netname
model_save_dir = Path(
config['dumps']['path']) / config['dumps']['weights'] / netname
os.makedirs(log_save_dir, exist_ok=True)
os.makedirs(model_save_dir, exist_ok=True)
config['train_params']['netname'] = netname
config['train_params']['model_path'] = model_save_dir
pprint(config)
data_loaders = make_data_fold(**config['data_params'],
fold=config['train_params']['fold'])
model = get_model(args.netname, config)
callbacks = create_callbacks(netname, config['dumps'])
model_trainer = Trainer(model, callbacks, data_loaders,
**config['train_params'])
model_trainer.start()
# PLOT TRAINING
losses = model_trainer.losses
dice_scores = model_trainer.dice_scores # overall dice
iou_scores = model_trainer.iou_scores
def plot(scores, name=args.netname, is_save=True):
plt.figure(figsize=(15, 5))
plt.plot(range(len(scores["train"])),
scores["train"],
label=f'train {name}')
plt.plot(range(len(scores["train"])),
scores["val"],
label=f'val {name}')
plt.title(f'{name} plot')
plt.xlabel('Epoch')
plt.ylabel(f'{name}')
plt.legend()
if is_save:
plt.savefig(os.path.join(log_save_dir, name + '.png'))
plot(losses, "Loss")
plot(dice_scores, "Dice score")
plot(iou_scores, "IoU score")
async def execute_model(message_params):
task_id = message_params.get('task_id')
model_id = message_params.get('model_id')
model_params = message_params.get('model_params')
action = message_params.get('action')
dir_path = Path("./data")
train_file = dir_path / "train.csv"
test_file = dir_path / "test.csv"
save_path = Path("./models")
plot_eras = False
model_name = model_id
if model_id in model_mapper:
model_name = model_mapper[model_id]
submissions_path = Path("./upload")
filename = f"upload/{uuid.uuid4().hex}.csv"
trainer = Trainer(
train_file,
test_file,
submissions_path,
model_name,
model_params,
save_path,
plot_eras
)
if action == 1:
trainer.train()
elif action == 2:
trainer.find_hyperparameters()
elif action == 3:
trainer.evaluate()
trainer.submission_df[["id", "prediction"]].to_csv(
filename,
index=False
)
else:
trainer.evaluate_for_submition()
trainer.submission_df[["id", "prediction"]].to_csv(
filename,
index=False
)
new_model_params = {}
return filename, task_id, model_id, new_model_params
def run_simulate(user_document_params, click_exposure_params):
user_document_generator = UserDocumentDataGenerator(**user_document_params)
click_exposure_generator = ClickExposureDataGenerator(
user_document=user_document_generator, **click_exposure_params)
user_document_data = user_document_generator.generate_data()
relevance, exposure, click, exposure_labels, implicit_feedback = click_exposure_generator.generate_data(
)
# model setup
model = get_model(implicit_feedback, user_document_data, exposure_labels)
# train
trainer = Trainer(model)
trainer.train(relevance[0].reshape(-1),
user_document_data.reshape(-1, 1100))
return trainer
def main(argv):
# load config
config = load_config(FLAGS.config_path)
# specify and create experiment path
timestamp = datetime.now().strftime("_%Y%m%d-%H%M%S")
current_experiment_path = os.path.join(EXPERIMENT_PATH,
FLAGS.experiment_name + timestamp)
os.makedirs(current_experiment_path)
# copy current config file to experiment path
experiment_config_path = os.path.join(current_experiment_path,
EXPERIMENT_CONFIG_NAME)
shutil.copy2(FLAGS.config_path, experiment_config_path)
# initialize trainer and train
trainer = Trainer(config, current_experiment_path)
trainer.train()
def main(config: DictConfig):
# setup data_loader instances
data_loader, valid_data_loader = instantiate(config.data_loader)
# build model. print it's structure and # trainable params.
model = instantiate(config.arch)
logger.info(model)
trainable_params = filter(lambda p: p.requires_grad, model.parameters())
logger.info(
f'Trainable parameters: {sum([p.numel() for p in trainable_params])}')
# get function handles of loss and metrics
criterion = instantiate(config.loss, is_func=True)
metrics = [instantiate(met, is_func=True) for met in config['metrics']]
# build optimizer, learning rate scheduler.
optimizer = instantiate(config.optimizer, model.parameters())
lr_scheduler = instantiate(config.lr_scheduler, optimizer)
# setup mlflow
mlflow.set_tracking_uri('file://' + utils.get_original_cwd() + '/mlruns')
mlflow_writer = MlflowWriter(config.experiment_name)
mlflow_writer.log_params_from_omegaconf_dict(config)
mlflow_writer.log_torch_model(model)
trainer = Trainer(model,
criterion,
metrics,
optimizer,
config=config,
data_loader=data_loader,
valid_data_loader=valid_data_loader,
mlflow_writer=mlflow_writer,
lr_scheduler=lr_scheduler)
result = trainer.train()
mlflow_writer.log_artifact(os.path.join(os.getcwd(), '.hydra/config.yaml'))
mlflow_writer.log_artifact(os.path.join(os.getcwd(), '.hydra/hydra.yaml'))
mlflow_writer.log_artifact(
os.path.join(os.getcwd(), '.hydra/overrides.yaml'))
mlflow_writer.log_artifact(os.path.join(os.getcwd(), 'train.log'))
mlflow_writer.set_terminated()
return result['accuracy/valid']
def main():
argv = sys.argv
print(curLine(), "argv:", argv)
host_name = sys.argv[2]
if len(argv) == 3:
arg_groups = params.parse(sys.argv[1], host_name, mode="train")
test_score_sum = 0.0
max_test_score = 0.0
experiment_times = 0
eval_score_list = []
best_experiment_times = None
for args, config in arg_groups:
if not os.path.exists(args.summary_dir):
os.makedirs(args.summary_dir)
args.pretrained_embeddings = os.path.join(
"/home/%s/Word2Vector/Chinese" % host_name,
args.pretrained_embeddings)
# print(curLine(), "args.data_dir:%s, args.output_dir:%s" % (args.data_dir, args.output_dir))
trainer = Trainer(args)
states, best_eval_score = trainer.train(experiment_times)
eval_score_list.append(best_eval_score)
test_score_sum += best_eval_score
if max_test_score < best_eval_score:
max_test_score = best_eval_score
best_experiment_times = experiment_times
experiment_times += 1
print(
curLine(),
"experiment_times=%d/%d, best_experiment_times=%d, ave_test_score=%f, max_test_score=%f"
% (experiment_times, len(arg_groups), best_experiment_times,
test_score_sum / experiment_times, max_test_score))
with open('%s/log.jsonl' % args.output_dir, 'a') as f:
f.write(
json5.dumps({
'data': os.path.basename(args.data_dir),
'params': config,
'state': states,
}))
f.write('\n')
print(curLine(), "eval_score_list:", eval_score_list,
eval_score_list.index(max_test_score), "\n")
else:
print(curLine(),
'Usage: "python train.py configs/xxx.json5 host_name"')
def get_models(params):
assert not params.cuda or torch.cuda.is_available()
assert 0 <= params.dis_dropout < 1
assert 0 <= params.dis_input_dropout < 1
assert 0 <= params.dis_smooth < 0.5
assert params.dis_lambda > 0 and params.dis_steps > 0
assert 0 < params.lr_shrink <= 1
assert os.path.isfile(params.src_emb)
assert os.path.isfile(params.tgt_emb)
assert params.dico_eval == 'default' or os.path.isfile(params.dico_eval)
assert params.export in ["", "txt", "pth"]
# build model / trainer / evaluator
logger = initialize_exp(params)
src_emb, tgt_emb, mapping, discriminator = build_model(params, True)
trainer = Trainer(src_emb, tgt_emb, mapping, discriminator, params)
trainer.reload_best()
evaluator = Evaluator(trainer)
return evaluator, trainer
def train_one(save_path, config, log_file_dir, index, logfile_level,
console_level):
if log_file_dir:
logging.basicConfig(filename=log_file_dir.replace(
"tensorboard", "programlog"),
level=logfile_level)
console = logging.StreamHandler()
console.setLevel(console_level)
logging.getLogger().addHandler(console)
print("training at %s started" % index)
return Trainer(config,
save_path=save_path).train(log_file_dir=log_file_dir)
def main():
argv = sys.argv
if len(argv) == 2:
arg_groups = params.parse(sys.argv[1])
for args, config in arg_groups:
trainer = Trainer(args)
states = trainer.train()
with open('models/log.jsonl', 'a') as f:
f.write(
json5.dumps({
'data': os.path.basename(args.data_dir),
'params': config,
'state': states,
}))
f.write('\n')
elif len(argv) == 3 and '--dry' in argv:
argv.remove('--dry')
arg_groups = params.parse(sys.argv[1])
pprint([args.__dict__ for args, _ in arg_groups])
else:
print('Usage: "python train.py configs/xxx.json5"')
def train():
window_size = 5
hidden_size = 100
batch_size = 100
max_epoch = 10
corpus, word_to_id, id_to_word = ptb.load_data('train')
vocab_size = len(word_to_id)
contexts, target = create_contexts_target(corpus, window_size)
model = CBOW(vocab_size, hidden_size, window_size, corpus)
optimizer = Adam()
trainer = Trainer(model, optimizer)
trainer.fit(contexts, target, max_epoch, batch_size, None)
trainer.plot()
word_vecs = model.word_vecs
params = {}
params['word_vecs'] = word_vecs.astype(np.float16)
params['word_to_id'] = word_to_id
params['id_to_word'] = id_to_word
pkl_file = 'cbow_params.pkl'
with open(pkl_file, 'wb') as f:
pickle.dump(params, f, -1)
def main(config):
"""
Main
"""
data_loader = get_data_loader(
config.DATA_DIR,
config.TRAIN.BATCH_SIZE,
config.SEED,
config.TRAIN.NUM,
config.TRAIN.VAL_NUM,
config.TRAIN.IS_TRAIN,
config.TRAIN.NUM_WORKERS,
config.GPU,
config.TRAIN.FRAC_LABELS,
)
logger.debug("Calling trainer")
# instantiate trainer
trainer = Trainer(data_loader, config)
logger.debug("Start training")
# either train
if config.TRAIN.IS_TRAIN:
trainer.train()
# or load a pretrained model and test
else:
trainer.test()
def main(argv):
""" select process to do """
if FLAGS.job == 'w2v':
from src.word2vec import W2VTrainer
W2VTrainer(FLAGS.src_train_data).train(savedir=FLAGS.src_w2v)
if FLAGS.job == 't2id':
from src.utils import make_token_id
make_token_id(FLAGS.src_token2id, FLAGS.src_w2v, FLAGS.vocab_size)
if FLAGS.job == 'train':
from src.trainer import Trainer
Trainer().train()
def train(args):
config_path = args.conf
with open(config_path) as f:
config = yaml.load(f)
with open(config['labels_file']) as f:
dataset = json.load(f)
train_generator = DataGenerator(config, dataset['train'], shuffle=True)
val_generator = DataGenerator(config, dataset['val'], shuffle=True)
max_seq_length = train_generator.max_seq_length
num_decoder_tokens = train_generator.num_decoder_tokens
train_model = Models(config, max_seq_length, num_decoder_tokens)
trainer = Trainer(config, train_model, train_generator, val_generator)
H = trainer.train()
return H
def main():
args = parse_args()
trainer = Trainer(args)
if args.train:
trainer.train()
else:
trainer.test()
def prepare(self):
"""学習・評価のための各種データの準備を行う
"""
# ハイパーパラメータの初期化
self.params = ParamDeepConvNet()
# パスが指定されている場合は、そのデータを読み込む
if self.params_path is not None:
self.params.load(path=self.params_path)
params_dict = self.params.get()
learning_rate = params_dict['learning_rate']
self.batch_size = params_dict['batch_size']
self.max_epoch = params_dict['max_epoch']
# 各種設定情報(オプション)
# 重みデータのパス
if 'weight_path' in params_dict:
self.weight_path = params_dict['weight_path']
# 重みデータファイルを使用するかどうか
if 'use_weight' in params_dict:
self.b_use_weight = params_dict['use_weight']
else:
self.b_use_weight = False
# 結果グラフの保存先
if 'plot_path' in params_dict:
self.plot_path = params_dict['plot_path']
# 演算を実行するデバイス
device = None
if 'device' in params_dict:
device = params_dict['device']
# 各種インスタンスを構築する
self.provider = MnistProvider() # データセット
self.model = DeepConvNet() # ネットワークモデル
self.criterion = nn.CrossEntropyLoss() # 損失関数
self.optimizer = optim.Adam( # 最適化手法
self.model.parameters(), lr=learning_rate)
self.trainer = Trainer( # 学習器
self.model, self.optimizer, self.criterion, device=device)
def run():
parser = init_argparser()
opt = parser.parse_args()
trainer = Trainer(
train_path=opt.train_path,
dev_path=opt.dev_path,
test_path=opt.test_path,
unlabeled_path=opt.unlabeled_path,
save_to=opt.save_to,
semi_supervised=opt.semi_supervised,
batch_size=opt.batch_size,
learning_rate=opt.learning_rate,
weight_decay=opt.weight_decay,
dropout_lab=opt.dropout_labeled,
dropout_unlab=opt.dropout_unlabeled,
char_compose_method=opt.char_compose_method,
pretrained_embeddings_path=opt.pretrained_embeddings_path,
use_crf=opt.use_crf,
save_every=opt.save_every,
print_every=opt.print_every,
resume_training=opt.resume_training,
)
trainer.run()
def toy_problem(reverse=False, peeky=False):
(x_train, t_train), (x_test, t_test) = sequence.load_data()
if reverse:
x_train = x_train[:, ::-1]
x_test = x_test[:, ::-1]
char_to_id, id_to_char = sequence.get_vocab()
vocab_size = len(char_to_id)
wordvec_size = 16
hidden_size = 128
batch_size = 128
max_epoch = 25
max_grad = 5.0
if peeky:
model = PeekySeq2Seq(vocab_size, wordvec_size, hidden_size)
else:
model = Seq2Seq(vocab_size, wordvec_size, hidden_size)
optimizer = Adam()
trainer = Trainer(model, optimizer)
acc_list = []
for epoch in range(max_epoch):
trainer.fit(x_train, t_train, 1, batch_size, max_grad)
correct_num = 0
for i in range(len(x_test)):
question, correct = x_test[[i]], t_test[[i]]
verbose = i < 10
correct_num += eval_seq2seq(model, question, correct, id_to_char,
verbose, reverse)
acc = float(correct_num) / len(x_test)
acc_list.append(acc)
print(f'val acc {100*acc:.3f}%')
def init_zero_supervised(vocabulary, save_file, use_cuda):
model, discriminator = build_model(
max_length=opt.max_length,
output_size=vocabulary.size(),
rnn_size=opt.rnn_size,
encoder_n_layers=opt.layers,
decoder_n_layers=opt.layers,
dropout=opt.dropout,
use_cuda=use_cuda,
enable_embedding_training=bool(opt.sv_embedding_training),
discriminator_hidden_size=opt.discriminator_hidden_size,
bidirectional=bool(opt.bidirectional),
use_attention=bool(opt.attention))
if opt.src_embeddings is not None:
load_embeddings(model,
src_embeddings_filename=opt.src_embeddings,
tgt_embeddings_filename=opt.tgt_embeddings,
vocabulary=vocabulary)
model = model.cuda() if use_cuda else model
discriminator = discriminator.cuda() if use_cuda else discriminator
print_summary(model)
trainer = Trainer(
vocabulary,
max_length=opt.max_length,
use_cuda=use_cuda,
discriminator_lr=opt.discriminator_lr,
main_lr=opt.sv_learning_rate,
main_betas=(opt.adam_beta1, 0.999),
)
if opt.sv_load_from:
model, discriminator, main_optimizer, discriminator_optimizer = load_model(
opt.sv_load_from, use_cuda)
trainer.main_optimizer = main_optimizer
trainer.discriminator_optimizer = discriminator_optimizer
else:
pair_file_names = [
(opt.train_src_bi, opt.train_tgt_bi),
]
trainer.train_supervised(model,
discriminator,
pair_file_names,
vocabulary,
num_words_in_batch=opt.sv_num_words_in_batch,
max_length=opt.max_length,
save_file=save_file,
big_epochs=opt.supervised_epochs,
print_every=opt.print_every,
save_every=opt.save_every,
max_batch_count=opt.n_supervised_batches)
for param in model.parameters():
param.requires_grad = False
return Translator(model, vocabulary, use_cuda)
def main():
max_epoch = 300
batch_size = 30
x, t = load_data()
model = TwoLayerNet(in_size=2, hidden_size=10, out_size=3)
optimizer = SGD(1.0)
trainer = Trainer(model, optimizer)
trainer.fit(x, t, max_epoch, batch_size, None, 10)
trainer.plot()
def run_model(params, runid):
params.exp_name = params.src_lang + params.tgt_lang if params.exp_name is None else params.exp_name
seed = np.random.randint(10000, 20000)
params.seed = seed
params.exp_id = str(runid)
params.exp_path = ''
# build model / trainer / evaluator
logger = initialize_exp(params)
src_emb, tgt_emb, mapping, discriminator = build_model(params, True)
trainer = Trainer(src_emb, tgt_emb, mapping, discriminator, params)
evaluator = Evaluator(trainer)
base_nn, base_csls = _adversarial(params, logger, trainer, evaluator)
outputs = {
"run": runid,
"seed": seed,
"base_nn": base_nn,
"base_csls": base_csls
}
return logger, trainer, evaluator, outputs
# parse parameters
params = parser.parse_args()
# check parameters
assert not params.cuda or torch.cuda.is_available()
assert params.dico_train in ["identical_char", "default"] or os.path.isfile(params.dico_train)
assert params.dico_build in ["S2T", "T2S", "S2T|T2S", "S2T&T2S"]
assert params.dico_max_size == 0 or params.dico_max_size < params.dico_max_rank
assert params.dico_max_size == 0 or params.dico_max_size > params.dico_min_size
assert os.path.isfile(params.src_emb)
assert os.path.isfile(params.tgt_emb)
# build logger / model / trainer / evaluator
logger = initialize_exp(params)
src_emb, tgt_emb, mapping, _ = build_model(params, False)
trainer = Trainer(src_emb, tgt_emb, mapping, None, params)
evaluator = Evaluator(trainer)
# load a training dictionary. if a dictionary path is not provided, use a default
# one ("default") or create one based on identical character strings ("identical_char")
trainer.load_training_dico(params.dico_train)
"""
Learning loop for Procrustes Iterative Refinement
"""
for n_iter in range(params.n_iters):
logger.info('Starting refinement iteration %i...' % n_iter)
# build a dictionary from aligned embeddings (unless
# it is the first iteration and we use the init one)
# check parameters
assert not params.cuda or torch.cuda.is_available()
assert 0 <= params.dis_dropout < 1
assert 0 <= params.dis_input_dropout < 1
assert 0 <= params.dis_smooth < 0.5
assert params.dis_lambda > 0 and params.dis_steps > 0
assert 0 < params.lr_shrink <= 1
assert os.path.isfile(params.src_emb)
assert os.path.isfile(params.tgt_emb)
assert params.export in ["", "txt", "pth"]
# build model / trainer / evaluator
logger = initialize_exp(params)
src_emb, tgt_emb, mapping, discriminator = build_model(params, True)
trainer = Trainer(src_emb, tgt_emb, mapping, discriminator, params)
evaluator = Evaluator(trainer)
"""
Learning loop for Adversarial Training
"""
if params.adversarial:
logger.info('----> ADVERSARIAL TRAINING <----\n\n')
# training loop
for n_epoch in range(params.n_epochs):
logger.info('Starting adversarial training epoch %i...' % n_epoch)
tic = time.time()
n_words_proc = 0
