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')
