def test_train( validate, clip_grad_norm_, process_batch, DataLoader, VoiceDataset, Adam, Tacotron2Loss, Tacotron2, get_available_memory, is_available, calc_avgmax_attention, ): metadata_path = os.path.join("test_samples", "dataset", "metadata.csv") dataset_directory = os.path.join("test_samples", "dataset", "wavs") output_directory = "checkpoint" train_size = 0.67 train( metadata_path, dataset_directory, output_directory, epochs=1, batch_size=1, early_stopping=False, multi_gpu=False, train_size=train_size, ) # Check checkpoint checkpoint_path = os.path.join(output_directory, "checkpoint_2") assert os.path.isfile(checkpoint_path) shutil.rmtree(output_directory)
def train_classifier(config: Config): config_json = config.toDictionary() print('train_classifier') print(config_json) from training.train import train from torch.utils.data.dataloader import DataLoader from data.loader_segmentation import Segmentation model = get_model(config.classifier_name) wandb.init(entity='kobus_wits', project='wass_classifier', name=config.sweep_id + '_c_' + config.classifier_name, config=config_json) wandb.watch(model) train( model=model, dataloaders = { 'train': DataLoader( Segmentation( config.classifier_dataset_root, source='train', augmentation='train', image_size=config.classifier_image_size ), batch_size=config.classifier_batch_size_train, shuffle=True, pin_memory=True, num_workers=4, prefetch_factor=4 ), }, epochs=config.classifier_epochs, validation_mod=10 ) wandb.finish()
def test_checkpointing(self): callback_step_count = 0 def callback(output_location, step, model, optimizer, logger): nonlocal callback_step_count callback_step_count += 1 # Train to epoch 1, iteration 1. train.train(self.hparams.training_hparams, self.model, self.train_loader, self.root, callbacks=self.callbacks, end_step=Step.from_epoch(1, 1, len(self.train_loader))) # Add a step-counting callback. self.callbacks.append(callback) # Train to epoch 1, iteration 1 again. Checkpointing should ensure we # only train for one step. train.train(self.hparams.training_hparams, self.model, self.train_loader, self.root, callbacks=self.callbacks, end_step=Step.from_epoch(1, 1, len(self.train_loader))) self.assertEqual(callback_step_count, 2)
def test_nonrepeatable_data_order_without_seed(self): del self.hparams.training_hparams.data_order_seed init = { k: v.clone().detach() for k, v in self.model.state_dict().items() } # Train the model once and get the state. train.train(self.hparams.training_hparams, self.model, self.train_loader, self.root, callbacks=[self.callback], start_step=Step.from_epoch(1, 0, len(self.train_loader)), end_step=Step.from_epoch(1, 1, len(self.train_loader))) state1 = TestTrain.get_state(self.model) # Train the model again and get the state. self.model.load_state_dict(init) train.train(self.hparams.training_hparams, self.model, self.train_loader, self.root, callbacks=[self.callback], start_step=Step.from_epoch(1, 0, len(self.train_loader)), end_step=Step.from_epoch(1, 1, len(self.train_loader))) state2 = TestTrain.get_state(self.model) # Ensure that the model states are NOT the same. for k in state1: self.assertFalse(np.array_equal(state1[k], state2[k]))
def test_different_data_order_on_different_epochs(self): del self.hparams.training_hparams.gamma del self.hparams.training_hparams.milestone_steps del self.hparams.training_hparams.warmup_steps init = { k: v.clone().detach() for k, v in self.model.state_dict().items() } # Train the model once and get the state. train.train(self.hparams.training_hparams, self.model, self.train_loader, self.root, callbacks=[self.callback], start_step=Step.from_epoch(1, 0, len(self.train_loader)), end_step=Step.from_epoch(1, 1, len(self.train_loader))) state1 = TestTrain.get_state(self.model) # Train the model again and get the state. self.model.load_state_dict(init) train.train(self.hparams.training_hparams, self.model, self.train_loader, self.root, callbacks=[self.callback], start_step=Step.from_epoch(2, 0, len(self.train_loader)), end_step=Step.from_epoch(2, 1, len(self.train_loader))) state2 = TestTrain.get_state(self.model) # Ensure that the model states are NOT the same. for k in state1: self.assertFalse(np.array_equal(state1[k], state2[k]))
def test_first_step(self): init_state = TestStandardCallbacks.get_state(self.model) train.train(self.hparams.training_hparams, self.model, self.train_loader, self.root, callbacks=self.callbacks, end_step=Step.from_epoch(0, 1, len(self.train_loader))) # Check that the initial state has been saved. model_state_loc = paths.model(self.root, Step.zero(len(self.train_loader))) self.assertTrue(os.path.exists(model_state_loc)) # Check that the model state at init reflects the saved state. self.model.load_state_dict(torch.load(model_state_loc)) saved_state = TestStandardCallbacks.get_state(self.model) self.assertStateEqual(init_state, saved_state) # Check that the checkpoint file exists. self.assertTrue(os.path.exists(paths.checkpoint(self.root))) # Check that the logger file doesn't exist. self.assertFalse(os.path.exists(paths.logger(self.root)))
def test_last_step(self): train.train(self.hparams.training_hparams, self.model, self.train_loader, self.root, callbacks=self.callbacks, start_step=Step.from_epoch(2, 11, len(self.train_loader)), end_step=Step.from_epoch(3, 0, len(self.train_loader))) end_state = TestStandardCallbacks.get_state(self.model) # Check that final state has been saved. end_loc = paths.model(self.root, Step.from_epoch(3, 0, len(self.train_loader))) self.assertTrue(os.path.exists(end_loc)) # Check that the final state that is saved matches the final state of the network. self.model.load_state_dict(torch.load(end_loc)) saved_state = TestStandardCallbacks.get_state(self.model) self.assertStateEqual(end_state, saved_state) # Check that the logger has the right number of entries. self.assertTrue(os.path.exists(paths.logger(self.root))) logger = MetricLogger.create_from_file(self.root) self.assertEqual(len(logger.get_data('train_loss')), 1) self.assertEqual(len(logger.get_data('test_loss')), 1) self.assertEqual(len(logger.get_data('train_accuracy')), 1) self.assertEqual(len(logger.get_data('test_accuracy')), 1) # Check that the checkpoint file exists. self.assertTrue(os.path.exists(paths.checkpoint(self.root)))
def load_most_recent_model( model_dir: str, ) -> Tuple[Pipeline, Dict[str, str], Dict[str, str]]: """load model from file. If it does not yet exist, train a model Args: model_dir (str): Directory where models are stored. Returns: Pipeline: A trained model object """ try: version = max(os.listdir(model_dir)) logger.info("Load model") model_dir = os.path.join(model_dir, version) return ( joblib.load(os.path.join(model_dir, "model.joblib")), load_json(os.path.join(model_dir, "schema.json")), load_json(os.path.join(model_dir, "metadata.json")), ) except Exception as e: logger.error(e) logger.info("No model found, let's train one!") train(model_dir=model_dir) return load_most_recent_model(model_dir)
def start(): import numpy as np import cv2, wandb from artifacts.artifact_manager import artifact_manager from torch.utils.data.dataloader import DataLoader from models.wass import WASS from models.unet import UNet from models.fiiyc import FIIYC from models.vgg16 import Vgg16GAP from training.train import train from data.loader_segmentation import VOCSegmentation artifact_manager.setArtifactContainer('CAM') model = Vgg16GAP() # wandb.init(entity='kobus_wits', project='wass_adv', name='WASS_vgg16_cam') # train( # model=model, # dataloaders = { # 'train': DataLoader(VOCSegmentation('train', dataset='voc'), batch_size=32, shuffle=True, num_workers=8), # 'val': DataLoader(VOCSegmentation('val', dataset='voc'), batch_size=32, shuffle=False, num_workers=8) # }, # epochs=10, # validation_mod=15000 # ) # wandb.finish() # artifact_manager.setArtifactContainer('WASS_unet') # model = UNet() # wandb.init(entity='kobus_wits', project='wass_adv', name='WASS_unet') # train( # model=model, # dataloaders = { # 'train': DataLoader(VOCSegmentation('train', dataset='voco'), batch_size=16, shuffle=True, num_workers=8), # 'val': DataLoader(VOCSegmentation('val', dataset='voco'), batch_size=16, shuffle=False, num_workers=8) # }, # epochs=1, # validation_mod=15000 # ) # wandb.finish() artifact_manager.setArtifactContainer('WASS_base') model = WASS() wandb.init(entity='kobus_wits', project='wass_adv', name='WASS_base') train(model=model, dataloaders={ 'train': DataLoader(VOCSegmentation('train', dataset='voco'), batch_size=16, shuffle=True, num_workers=8), 'val': DataLoader(VOCSegmentation('val', dataset='voco'), batch_size=16, shuffle=False, num_workers=8) }, epochs=1000, validation_mod=15000) wandb.finish()
def test_train_in_full(self): train.train(self.hparams.training_hparams, self.model, self.train_loader, self.root, callbacks=[self.callback]) self.assertEqual(self.step_counter, 37) self.assertEqual(self.ep, 3) self.assertEqual(self.it, 0) self.assertEqual(self.lr, 0.01)
def test_train_in_full_later_start(self): train.train(self.hparams.training_hparams, self.model, self.train_loader, self.root, callbacks=[self.callback], start_step=Step.from_epoch(1, 5, len(self.train_loader))) self.assertEqual(self.step_counter, 20) self.assertEqual(self.ep, 3) self.assertEqual(self.it, 0) self.assertEqual(self.lr, 0.01)
def test_train_more_than_two_epochs(self): train.train(self.hparams.training_hparams, self.model, self.train_loader, self.root, callbacks=[self.callback], end_step=Step.from_epoch(2, 1, len(self.train_loader))) self.assertEqual(self.step_counter, 26) self.assertEqual(self.ep, 2) self.assertEqual(self.it, 1) self.assertEqual(self.lr, 0.01)
def start_training(cuda, epochs, general_seed, tensorflow_seed, batch_size, buffer_size, learning_rate): # Disable GPU support if no GPUs are supposed to be used if not cuda: tf.config.set_visible_devices([], 'GPU') with mlflow.start_run(): # Enable the logging of all parameters, metrics and models to mlflow and Tensorboard mlflow.tensorflow.autolog() # Fix all random seeds and Tensorflow specific reproducibility settings set_general_random_seeds(general_seed) set_tensorflow_random_seeds(tensorflow_seed) # Use Mirrored Strategy for multi GPU support strategy = tf.distribute.MirroredStrategy() click.echo( click.style(f'Number of devices: {strategy.num_replicas_in_sync}', fg='blue')) # Fetch and prepare dataset train_dataset, eval_dataset = load_train_test_data( strategy, batch_size, buffer_size, tensorflow_seed) with strategy.scope(): # Define model and compile model model = create_model(input_shape=(28, 28, 1)) model.compile(loss=tf.keras.losses.SparseCategoricalCrossentropy( from_logits=True), optimizer=tf.keras.optimizers.Adam( learning_rate=learning_rate), metrics=['accuracy']) # Train and evaluate the trained model runtime = time.time() train(model, epochs, train_dataset) eval_loss, eval_acc = test(model, eval_dataset) click.echo(f'Test loss: {eval_loss}, Test Accuracy: {eval_acc}') device = 'GPU' if cuda else 'CPU' click.echo( click.style( f'{device} Run Time: {str(time.time() - runtime)} seconds', fg='green')) # Log hardware and software log_sys_intel_conda_env() click.echo( click.style( f'\nLaunch TensorBoard with:\ntensorboard --logdir={os.path.join(mlflow.get_artifact_uri(), "tensorboard_logs", "train")}', fg='blue'))
def start_training(cuda, epochs, general_seed, pytorch_seed, log_interval, training_batch_size, test_batch_size, learning_rate): # Set GPU settings use_cuda = (True if cuda == 'True' else False) and torch.cuda.is_available() device = torch.device("cuda" if use_cuda else "cpu") if use_cuda and torch.cuda.device_count() > 0: click.echo(click.style(f'Using {torch.cuda.device_count()} GPUs!', fg='blue')) # Set all random seeds and possibly turn of GPU non determinism set_general_random_seeds(general_seed) set_pytorch_random_seeds(pytorch_seed, use_cuda=use_cuda) # Load training and testing data train_loader, test_loader = load_train_test_data(training_batch_size, test_batch_size) # Define model, device and optimizer if torch.cuda.device_count() > 1: model = create_parallel_model() else: model = create_model() model.to(device) optimizer = optim.Adam(model.parameters()) optimizer.step() with mlflow.start_run(): # Create a SummaryWriter to write TensorBoard events locally events_output_dir = tempfile.mkdtemp() writer = SummaryWriter(events_output_dir) click.echo(click.style(f'Writing TensorBoard events locally to {events_output_dir}\n', fg='blue')) # Start training runtime = time.time() for epoch in range(1, epochs + 1): train(use_cuda, model, epoch, optimizer, log_interval, train_loader, writer) test(use_cuda, model, epoch, test_loader, writer) device = 'GPU' if use_cuda else 'CPU' click.echo(click.style(f'{device} Run Time: {str(time.time() - runtime)} seconds', fg='green')) # Closing writer to allow for the model to be logged writer.close() # Log the model to mlflow click.echo(click.style('Logging model to mlflow...', fg='blue')) mlflow.pytorch.log_model(model, 'models') # Log hardware and software log_sys_intel_conda_env() # Upload the TensorBoard event logs as a run artifact click.echo(click.style('Uploading TensorBoard events as a run artifact...', fg='blue')) mlflow.log_artifacts(events_output_dir, artifact_path='events') click.echo(click.style(f'\nLaunch TensorBoard with:\ntensorboard --logdir={os.path.join(mlflow.get_artifact_uri(), "events")}', fg='blue'))
def test_train_two_epoch_late_start(self): train.train(self.hparams.training_hparams, self.model, self.train_loader, self.root, callbacks=[self.callback], start_step=Step.from_epoch(0, 5, len(self.train_loader)), end_step=Step.from_epoch(2, 5, len(self.train_loader))) self.assertEqual(self.step_counter, 25) self.assertEqual(self.ep, 2) self.assertEqual(self.it, 5) self.assertEqual(self.lr, 0.01)
def test_train_one_epoch(self): train.train(self.hparams.training_hparams, self.model, self.train_loader, self.root, callbacks=[self.callback], end_step=Step.from_epoch(1, 0, len(self.train_loader))) self.assertEqual(self.step_counter, 13) # Same as len(self.train_loader) + 1 self.assertEqual(self.ep, 1) self.assertEqual(self.it, 0) self.assertEqual(self.lr, 0.1)
def test_train_zero_steps(self): before = TestTrain.get_state(self.model) train.train(self.hparams.training_hparams, self.model, self.train_loader, self.root, callbacks=[self.callback], end_step=Step.from_iteration(0, len(self.train_loader))) after = TestTrain.get_state(self.model) for k in before: self.assertTrue(np.array_equal(before[k], after[k])) self.assertEqual(self.step_counter, 0) self.assertEqual(self.ep, 0) self.assertEqual(self.it, 0)
def test_train_one_step_late_start(self): before = TestTrain.get_state(self.model) train.train(self.hparams.training_hparams, self.model, self.train_loader, self.root, callbacks=[self.callback], start_step=Step.from_epoch(0, 5, len(self.train_loader)), end_step=Step.from_epoch(0, 6, len(self.train_loader))) after = TestTrain.get_state(self.model) for k in before: self.assertFalse(np.array_equal(before[k], after[k])) self.assertEqual(self.step_counter, 2) self.assertEqual(self.ep, 0) self.assertEqual(self.it, 6) self.assertEqual(self.lr, 0.06)
def test_train_two_steps(self): before = TestTrain.get_state(self.model) train.train(self.hparams.training_hparams, self.model, self.train_loader, self.root, callbacks=[self.callback], end_step=Step.from_iteration(2, len(self.train_loader))) after = TestTrain.get_state(self.model) for k in before: with self.subTest(k=k): self.assertFalse(np.array_equal(before[k], after[k]), k) self.assertEqual(self.step_counter, 3) self.assertEqual(self.ep, 0) self.assertEqual(self.it, 2) self.assertEqual(self.lr, 0.02)
def test_end_to_end(self): init_loc = paths.model(self.root, Step.zero(len(self.train_loader))) end_loc = paths.model(self.root, Step.from_epoch(3, 0, len(self.train_loader))) init_state = TestStandardCallbacks.get_state(self.model) train.train(self.hparams.training_hparams, self.model, self.train_loader, self.root, callbacks=self.callbacks, start_step=Step.from_epoch(0, 0, len(self.train_loader)), end_step=Step.from_epoch(3, 0, len(self.train_loader))) end_state = TestStandardCallbacks.get_state(self.model) # Check that final state has been saved. self.assertTrue(os.path.exists(init_loc)) self.assertTrue(os.path.exists(end_loc)) # Check that the checkpoint file still exists. self.assertTrue(os.path.exists(paths.checkpoint(self.root))) # Check that the initial and final states match those that were saved. self.model.load_state_dict(torch.load(init_loc)) saved_state = TestStandardCallbacks.get_state(self.model) self.assertStateEqual(init_state, saved_state) self.model.load_state_dict(torch.load(end_loc)) saved_state = TestStandardCallbacks.get_state(self.model) self.assertStateEqual(end_state, saved_state) # Check that the logger has the right number of entries. self.assertTrue(os.path.exists(paths.logger(self.root))) logger = MetricLogger.create_from_file(self.root) self.assertEqual(len(logger.get_data('train_loss')), 4) self.assertEqual(len(logger.get_data('test_loss')), 4) self.assertEqual(len(logger.get_data('train_accuracy')), 4) self.assertEqual(len(logger.get_data('test_accuracy')), 4)
def train_affinitynet(config: Config): config_json = config.toDictionary() print('train_affinitynet') print(config_json) from training.train import train from torch.utils.data.dataloader import DataLoader from data.loader_segmentation import Segmentation from artifacts.artifact_manager import artifact_manager model = get_model(config.affinity_net_name) wandb.init(entity='kobus_wits', project='wass_affinity', name=config.sweep_id + '_a_' + config.affinity_net_name, config=config_json) wandb.watch(model) train( model=model, dataloaders = { 'train': DataLoader( Segmentation( config.classifier_dataset_root, source='train', augmentation='train', image_size=config.affinity_net_image_size, requested_labels=['affinity'], affinity_root=artifact_manager.getDir() ), batch_size=config.affinity_net_batch_size, shuffle=False, pin_memory=False, num_workers=4, prefetch_factor=4 ), }, epochs=config.affinity_net_epochs, validation_mod=10 ) wandb.finish()
def neural(): datasets = [ # { # 'name': 'netflix', # 'nTimes': 10, # 'rate': 0.0001 # }, { 'name': 'SPECT', 'nTimes': 1000, 'rate': 0.001 } ] mh = 13 # number of neurons in the hidden layer for ds in datasets: thetas = train(ds['name'], ds['nTimes'], ds['rate'], mh) test(ds['name'], thetas)
def main(): env = UnityEnvironment( file_name= "/home/faten/projects/deep-reinforcement-learning/p1_navigation/Banana_Linux/Banana.x86_64" ) brain_name = env.brain_names[0] brain = env.brains[brain_name] action_size = brain.vector_action_space_size env_info = env.reset(train_mode=True)[brain_name] state = env_info.vector_observations[0] state_size = len(state) agent = DQNAgent(state_size, action_size, seed=0) scores = train(env, agent) # plot the scores fig = plt.figure() ax = fig.add_subplot(111) plt.plot(np.arange(len(scores)), scores) plt.ylabel('Score') plt.xlabel('Epsiode #') plt.show() agent.qnetwork_local.load_state_dict(torch.load('checkpoint.pth')) for i in range(3): state = env.reset() for j in range(200): action = agent.act(state) env.render() state, reward, done, _ = env.step(action) if done: break env.close()
import torch import models.model_conv_best as model import log_utils.log_tensorboard as log # import training.scheduler as scheduler from training.train import train import training.dataset as ds from training.validation import test if __name__ == "__main__": log.init("lel_kek") # Try to use GPU device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") print(device) # Create an instance of the model net = model.Net() net.to(device) # PATH = 'model_instances/cifar_net_79%_best.pth' # net.load_state_dict(torch.load(PATH)) train(net, epoch_count=20, start_epoch=10, use_scheduler=False) # test(net) # Save our beautiful model for future generations # PATH = 'model_instances/cifar_net_tmp.pth' # torch.save(net.state_dict(), PATH)
def train_classifiers(X_train_list, y_train, model): C_list = [] for X_train in X_train_list: C = train(X_train, y_train, model) C_list.append(C) return C_list
checkpointing = True freq_checkpointing = 10 reload = False model_full_name = "test_dbc4" model_id_pref = "" add_start_char = 1 add_end_char = 1 dict_path = "./dictionaries" model_dir = os.path.join(CHECKPOINT_DIR, model_full_name+"-folder") if reload: dict_path = os.path.join(model_dir, "dictionaries") train(test_path, test_path, n_epochs=n_epochs, normalization=normalization, batch_size=batch_size, dict_path=dict_path, model_dir=model_dir, add_start_char=add_start_char, add_end_char=add_end_char, freq_checkpointing=freq_checkpointing, reload=reload, model_specific_dictionary=True, debug=False, model_full_name=model_full_name, ) else: train(dev_path, test_path, n_epochs=n_epochs, normalization=normalization, batch_size=batch_size, model_specific_dictionary=True, dict_path=None, model_dir=None, add_start_char=add_start_char, add_end_char=add_end_char, use_gpu=None, label_train=REPO_DATASET[test_path], label_dev=REPO_DATASET[test_path], freq_checkpointing=freq_checkpointing, reload=reload, model_id_pref="test",#"compare_normalization_all", hidden_size_encoder=250, output_dim=300, char_embedding_dim=300, debug=False, hidden_size_sent_encoder=250, hidden_size_decoder=300, print_raw=False, checkpointing=True ) # TODO : add DEV_5 to decode_sequence : 3d shapes in the decoded sequence also
activation=act, mask_value=MASK_VALUE, regularization=None) # '{layer_pre}x{n_nodes}*{act}->[{memory}]{n_lstm}->{layer_pos}{n_nodes}*{act}' log_dir = 'out/{}-{}-{}-{}{}-{}-{}-{}'.format( n_dense_pre, int(n_node * 10), act, memory_unit, n_memory, n_dense_pos, int(n_stations / n_dense_pre), act) train( radius=radius, batch_size=batch_size, log_dir=log_dir, t_train_h=t_train_h, t_pred_d=t_pred_d, t_pred_resolution_h=t_pred_resolution_h, model_name=model, filenames_train=filenames_train, filenames_valid=filenames_valid, features_train=features_train, features_predict=features_predict, ) """ Experiment II: Activation Function """ n_dense_pos = 3 n_node = 1.0 acts = 'relu', 'leaky_relu', 'tanh' n_memory = 2 n_dense_pre = 3 memory_unit = 'lstm'
train_tasks.append(train_task) override_cfg = ["DATASETS.TRAIN", tuple(train_tasks)] # validation tasks if args.val_job_id is not None: valid_tasks = [] for val_job_id in args.val_job_id: data, task_id = get_data_set(val_job_id) coco_json = f"datasets/valid_cvat_{task_id}.coco.json" with open(coco_json, "w") as f: json.dump(data, f) valid_task = f"cvat/valid_{task_id}" register_coco_instances(valid_task, {}, coco_json, args.cvat_base) valid_tasks.append(valid_task) override_cfg.extend(["DATASETS.TEST", tuple(valid_tasks)]) if args.output is not None: override_cfg.extend(["OUTPUT_DIR", args.output]) override_cfg.extend( ["MODEL.WEIGHTS", f"{args.output}/model_final.pth"]) if args.epoch is not None: override_cfg.extend(["SOLVER.MAX_ITER", args.epoch]) train( config_file=args.config, override_cfg=override_cfg, resume=args.resume, restart=args.restart, force_test=args.force_test, )
use_gpu = False batch_size = 2 n_epochs = 1 dropout_sent_encoder = 0 dropout_word_encoder = 0 dropout_word_decoder = 0 model_id_pref = "time" hidden_size_encoder = 250 output_dim = 100 char_embedding_dim = 51 hidden_size_sent_encoder = 125 hidden_size_decoder = 300 n_layers_word_encoder = 1 dir_sent_src = 1 model_full_name = train(train_path, test_path, n_epochs=n_epochs, normalization=True, batch_size=batch_size, model_specific_dictionary=True, dict_path=None, model_dir=None, add_start_char=1, add_end_char=1, use_gpu=use_gpu, verbose=1, word_recurrent_cell_decoder="LSTM", word_recurrent_cell_encoder="LSTM", clipping=0.5, char_src_attention=True, unrolling_word=True, shared_context="all", label_train=REPO_DATASET[train_path], label_dev=REPO_DATASET[test_path], freq_checkpointing=10, reload=False, model_id_pref=model_id_pref, hidden_size_encoder=hidden_size_encoder, output_dim=output_dim, char_embedding_dim=char_embedding_dim, hidden_size_sent_encoder=hidden_size_sent_encoder, hidden_size_decoder=hidden_size_decoder, n_layers_word_encoder=n_layers_word_encoder, print_raw=False, debug=False, timing=True, dir_sent_encoder=dir_sent_src, checkpointing=True)
#from src.evaluation.test import test from training.train import train session_name = train("batch16") # test(session_name=session_name, is_visualize=False) # test(session_name='test', is_visualize=True)