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