def main(args):
data = myDataset(args)
train_data, val_data, test_data = data.getTrData(), data.getValData(
), data.getTsData()
m, n_in = train_data.shape
n_fin = n_in
n_h = 1000
net_dims = [n_in, n_h, n_fin]
epochs = int(args.epochs)
plot_costs = []
plot_costs_ = []
test_acc = []
net_dims = [n_in, n_h, n_fin]
costs,costs_, parameters = train(train_data, val_data, net_dims, \
epochs=epochs, learningRate=args.learningRate, costEstimate=args.costEstimate, decayRate = args.decayRate)
predict(parameters)
it = list(range(0, epochs))
plt.plot(it, costs, label='train')
plt.plot(it, costs_, label='val')
plt.title('Train_cost and Val_cost vs iterations')
plt.xlabel('iterations')
plt.ylabel('Cost')
plt.legend()
plt.show()
def classifierTrain(X,
Y,
X_val,
Y_val,
net_dims,
epochs=100,
learningRate=0.1,
decayRate=0.5):
learningRate = float(args.learningRate1)
epochs = int(args.epochs1)
#decayRate = float(args.decayRate)
decayRate = 0.2
batchSize = int(args.batchSize)
data = myDataset(args)
model = Model()
parameters = model.initialize_multilayer_weights(net_dims)
costs = []
costs_ = []
A0 = X
# print(X.shape)
# print(X_val.shape)
for ii in range(epochs):
noBatches = int(X.shape[0] / batchSize)
learningRate = learningRate * (1 / (1 + decayRate * ii))
for jj in range(noBatches):
#XTrBatch, YTrBatch= data.getTrMiniBatch(X, Y)
AL, cache1 = model.multi_layer_forward(A0, parameters)
A, cache2, cost = model.softmax_cross_entropy_loss(AL, Y)
# Backward Prop
dZ = model.softmax_cross_entropy_loss_der(Y, cache2)
grads = model.multi_layer_backward(dZ, cache1, parameters)
parameters, alpha = model.update_parameters(
parameters, grads, epochs, learningRate, decayRate)
if jj % 50 == 0:
print("Cost at iteration %i is: %.05f, learning rate: %.05f" %
(jj, cost, alpha))
#XValBatch, YValBatch = data.getValMiniBatch(X_val, Y_val)
costs.append(cost)
AL_, cache1_ = model.multi_layer_forward(X_val, parameters)
A_, cache2_, cost_ = model.softmax_cross_entropy_loss(AL_, Y_val)
costs_.append(cost_)
return costs, costs_, parameters
def softmaxTr(net_dims, X, Xval, Y, Yval, l):
data = myDataset(args)
learningRate = float(args.learningRate1)
epochs = int(args.epochs1)
#decayRate = float(args.decayRate)
#batchSize=int(args.batchSize)
decayRate = 0.2
batchSize = l * 10
model = Model()
costs = []
costs_ = []
n_in, n_h, n_fin = net_dims
parameters = model.initialize_2layer_weights(n_in, n_h, n_fin)
A0 = X
#print(X.shape,"shape of X") nxm
#W1,b1 = parameters["W1"],parameters["b1"]
for ii in range(epochs):
noBatches = int(X.shape[0] / batchSize)
learningRate = learningRate * (1 / (1 + decayRate * ii))
print(learningRate)
print("Epoch: ", ii)
for jj in range(noBatches):
#XTrBatch, YTrBatch= data.getTrMiniBatch(X, Y)
W1, b1 = parameters["W1"], parameters["b1"]
AL, cache1 = model.layer_forward(A0, W1, b1, "linear")
A, cache2, cost = model.softmax_cross_entropy_loss(AL, Y)
dZ = model.softmax_cross_entropy_loss_der(Y, cache2)
dA_prev, dW1, db1 = model.layer_backward(dZ, cache1, W1, b1,
"linear")
parameters['W1'] += -learningRate * dW1
parameters['b1'] += -learningRate * db1
if jj % 50 == 0:
print("Cost at iteration %i is: %f" % (jj * 50, cost))
costs.append(cost)
#XValBatch, YValBatch = data.getValMiniBatch(Xval, Yval)
AL_, cache1_ = model.layer_forward(Xval, W1, b1, "linear")
A_, cache2_, cost_ = model.softmax_cross_entropy_loss(AL_, Yval)
costs_.append(cost_)
return costs, costs_, parameters
def predict(parameters):
data = myDataset(args)
model = Model()
noise = Noise()
XTsBatch = data.getTsMiniBatch()
noisyXTsBatch = noise.GaussianNoise(XTsBatch, sd=0.3)
W1, b1 = parameters["W1"], parameters["b1"]
W2, b2 = parameters["W2"], parameters["b2"]
A1, cache1 = model.layer_forward(noisyXTsBatch, W1, b1, "relu")
A2, cache2 = model.layer_forward(A1, W2, b2, "sigmoid")
fig1 = plt.figure(figsize=(8, 8))
columns = 4
rows = 4
for i in range(1, columns * rows + 1):
pixels1 = A2[:, i]
img = pixels1.reshape((28, 28))
fig1.add_subplot(rows, columns, i)
plt.imshow(img)
fig2 = plt.figure(figsize=(8, 8))
columns = 4
rows = 4
for i in range(1, columns * rows + 1):
pixels2 = XTsBatch[:, i]
img = pixels2.reshape((28, 28))
fig2.add_subplot(rows, columns, i)
plt.imshow(img)
fig3 = plt.figure(figsize=(8, 8))
columns = 4
rows = 4
for i in range(1, columns * rows + 1):
pixels3 = noisyXTsBatch[:, i]
img = pixels3.reshape((28, 28))
fig3.add_subplot(rows, columns, i)
plt.imshow(img)
plt.show()
def main():
global args, date
args = parser.parse_args()
date = '1220'
os.environ["CUDA_VISIBLE_DEVICES"] = str(args.gpu)
model_G = ConvGen()
model_D = ConvDis(large=args.large)
start_epoch_G = start_epoch_D = 0
if args.model_G:
print('Resume model G: %s' % args.model_G)
checkpoint_G = torch.load(resume)
model_G.load_state_dict(checkpoint_G['state_dict'])
start_epoch_G = checkpoint_G['epoch']
if args.model_D:
print('Resume model D: %s' % args.model_D)
checkpoint_D = torch.load(resume)
model_D.load_state_dict(checkpoint_D['state_dict'])
start_epoch_D = checkpoint_D['epoch']
assert start_epoch_G == start_epoch_D
if args.model_G == '' and args.model_D == '':
print('No Resume')
start_epoch = 0
model_G.cuda()
model_D.cuda()
# optimizer
optimizer_G = optim.Adam(model_G.parameters(),
lr=args.lr,
betas=(0.5, 0.999),
eps=1e-8,
weight_decay=args.weight_decay)
optimizer_D = optim.Adam(model_D.parameters(),
lr=args.lr,
betas=(0.5, 0.999),
eps=1e-8,
weight_decay=args.weight_decay)
if args.model_G:
optimizer_G.load_state_dict(checkpoint_G['optimizer'])
if args.model_D:
optimizer_D.load_state_dict(checkpoint_D['optimizer'])
# loss function
global criterion
criterion = nn.BCELoss()
global L1
L1 = nn.L1Loss()
# dataset
# data_root = '/home/users/u5612799/DATA/Spongebob/'
data_root = args.path
dataset = args.dataset
if dataset == 'sc2':
from load_data import SC2_Dataset as myDataset
elif dataset == 'flower':
from load_data import Flower_Dataset as myDataset
elif dataset == 'bob':
from load_data import Spongebob_Dataset as myDataset
else:
raise ValueError('dataset type not supported')
if args.large:
image_transform = transforms.Compose(
[transforms.CenterCrop(480),
transforms.ToTensor()])
else:
image_transform = transforms.Compose(
[transforms.CenterCrop(224),
transforms.ToTensor()])
data_train = myDataset(data_root,
mode='train',
transform=image_transform,
types='raw',
shuffle=True,
large=args.large)
train_loader = data.DataLoader(data_train,
batch_size=args.batch_size,
shuffle=False,
num_workers=4)
data_val = myDataset(data_root,
mode='test',
transform=image_transform,
types='raw',
shuffle=True,
large=args.large)
val_loader = data.DataLoader(data_val,
batch_size=args.batch_size,
shuffle=False,
num_workers=4)
global val_bs
val_bs = val_loader.batch_size
# set up plotter, path, etc.
global iteration, print_interval, plotter, plotter_basic
iteration = 0
print_interval = 5
plotter = Plotter_GAN_TV()
plotter_basic = Plotter_GAN()
global img_path
size = ''
if args.large: size = '_Large'
img_path = 'img/%s/GAN_%s%s_%dL1_bs%d_%s_lr%s/' \
% (date, args.dataset, size, args.lamb, args.batch_size, 'Adam', str(args.lr))
model_path = 'model/%s/GAN_%s%s_%dL1_bs%d_%s_lr%s/' \
% (date, args.dataset, size, args.lamb, args.batch_size, 'Adam', str(args.lr))
if not os.path.exists(img_path):
os.makedirs(img_path)
if not os.path.exists(model_path):
os.makedirs(model_path)
# start loop
start_epoch = 0
for epoch in range(start_epoch, args.num_epoch):
print('Epoch {}/{}'.format(epoch, args.num_epoch - 1))
print('-' * 20)
if epoch == 0:
val_lerrG, val_errD = validate(val_loader,
model_G,
model_D,
optimizer_G,
optimizer_D,
epoch=-1)
# train
train_errG, train_errD = train(train_loader, model_G, model_D,
optimizer_G, optimizer_D, epoch,
iteration)
# validate
val_lerrG, val_errD = validate(val_loader, model_G, model_D,
optimizer_G, optimizer_D, epoch)
plotter.train_update(train_errG, train_errD)
plotter.val_update(val_lerrG, val_errD)
plotter.draw(img_path + 'train_val.png')
if args.save:
print('Saving check point')
save_checkpoint({'epoch': epoch + 1,
'state_dict': model_G.state_dict(),
'optimizer': optimizer_G.state_dict(),
},
filename=model_path+'G_epoch%d.pth.tar' \
% epoch)
save_checkpoint({'epoch': epoch + 1,
'state_dict': model_D.state_dict(),
'optimizer': optimizer_D.state_dict(),
},
filename=model_path+'D_epoch%d.pth.tar' \
% epoch)
def main():
"""
Executable
"""
# Declaring globals to be used in train, validate functions
# noinspection PyGlobalUndefined
global args, writer, criterion, L1, val_batch_size, img_path, model_path
args = parser.parse_args()
size = ''
if args.large:
size = '_large'
model_name = '{}{}_lambda={}_bs={}_lr={}_wd={}_n_epochs={}/'.format(args.dataset,
size,
args.lamb,
args.batch_size,
str(args.lr),
str(args.weight_decay),
args.num_epoch)
if args.prefix:
model_name = '{}_{}'.format(args.prefix, model_name)
print('Now training {}'.format(model_name))
writer = SummaryWriter(log_dir='runs/{}'.format(model_name))
os.environ["CUDA_VISIBLE_DEVICES"] = str(args.gpu)
# Loading models
model_G = ConvGen()
model_D = ConvDis(large=args.large)
# Setting starting epochs
start_epoch_G = start_epoch_D = 0
if args.model_G:
print('Resuming model G: {}'.format(args.model_G))
checkpoint_G = torch.load(args.model_G)
model_G.load_state_dict(checkpoint_G['state_dict'])
start_epoch_G = checkpoint_G['epoch']
if args.model_D:
print('Resuming model D: {}'.format(args.model_D))
checkpoint_D = torch.load(args.model_D)
model_D.load_state_dict(checkpoint_D['state_dict'])
start_epoch_D = checkpoint_D['epoch']
# Check
assert start_epoch_G == start_epoch_D
if args.model_G == '' and args.model_D == '':
print('Not resuming training for D, G.')
if args.use_cuda:
model_G.cuda()
model_D.cuda()
# Define optimizer
optimizer_G = optim.Adam(model_G.parameters(),
lr=args.lr, betas=(0.5, 0.999),
eps=1e-8, weight_decay=args.weight_decay)
optimizer_D = optim.Adam(model_D.parameters(),
lr=args.lr, betas=(0.5, 0.999),
eps=1e-8, weight_decay=args.weight_decay)
if args.model_G:
optimizer_G.load_state_dict(checkpoint_G['optimizer'])
if args.model_D:
optimizer_D.load_state_dict(checkpoint_D['optimizer'])
# Define loss function
criterion = nn.BCELoss()
L1 = nn.L1Loss()
# Define dataset
data_root = args.path
dataset = args.dataset
if dataset == 'sc2':
from load_data import SC2Dataset as myDataset
elif dataset == 'flower':
from load_data import FlowerDataset as myDataset
elif dataset == 'bob':
from load_data import BobDataset as myDataset
else:
raise ValueError('dataset type not supported')
if args.large:
image_transform = transforms.Compose([transforms.CenterCrop(480),
transforms.ToTensor()])
else:
image_transform = transforms.Compose([transforms.CenterCrop(224),
transforms.ToTensor()])
data_train = myDataset(data_root,
mode='train',
transform=image_transform,
types='raw',
shuffle=True,
large=args.large)
# train_loader __getitem__ returns (data [1, 224, 224]), target [3, 224, 224])
train_loader = torchdata.DataLoader(data_train,
batch_size=args.batch_size,
shuffle=False,
num_workers=4)
data_val = myDataset(data_root,
mode='test',
transform=image_transform,
types='raw',
shuffle=True,
large=args.large)
val_loader = torchdata.DataLoader(data_val,
batch_size=args.batch_size,
shuffle=False,
num_workers=4)
val_batch_size = val_loader.batch_size
# Set up plotter, path, etc.
global iteration, print_interval, plotter, plotter_basic
iteration = 0
print_interval = 5
plotter = Plotter_GAN_TV()
plotter_basic = Plotter_GAN()
# Define paths
img_path = 'img/{}/'.format(model_name)
model_path = 'model/{}/'.format(model_name)
# Create the folders
if not os.path.exists(img_path):
os.makedirs(img_path)
if not os.path.exists(model_path):
os.makedirs(model_path)
############################################
# TRAINING LOOP
############################################
# start loop
start_epoch = 0
global_step = 0
for epoch in range(start_epoch, args.num_epoch):
print('Epoch {}/{}'.format(epoch, args.num_epoch - 1))
print('-' * 20)
if epoch == 0:
val_errG, val_errD = validate(val_loader=val_loader, model_G=model_G, model_D=model_D,
epoch=-1, global_step=global_step)
# TensorboardX
writer.add_scalar('val/val_errG', val_errG, epoch)
writer.add_scalar('val/val_errD', val_errD, epoch)
# Train
train_errG, train_errD, global_step = train(train_loader=train_loader, model_G=model_G, model_D=model_D,
optimizer_G=optimizer_G, optimizer_D=optimizer_D, epoch=epoch,
iteration=iteration)
# Validate
val_errG, val_errD = validate(val_loader=val_loader, model_G=model_G, model_D=model_D,
epoch=epoch, global_step=global_step)
# TensorboardX
writer.add_scalar('train/train_errG_epoch', train_errG, epoch)
writer.add_scalar('train/train_errD_epoch', train_errD, epoch)
writer.add_scalar('val/val_errG_epoch', val_errG, epoch)
writer.add_scalar('val/val_errD_epoch', val_errD, epoch)
# Plotting
plotter.train_update(train_errG, train_errD)
plotter.val_update(val_errG, val_errD)
plotter.draw(img_path + 'train_val.png')
if args.save:
print('Saving checkpoint.')
save_checkpoint({'epoch': epoch + 1,
'state_dict': model_G.state_dict(),
'optimizer': optimizer_G.state_dict()},
filename=os.path.join(model_path, 'G_epoch_{}.pth.tar'.format(epoch)))
save_checkpoint({'epoch': epoch + 1,
'state_dict': model_D.state_dict(),
'optimizer': optimizer_D.state_dict()},
filename=os.path.join(model_path, 'D_epoch_{}.pth.tar'.format(epoch)))
def train(X,
X_val,
net_dims,
epochs=2000,
learningRate=0.1,
costEstimate="MSE",
decayRate=0.5):
learningRate = float(args.learningRate)
epochs = int(args.epochs)
decayRate = float(args.decayRate)
batchSize = int(args.batchSize)
n_in, n_h, n_fin = net_dims
data = myDataset(args)
model = Model()
noise = Noise()
parameters = model.initialize_2layer_weights(n_in, n_h, n_fin)
costs = []
costs_ = []
for ii in range(epochs):
noBatches = int(X.shape[0] / batchSize)
learningRate = learningRate * (1 / (1 + decayRate * ii))
print(learningRate)
print("Epoch: ", ii)
for jj in range(noBatches):
XTrBatch = data.getTrMiniBatch()
noisyXTrBatch = noise.GaussianNoise(XTrBatch, sd=0.3)
#print(noisyXTrBatch.shape)
W1, b1 = parameters["W1"], parameters["b1"]
W2, b2 = parameters["W2"], parameters["b2"]
A1, cache1 = model.layer_forward(noisyXTrBatch, W1, b1, "relu")
A2, cache2 = model.layer_forward(A1, W2, b2, "sigmoid")
# print(A2.shape)
if costEstimate == "MSE":
cost = model.MSE(A2, XTrBatch)
dA = (A2 - XTrBatch) / (XTrBatch.shape[1])
# dA = np.mean((A2-XTrBatch)*2)
# print(dA)
else:
cost = model.crossEntropy(A2, XTrBatch)
dA = ((A2 - XTrBatch) / (A2 * (1.0 - A2))) / XTrBatch.shape[1]
dA_prev2, dW2, db2 = model.layer_backward(dA, cache2, W2, b2,
"sigmoid")
dA_prev1, dW1, db1 = model.layer_backward(dA_prev2, cache1, W1, b1,
"relu")
parameters['W2'] += -learningRate * dW2
parameters['b2'] += -learningRate * db2
parameters['W1'] += -learningRate * dW1
parameters['b1'] += -learningRate * db1
if jj % 50 == 0:
print("Cost at iteration %i is: %f" % (jj * 50, cost))
XValBatch = data.getValMiniBatch()
noisyXValBatch = noise.GaussianNoise(XValBatch, sd=0.3)
costs.append(cost)
A1_, cache1_ = model.layer_forward(noisyXValBatch, W1, b1, "relu")
A2_, cache2_ = model.layer_forward(A1_, W2, b2, "sigmoid")
if costEstimate == "MSE":
cost_ = model.MSE(A2_, XValBatch)
else:
cost_ = model.crossEntropy(A2_, XValBatch)
costs_.append(cost_)
return costs, costs_, parameters
def main(args):
data = myDataset(args)
model = Model()
learningRate = float(args.learningRate)
decayRate = float(args.decayRate)
epochs = int(args.epochs)
costEstimate = args.costEstimate
train_data, train_label = data.getTrData()
print(train_data.shape)
val_data, val_label = data.getValData()
test_data, test_label = data.getTsData()
initialM, initial_in = train_data.shape
m, n_in = train_data.shape
n_fin = n_in
n_h1 = int(args.n_h1)
net_dims = [n_in, n_h1, n_fin]
autoParameters = {}
print(" Training of Autoencoder Layer1 ")
costs,costs_, parameters = train(train_data, train_label, val_data, val_label, net_dims, \
epochs=epochs, learningRate=learningRate, costEstimate=costEstimate, decayRate = decayRate)
#plot(costs,costs_)
autoParameters = autoParas(autoParameters, parameters, 1)
inputnextTr1 = autoencoder(parameters, train_data)
inputnextVal1 = autoencoder(parameters, val_data)
inputnextTs1 = autoencoder(parameters, test_data)
m, n_in = inputnextTr1.shape
n_fin = n_in
n_h2 = int(args.n_h2)
net_dims = [n_in, n_h2, n_fin]
print(" Training of Autoencoder Layer2 ")
costs,costs_, parameters = train(inputnextTr1, train_label, inputnextVal1, val_label, net_dims, \
epochs=epochs, learningRate=learningRate, costEstimate=costEstimate, decayRate = decayRate)
#plot(costs,costs_)
autoParameters = autoParas(autoParameters, parameters, 2)
inputnextTr2 = autoencoder(parameters, inputnextTr1)
inputnextVal2 = autoencoder(parameters, inputnextVal1)
inputnextTs2 = autoencoder(parameters, inputnextTs1)
m, n_in = inputnextTr2.shape
n_fin = n_in
n_h3 = int(args.n_h3)
net_dims = [n_in, n_h3, n_fin]
print(" Training of Autoencoder Layer3 ")
costs,costs_, parameters = train(inputnextTr2, train_label, inputnextVal2, val_label, net_dims, \
epochs=epochs, learningRate=learningRate, costEstimate=costEstimate,decayRate = decayRate)
#plot(costs,costs_)
autoParameters = autoParas(autoParameters, parameters, 3)
inputnextTr3 = autoencoder(parameters, inputnextTr2)
inputnextVal3 = autoencoder(parameters, inputnextVal2)
inputnextTs3 = autoencoder(parameters, inputnextTs2)
print(
" Training of Autoencoder Final Layer with 1labled sample per class "
)
n_last = len(args.labelRange)
net_dims = [n_h3, n_last, n_last]
noLabels = 1
trX, trXt, trY = getTrDataFinetune(inputnextTr3, train_data, train_label,
args.labelRange, n_h3, noLabels)
valX, valXt, valY = getValDataFinetune(inputnextVal3, val_data, val_label,
noLabels)
costs, costs_, parameters = softmaxTr(net_dims, trX, valX, trY, valY,
noLabels)
plotLL(costs, costs_)
print(
" Classification using features extracted from autoencoder and fine tuning with 1labled sample per class "
)
autoParameters = autoParas(autoParameters, parameters, 4)
# compute the accuracy for training set and testing set
#print(trXt.shape)
train_autoPred = model.classify(trXt.T, autoParameters)
test_autoPred = model.classify(test_data, autoParameters)
train_autoPred = train_autoPred.reshape(1, -1)
test_autoPred = test_autoPred.reshape(1, -1)
test_label1 = test_label.T
trAcc = (
(np.sum(train_autoPred == trY.astype(int))) / trY.shape[1]) * 100.0
teAcc = ((np.sum(test_autoPred == test_label1.astype(int))) /
test_label1.shape[1]) * 100.0
print("Accuracy for training set is {0:0.3f} %".format(trAcc))
print("Validation cost is{0:0.3f} %".format(costs_[-1]))
print("Accuracy for testing set is {0:0.3f} %".format(teAcc))
print(" Training of deep neural network with 10 examples ")
net_dims = [initial_in, n_h1, n_h2, n_h3, n_last]
print("Network dimensions are:" + str(net_dims))
costs, costs_,parameters = classifierTrain(trXt, trY,valXt, valY, net_dims, \
epochs=epochs, learningRate=learningRate,decayRate = decayRate)
print(" General Classification using deep neural network ")
# compute the accuracy for training set and testing set
train_Pred = model.classify(trXt.T, parameters)
test_Pred = model.classify(test_data, parameters)
train_Pred = train_Pred.reshape(1, -1)
test_Pred = test_Pred.reshape(1, -1)
test_label1 = test_label.T
trAcc = ((np.sum(train_Pred == trY.astype(int))) / trY.shape[1]) * 100.0
teAcc = ((np.sum(test_Pred == test_label1.astype(int))) /
test_label1.shape[1]) * 100.0
print("Accuracy for training set is {0:0.3f} %".format(trAcc))
print("Validation cost is{0:0.3f} %".format(costs_[-1]))
print("Accuracy for testing set is {0:0.3f} %".format(teAcc))
###############################################################################################
###############################################################################################
################################################################################################
print(
" Training of Autoencoder Final Layer with 5labled samples per class "
)
n_last = len(args.labelRange)
net_dims = [n_h3, n_last, n_last]
noLabels = 5
trX, trXt, trY = getTrDataFinetune(inputnextTr3, train_data, train_label,
args.labelRange, n_h3, noLabels)
valX, valXt, valY = getValDataFinetune(inputnextVal3, val_data, val_label,
noLabels)
costs, costs_, parameters = softmaxTr(net_dims, trX, valX, trY, valY,
noLabels)
plotLL(costs, costs_)
print(
" Classification using features extracted from autoencoder and fine tuning with 5labled samples per class "
)
autoParameters = autoParas(autoParameters, parameters, 4)
# compute the accuracy for training set and testing set
train_autoPred = model.classify(trXt.T, autoParameters)
test_autoPred = model.classify(test_data, autoParameters)
train_autoPred = train_autoPred.reshape(1, -1)
test_autoPred = test_autoPred.reshape(1, -1)
test_label2 = test_label.T
trAcc = (
(np.sum(train_autoPred == trY.astype(int))) / trY.shape[1]) * 100.0
teAcc = ((np.sum(test_autoPred == test_label2.astype(int))) /
test_label2.shape[1]) * 100.0
print("Accuracy for training set is {0:0.3f} %".format(trAcc))
print("Validation cost is{0:0.3f} %".format(costs_[-1]))
print("Accuracy for testing set is {0:0.3f} %".format(teAcc))
print(" Training of deep neural network with 50 examples ")
net_dims = [initial_in, n_h1, n_h2, n_h3, n_last]
print("Network dimensions are:" + str(net_dims))
costs, costs_,parameters = classifierTrain(trXt, trY,valXt, valY, net_dims, \
epochs=epochs, learningRate=learningRate,decayRate = decayRate)
print(" General Classification using deep neural network ")
# compute the accuracy for training set and testing set
train_Pred = model.classify(trXt.T, parameters)
test_Pred = model.classify(test_data, parameters)
train_Pred = train_Pred.reshape(1, -1)
test_Pred = test_Pred.reshape(1, -1)
test_label2 = test_label.T
trAcc = ((np.sum(train_Pred == trY.astype(int))) / trY.shape[1]) * 100.0
teAcc = ((np.sum(test_Pred == test_label2.astype(int))) /
test_label1.shape[1]) * 100.0
print("Accuracy for training set is {0:0.3f} %".format(trAcc))
print("Validation cost is{0:0.3f} %".format(costs_[-1]))
print("Accuracy for testing set is {0:0.3f} %".format(teAcc))
def main(args):
data = myDataset(args)
train_data, val_data, test_data = data.getTrData(), data.getValData(
), data.getTsData()
m, n_in = train_data.shape
n_fin = n_in
n_h = 1000
net_dims = [n_in, n_h, n_fin]
epochs = int(args.epochs)
plot_costs = []
plot_costs_ = []
test_acc = []
net_dims = [n_in, n_h, n_fin]
## Following list store the train, val costs and parameters
trainingCost_list = []
validationCost_list = []
parametersDict_list = []
# xAxis = list(range(epochs))
## This noise_level parameter can be changed to any other parameter and can conduct experiments
## Change the for loop to a list of other variables
## Ex: for noise_name in ['gaussian', 's&p', 'masking']
## tested learning rated [0.5, 0.1, 0.05, 0.005, 0.0005]
# learning_rates = [1, 0.5, 0.1, 0.05, 0.01, 0.005]
noise_ranges = list(np.arange(0.1, 1, 0.1))
for noise_level in noise_ranges:
costs,costs_, parameters = train(train_data, val_data, net_dims, noise_level,\
epochs=epochs, learningRate=args.learningRate, costEstimate=args.costEstimate, decayRate = args.decayRate)
trainingCost_list.append(costs)
validationCost_list.append(costs_)
parametersDict_list.append(parameters)
# predict(parameters)
## The plots of training curve vs parameter
xAxis = list(range(len(trainingCost_list[0])))
for i in range(len(noise_ranges)):
plt.plot(xAxis,
trainingCost_list[i],
label=('train' + str(noise_ranges[i])))
plt.title('Train_cost at different noise levels')
# plt.plot(it, costs_, label='val')
# plt.plot(xAxis, validationCost_list[i], label=('val' + str(learning_rates[i])))
# plt.title('Val_cost at different noise levels')
# plt.xlabel('iterations')
# plt.ylabel('Cost')
plt.legend(loc=1)
plt.figure()
for i in range(len(noise_ranges)):
plt.plot(xAxis,
validationCost_list[i],
label=('val' + str(noise_ranges[i])))
plt.title('Val_cost at different noise levels')
# plt.xlabel('iterations')
# plt.ylabel('Cost')
plt.legend(loc=1)
plt.show()