def train_with_train_valid_data(): # load train_data, valid_data, test_data train_data, valid_data, test_data = load_data() # Concat train and valid dataset train_valid_data = [[], []] train_data[0].extend(valid_data[0]) train_data[1].extend(valid_data[1]) # train_valid_data.append(train_data[0] + valid_data[0]) # train_valid_data.append(train_data[1] + valid_data[1]) print(len(train_data[0])) print(len(train_data[1])) # construct the network model = network2.Network([784, 20, 10]) # train the network using SGD model.SGD(training_data=train_data, epochs=20, mini_batch_size=128, eta=7e-3, lmbda=0.0, evaluation_data=None, monitor_evaluation_cost=False, monitor_evaluation_accuracy=False, monitor_training_cost=False, monitor_training_accuracy=True) model.save('../../sgd_model_opt.json')
def run_network(filename, num_epochs, training_set_size=1000, lmbda=0.0): """Train the network for ``num_epochs`` on ``training_set_size`` images, and store the results in ``filename``. Those results can later be used by ``make_plots``. Note that the results are stored to disk in large part because it's convenient not to have to ``run_network`` each time we want to make a plot (it's slow). """ # Make results more easily reproducible random.seed(12345678) np.random.seed(12345678) training_data, validation_data, test_data = mnist_loader.load_data_wrapper( ) net = network2.Network([784, 30, 10], cost=network2.CrossEntropyCost()) net.large_weight_initializer() test_cost, test_accuracy, training_cost, training_accuracy \ = net.SGD(training_data[:training_set_size], num_epochs, 10, 0.5, evaluation_data=test_data, lmbda = lmbda, monitor_evaluation_cost=True, monitor_evaluation_accuracy=True, monitor_training_cost=True, monitor_training_accuracy=True) f = open(filename, "w") json.dump([test_cost, test_accuracy, training_cost, training_accuracy], f) f.close()
def main(phase): # load train_data, valid_data, test_data train_data, valid_data, test_data = load_data() # pdb.set_trace() # construct the network model = network2.Network([784, 20, 10]) # train the network using SGD if phase == "train": result = model.SGD(training_data=train_data, epochs=100, mini_batch_size=128, eta=1e-3, lmbda=0.0, evaluation_data=valid_data, monitor_evaluation_cost=True, monitor_evaluation_accuracy=True, monitor_training_cost=True, monitor_training_accuracy=True) show_metric_plot(result[2], result[0], 100, 'Training Error', 'Validation Error', 'Loss', 'Loss v/s Epochs') evaluation_accuracy = list(map(lambda x: x * 100 / 10000, result[1])) training_accuracy = list(map(lambda x: x * 100 / 3000, result[3])) show_metric_plot(training_accuracy, evaluation_accuracy, 100, 'Training Accuracy', 'Validation Accuracy', 'Accuracy %', 'Accuracy v/s Epochs') model.save('train_model') if phase == "test": net = network2.load('train_model') print('Accuracy for Test Data:{}%'.format( net.accuracy(test_data) / 100))
def gradient_check(): train_data, valid_data, test_data = load_data() model = network2.Network([784, 20, 10]) model.gradient_check(training_data=train_data, layer_id=1, unit_id=5, weight_id=3)
def run_networks(): """Train networks using three different values for the learning rate, and store the cost curves in the file ``multiple_eta.json``, where they can later be used by ``make_plot``. """ # Make results more easily reproducible random.seed(12345678) np.random.seed(12345678) training_data, validation_data, test_data = mnist_loader.load_data_wrapper( ) results = [] for eta in LEARNING_RATES: print("\nTrain a network using eta = " + str(eta)) net = network2.Network([784, 30, 10]) results.append( net.SGD(training_data, NUM_EPOCHS, 10, eta, lmbda=5.0, evaluation_data=validation_data, monitor_training_cost=True)) f = open("multiple_eta.json", "w") json.dump(results, f) f.close()
def gradient_check(): train_data, valid_data, test_data = load_data() model = network2.Network([784, 20, 15, 10]) # modified # model = network2.Network([784, 20, 10]) # original model.gradient_check(training_data=train_data, layer_id=1, unit_id=3, weight_id=3) # modified
def main(): # load train_data, valid_data, test_data train_data, valid_data, test_data = load_data() # construct the network model = network2.Network([784,30,10]) # train the network using SGD evaluation_cost,evaluation_accuracy,training_cost,training_accuracy,epochs=model.SGD( training_data=train_data, epochs=100, mini_batch_size=128, eta=1e-3, lmbda = 0.0, evaluation_data=valid_data, monitor_evaluation_cost=True, monitor_evaluation_accuracy=True, monitor_training_cost=True, monitor_training_accuracy=True) prediction=[np.argmax(model.feedforward(test_data[0][x])) for x in range(len(test_data[0]))] accuracy=model.accuracy(test_data,convert='False') ohe=[network2.vectorized_result(i) for i in prediction] with open('predictions.csv','w',newline='') as csvfile: record=csv.writer(csvfile) for i in ohe: record.writerow(int(j) for j in (i)) plt.figure() plt.plot(range(epochs),evaluation_cost,range(epochs),training_cost) plt.legend(('evaluation_cost','traning_cost'),loc='upper right') plt.title('loss trend') plt.xlabel('Epochs') plt.ylabel('Cost') plt.show() plt.figure() plt.plot(range(epochs),evaluation_cost,range(epochs),training_cost) plt.legend(('evaluation_accuracy','traning_accuracy'),loc='upper right') plt.title('accuracy trend') plt.xlabel('Epochs') plt.ylabel('Accuracy') plt.show() #Testing the trained model n=len(test_data[0]) accuracy=model.accuracy(test_data) print("[Testing Accuracy]: {} / {}".format(accuracy,n)) results=[np.argmax(model.feedforward(test_data[0][x])) for x in range(len(test_data[0]))] results=np.array(results) m=results.max() +1 results=np.eye(m)[results] #print(results) np.savetxt("predictions.csv",results,fmt="%d",delimiter=",") # using %d to convert the floating point values to int and store in the csv file
def main(): # load train_data, valid_data, test_data train_data, valid_data, test_data = load_data() # construct the network model = network2.Network([784, 300, 100, 10]) # train the network using SGD num_epochs = 100 lr = 3e-3 [val_loss, val_acc, train_loss, train_acc] = model.SGD(training_data=train_data, epochs=num_epochs, mini_batch_size=128, eta=lr, lmbda=0.0, evaluation_data=valid_data, monitor_evaluation_cost=True, monitor_evaluation_accuracy=True, monitor_training_cost=True, monitor_training_accuracy=True) _predict(model, test_data) model.save('weights.json') plt.subplots_adjust(hspace=0.5) plt.subplot(2, 1, 1) plt.title("Loss (Eta = %.4f)" % lr) plt.xlabel('Epochs') plt.ylabel('Loss') line1, = plt.plot(train_loss, label='Train Loss') line2, = plt.plot(val_loss, label='Validation Loss') plt.legend(handles=[line1, line2]) plt.grid() train_acc = np.array(train_acc) val_acc = np.array(val_acc) train_acc = train_acc / 30.0 val_acc = val_acc / 100.0 plt.subplot(2, 1, 2) plt.title("Accuracy (Eta = %.4f)" % lr) plt.xlabel('Epochs') plt.ylabel('Accuracy') line1, = plt.plot(train_acc, label='Train Accuracy') line2, = plt.plot(val_acc, label='Validation Accuracy') plt.legend(handles=[line1, line2]) plt.grid() plt.show()
def main(): # load train_data, valid_data, test_data train_data, valid_data, test_data = load_data() # construct the network model = network2.Network([784, 40, 20, 10]) # train the network using SGD evaluation_cost, evaluation_accuracy, \ training_cost, training_accuracy = model.SGD( training_data=train_data, epochs=100, mini_batch_size=128, eta=1e-3, lmbda = 0.0, evaluation_data=valid_data, monitor_evaluation_cost=True, monitor_evaluation_accuracy=True, monitor_training_cost=True, monitor_training_accuracy=True) plt.figure() plt.subplot(2, 2, 1) plt.plot(evaluation_cost) plt.title('Evaluation Cost') plt.subplot(2, 2, 2) plt.plot(evaluation_accuracy) plt.title('Evaluation Accuracy') plt.subplot(2, 2, 3) plt.plot(training_cost) plt.title('Training Cost') plt.subplot(2, 2, 4) plt.plot(training_accuracy) plt.title('Training Accuracy') plt.show() predictions = [] for i in range(len(test_data[0])): prediction = np.argmax(model.feedforward(test_data[0][i])) predictions.append(prediction) output = np.zeros([10000, 10]) for i in range(len(predictions)): output[i, :] = np.reshape(network2.vectorized_result(predictions[i]), 10) df = pd.DataFrame(output) df.to_csv("prediction_3_layer.csv", header=None, index=False)
def main(): # Load the data full_td, _, _ = mnist_loader.load_data_wrapper() td = full_td[:1000] # Just use the first 1000 items of training data epochs = 500 # Number of epochs to train for print("\nTwo hidden layers:") net = network2.Network([784, 30, 30, 10]) initial_norms(td, net) abbreviated_gradient = [ ag[:6] for ag in get_average_gradient(net, td)[:-1]] print("Saving the averaged gradient for the top six neurons in each " + \ "layer.\nWARNING: This will affect the look of the book, so be " + \ "sure to check the\nrelevant material (early chapter 5).") f = open("initial_gradient.json", "w") json.dump(abbreviated_gradient, f) f.close() shutil.copy("initial_gradient.json", "../../js/initial_gradient.json") training(td, net, epochs, "norms_during_training_2_layers.json") plot_training( epochs, "norms_during_training_2_layers.json", 2) print("\nThree hidden layers:") net = network2.Network([784, 30, 30, 30, 10]) initial_norms(td, net) training(td, net, epochs, "norms_during_training_3_layers.json") plot_training( epochs, "norms_during_training_3_layers.json", 3) print("\nFour hidden layers:") net = network2.Network([784, 30, 30, 30, 30, 10]) initial_norms(td, net) training(td, net, epochs, "norms_during_training_4_layers.json") plot_training( epochs, "norms_during_training_4_layers.json", 4)
def train(): # load train_data, valid_data, test_data train_data, valid_data, test_data = load_data() # construct the network model = network2.Network([784, 50, 20, 16, 10]) # train the network using SGD e = 100 eval_cost, eval_accuracy, train_cost, train_accuracy = model.SGD( training_data=train_data, epochs=e, mini_batch_size=50, eta=1e-3, lmbda=0.001, evaluation_data=valid_data, monitor_evaluation_cost=True, monitor_evaluation_accuracy=True, monitor_training_cost=True, monitor_training_accuracy=True) #Saving the Neuaral Network model.save('NeuralNet_new_fc.csv') #Saving the errors vs Epcoh data SaveCsv = { 'Evaluation Cost': eval_cost, 'Evaluation Accuracy': eval_accuracy, 'Train Cost': train_cost, 'Train Accuracy': train_accuracy } df = pd.DataFrame(SaveCsv) df.to_csv('Error_Details_layers_new_fc' + '.csv') #Visualising the error vs epoch plt.figure() x = [i for i in range(0, e)] ax = plt.subplot(1, 2, 1) ax.plot(x, train_cost, 'r-', label='Training Cost') ax.plot(x, eval_cost, 'b-', label='Evaluation Cost') plt.title('Error comparision plot') #plt.legend() ay = plt.subplot(1, 2, 2) ay.plot(x, train_accuracy, 'r-', label='Training accuracy') ay.plot(x, eval_accuracy, 'b-', label='Evaluation accuracy') plt.title('Classification comparision plot') #plt.legend() plt.show()
def main(): # load train_data, valid_data, test_data train_data, valid_data, test_data = load_data() # construct the network model = network2.Network([784, 20, 10]) # train the network using SGD model.SGD(training_data=train_data, epochs=100, mini_batch_size=128, eta=1e-3, lmbda=0.0, evaluation_data=valid_data, monitor_evaluation_cost=True, monitor_evaluation_accuracy=True, monitor_training_cost=True, monitor_training_accuracy=True)
def main(): train_data, valid_data, test_data = load_data() model = network2.Network([784,80,10]) # train the network using SGD e_cost, e_accuracy, t_cost, t_accuracy = model.SGD( training_data=train_data, epochs=100, mini_batch_size=16, eta=6e-4, lmbda = 0, evaluation_data=valid_data, monitor_evaluation_cost=True, monitor_evaluation_accuracy=True, monitor_training_cost=True, monitor_training_accuracy=True) num_correct = 0 plt.plot(list(range(0,len(t_accuracy))),[x/len(train_data[0]) for x in t_accuracy], label='Training') plt.plot(list(range(0,len(e_accuracy))),[x/len(valid_data[0]) for x in e_accuracy], label='Validation') legend = plt.legend(loc='upper left', shadow=True) plt.title("Learning curve for Accuracy") plt.xlabel('Epoch') plt.ylabel('Accuracy') plt.savefig('accuracy') plt.clf() plt.plot(list(range(0,len(t_cost))),t_cost,label='Training') plt.plot(list(range(0,len(e_cost))),e_cost,label='Validation') legend = plt.legend(loc='upper left', shadow=True) plt.title(" Learning curve for Loss") plt.xlabel('Epoch') plt.ylabel('Loss') plt.savefig('loss') plt.clf() for i in range(len(test_data[0])): prediction = np.argmax(model.feedforward(test_data[0][i])) if prediction == test_data[1][i]: num_correct += 1 test_accuracy = num_correct / len(test_data[0]) print("Test accuracy: " + str(test_accuracy))
def main(): # load train_data, valid_data, test_data train_data, valid_data, test_data = load_data() # construct the network model = network2.Network([784, 32, 10]) # train the network using SGD eval_cost, eval_accuracy,train_cost, train_accuracy = model.SGD( training_data=train_data, epochs=100, mini_batch_size=64, eta=1e-2, lmbda = 0.0, evaluation_data=valid_data, monitor_evaluation_cost=True, monitor_evaluation_accuracy=True, monitor_training_cost=True, monitor_training_accuracy=True) test_total = model.accuracy(test_data, convert=False) results = [np.argmax(model.feedforward(x)) for (x, y) in zip(*test_data)] one_hot = [network2.vectorized_result(i) for i in results] with open('predictions.csv', 'w', newline='') as csvfile: spamwriter = csv.writer(csvfile) for i in one_hot: spamwriter.writerow(int(j) for j in i) print("Testing: {}/{}".format(test_total,len(test_data[0]))) # Plot Learning curves print("PLOTING") #Loss plt.plot(list(range(len(eval_cost))),eval_cost,'b-',list(range(len(train_cost))),train_cost,'r-') plt.legend(('Validation Loss','Training Loss')) plt.title("Loss Curve: batch=128, eta=e-2, hl=20") plt.xlabel("Epochs") plt.ylabel("Loss") plt.show() #Error plt.plot(list(range(len(eval_accuracy))),[x/len(valid_data[0]) for x in eval_accuracy],'b-',list(range(len(train_accuracy))),[x/len(train_data[0]) for x in train_accuracy],'r-') plt.legend(('Validation Accuracy','Training Accuracy')) plt.title("Accuracy Curve: batch=128, eta=e-2, hl=20") plt.xlabel("Epochs") plt.ylabel("Accuracy") plt.show()
def main(): # load train_data, valid_data, test_data train_data, valid_data, test_data = load_data() # construct the network model = network2.Network([784, 20, 10]) # train the network using SGD epoch_size = 100 ev_cost, ev_acc, train_cost, train_acc = model.SGD( training_data=train_data, epochs=epoch_size, mini_batch_size=128, eta=7e-3, lmbda=0.0, evaluation_data=valid_data, monitor_evaluation_cost=True, monitor_evaluation_accuracy=True, monitor_training_cost=True, monitor_training_accuracy=True) model.save('../../sgd_model.json') z = np.arange(0, epoch_size, 1) fig = plt.figure() plt.subplots_adjust(hspace=0.6, wspace=0.4) plt.subplot(2, 2, 1) plt.plot(z, train_cost) plt.title('training') plt.ylabel('cost') plt.subplot(2, 2, 2) plt.plot(z, ev_cost) plt.title('validation') plt.subplot(2, 2, 3) plt.plot(z, train_acc) plt.ylabel('accuracy') plt.subplot(2, 2, 4) plt.plot(z, ev_acc) fig.text(0.5, 0.04, 'epoch size', ha='center') plt.show()
def main(): # load train_data, valid_data, test_data train_data, valid_data, test_data = load_data() # construct the network model = network2.Network([784, 100, 10]) # train the network using SGD print(model) evaluation_cost, evaluation_accuracy, training_cost, training_accuracy = model.SGD( training_data=train_data, epochs=100, mini_batch_size=128, eta=5e-3, lmbda=0.0, evaluation_data=valid_data, monitor_evaluation_cost=True, monitor_evaluation_accuracy=True, monitor_training_cost=True, monitor_training_accuracy=True) plt.figure() plt.plot(training_cost) plt.xlabel("epochs") plt.ylabel("Cost") plt.title('Cost during training') plt.show() plt.figure() plt.plot(training_accuracy) plt.title('Accuracy during training') plt.xlabel("epochs") plt.ylabel("Accuracy") plt.show() plt.figure() plt.plot(evaluation_cost) plt.title('Cost during validation') plt.xlabel("epochs") plt.ylabel("Cost") plt.show() plt.figure() plt.plot(evaluation_accuracy) plt.title('Accuracy during validation') plt.xlabel("epochs") plt.ylabel("Accuracy") plt.show() model.save("weights.json")
def main(): # load train_data, valid_data, test_data train_data, valid_data, test_data = load_data() # construct the network model = network2.Network([784, 20, 10]) #model = network2.load('saver') #train the network using SGD evaluation_cost, evaluation_accuracy, training_cost, training_accuracy = model.SGD( training_data=train_data, epochs=100, mini_batch_size=128, eta=0.5e-3, lmbda = 0.0, evaluation_data=test_data, monitor_evaluation_cost=True, monitor_evaluation_accuracy=True, monitor_training_cost=True, monitor_training_accuracy=True) training_accuracy = np.divide(training_accuracy, len(train_data[0]))*100 evaluation_accuracy = np.divide(evaluation_accuracy, len(test_data[0]))*100 fig1, ax1 = plt.subplots() ax1.plot(training_cost, 'k', label = 'Training cost') ax1.plot(evaluation_cost, 'r', label = 'Validation cost') ax1.legend() plt.title('Training cost vs Evaluation cost') legend1 = ax1.legend(loc='upper center', fontsize='medium') plt.ylabel('Cost') plt.xlabel('Number of epochs') plt.savefig('Cost') plt.show() fig2, ax2 = plt.subplots() ax2.plot(training_accuracy, 'k', label = 'Training accuracy') ax2.plot(evaluation_accuracy, 'r', label = 'Validation accuracy') ax2.legend() plt.title('Training accuracy vs Evaluation accuracy') legend2 = ax2.legend(loc='upper left', fontsize='medium') plt.ylabel('Accuracy (%)') plt.xlabel('Number of epochs') plt.savefig('Accuracy') plt.show() model.save('saver')
def main(): # load train_data, valid_data, test_data train_data, valid_data, test_data = load_data() # construct the network model = network2.Network([784, 20,10]) # train the network using SGD e_c,e_a,t_c,t_a=model.SGD( training_data=train_data, epochs=100, mini_batch_size=256, eta=1e-3, lmbda = 0.0, evaluation_data=valid_data, monitor_evaluation_cost=True, monitor_evaluation_accuracy=True, monitor_training_cost=True, monitor_training_accuracy=True) model.save('Saved_Weights') plt.figure(1) e_c_plot = np.squeeze(e_c) t_c_plot = np.squeeze(t_c) plt.plot(e_c_plot,'r',label="Validation") plt.plot(t_c_plot,'b',label="Training") plt.ylabel('Cost') plt.xlabel('Epochs') plt.title("Learning Curve: cost vs epochs") plt.legend(loc='upper center') plt.show() plt.figure(2) e_a_plot = np.squeeze(e_a) t_a_plot = np.squeeze(t_a) plt.plot(e_a_plot,'r',label="Validation") plt.plot(t_a_plot,'b',label="Training") plt.ylabel('Accuracy') plt.xlabel('Epochs') plt.title("Learning Curve: accuracy vs epochs") plt.legend(loc='lower right') plt.show()
def run_networks(): # Make results more easily reproducible random.seed(12345678) np.random.seed(12345678) training_data, validation_data, test_data = mnist_loader.load_data_wrapper( ) net = network2.Network([784, 30, 10], cost=network2.CrossEntropyCost()) accuracies = [] for size in SIZES: print "\n\nTraining network with data set size %s" % size net.large_weight_initializer() num_epochs = 1500000 / size net.SGD(training_data[:size], num_epochs, 10, 0.5, lmbda=size * 0.0001) accuracy = net.accuracy(validation_data) / 100.0 print "Accuracy was %s percent" % accuracy accuracies.append(accuracy) f = open("more_data.json", "w") json.dump(accuracies, f) f.close()
def main(): # load train_data, valid_data, test_data train_data, valid_data, test_data = load_data() # construct the network model = network2.Network([784, 20, 10]) # train the network using SGD evaluation_cost, evaluation_accuracy, \ training_cost, training_accuracy = model.SGD( training_data=train_data, epochs=100, mini_batch_size=32, eta=1e-3, lmbda = 0.00, evaluation_data=valid_data, monitor_evaluation_cost=True, monitor_evaluation_accuracy=True, monitor_training_cost=True, monitor_training_accuracy=True) training_accuracy = list( map(lambda x: x / len(train_data[0]), training_accuracy)) evaluation_accuracy = list( map(lambda x: x / len(valid_data[0]), evaluation_accuracy)) plt.plot(training_accuracy, label='Training Accuracy') plt.plot(evaluation_accuracy, label='Validation Accuracy') plt.legend(loc='best') plt.xlabel('Epoch') plt.ylabel('Accuracy') plt.savefig('accuracy.png') plt.clf() plt.plot(training_cost, label='Training Cost') plt.plot(evaluation_cost, label='Validation Cost') plt.legend(loc='best') plt.xlabel('Epoch') plt.ylabel('Cost') plt.savefig('cost.png') model.save('final_model.json')
def main(): # load train_data, valid_data, test_data train_data, valid_data, test_data = load_data() # construct the network model = network2.Network([784, 32, 10]) # train the network using SGD validation_loss , validation_accuracy, training_loss, training_accuracy = model.SGD( training_data=train_data, epochs=75, mini_batch_size=64, eta=0.002, lmbda = 0.0, evaluation_data=valid_data, monitor_evaluation_cost=True, monitor_evaluation_accuracy=True, monitor_training_cost=True, monitor_training_accuracy=True) model.save("model0.json") model = network2.load("model0.json") predictions , prob, vector_base = predict(test_data, model) plot_learning_curve(validation_loss, training_loss, validation_accuracy, training_accuracy) csvfile = open('predictions.csv','w', newline='') obj = csv.writer(csvfile) obj.writerows(predictions) csvfile.close() csvfile = open('raw.csv','w', newline='') obj1 = csv.writer(csvfile) obj1.writerows(prob) csvfile.close() test_accuracy = 0; for x, y in zip(vector_base, test_data[1]): if x == y: test_accuracy += 1 print("The accuracy on test set is: " , test_accuracy)
def main(): # load train_data, valid_data, test_data train_data, valid_data, test_data = load_data() # construct the network model = network2.Network([784, 20, 10]) # train the network using SGD eval_cost, eval_accuracy, training_cost, training_accuracy = model.SGD( training_data=train_data, epochs=100, mini_batch_size=128, eta=1e-3, lmbda=0, evaluation_data=valid_data, monitor_evaluation_cost=True, monitor_evaluation_accuracy=True, monitor_training_cost=True, monitor_training_accuracy=True) for k in range(len(training_accuracy)): training_accuracy[k] = training_accuracy[k] / len(train_data[0]) eval_accuracy[k] = eval_accuracy[k] / len(valid_data[0]) model.save("train.data") # Plot Learning curves print("PLOTING") #Training Loss plt.plot(list(range(0, len(model.training_loss_l))), model.training_loss_l) plt.title("Training Loss Curve") plt.savefig('training_loss') #plt.show() plt.clf() #Training accuracy plt.plot(list(range(0, len(training_accuracy))), training_accuracy) plt.title("Training Accuracy Curve") plt.savefig('training_accuracy') #plt.show() plt.clf() #Validation Loss plt.plot(list(range(0, len(model.validation_loss_l))), model.validation_loss_l) plt.title("Validation Loss Curve") plt.savefig('validation_loss') #plt.show() plt.clf() #Validation Accuracy plt.plot(list(range(0, len(eval_accuracy))), eval_accuracy) plt.title("Validation Accuracy Curve") plt.savefig('eval_accuracy') #plt.show() plt.clf() # Evaluate test data num_correct = 0 for i in range(len(test_data[0])): prediction = np.argmax(model.feedforward(test_data[0][i])) if prediction == test_data[1][i]: num_correct += 1 test_accuracy = num_correct / len(test_data[0]) print("Test accuracy: " + str(test_accuracy))
import src.mnist_loader as mnist_loader import src.network as network import src.network2 as network2 training_data, validation_data, test_data = mnist_loader.load_data_wrapper() # Network 1 # net = network.Network([784, 30, 10]) # net.SGD(training_data, 30, 10, 3.0, test_data=test_data) # Network 2 net = network2.Network([784, 30, 10]) evaluation_cost, evaluation_accuracy, training_cost, training_accuracy = net.SGD( training_data, 30, 10, 0.5, lmbda=5.0, evaluation_data=validation_data, monitor_evaluation_accuracy=True, monitor_evaluation_cost=True, monitor_training_accuracy=True, monitor_training_cost=True)
""" Moduł służący do śledzenia postępów sieci neuronowej zaimplementowanej w module netowrk2.py """ import src.mnist_loader as mnist_loader import src.network2 as network2 training_data, validation_data, test_data = mnist_loader.load_data_wrapper() net = network2.Network([784, 20, 10], cost=network2.CrossEntropyCost) net.large_weight_initializer() net.SGD(training_data=training_data, epochs=50, mini_batch_size=10, eta=0.1, lmbda=5.0, evaluation_data=list(validation_data)[:100], monitor_evaluation_accuracy=True)