def __init__(self, weights=None, ai=None): self.x = 60 self.y = randint(10,cn.HEIGHT-10)#height of screen -10 self.speed = 7 self.ai = ai self.rect = pg.Rect(self.x,self.y,cn.B_WIDTH, cn.B_HEIGHT) self.dead = False if not weights: self.net = nn.Network()#call for the neural network else: self.net = nn.Network(weights)#give the neural networks the weights the weight self.fitness = 0
def __init__(self,env): self.action_space=env.action_space print('env.action_space:'), print(env.action_space) print('env.observation_space:'), print(env.observation_space) print('env.reward_range:'), print(env.reward_range) INPUTS=env.observation_space.shape[0] OUTPUTS=env.action_space.n highVec=env.observation_space.high lowVec=env.observation_space.low #LAYERDIM=[2,1025,2] #LAYERDIM=[2,500,10,2] LAYERDIM=[INPUTS,500,OUTPUTS] GAMMA=0.005 self.NN=nn.Network(LAYERDIM,GAMMA) filename=task+'.csv' self.filename=filename try: open(filename,'r') x=raw_input('found '+filename+'. load network? ([y]/n)') if(x=='' or x=='y'): print('loading '+filename+'...') self.NN=nn.loadNetwork(filename) except: x=raw_input(filename+' not found. start? ([y]/n)') if(x=='n'): exit()
def test_2layer_net(): params = init_toy_model() X, y = init_toy_data() Y_enc = ut.encode_labels(y) # Make the net layer_1 = layers.Linear(*params['W1'].T.shape, reg='frob', reg_param=0.05, init_vals=(params['W1'].T, params['b1'].ravel())) act_1 = layers.Relu() layer_2 = layers.Linear(*params['W2'].T.shape, reg='frob', reg_param=0.05, init_vals=(params['W2'].T, params['b2'].ravel())) net_2 = nn.Network([layer_1, act_1, layer_2], ls.CrossEntropy(), optim.SGD(lr=1e-5)) scores = net_2.forward(X) correct_scores = np.asarray([[-1.07260209, 0.05083871, -0.87253915], [-2.02778743, -0.10832494, -1.52641362], [-0.74225908, 0.15259725, -0.39578548], [-0.38172726, 0.10835902, -0.17328274], [-0.64417314, -0.18886813, -0.41106892]]) diff = np.sum(np.abs(scores - correct_scores)) assert (np.isclose(diff, 0.0, atol=1e-6)) loss = net_2.loss(X, Y_enc) correct_loss = 1.071696123862817 assert (np.isclose(loss, correct_loss, atol=1e-8))
def init_and_train_network(self, params_net): data_loader = self.load_data(params_net['data']) use_bias = bool(params_net['use_bias']) neural_network = nn.Network( bias=use_bias, shape_in=pd.DataFrame( data_loader.train_x).shape).init_network(save_plot_values=True) for layer in params_net['hidden_layers']: if layer['type'] == 'dropout': neural_network.add_layer( layer=layers.DropoutLayer(dropout_prob=layer['prob'], nr_neurons=layer['nr_neurons'])) else: neural_network.add_layer(size=layer['nr_neurons'], activation=layer['activation'], init_type=layer['init']) neural_network.add_output(data_loader.train_y.shape, params_net['out_activ'], params_net['loss'], init_type=params_net['out_init']) batch_size = params_net['batch_size'] if params_net['online']: batch_size = len(data_loader.train_x) neural_network.train_network(data_loader.train_x, data_loader.train_y, data_loader.test_x, data_loader.test_y, online=params_net['online'], learning_rate=params_net['learning_rate'], nr_epochs=params_net['epochs'], batch_size=batch_size) return
def loss_func_b(bb): layer_lin = layers.Linear(n, c, reg='l2', reg_param=0.05, init_vals=(W.T, bb.ravel())) loss_func = ls.CrossEntropy() net = nn.Network([layer_lin], loss_func, optimizer=None) return net.loss(X_dev, Y_dev_enc)
def test_CrossEntropyLoss(): np.random.seed(1) W = np.random.randn(c, n) * 0.0001 b = np.random.randn(c, 1) * 0.0001 layer_lin = layers.Linear(n, c, init_vals=(W.T, b.ravel())) loss_func = ls.CrossEntropy() net = nn.Network([layer_lin], loss_func, optimizer=None) my_loss = net.loss(X_dev, Y_dev_enc) assert (np.isclose(my_loss, -np.log(.1), atol=1e-2))
def test_Network(): shape=[2,2,2] net=nn.Network(shape) coef=np.array([xrange(net.initialParametersSize())]).T*0.1+1e-12 input=np.array([[0.4,0.5],[6.0,7]]); out=np.array([[0.1,0.8],[2,1.1]]); net.calculate(input,coef,out,verbose=True) assert(aux.testDerivative(lambda x:net.calculate(input,x,out),coef)) print "Tests passed."
def test_EncDecode(): net=nn.Network([3,2,3]) ip=np.array([xrange(net.initialParametersSize())]).T mc=net.__decode__(ip); fv=net.__encode__(mc); print ip print mc print fv assert(all(fv==ip)) print "Tests passed."
def create_phenotype(chromosome): """ Receives a chromosome and returns its phenotype (a neural network) """ import nn # bias parameter is missing (default=0) neurons_list = [nn.Neuron(ng.type, ng.id, ng.bias, ng.response) \ for ng in chromosome.node_genes] conn_list = [(cg.innodeid, cg.outnodeid, cg.weight) \ for cg in chromosome.conn_genes if cg.enabled] return nn.Network(neurons_list, conn_list)
def __init__(self, *largs, **dargs): super(TestFFNN, self).__init__(*largs, **dargs) bow = data.S1DataSet('label_sent.txt', 2, True) F = nn.FeedForwardLayer S = nn.Sigmoid T = nn.Tanh opt = nn.SteepestGradientOptimizer(1, 0.9) layers = ((F, 2, S), (F, None, T)) self.w = nn.Network(layers, bow, opt) opt.init_weights(np.random.uniform) self.opt = opt
def __init__(self, playerNum): self.num = playerNum self.epsilon = 1.0 self.gamma = 0.6 #self.alpha = 0.052 using network defualt self.last = None self.experiences = [] self.max_experiences = 500 self.experience_idx = 0 self.NN = nn.Network( [nn.Layer(18, 150, activation=nn.ReLU()), nn.Layer(150, 9)])
def sphere_experiment(dim,samples,network_shape,penalty=nn.MixedPenalty,proving_samples=1000): print "Starting experiment on spheres of dimension",dim,"learning samples=",samples,"shape",network_shape input=np.random.rand(dim,samples)*4-2 #All values belong to [-2,2] #input=aux.regularGrid() output=sphere(input) assert(len(network_shape)>=2 and network_shape[0]==dim and network_shape[-1]==1) network=nn.Network(network_shape,penalty=penalty) parameters,err=opt.optimizeNetwork(network,input,output) proving_input=np.random.rand(dim,proving_samples)*4-2 proving_output=sphere(proving_input) network_on_learning=network.calculate(input,parameters) network_on_new=network.calculate(proving_input,parameters) output_statistics(output,network_on_learning,"Learning subset") output_statistics(proving_output,network_on_new,"New subset")
def main(): # import mnist_loader as mn # training_data, validation_data, test_data = mn.load_data_wrapper() # print(type(test_data)) import loadMNIST as dl training_data, validation_data, test_data = dl.load_data() print "Datset Loaded" import nn net = nn.Network([784, 30, 10]) print "network done" accuracy = net.SGD(training_data, 1, 25, 3.0, test_data=test_data) print "Accuracy " + str(accuracy)
def test_CrossEntropy_Linear_Grad(): np.random.seed(1) W = np.random.randn(c, n) * 0.0001 b = np.random.randn(c, 1) * 0.0001 layer_lin = layers.Linear(n, c, reg='l2', reg_param=0.05, init_vals=(W.T, b.ravel())) loss_func = ls.CrossEntropy() net = nn.Network([layer_lin], loss_func, optimizer=None) net_loss = net.loss(X_dev, Y_dev_enc) ngrad = net.backward() # Define functions to pass to helper def loss_func_W(ww): layer_lin = layers.Linear(n, c, reg='l2', reg_param=0.05, init_vals=(ww.T, b.ravel())) loss_func = ls.CrossEntropy() net = nn.Network([layer_lin], loss_func, optimizer=None) return net.loss(X_dev, Y_dev_enc) def loss_func_b(bb): layer_lin = layers.Linear(n, c, reg='l2', reg_param=0.05, init_vals=(W.T, bb.ravel())) loss_func = ls.CrossEntropy() net = nn.Network([layer_lin], loss_func, optimizer=None) return net.loss(X_dev, Y_dev_enc) # Actually run the test rel_err_weight = dutil.grad_check_sparse(loss_func_W, W, net.grads[0].T, 10, seed=42) rel_err_bias = dutil.grad_check_sparse(loss_func_b, b.ravel(), net.grads[1], 10, seed=42) assert (np.allclose(rel_err_weight, np.zeros(rel_err_weight.shape), atol=1e-4)) assert (np.allclose(rel_err_bias, np.zeros(rel_err_bias.shape), atol=1e-4))
def main(): # import mnist_loader as mn # training_data, validation_data, test_data = mn.load_data_wrapper() # print(type(test_data)) import dataset_loader as dl training_data, validation_data, test_data = dl.load_data() # import network # net = network.Network([784, 30, 10]) # net.SGD(training_data, 30, 10, 3.0, test_data=test_data) Max = -9999 alpha = 3 neuronNumber = 30 for X in range(30, 100, 5): import nn net = nn.Network([8, X, 30]) # print len(net.biases[1]) # print net.weights Y = 0.1 for y in range(0, 100): accuracy = net.SGD(training_data, 20, 10, Y, validation_data) Y += .1 if (Y == 3.0): break print "Accuracy " + str(accuracy) if (accuracy > Max): alpha = Y neuronNumber = X import nn net = nn.Network([8, neuronNumber, 30]) # print len(net.biases[1]) # print net.weights accuracy = net.SGD(training_data, 20, 10, alpha, test_data) print "TestAccuracy " + str(accuracy)
def test_2layer_grad(): params = init_toy_model() X, y = init_toy_data() Y_enc = ut.encode_labels(y) # Make the net layer_1 = layers.Linear(*params['W1'].T.shape, reg='frob', reg_param=0.05, init_vals=(params['W1'].T, params['b1'].ravel())) act_1 = layers.Relu() layer_2 = layers.Linear(*params['W2'].T.shape, reg='frob', reg_param=0.05, init_vals=(params['W2'].T, params['b2'].ravel())) net_2 = nn.Network([layer_1, act_1, layer_2], ls.CrossEntropy(), optim.SGD(lr=1e-5)) loss = net_2.loss(X, Y_enc) net_2.backward() def f_change_param(param_name, U): if param_name == 3: net_2.layers[0].params['b'] = U if param_name == 2: net_2.layers[0].params['W'] = U if param_name == 1: net_2.layers[2].params['b'] = U if param_name == 0: net_2.layers[2].params['W'] = U return net_2.loss(X, Y_enc) rel_errs = np.empty(4) for param_name in range(4): f = lambda U: f_change_param(param_name, U) if param_name == 3: pass_pars = net_2.layers[0].params['b'] if param_name == 2: pass_pars = net_2.layers[0].params['W'] if param_name == 1: pass_pars = net_2.layers[2].params['b'] if param_name == 0: pass_pars = net_2.layers[2].params['W'] param_grad_num = dutil.grad_check(f, pass_pars, epsilon=1e-5) rel_errs[param_name] = ut.rel_error(param_grad_num, net_2.grads[param_name]) assert (np.allclose(rel_errs, np.zeros(4), atol=1e-7))
def create_phenotype(chromosome): """ Receives a chromosome and returns its phenotype (a neural network) """ # first create inputs neurons_list = [nn.Neuron('INPUT', i.id, 0, 0) \ for i in chromosome.node_genes if i.type == 'INPUT'] # Add hidden nodes in the right order for id in chromosome.node_order: neurons_list.append(nn.Neuron('HIDDEN', id, chromosome.node_genes[id - 1].bias, chromosome.node_genes[id - 1].response)) # finally the output neurons_list.extend(nn.Neuron('OUTPUT', o.id, o.bias, o.response) \ for o in chromosome.node_genes if o.type == 'OUTPUT') assert(len(neurons_list) == len(chromosome.node_genes)) conn_list = [(cg.innodeid, cg.outnodeid, cg.weight) \ for cg in chromosome.conn_genes if cg.enabled] return nn.Network(neurons_list, conn_list)
def main(): mnist = dts.MNIST('./') net = nn.Network([784, 300, 10], cost_func=nn.CrossEntropyCost) times = 80 evaluation_cost, evaluation_accuracy, training_cost, training_accuracy = \ net.SGD(mnist.train_data, times, 10, 0.001, evaluation_data=mnist.test_data, monitor_evaluation_accuracy=True, monitor_training_cost=True, monitor_training_accuracy=True) temp = np.tile(100.0, times) evaluation_accuracy = evaluation_accuracy / temp x = np.arange(1, times + 1, 1) fig = plt.figure() ax1 = fig.add_subplot(2, 1, 1) ax1 = plt.plot(x, evaluation_accuracy, 'g-', linewidth=2) plt.xlabel('Epoch') plt.grid() ax2 = fig.add_subplot(2, 1, 2) ax2 = plt.plot(x, training_cost, 'r-', linewidth=2) plt.ylabel('training_lost') plt.xlabel('Epoch') plt.grid() plt.show()
def test_load_params(batch_size=45, random_state=123, init=False): train_sets = test_init() train_set_without_negatives = train_sets['train_set'] net = nn.Network(batch_size=batch_size, random_state=random_state) test_img = np.array(list(train_set_without_negatives.keys())) test_img.sort() lbl_test = np.array([ train_set_without_negatives.get(key).get_coordinates() for key in test_img ]) for i in range(test_img.shape[0]): imgs, lbls = prepare_images.prepare( DATASET_PATH + test_img[i].decode('utf8'), lbl_test[i]) y_pred = net.predict_values(imgs) tmp = lbls - y_pred tp = np.sum((y_pred == 1) & (lbls == 1)) tn = np.sum((y_pred == 0) & (lbls == 0)) fp = np.sum(tmp == -1) fn = np.sum(tmp == 1) f1_score = 2 * tp / (2 * tp + fn + fp) print( " f1 score = {}, true positive = {}, true negative = {}, false positive = {}, false negative = {}" .format(f1_score, tp, tn, fp, fn))
import numpy as np import utils logging.basicConfig(level=logging.ERROR) dataset = { "train": utils.Dataset("data/mnist_train.csv", 1000), "test": utils.Dataset("data/mnist_test.csv", 100) } INPUT_DIM = 28 * 28 OUTPUT_DIM = 10 LAYERS = [(INPUT_DIM, 256), (256, 64), (64, 10)] net = nn.Network("MNIST_Net") for layer in LAYERS: net.add_layer(*layer) print(net) for epoch in range(10): avg_loss = 0 for idx, data in enumerate(dataset["train"]): x, y = data.get_training_data() y_hat = net.forward_propagate(x) # predict net.backward_propagate(y_hat, y) # backprop net.update_parameters() # update loss = np.sum((y_hat - y)**2)
#!/usr/bin/python import nn the_Network = nn.Network() print the_Network.run(1) print the_Network.run(0.5) print the_Network.run(0)
train_data['dis'] = (train_data['dis'] - data_stats['min']['dis']) / ( data_stats['max']['dis'] - data_stats['min']['dis']) train_data['rad'] = (train_data['rad'] - data_stats['min']['rad']) / ( data_stats['max']['rad'] - data_stats['min']['rad']) train_data['tax'] = (train_data['tax'] - data_stats['min']['tax']) / ( data_stats['max']['tax'] - data_stats['min']['tax']) train_data['ptratio'] = (train_data['ptratio'] - data_stats['min']['ptratio'] ) / (data_stats['max']['ptratio'] - data_stats['min']['ptratio']) train_data['black'] = (train_data['black'] - data_stats['min']['black']) / ( data_stats['max']['black'] - data_stats['min']['black']) # create neural network with two layers neural_network = nn.Network( [layer.Layer(13, 8, activation=tools.Relu), layer.Layer(8, 1)], loss_function=tools.MeanSquaredError, optimizer=tools.Momentum) # prepare list of nodes with data for training train_feature = list() train_label = list() for x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, y in zip( train_data['rm'], train_data['lstat'], train_data['crim'], train_data['zn'], train_data['indus'], train_data['chas'], train_data['nox'], train_data['age'], train_data['dis'], train_data['rad'], train_data['tax'], train_data['ptratio'], train_data['black'], train_data['medv']): # it has to be arrays of arrays, because it's possible to have # more then one feature per sample
predicted = np.argmax(Y_hat) + 1 y = test_y[j] if print_flag: print(Y_hat, predicted, y) if flag: if predicted == y: cnt += 1 else: if [1 if t + 1 == predicted else 0 for t in range(3)] == y: cnt += 1 return (cnt / len(test_X)) # In[5]: net = nn.Network(len(train_data.columns.values), 5, 3, 0.1) # with open("checkpoint/nn-20000.pkl","rb") as netfile: # net = pickle.load(netfile) # net.learning_rate = 0.01 loss_history, accuracy_history = train(net, 100000, True) # In[8]: """ Plot the train loss curve """ import matplotlib.pyplot as plt fig = plt.figure() ax = fig.add_subplot(111) lns1 = ax.plot(loss_history, label="Loss")
#!/usr/bin/python import pygame from pygame.locals import * import nn the_network = nn.Network() pygame.init() screen = pygame.display.set_mode((640, 480), 0, 32) pygame.display.set_caption("NN_maze") screen.fill((255, 255, 255)) begin_pos = [240, 220] #screen settings rc_wall = [0, 0, 0] rc_space = [255, 255, 255] rc_apple = [0, 255, 0] rc_hero = [255, 0, 0] rs = [10, 10] #map settings mazeA = [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]] def screen_draw(): global hero_pos rp = [begin_pos[0], begin_pos[1]]
from random import shuffle import numpy as np import utils import nn HIDDEN_NEURONS = 100 def validation_test(output, label): return np.argmax(output) == np.argmax(label) train_x, train_y, valid_x, valid_y, test_x, test_y = utils.load_mnist_data() train_data = [(feature.reshape((784, 1)), utils.vectorize_y(label)) for feature, label in zip(train_x, train_y)] valid_data = [(feature.reshape((784, 1)), utils.vectorize_y(label)) for feature, label in zip(valid_x, valid_y)] test_data = [(feature.reshape(784, 1), utils.vectorize_y(label)) for feature, label in zip(test_x, test_y)] net = nn.Network([28 * 28, HIDDEN_NEURONS, 10]) net.train(train_data, 50, 0.3, 1.0, momentum=0.5, mini_batch_size=32, cost=nn.CrossEntropyCost, validation_data=valid_data, validation_test=validation_test) test_correct = net.evaluate(test_data, validation_test) print("----------------------------------------") print( "Test accuracy: " + str(test_correct) + "/" + str(len(test_data)) + ";" + str(test_correct / len(test_data) * 100))
import numpy as np import nn import nnfs from nnfs.datasets import spiral_data X = np.random.randn(1, 5) net = nn.Network([5, 5, 5, 5, 5, 3]) print(net.forward_prop(X))
import nn import data_loader import parse_tsv import numpy as np import sys # # Initialze a training data object. d = data_loader.Loader() d.load2() trdata = [(x, y[:2]) for x, y, z in d.data] d.y_headers = d.y_headers[:2] # Initialize a network object sizes = [len(d.x_headers), 10, 10, 10, 10, 10, len(d.y_headers)] net = nn.Network(sizes) training_data = trdata epochs = 30 eta = 3. mini_batch_size = 10 # optimize the biases and weights of the net net.SGD2(training_data, epochs, eta, mini_batch_size) # parse input file infile = sys.argv[1] headers, data = parse_tsv.parse_tsv(infile) # rank samples indices = [i for i, item in enumerate(headers) if item in d.x_headers] results = []
OUTPUTS = len(out[0]) BATCHSIZE = 1 #raise Exception #LAYERDIM=[2,1025,2] #LAYERDIM=[2,500,10,2] LAYERDIM = [INPUTS, 500, OUTPUTS] EPOCHS = 100 GAMMA = 0.005 PRINTFREQ = BATCHSIZE nExamples = len(inp) np.set_printoptions(precision=4) NN = nn.Network(LAYERDIM, GAMMA) filename = task + '.csv' try: open(filename, 'r') x = raw_input('found ' + filename + '. load network? ([y]/n)') if (x == '' or x == 'y'): print('loading ' + filename + '...') NN = nn.loadNetwork(filename) except: x = raw_input(filename + ' not found. start? ([y]/n)') if (x == 'n'): exit() t0 = time.clock() for epoch in range(EPOCHS): bInp = [] bOut = []
import nn import datetime start_time = datetime.datetime.now() topology = [] topology.append(3) topology.append(3) topology.append(2) net = nn.Network(topology) nn.Neuron.eta = 0.5 nn.Neuron.alpha = 0.015 while True: err = 0 inputs = [[0, 0, 0], [0, 0, 1], [0, 1, 0], [0, 1, 1], [1, 0, 0], [1, 0, 1], [1, 1, 0], [1, 1, 1]] outputs = [[0, 0], [0, 1], [0, 1], [1, 0], [0, 1], [1, 0], [1, 0], [1, 1]] for i in range(len(inputs)): net.setInput(inputs[i]) net.feedForword() net.backPropagate(outputs[i]) err = err + net.getError(outputs[i]) print("error: ", err) if err < 0.01: break stopped_time = datetime.datetime.now() print("time to train = ", stopped_time - start_time) while True:
import nn import mnist_loader test_data, valid_data, test_data = mnist_loader.load_data_wrapper() net = nn.Network([784, 30, 10]) net.train(test_data, 30, 30, 3.0, test_data)