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 load_data(): train_data, valid_data, test_data = loader.load_data_wrapper(DATA_PATH) print('Number of training: {}'.format(len(train_data[0]))) print('Number of validation: {}'.format(len(valid_data[0]))) print('Number of testing: {}'.format(len(test_data[0]))) #print(test_data[0][0] , test_data[1][0]) return train_data, valid_data, test_data
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(): training_data, validation_data, test_data = load_data_wrapper() network = Network([784, 15, 10]) network.SGD(training_data=training_data, epochs=30, mini_batch_size=64, eta=0.5, test_data=test_data)
def main(): training_set, validation_set, test_set = mnist_loader.load_data_wrapper() training_set = get_modified_training_set2(training_set) print (len(training_set)) net = src.network.Network([784, 30, 10]) net.SGD(training_set, 10, 10, 3.0, test_data=test_set) pass
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(): training_data, validation_data, test_data = mnist_loader.load_data_wrapper( ) architecture = [{ 'size': 784, 'activation': 'sigmoid' }, { 'size': 30, 'activation': 'sigmoid' }, { 'size': 10, 'activation': 'sigmoid' }] net = Network(architecture, 'mse', seed=1) train_X = np.array([pair[0] for pair in training_data]).reshape(50000, 784) train_Y = np.array([pair[1] for pair in training_data]).reshape(50000, 10) test_X = np.array([pair[0] for pair in test_data]).reshape(10000, 784) test_y = np.array([pair[1] for pair in test_data]).reshape(10000) net.fit(train_X, train_Y, 30, 30, 80.0, test_X, test_y)
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)
from src import mnist_loader from src import network training_data, validation_data, test_data = mnist_loader.load_data_wrapper() net = network.Network([784, 30, 10]) net.SGD(training_data, 30, 10, 3.0, test_data=test_data)
from __future__ import absolute_import import src.network as network import src.network_batch_backprop as network_batch_b import src.mnist_loader as mnist_loader import src.cnn_network as cnn_network import src.graph_plot as graph # import src.mnist_data x_train, y_train, x_validation, y_validation, x_test, y_test = mnist_loader.load_data_wrapper( ) # # Using Mini Batch for Training the Model print("*" * 100) print("Training Mini Batch BackPropagation") print("*" * 100) net = network.Network([784, 20, 40, 10]) net.SGD(x_train, y_train, 50, 10, 3.0, x_test, y_test) # # #Using Batch Propagation to train the network print("*" * 100) print("Training Batch BackPropagation") print("*" * 100) net = network_batch_b.Network_batch([784, 20, 40, 10]) net.SGD(x_train, y_train, 500, 3.0, x_test, y_test) print("*" * 100) # #Using CNN Encoder with adding some noise to training data print("*" * 100) print("Training CNN") print("*" * 100) # parameters are epoch, batch_size, n_factor(what percentage of noise we need to add in data) network = cnn_network.CNN_network(30, 128, 10) print("Accuracy on Test Data : ", network.save_weights()[1] * 100)
def trainNetwork(): training_data, validation_data, test_data = load_data_wrapper() net = Network([784, 60, 30, 10]) net.SGD(training_data, 50, 10, 3.0, test_data=test_data) return net
import os, sys import random import cPickle from src.network import Network from src import network as network from src import mnist_loader from user_network import analyzer training_data, validation_data, test_data = mnist_loader.load_data_wrapper() del validation_data mode = 'Test' # create analyzer my_analyzer = analyzer.Analyzer() # set training's data basic_dir = os.path.abspath(os.path.join(os.getcwd(), os.pardir)) # list_of_dicts = ['sobel', 'laplacian', 'canny', 'harris', 'basic2'] list_of_dicts = ['basic2'] norm = lambda (x) : x / float(sum(x)) for dic_name in list_of_dicts: print "Start prediciotn on " + dic_name training_directory = os.path.join(basic_dir, "outputs/NN_" + dic_name) my_analyzer.update_trainings_results(training_directory) # compare_nets = lambda net : net.num_of_training_data nets = my_analyzer.nets predictions = {}
from src.mnist_loader import load_data_wrapper from src.network import Network if __name__ == '__main__': train, vaild, test = load_data_wrapper() net = Network([784, 30, 10]) net.SGD(train, 30, 10, 3.0, test_data=test)
return [output_unit.output(middle_output) for output_unit in self._output] if __name__ == '__main__': INPUT_SIGNAL = 784 OUTPUT_SIGNAL = 10 MIDDLE_SIGNAL = 3 def get_max_index(arr): tmp = [item for item in arr] return tmp.index(max(tmp)) n = Network(INPUT_SIGNAL, OUTPUT_SIGNAL, MIDDLE_SIGNAL) training_data, validation_data, test_data = load_data_wrapper() # while True: # flag = False # 未出现误差点 # counter = 0 # for each in training_data: # counter += 1 # result = n.output(each[0]) # if not get_max_index(result) == get_max_index(each[1]): # n.train(each[1]) # flag = True # break # else: # print(counter) # if not flag: # break
from src.mnist_loader import load_data_wrapper from src.utils import * from matplotlib import pyplot as plt def noise_img(arr, noise_coefficient): new_arr = [] len_column = len(arr) for i in range(len_column): new_iter = clamp(arr[i] + noise_coefficient, 0, 1) new_arr.append(new_iter) return new_arr tr_data, test_data, size_picture = load_data_wrapper() weights = np.zeros(size_picture) lr = 0.1 epochs = 500000 for e in range(epochs): for data, target in tr_data: if target == 0: target = 1 else: target = 0 x = np.sum(weights * data) y = sigmoid(x) E = -(target - y)