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