def lime(): print('Loading dataset ...') X_train, Y_train, X_val, Y_val, X_test, Y_test = get_dataset( minibatch_size=32, sampling='None', numpy='True') net = load_fraudnet() lime_list = [] explainer = LimeTabularExplainer(X_train, training_labels=Y_train) def func_call(x): print(x.shape) input_ = torch.from_numpy(x).to(device=device).float() prob_1 = net(input_).view(-1, 1).cpu().data.numpy() prob_0 = 1 - prob_1 prob = np.concatenate([prob_0, prob_1], axis=1) return prob for i in range(X_test.shape[0]): exp = explainer.explain_instance(X_test[i, :], func_call, labels=(0, 1), num_features=50) lime_list.append(exp) lime_list = np.array(lime_list) lime_list = preprocess(lime_list) pickle.dump(lime_list, open('./saved_attributions/lime.pkl', 'wb'))
def train_model(config_path: str): writer = SummaryWriter() config = read_training_pipeline_params(config_path) logger.info("pretrained_emb {b}", b=config.net_params.pretrained_emb) device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') logger.info("Device is {device}", device=device) SRC, TRG, dataset = get_dataset(config.dataset_path, False) train_data, valid_data, test_data = split_data( dataset, **config.split_ration.__dict__) SRC.build_vocab(train_data, min_freq=3) TRG.build_vocab(train_data, min_freq=3) torch.save(SRC.vocab, config.src_vocab_name) torch.save(TRG.vocab, config.trg_vocab_name) logger.info("Vocab saved") print(f"Unique tokens in source (ru) vocabulary: {len(SRC.vocab)}") print(f"Unique tokens in target (en) vocabulary: {len(TRG.vocab)}") train_iterator, valid_iterator, test_iterator = BucketIterator.splits( (train_data, valid_data, test_data), batch_size=config.BATCH_SIZE, device=device, sort_key=_len_sort_key, ) INPUT_DIM = len(SRC.vocab) OUTPUT_DIM = len(TRG.vocab) config_encoder = BertConfig(vocab_size=INPUT_DIM) config_decoder = BertConfig(vocab_size=OUTPUT_DIM) config = EncoderDecoderConfig.from_encoder_decoder_configs( config_encoder, config_decoder) model = EncoderDecoderModel(config=config) config_encoder = model.config.encoder config_decoder = model.config.decoder config_decoder.is_decoder = True config_decoder.add_cross_attention = True config = EncoderDecoderConfig.from_encoder_decoder_configs( config_encoder, config_decoder) model = EncoderDecoderModel(config=config) args = TrainingArguments( output_dir="output", evaluation_strategy="steps", eval_steps=500, per_device_train_batch_size=128, per_device_eval_batch_size=128, num_train_epochs=10, save_steps=3000, seed=0, load_best_model_at_end=True, ) # args.place_model_on_device = device trainer = Trainer( model=model, args=args, train_dataset=train_iterator, eval_dataset=valid_iterator, callbacks=[EarlyStoppingCallback(early_stopping_patience=3)], ) trainer.train() model.save_pretrained("bert2bert")
def train(model_name='fraud_net', ch=1, tbd='logs', smote=False): no_epochs = 30 lr = 1e-3 batch_size = 1024 weight_factor = 1.0 #40.67 #weight given to class 1 print('Loading dataset ...') train_loader, valid_loader, test_loader = get_dataset( minibatch_size=batch_size, sampling='None') net = FraudNet(ch, continuous).to(device='cuda').train() print('Model:') print(net) optimizer = torch.optim.Adam(net.parameters(), lr=lr) best_valid_loss = float('inf') writer = SummaryWriter('runs/' + tbd) for i in range(no_epochs): for b, data in enumerate(train_loader): inputs, labels = data if smote: inputs, labels = smote_func(inputs, labels) y_pred = net(inputs) mask = (labels > 0.5).float() batch_weights = mask * weight_factor + (1 - mask) * (1) loss = nn.BCELoss(weight=(batch_weights))(y_pred, labels) # print ('batch_weights',batch_weights) if b % 100000000: print('Epochs: {}, batch: {} loss: {}'.format(i, b, loss)) sys.stdout.flush() optimizer.zero_grad() loss.backward() optimizer.step() writer.add_scalar('train_loss', loss, i) valid_loss = evaluate(valid_loader, net) writer.add_scalar('valid_loss', valid_loss, i) test_loss = evaluate(test_loader, net) writer.add_scalar('test_loss', test_loss, i) print('Epochs: {}, Valid loss: {}, Test Loss: {}'.format( i, valid_loss, test_loss)) if valid_loss < best_valid_loss: torch.save( net.state_dict(), './saved_checkpoints/' + model_name + '_' + '{0:.3f}'.format(valid_loss) + '_' + '{0:.3f}'.format(test_loss) + '.th') best_valid_loss = valid_loss print('Saving checkpoint at epoch: {}'.format(i))
def lime1(): print('Loading dataset ...') train_loader, valid_loader, test_loader = get_dataset(minibatch_size=1024, sampling='None') test_loader = get_dataset_test(minibatch_size=batch_size) net = load_fraudnet() train_embeds = [] for data in train_loader: x, y = data embed = net.embedding_forward(x).cpu().data.numpy() train_embeds.append(embed) train_embeds = np.concatenate(train_embeds, axis=0) test_embeds = [] for data in test_loader: x = data embed = net.embedding_forward(x).cpu().data.numpy() test_embeds.append(embed) test_embeds = np.concatenate(test_embeds, axis=0) print('train test', train_embeds.shape, test_embeds.shape) lime_list = [] explainer = LimeTabularExplainer(train_embeds) def func_call(x): print(x.shape) input_ = torch.from_numpy(x).to(device=device).float() prob_1 = net.feedforward(input_).view(-1, 1).cpu().data.numpy() prob_0 = 1 - prob_1 prob = np.concatenate([prob_0, prob_1], axis=1) return prob for i in range(test_embeds.shape[0]): exp = explainer.explain_instance(test_embeds[i, :], func_call, labels=(0, 1), num_features=91) lime_list.append(exp) lime_list = np.array(lime_list) lime_list = preprocess1(lime_list) pickle.dump(lime_list, open('./saved_attributions/lime.pkl', 'wb'))
def train(): tf.enable_eager_execution() BATCH_SIZE = 16 MAX_STEP = 10000 train_dir = './data/train' image_paths, image_labels = load_data.get_path_and_label(train_dir, is_random=True) image_label_ds = load_data.get_dataset(image_paths, image_labels, BATCH_SIZE, is_random=True) demo_model = tf.keras.Sequential([ tf.keras.layers.Conv2D(16, [3, 3], padding='same', activation='relu'), tf.keras.layers.MaxPooling2D(strides=2, padding='same'), tf.keras.layers.Conv2D(16, [3, 3], padding='same', activation='relu'), tf.keras.layers.MaxPooling2D(strides=2, padding='same'), tf.keras.layers.Flatten(), tf.keras.layers.Dense(128, activation='relu'), tf.keras.layers.Dropout(0.5), tf.keras.layers.Dense(128, activation='relu'), tf.keras.layers.Dropout(0.5), tf.keras.layers.Dense(2, activation='softmax') ]) optimizer = tf.train.AdamOptimizer(learning_rate=1e-4) checkpoint_dir = './logs_2' checkpoint_prefix = os.path.join(checkpoint_dir, 'ckpt') checkpoint = tf.train.Checkpoint(optimizer=optimizer, model=demo_model) start = time.time() for step, (images, labels) in enumerate(image_label_ds.take(MAX_STEP)): with tf.GradientTape() as tape: logits = demo_model(images, training=True) loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits) grads = tape.gradient(loss, demo_model.variables) optimizer.apply_gradients(zip(grads, demo_model.variables), global_step=tf.train.get_or_create_global_step()) if step % 100 == 0: acc = tf.nn.in_top_k(logits, labels, 1) acc = tf.reduce_mean(tf.cast(acc, tf.float16)) end = time.time() print('Step:%6d, loss:%.6f, accuracy:%.2f%%, time:%.2fs' % (step, loss, acc * 100, end - start)) start = time.time() if step % 1000 == 0: checkpoint.save(file_prefix=checkpoint_prefix)
def train(WORD, CHAR, ARC, REL, transform, encoder, epoch=60, word_dim=100): model = BiaffineDependencyModel(n_words=WORD.vocab.n_init, n_feats=len(CHAR.vocab), n_rels=len(REL.vocab), pad_index=WORD.pad_index, unk_index=WORD.unk_index, bos_index=WORD.bos_index, feat_pad_index=CHAR.pad_index, encoder=encoder, n_embed=word_dim) model.load_pretrained(WORD.embed) device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") print(device) model.to(device) puncts = torch.tensor( [i for s, i in WORD.vocab.stoi.items() if ispunct(s)]).to(device) train, dev, test = get_dataset(transform) # train.sentences = train.sentences[:30000] dev.sentences = dev.sentences[:200] test.sentences = test.sentences[:200] print('train sentences:%d dev sentences:%d test sentences:%d' % (len(train.sentences), len(dev.sentences), len(test.sentences))) if (encoder == 'lstm'): optimizer = Adam(model.parameters(), lr=2e-3, betas=(0.9, 0.9), eps=1e-12) else: optimizer = ScheduledOptim( Adam(model.parameters(), betas=(0.9, 0.98), eps=1e-09), 2.0, 800, 4000) train_parser(train, dev, test, model, optimizer, transform, WORD, puncts, encoder, epochs=epoch, path=encoder + '_model')
def train_model(config_path: str): writer = SummaryWriter() config = read_training_pipeline_params(config_path) logger.info("pretrained_emb {b}", b=config.net_params.pretrained_emb) device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') logger.info("Device is {device}", device=device) SRC, TRG, dataset = get_dataset(config.dataset_path, config.net_params.transformer) train_data, valid_data, test_data = split_data( dataset, **config.split_ration.__dict__) if config.net_params.pretrained_emb: src_vectors = torchtext.vocab.FastText(language='ru') SRC.build_vocab(train_data, min_freq=3) if config.net_params.pretrained_emb: SRC.vocab.load_vectors(src_vectors) TRG.build_vocab(train_data, min_freq=3) torch.save(SRC.vocab, config.src_vocab_name) torch.save(TRG.vocab, config.trg_vocab_name) logger.info("Vocab saved") print(f"Unique tokens in source (ru) vocabulary: {len(SRC.vocab)}") print(f"Unique tokens in target (en) vocabulary: {len(TRG.vocab)}") train_iterator, valid_iterator, test_iterator = BucketIterator.splits( (train_data, valid_data, test_data), batch_size=config.BATCH_SIZE, device=device, sort_key=_len_sort_key, ) INPUT_DIM = len(SRC.vocab) OUTPUT_DIM = len(TRG.vocab) if config.net_params.attention: Encoder = network_gru_attention.Encoder Decoder = network_gru_attention.Decoder Seq2Seq = network_gru_attention.Seq2Seq Attention = network_gru_attention.Attention attn = Attention(config.net_params.HID_DIM, config.net_params.HID_DIM) enc = Encoder(INPUT_DIM, config.net_params.ENC_EMB_DIM, config.net_params.HID_DIM, config.net_params.HID_DIM, config.net_params.ENC_DROPOUT) dec = Decoder(OUTPUT_DIM, config.net_params.DEC_EMB_DIM, config.net_params.HID_DIM, config.net_params.HID_DIM, config.net_params.DEC_DROPOUT, attn) model = Seq2Seq(enc, dec, device) if config.net_params.transformer: logger.info("Transformer lets go") Encoder = network_transformer.Encoder Decoder = network_transformer.Decoder Seq2Seq = network_transformer.Seq2Seq SRC_PAD_IDX = SRC.vocab.stoi[SRC.pad_token] TRG_PAD_IDX = TRG.vocab.stoi[TRG.pad_token] HID_DIM = 512 ENC_LAYERS = 6 DEC_LAYERS = 6 ENC_HEADS = 8 DEC_HEADS = 8 ENC_PF_DIM = 2048 DEC_PF_DIM = 2048 ENC_DROPOUT = 0.1 DEC_DROPOUT = 0.1 enc = Encoder(INPUT_DIM, HID_DIM, ENC_LAYERS, ENC_HEADS, ENC_PF_DIM, ENC_DROPOUT, device) dec = Decoder(OUTPUT_DIM, HID_DIM, DEC_LAYERS, DEC_HEADS, DEC_PF_DIM, DEC_DROPOUT, device) model = Seq2Seq(enc, dec, SRC_PAD_IDX, TRG_PAD_IDX, device) if not config.net_params.attention and not config.net_params.transformer: Encoder = my_network.Encoder Decoder = my_network.Decoder Seq2Seq = my_network.Seq2Seq enc = Encoder(INPUT_DIM, config.net_params.ENC_EMB_DIM, config.net_params.HID_DIM, config.net_params.N_LAYERS, config.net_params.ENC_DROPOUT) dec = Decoder(OUTPUT_DIM, config.net_params.DEC_EMB_DIM, config.net_params.HID_DIM, config.net_params.N_LAYERS, config.net_params.DEC_DROPOUT) model = Seq2Seq(enc, dec, device) model.apply(init_weights) if config.net_params.pretrained_emb: model.encoder.tok_embedding = nn.Embedding.from_pretrained( torch.FloatTensor(SRC.vocab.vectors)) model.to(device) PAD_IDX = TRG.vocab.stoi[TRG.pad_token] optimizer = optim.Adam(model.parameters(), config.lr) criterion = nn.CrossEntropyLoss(ignore_index=PAD_IDX) lr_scheduler = optim.lr_scheduler.ReduceLROnPlateau( optimizer, **config.lr_scheduler.__dict__) train_history = [] valid_history = [] best_valid_loss = float('inf') print("Let's go") # for p in model.encoder.parameters(): # p.requires_grad = True # for p in model.decoder.parameters(): # p.requires_grad = True for epoch in range(config.N_EPOCHS): start_time = time.time() train_loss = train(model, train_iterator, optimizer, criterion, config.CLIP, train_history, valid_history) valid_loss = evaluate(model, valid_iterator, criterion) lr_scheduler.step(valid_loss) end_time = time.time() epoch_mins, epoch_secs = epoch_time(start_time, end_time) if valid_loss < best_valid_loss: best_valid_loss = valid_loss torch.save(model.state_dict(), config.model_out_name) train_history.append(train_loss) valid_history.append(valid_loss) writer.add_scalar('train loss', train_history[-1], epoch) writer.add_scalar('valid loss', valid_history[-1], epoch) writer.add_scalar('learning rate', lr_scheduler._last_lr[0], epoch) print(f'Epoch: {epoch + 1:02} | Time: {epoch_mins}m {epoch_secs}s') print( f'\tTrain Loss: {train_loss:.3f} | Train PPL: {math.exp(train_loss):7.3f}' ) print( f'\t Val. Loss: {valid_loss:.3f} | Val. PPL: {math.exp(valid_loss):7.3f}' ) for idx, batch in enumerate(valid_iterator): if idx > 3: break src = batch.src[:, idx:idx + 1] trg = batch.trg[:, idx:idx + 1] generate_translation(src, trg, model, TRG.vocab, SRC.vocab, config.net_params.transformer) get_bleu(model, test_iterator, TRG, config.net_params.transformer)
from sklearn import ensemble from sklearn import feature_extraction from sklearn import linear_model from sklearn import pipeline from sklearn import cross_validation from sklearn import metrics from sklearn.externals import joblib import load_data import pickle # Load the dataset from the csv file. Handled by load_data.py. Each email is split in characters and each one has label assigned X, y, label_names = load_data.get_dataset() # Split the dataset on training and testing sets X_train, X_test, y_train, y_test = cross_validation.train_test_split(X,y,test_size=0.2,random_state=0) #Setting up vectorizer that will convert dataset into vectors using n-gram vectorizer = feature_extraction.text.TfidfVectorizer(ngram_range=(1, 4), analyzer='char') #Setting up pipeline to flow data though vectorizer to the liner model implementation pipe = pipeline.Pipeline([('vectorizer', vectorizer), ('clf', linear_model.LogisticRegression())]) #Pass training set of features and labels though pipe. pipe.fit(X_train, y_train) #Test model accuracy by running feature test set y_predicted = pipe.predict(X_test) print(metrics.classification_report(y_test, y_predicted,target_names=label_names))
from torch.utils.data import DataLoader, random_split from load_data import get_dataset, MyCollate from torchvision import transforms as T import pickle from torch import nn import numpy as np #split() transforms = T.Compose([ T.Resize(256), T.CenterCrop(224), T.ToTensor(), T.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)) ]) dataset, data_loader = get_dataset(root_dir="Flickr8k", caption_file="captions_train.txt", transforms=transforms) print(len(dataset.vocabulary)) def convert_data_loader(loader): pad_idx = dataset.vocabulary.stoi["<PAD>"] return DataLoader( dataset=loader, batch_size=16, #how many sample which load to the batch shuffle=True, num_workers=2, #how many subprocess to uses for data loading pin_memory=True, collate_fn=MyCollate( pad_idx) #merge list of sample to form a mini batch tensor
import torch, torchvision from torchvision import datasets, transforms from torch import nn, optim from torch.nn import functional as F import numpy as np # pip install shap import shap from load_data import get_dataset, get_dataset_test model = torch.load( './saved_checkpoints/continuous_sameWt_eqSample_new_fc_0.3_2_0.333_0.333.th', map_location='cpu') train_loader, valid_loader, test_loader = get_dataset(minibatch_size=128) # since shuffle=True, this is a random sample of test data batch = next(iter(test_loader)) images, _ = batch background = images[:100] test_images = images[100:103] e = shap.DeepExplainer(model, background) shap_values = e.shap_values(test_images) print(shap_values.shape)
X_tsne = preprocessing.normalize(X_tsne.embedding_, norm='l2') fig = plt.figure() ax = plt.subplot(111) for i in range(X_tsne.shape[0]): plt.text(X_tsne[i, 0], X_tsne[i, 1], str(labels[i]), color=plt.cm.Set1(labels[i] / kmeans_clusters), fontdict={'weight': 'bold', 'size': 3}) plt.legend() # plt.show() ''' print() if __name__ == '__main__': train_epoch = sys.argv[1] test = int(sys.argv[2]) if test != 0: test = True else: test = False data = load_data.get_dataset(test=test) model_dm, model_dbow = train_doc2vec(data, new_model=True) vecs_dm = load_data.get_doc_vec(model_dm, data) vecs_dbow = load_data.get_doc_vec(model_dbow, data) labels_dm, cluster_centers_dm = train_cluster(vecs_dm, 'kmeans_dm.pkl') labels_dbow, cluster_centers_dbow = train_cluster(vecs_dbow, 'kmeans_dbow.pkl') train_tsne(vecs_dm, labels_dm, 'tsne_dm.pkl') train_tsne(vecs_dbow, labels_dbow, 'tsne_dbow.pkl') print()
def test(model_name, ch): batch_size = 64 train_loader, valid_loader, test_loader = get_dataset( minibatch_size=batch_size) net = FraudNet(ch, continuous).to(device='cuda') paths = glob('./saved_checkpoints/' + model_name + '_*') print('paths', paths) test_loss = np.array( [float(path.split('.th')[0].split('_')[-1]) for path in paths]) print(test_loss) idx = np.argmin(test_loss) print(idx) path = paths[idx] print(path) # net.load_state_dict(torch.load(path)) loss = 0.0 steps = 0.0 weight_factor = 1.0 net = net.eval() predicted_list = [] labels_list = [] loss_list = [] loss = evaluate(test_loader, net) print('loss', loss) exit() with torch.no_grad(): for b, data in enumerate(test_loader): inputs, labels = data y_pred = net(inputs) mask = (labels > 0.5).float() batch_weights = mask * weight_factor + (1 - mask) * (1) loss += nn.BCELoss(weight=batch_weights)(y_pred, labels) steps += 1.0 bce_loss = nn.BCELoss(reduction='none')(y_pred, labels) predicted_list.append(y_pred.cpu().data.numpy()) labels_list.append(labels.cpu().data.numpy()) loss_list.append(bce_loss.cpu().data.numpy()) predicted_list = np.array([x for y in predicted_list for x in y]) labels_list = np.array([x for y in labels_list for x in y]) actual_labels = (labels_list >= 0.5).astype(np.int32) loss_list = np.array([x for y in loss_list for x in y]) positive_loss = loss_list[labels_list >= 0.5].mean() negative_loss = loss_list[labels_list < 0.5].mean() overall_loss = loss_list.mean() weighted_loss = loss / steps result = calc_metrics_classification(actual_labels, predicted_list) result.update({ 'positive_loss': positive_loss, 'negative_loss': negative_loss, 'overall_loss': overall_loss, 'weighted_loss': weighted_loss }) print(result)
def save_labeled_data(corpus, labels, file_name): index = 0 res = {} for key in corpus: tmp_re_ = [] for text in corpus[key]: tmp_dict_ = {'text': text, 'label': str(labels[index])} tmp_re_.append(tmp_dict_) index += 1 res[key] = tmp_re_ with open(os.path.join(path_data, file_name), 'w') as f: json.dump(res, f, ensure_ascii=False, indent=4, separators=(',', ': ')) if __name__ == '__main__': test = False doc2vec_dm_model = Doc2Vec.load(os.path.join(path_model, 'doc2vec_dm')) doc2vec_dbow_model = Doc2Vec.load(os.path.join(path_model, 'doc2vec_dbow')) km_dm_model = joblib.load(os.path.join(path_model, 'kmeans_dm.pkl')) km_dbow_model = joblib.load(os.path.join(path_model, 'kmeans_dbow.pkl')) corpus = load_data.get_dataset(test=test, cut=False) vecs_dm = load_data.get_doc_vec(doc2vec_dm_model, corpus) vecs_dbow = load_data.get_doc_vec(doc2vec_dbow_model, corpus) print('get vecs') labels_dm = label_infer(km_dm_model, vecs_dm) labels_dbow = label_infer(km_dbow_model, vecs_dbow) corpus = load_data.get_dataset(raw=True, test=test) save_labeled_data(corpus, labels_dm, 'match-data-dm.json') save_labeled_data(corpus, labels_dm, 'match-data-dbow.json')
def train(model_name='RL_net', tbd='logs', sparsity_lambda=0.5, ch=3): no_epochs = 30 lr = 1e-3 batch_size = 1024 print('Loading dataset ...') train_loader, valid_loader, test_loader = get_dataset( minibatch_size=batch_size) fraud_net = load_fraudnet() net = RLNet(ch=ch).to(device='cuda').train() print('Model:') print(net) optimizer = torch.optim.Adam(net.parameters(), lr=lr) best_valid_reward = -1 * float('inf') writer = SummaryWriter('RL_runs/' + tbd) for i in range(no_epochs): for b, data in enumerate(train_loader): inputs, labels = data inputs, labels = smote_func(inputs, labels) y_logits = net(inputs) y_probs = F.sigmoid(y_logits) m = Bernoulli(probs=y_probs) selected_features = m.sample() number_selected = selected_features.sum(1) #fraction selected # print (selected_features,default_features) selected_inputs = inputs * selected_features + ( 1 - selected_features) * default_features y_pred = fraud_net(selected_inputs) bce_loss = nn.BCELoss(reduction='none')(y_pred, labels) # print('number_selected, bce_loss',number_selected.shape,bce_loss.shape) number_dropped = 50 - number_selected reward = -1 * bce_loss - sparsity_lambda * torch.abs( number_selected - 5).unsqueeze(1) log_probs = m.log_prob(selected_features) print(log_probs.shape, reward.shape) loss = -log_probs * reward loss = loss.mean() if b % 100: print( 'Epochs: {}, batch: {}, loss: {}, reward: {}, bce loss: {}, fraction selected: {}' .format(i, b, loss, reward.mean().item(), bce_loss.mean().item(), number_selected.mean().item())) sys.stdout.flush() optimizer.zero_grad() loss.backward() optimizer.step() writer.add_scalar('train_loss', loss, i) writer.add_scalar('reward', reward.mean(), i) writer.add_scalar('bce_loss', bce_loss.mean(), i) writer.add_scalar('number_selected', number_selected.mean(), i) valid_result = evaluate(valid_loader, fraud_net, net, sparsity_lambda) valid_result.update({'name': 'Valid_Epoch_{}'.format(i)}) print(valid_result) valid_reward = valid_result['reward'] if valid_reward > best_valid_reward: torch.save(net.state_dict(), './saved_rl_checkpoints/' + model_name + '.th') best_valid_reward = valid_reward test_result = evaluate(test_loader, fraud_net, net, sparsity_lambda) test_result.update({'name': 'test_Epoch_{}'.format(i)}) print(test_result) print('Saving checkpoint at epoch: {}'.format(i)) print(test_result)