def dcgan_train(config, checkpoint_dir=None): step = 0 use_cuda = config.get("use_gpu") and torch.cuda.is_available() device = torch.device("cuda" if use_cuda else "cpu") netD = Discriminator().to(device) netD.apply(weights_init) netG = Generator().to(device) netG.apply(weights_init) criterion = nn.BCELoss() optimizerD = optim.Adam(netD.parameters(), lr=config.get("lr", 0.01), betas=(beta1, 0.999)) optimizerG = optim.Adam(netG.parameters(), lr=config.get("lr", 0.01), betas=(beta1, 0.999)) with FileLock(os.path.expanduser("~/.data.lock")): dataloader = get_data_loader() if checkpoint_dir is not None: path = os.path.join(checkpoint_dir, "checkpoint") checkpoint = torch.load(path) netD.load_state_dict(checkpoint["netDmodel"]) netG.load_state_dict(checkpoint["netGmodel"]) optimizerD.load_state_dict(checkpoint["optimD"]) optimizerG.load_state_dict(checkpoint["optimG"]) step = checkpoint["step"] if "netD_lr" in config: for param_group in optimizerD.param_groups: param_group["lr"] = config["netD_lr"] if "netG_lr" in config: for param_group in optimizerG.param_groups: param_group["lr"] = config["netG_lr"] while True: lossG, lossD, is_score = train( netD, netG, optimizerG, optimizerD, criterion, dataloader, step, device, config["mnist_model_ref"], ) step += 1 with tune.checkpoint_dir(step=step) as checkpoint_dir: path = os.path.join(checkpoint_dir, "checkpoint") torch.save( { "netDmodel": netD.state_dict(), "netGmodel": netG.state_dict(), "optimD": optimizerD.state_dict(), "optimG": optimizerG.state_dict(), "step": step, }, path, ) tune.report(lossg=lossG, lossd=lossD, is_score=is_score)
def step(self): lossG, lossD, is_score = train( self.netD, self.netG, self.optimizerG, self.optimizerD, self.criterion, self.dataloader, self._iteration, self.device, self.mnist_model_ref, ) return {"lossg": lossG, "lossd": lossD, "is_score": is_score}
print("After Decryption\n", dec_model_state[temp_key][0]) logger.info("{} weight is {}".format(client.configs['username'], client.weight / _weight_sum)) logger.info("weight sum is {}\t client num is {}".format( _weight_sum, _client_num)) model.load_state_dict(dec_model_state) fileName = 'model_state_{}.pth'.format(client.configs['username']) update_name = train(filename=fileName, device=device, train_data_loader=train_data_loader, model=model, optimizer=optimizer, log=log, warm_epoch=warm_epoch, epoch=epoch_num, criterion=criterion, warmup_scheduler=warmup_scheduler, train_scheduler=train_scheduler, save_interval=5, save_folder='./model/') # encryption, then send the model back to the server trained_model_state_dict = torch.load(update_name) print("After training, some updated model parameters: ") print(trained_model_state_dict[temp_key][0]) print("*****************************\n*****************************\n") for key in trained_model_state_dict.keys(): trained_model_state_dict[key] = trained_model_state_dict[ key] * client.weight / _weight_sum
from sklearn.svm import SVC import common common.train(SVC(), '../svm-models/')
LSTM(1000, activation='tanh', input_shape=(4, 1), return_sequences=True)) model.add(Dropout(0.3)) model.add(LSTM(500, activation='tanh', return_sequences=True)) model.add(Dropout(0.3)) model.add(LSTM(200, activation='tanh', return_sequences=True)) model.add(Dropout(0.3)) model.add(LSTM(200, activation='tanh', return_sequences=True)) model.add(Dropout(0.3)) model.add(LSTM(200, activation='tanh', return_sequences=True)) model.add(Dense(1, activation='linear')) rmsprop = optimizers.RMSprop(lr=0.00005, rho=0.8, epsilon=1e-08) model.compile(loss="mean_squared_error", optimizer=rmsprop) return model if __name__ == '__main__': file = common.readData() scaler = preprocessing.MinMaxScaler(feature_range=(-1, 1)) data = common.preprocessData(file, scaler) train_data, test_data = common.splitData(data, 0.8) common.plotTestAndTrain(train_data, test_data) x_train, y_train, x_test, y_test = common.prepareForTraining( train_data, test_data) model = getModel() common.train(x_train, y_train, model, 8, 15, "model03.h5") common.test(model, x_train, y_train, x_test, y_test) common.predict(model, x_test, y_test, scaler)
NN_m = partial(get_NN, m=m) comm = MPI.COMM_WORLD nlocal_jobs = args.nnets/comm.size if comm.rank == comm.size - 1: nlocal_jobs = args.nnets - nlocal_jobs*comm.rank x = np.linspace(0, 1, 20001) yY = Yaro_m(x) # Reference we want to beat eY = sup_norm(x**2 - yY) local_errors = [] for i in range(nlocal_jobs): with tf.Session() as session: # Get back the trained net NN, ndofs = train(session, args.m, NN_m, verbose=True) yL = NN(x) eL = sup_norm(x**2 - yL) # FIXME: How shall we eval the error? # print i, 'Learned error', eL, 'vs', eY local_errors.append(eL) errors = comm.gather(local_errors) if comm.rank == 0: errors = sum(errors, []) print 'Learned Max/Min/Mean', np.max(errors), np.min(errors), np.mean(errors) print 'Yarotsky', eY
model = model.to(device) #Hyperparameters if (ADAM_OPTIMISER): optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE) else: optimizer = optim.SGD(model.classifier.parameters(), lr=0.001, momentum=0.5) #Train best_valid_loss = float('inf') for epoch in range(EPOCHS): #Range of Epochs print(epoch) train_loss, train_acc = common.train(model, device, train_iterator, optimizer, criterion) #Train Loss Calculation valid_loss, valid_acc = common.evaluate( model, device, valid_iterator, criterion) #Validation Loss Calculation if valid_loss < best_valid_loss: #Validation Loss - Is current lower than the saved validation loss. best_valid_loss = valid_loss #Save the best loss (lowest) torch.save(model.state_dict(), MODEL_SAVE_PATH) #Save the model print( f'| Epoch: {epoch+1:02} | Train Loss: {train_loss:.3f} | Train Acc: {train_acc*100:05.2f}% | Val. Loss: {valid_loss:.3f} | Val. Acc: {valid_acc*100:05.2f}% |' ) #3. OUTPUT model.load_state_dict(
common.train_grn16(train_loader, model, criterion, optimizer, epoch, args['cuda'], args['clip'], args['print_freq']) common.test_grn16(val_loader, model, criterion, args['cuda'], args['print_freq']) elif args['model'] == 'keann': common.train_keann(train_loader, model, criterion, optimizer, epoch, args['cuda'], args['clip'], args['print_freq']) common.test_keann(val_loader, model, criterion, args['cuda'], args['print_freq'], args['pdtb_category']) elif args['model'] == 'keann_kg': common.train_keann_kg(train_loader, model, criterion, optimizer, epoch, args['cuda'], args['clip'], args['print_freq'], writer) common.test_keann_kg(val_loader, model, criterion, args['cuda'], args['print_freq'], args['pdtb_category']) else: common.train(train_loader, model, criterion, optimizer, epoch, args['cuda'], args['clip'], args['print_freq']) common.test(val_loader, model, criterion, args['cuda'], args['print_freq']) print('cost_time:%.4f' % (time.time() - start_time)) # save current model if epoch % args['save_freq'] == 0: if args['pdtb_category']: path_save_model = results_path + '/' + args['model'] + '_' + args[ 'pdtb_category'] + '_{}.pkl'.format(epoch) else: path_save_model = results_path + '/' + args[ 'model'] + '_{}.pkl'.format(epoch) joblib.dump(model.float(), path_save_model, compress=2)
logger.log_dirname(f"Epoch {epoch}") model.train() if P.multi_gpu: train_sampler.set_epoch(epoch) kwargs = {} kwargs['linear'] = linear kwargs['linear_optim'] = linear_optim kwargs['simclr_aug'] = simclr_aug train(P, epoch, model, criterion, optimizer, scheduler_warmup, train_loader, logger=logger, **kwargs) model.eval() if epoch % P.save_step == 0 and P.local_rank == 0: if P.multi_gpu: save_states = model.module.state_dict() else: save_states = model.state_dict() evaluate(model, dev_dl) save_checkpoint(epoch, save_states, optimizer.state_dict(),
loss = 0 # sum of losses for an epoch total_loss = 0 # now! start = time.time() print() print("----------------") print("training starts!") print("----------------") print() for i in range(1, n_iter + 1): output, loss = cm.train(*cm.random_training_example()) total_loss += loss if i % print_every == 0: sys.stdout.write("%d %d%% (%s) %.4f\n" % (i, i / n_iter * 100, cm.time_since(start), loss)) if i % plot_every == 0: losses.append(total_loss / plot_every) total_loss = 0 plt.figure() plt.plot(losses) plt.show() torch.save(model, "gru.pt")
from sklearn.linear_model import SGDClassifier import common common.train( SGDClassifier( n_jobs=-1, loss='log', n_iter=100 ), '../sgd-models/' )
from keras.layers.core import Dense from keras.layers.recurrent import LSTM from keras.models import Sequential from scipy.ndimage.interpolation import shift from sklearn import preprocessing def getModel(): model = Sequential () model.add(LSTM(1000 , activation = 'tanh', input_shape=(4,1),return_sequences=True)) model.add(Dropout(0.5)) model.add(LSTM(500 , activation = 'tanh', return_sequences=True)) model.add(Dropout(0.5)) model.add(LSTM(200 , activation = 'tanh',return_sequences=True)) model.add(Dense (1, activation ='linear')) rmsprop = optimizers.RMSprop(lr=0.0001, rho=0.8, epsilon=1e-08) model.compile (loss ="mean_squared_error" , optimizer = rmsprop) return model if __name__ == '__main__': file = common.readData() scaler = preprocessing.MinMaxScaler(feature_range=(-1, 1)) data = common.preprocessData(file, scaler) train_data, test_data = common.splitData(data, 0.8) common.plotTestAndTrain(train_data, test_data) x_train, y_train, x_test, y_test = common.prepareForTraining(train_data, test_data) model = getModel() common.train(x_train, y_train, model, 8, 10, "model02.h5") common.test(model, x_train, y_train, x_test, y_test) common.predict(model,x_test, y_test, scaler)
SigmoidBinaryCrossEntropyLoss(from_sigmoid=False, batch_axis=0), input_dim, args.latent_dim) # optimizer trainer = Trainer(params=model_params, optimizer='adam', optimizer_params={'learning_rate': args.learning_rate}) # forward function for training def forward_fn(batch): x = batch.data[0].as_in_context(ctx) y, q = vae_nn(x) loss = loss_fn(x, q, y) return loss # train run_id = train(forward_fn, train_iter, val_iter, trainer, args.num_train_samples, args.num_val_samples, args.val_freq, args.logdir) # generate latent space figure if latent dim = 2 sw = mxboard.SummaryWriter(logdir=os.path.join(args.logdir, run_id)) if args.latent_dim == 2: img = generate_2d_latent_space_image(vae_nn, val_iter, input_shape, n=20, ctx=ctx) sw.add_image('2D_Latent_space', img) sw.close()
# forward function for training def forward_fn(batch, pixel_std): context_frames, context_cameras, query_cameras = batch.data[:3] query_frames = batch.label[0] y, qs, ps = gqn_nn(query_frames, query_cameras, context_frames, context_cameras) # update pixel std loss_fit.set_std(pixel_std) loss = loss_fn(query_frames, qs, ps, y) return loss plot_grad_cb = PlotGradientHistogram(gqn_nn, freq=1000) plot_batch = val_iter.next() plt_context_frames, plt_context_cameras, plt_query_cameras = plot_batch.data[:3] conditioning_variables=(plt_query_cameras, plt_context_frames, plt_context_cameras) generate_image_cb = PlotGenerateImage(gqn_nn, conditioning_variables=conditioning_variables, freq=args.val_freq, image_shape=input_shape) # train run_id = train(forward_fn, train_iter, val_iter, trainer, args.num_train_samples, args.num_val_samples, args.val_freq, args.logdir, validate_at_end=False, hyperparam_scheduler=pixel_std_scheduler, plot_callbacks=(plot_grad_cb, generate_image_cb), run_suffix=args.run_suffix) # save model gqn_nn.save_parameters('results/gqn_{}_{}.params'.format(args.dataset_name, run_id)) # generate samples # generate_samples(conv_draw_nn, input_shape, 'results', run_id, scale_factor=2.0)
'learning_rate': args.learning_rate, 'clip_gradient': 10. }) # forward function for training def forward_fn(batch): x = batch.data[0].as_in_context(ctx) y, qs, ps = conv_draw_nn(x) loss = loss_fn(x, qs, ps, y) return loss plot_grad_cb = PlotGradientHistogram(conv_draw_nn, freq=1000) generate_image_cb = PlotGenerateImage(conv_draw_nn, freq=args.val_freq, image_shape=input_shape) # train run_id = train(forward_fn, train_iter, val_iter, trainer, args.num_train_samples, args.num_val_samples, args.val_freq, args.logdir, (plot_grad_cb, generate_image_cb)) # save model conv_draw_nn.save_parameters('results/conv_draw_{}.params'.format(run_id)) # generate samples generate_samples(conv_draw_nn, input_shape, 'results', run_id, scale_factor=2.0)
from sklearn.neighbors import KNeighborsClassifier import common common.train(KNeighborsClassifier(n_jobs=-1), '../knn-models/')
def getModel(): model = Sequential() model.add( LSTM(1000, activation='tanh', input_shape=(4, 1), return_sequences=True)) model.add(Dropout(0.2)) model.add(LSTM(500, activation='tanh', return_sequences=True)) model.add(Dropout(0.2)) model.add(LSTM(200, activation='tanh', return_sequences=True)) model.add(Dense(1, activation='linear')) adam = optimizers.Adam(lr=0.0001) model.compile(loss="mean_squared_error", optimizer=adam) return model if __name__ == '__main__': file = common.readData() scaler = preprocessing.MinMaxScaler(feature_range=(-1, 1)) data = common.preprocessData(file, scaler) train_data, test_data = common.splitData(data, 0.8) common.plotTestAndTrain(train_data, test_data) x_train, y_train, x_test, y_test = common.prepareForTraining( train_data, test_data) model = getModel() common.train(x_train, y_train, model, 16, 10, "model01.h5") common.test(model, x_train, y_train, x_test, y_test) common.predict(model, x_test, y_test, scaler)
for epoch in range(1, args.epochs + 1): util.adjust_learning_rate(args.lr, optimizer, epoch) if args.model == 'grn16': common.train_grn16(train_loader, model, criterion, optimizer, epoch, args.cuda, args.clip, args.print_freq) common.test_grn16(val_loader, model, criterion, args.cuda, args.print_freq) elif args.model == 'keann': common.train_keann(train_loader, model, criterion, optimizer, epoch, args.cuda, args.clip, args.print_freq) common.test_keann(val_loader, model, criterion, args.cuda, args.print_freq) elif args.model == 'keann_kg': common.train_keann_kg(train_loader, model, criterion, optimizer, epoch, args.cuda, args.clip, args.print_freq) common.test_keann_kg(val_loader, model, criterion, args.cuda, args.print_freq) else: common.train(train_loader, model, criterion, optimizer, epoch, args.cuda, args.clip, args.print_freq) common.test(val_loader, model, criterion, args.cuda, args.print_freq) # save current model if epoch % args.save_freq == 0: if args.pdtb_category: path_save_model = results_path + '/' + args.model + '_' + args.pdtb_category + '_{}.pkl'.format( epoch) else: path_save_model = results_path + '/' + args.model + '_{}.pkl'.format( epoch) joblib.dump(model.float(), path_save_model, compress=2)
comm = MPI.COMM_WORLD nlocal_jobs = args.nnets / comm.size if comm.rank == comm.size - 1: nlocal_jobs = args.nnets - nlocal_jobs * comm.rank x = np.linspace(0, 1, 20001) yY = Yaro_m(x) # Reference we want to beat eY = sup_norm(x**2 - yY) local_errors = [] for i in range(nlocal_jobs): with tf.Session() as session: # Get back the trained net NN, ndofs = train(session, args.m, NN_m, verbose=True, points=args.points, penalty=args.penalty) yL = NN(x) eL = sup_norm(x**2 - yL) # FIXME: How shall we eval the error? # print i, 'Learned error', eL, 'vs', eY local_errors.append(eL) errors = comm.gather(local_errors) if comm.rank == 0: errors = sum(errors, []) print 'Learned Max/Min/Mean %s', np.max(errors), np.min(errors), np.mean(
return x # device = 'cuda' device = 'cpu' n_components = 30 model = CommonSpatialFilterModel(spatial_dim=epochs_data.shape[1], n_components=n_components) # Test model works: n_samples_test = 10 y_test = torch.randint(0, 2, (n_samples_test,)) y_pred = model.forward(torch.randn(n_samples_test, 1, *epochs_data.shape[1:])) output = F.nll_loss(y_pred, y_test) _, top_class = y_pred.topk(1, dim=1) ############################################################################## # Train from common import train # noqa lr = 1e-3 n_epochs = 300 patience = 100 model.to(device=device) # move to device before creating the optimizer optimizer = optim.SGD(model.parameters(), lr=lr, momentum=0.9, weight_decay=1e-4) train(model, loader_train, loader_valid, optimizer, n_epochs, patience, device)
def dcgan_train(config): step = 0 use_cuda = config.get("use_gpu") and torch.cuda.is_available() device = torch.device("cuda" if use_cuda else "cpu") netD = Discriminator().to(device) netD.apply(weights_init) netG = Generator().to(device) netG.apply(weights_init) criterion = nn.BCELoss() optimizerD = optim.Adam(netD.parameters(), lr=config.get("lr", 0.01), betas=(beta1, 0.999)) optimizerG = optim.Adam(netG.parameters(), lr=config.get("lr", 0.01), betas=(beta1, 0.999)) with FileLock(os.path.expanduser("~/.data.lock")): dataloader = get_data_loader() if session.get_checkpoint(): loaded_checkpoint = session.get_checkpoint() with loaded_checkpoint.as_directory() as loaded_checkpoint_dir: path = os.path.join(loaded_checkpoint_dir, "checkpoint.pt") checkpoint = torch.load(path) netD.load_state_dict(checkpoint["netDmodel"]) netG.load_state_dict(checkpoint["netGmodel"]) optimizerD.load_state_dict(checkpoint["optimD"]) optimizerG.load_state_dict(checkpoint["optimG"]) step = checkpoint["step"] if "netD_lr" in config: for param_group in optimizerD.param_groups: param_group["lr"] = config["netD_lr"] if "netG_lr" in config: for param_group in optimizerG.param_groups: param_group["lr"] = config["netG_lr"] while True: lossG, lossD, is_score = train( netD, netG, optimizerG, optimizerD, criterion, dataloader, step, device, config["mnist_model_ref"], ) step += 1 os.makedirs("my_model", exist_ok=True) torch.save( { "netDmodel": netD.state_dict(), "netGmodel": netG.state_dict(), "optimD": optimizerD.state_dict(), "optimG": optimizerG.state_dict(), "step": step, }, "my_model/checkpoint.pt", ) session.report( { "lossg": lossG, "lossd": lossD, "is_score": is_score }, checkpoint=Checkpoint.from_directory("my_model"), )
def mnist_classifier_tanh(): # paths path = dict() path['project'] = os.path.dirname(os.path.abspath(__file__)) path['state'] = os.path.join(path['project'], 'epoch') path['dataset'] = os.path.join(path['project'], 'dataset') path['graph'] = os.path.join(path['project'], 'graph') path['array'] = os.path.join(path['project'], 'array') for key, value in path.items(): if not os.path.exists(path[key]): os.mkdir(path[key]) # parameters batch_size = 1000 number_of_epochs = 20 learning_rate = 1e-3 device = 'cuda' if torch.cuda.is_available() else 'cpu' mean = 0.1307 std = 0.3081 loss = nn.CrossEntropyLoss() train_info_per_batch = 6 validation_info_per_batch = 3 test_info_per_batch = 5 validation_ratio = 0.1 # transform transform = torchvision.transforms.Compose([ torchvision.transforms.ToTensor(), torchvision.transforms.Normalize(mean=(mean, ), std=(std, )) ]) # dataset train_dataset = torchvision.datasets.MNIST(root=path['dataset'], train=True, transform=transform, download=True) test_dataset = torchvision.datasets.MNIST(root=path['dataset'], train=False, transform=transform, download=True) # validation dataset validation_limit = int((1 - validation_ratio) * len(train_dataset)) index_list = list(range(len(train_dataset))) train_indexes, validation_indexes = index_list[: validation_limit], index_list[ validation_limit:] train_sampler = SubsetRandomSampler(train_indexes) validation_sampler = SequentialSampler(validation_indexes) # dataset loaders train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=batch_size, sampler=train_sampler) validation_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=batch_size, sampler=validation_sampler) test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=batch_size) # model model = MnistClassifierTanh().to(device) # optimizer optimizer = optim.SGD(params=model.parameters(), lr=learning_rate) epochs = np.arange(start=1, stop=(number_of_epochs + 1), step=1, dtype=int) print('Mnist Classifier Tanh') train_losses = [] train_accuracies = [] validation_losses = [] validation_accuracies = [] test_losses = [] test_accuracies = [] for epoch in epochs: info = 'Epoch {epoch_index}/{number_of_epochs}' print(info.format(epoch_index=epoch, number_of_epochs=number_of_epochs)) # train train_loss, train_accuracy = train(model=model, device=device, loader=train_loader, optimizer=optimizer, loss=loss, info_per_batch=train_info_per_batch) info = 'Train: Average Loss: {train_loss:.5f}, Accuracy: % {train_accuracy:.2f}' print( info.format(train_loss=train_loss, train_accuracy=(100 * train_accuracy))) train_losses.append(train_loss) train_accuracies.append(train_accuracy) # validation validation_loss, validation_accuracy = test( model=model, loader=validation_loader, device=device, loss=loss, info_per_batch=validation_info_per_batch, info_name='Validation') info = 'Validation: Average Loss: {validation_loss:.5f}, Accuracy: % {validation_accuracy:.2f}' print( info.format(validation_loss=validation_loss, validation_accuracy=(100 * validation_accuracy))) validation_losses.append(validation_loss) validation_accuracies.append(validation_accuracy) # test test_loss, test_accuracy = test(model=model, loader=test_loader, device=device, loss=loss, info_per_batch=test_info_per_batch, info_name='Test') info = 'Test: Average Loss: {test_loss:.5f}, Accuracy: % {test_accuracy:.2f}' print( info.format(test_loss=test_loss, test_accuracy=(100 * test_accuracy))) test_losses.append(test_loss) test_accuracies.append(test_accuracy) # epoch state state_file_name = 'mnist_classifier_tanh_epoch_{epoch_index}.pkl'.format( epoch_index=epoch) save_state(model=model, directory=path['state'], file_name=state_file_name) # train loss save_data(array=train_losses, directory=path['array'], file_name='mnist_classifier_tanh_train_loss.npy') draw_line_graph(x=epochs, y=train_losses, x_label='Epoch', y_label='Loss', title='Mnist Classifier Tanh Train Loss', directory=path['graph'], file_name='mnist_classifier_tanh_train_loss.png') # train accuracy save_data(array=train_accuracies, directory=path['array'], file_name='mnist_classifier_tanh_train_accuracy.npy') draw_line_graph(x=epochs, y=train_accuracies, x_label='Epoch', y_label='Accuracy', title='Mnist Classifier Tanh Train Accuracy', directory=path['graph'], file_name='mnist_classifier_tanh_train_accuracy.png') # validation loss save_data(array=validation_losses, directory=path['array'], file_name='mnist_classifier_tanh_validation_loss.npy') draw_line_graph(x=epochs, y=validation_losses, x_label='Epoch', y_label='Loss', title='Mnist Classifier Tanh Validation Loss', directory=path['graph'], file_name='mnist_classifier_tanh_validation_loss.png') # validation accuracy save_data(array=validation_accuracies, directory=path['array'], file_name='mnist_classifier_tanh_validation_accuracy.npy') draw_line_graph(x=epochs, y=validation_accuracies, x_label='Epoch', y_label='Accuracy', title='Mnist Classifier Tanh Validation Accuracy', directory=path['graph'], file_name='mnist_classifier_tanh_validation_accuracy.png') # test loss save_data(array=test_losses, directory=path['array'], file_name='mnist_classifier_tanh_test_loss.npy') draw_line_graph(x=epochs, y=test_losses, x_label='Epoch', y_label='Loss', title='Mnist Classifier Tanh Test Loss', directory=path['graph'], file_name='mnist_classifier_tanh_test_loss.png') # test accuracy save_data(array=test_accuracies, directory=path['array'], file_name='mnist_classifier_tanh_test_accuracy.npy') draw_line_graph(x=epochs, y=test_accuracies, x_label='Epoch', y_label='Accuracy', title='Mnist Classifier Tanh Test Accuracy', directory=path['graph'], file_name='mnist_classifier_tanh_test_accuracy.png') # loss draw_multi_lines_graph(lines=[ dict(label='Train', data=dict(x=epochs, y=train_losses)), dict(label='Validation', data=dict(x=epochs, y=validation_losses)), dict(label='Test', data=dict(x=epochs, y=test_losses)) ], x_label='Epoch', y_label='Loss', title='Mnist Classifier Tanh Loss', directory=path['graph'], file_name='mnist_classifier_tanh_loss.png') # accuracy draw_multi_lines_graph(lines=[ dict(label='Train', data=dict(x=epochs, y=train_accuracies)), dict(label='Validation', data=dict(x=epochs, y=validation_accuracies)), dict(label='Test', data=dict(x=epochs, y=test_accuracies)) ], x_label='Epoch', y_label='Accuracy', title='Mnist Classifier Tanh Accuracy', directory=path['graph'], file_name='mnist_classifier_tanh_accuracy.png')