def generate_initial_population(self): new_population = [] for i in range(self.population_size): new_population.append(NeuralNetwork(self.n_layers)) return new_population
def test_forward_pass(self): input_dim = 2 number_labels = 2 intermediate_neurons = 3 intermediate_layers = 1 neural_net = NeuralNetwork(input_dim=input_dim, number_labels=number_labels, intermediate_neurons=intermediate_neurons, intermediate_layers=intermediate_layers) # the layers in the neural net are randomly initialized # modify them to fixed numbers in order to test first_layer = np.array([[1, 1, 1], [2, 2, 2], [3, 3, 3]]) intermediate_layer = np.array([[1, 1, 1], [2, 2, 2], [3, 3, 3]]) intermediate_layer = np.vstack((intermediate_layer, np.array([1, 1, 1]).T)) last_layer = np.array([[0.5, 1], [0.5, 1], [0.5, 1], [1, 1]]) neural_net.layers = [first_layer, intermediate_layer, last_layer] expected_result = [92.5, 184] actual_result = neural_net.forward_pass(np.array([1, 3])) for actual, expected in zip(actual_result, expected_result): self.assertEqual(expected, actual)
def crossover(self): #Introduce crossover i = 0 while len(self.new_generation) < self.number_of_agents: new_agent = NeuralNetwork() #Copy half of all weights from parent i and parent i+1 new_agent.weights_left = np.concatenate((self.list_of_neural_nets[i].weights_left[:int(len(self.list_of_neural_nets[i].weights_left)/2)], \ self.list_of_neural_nets[i+1].weights_left[int(len(self.list_of_neural_nets[i+1].weights_left)/2):])) new_agent.weights_down = np.concatenate((self.list_of_neural_nets[i].weights_down[:int(len(self.list_of_neural_nets[i].weights_down)/2)], \ self.list_of_neural_nets[i+1].weights_down[int(len(self.list_of_neural_nets[i+1].weights_down)/2):])) new_agent.weights_right = np.concatenate((self.list_of_neural_nets[i].weights_right[:int(len(self.list_of_neural_nets[i].weights_right)/2)], \ self.list_of_neural_nets[i+1].weights_right[int(len(self.list_of_neural_nets[i+1].weights_right)/2):])) new_agent.weights_rotate = np.concatenate((self.list_of_neural_nets[i].weights_rotate[:int(len(self.list_of_neural_nets[i].weights_rotate)/2)], \ self.list_of_neural_nets[i+1].weights_rotate[int(len(self.list_of_neural_nets[i+1].weights_rotate)/2):])) self.new_generation.append(new_agent) i += 1 print(f"Number of agents for next generation: {len(self.list_of_neural_nets)}")
def load_model_from_file(self, classifier_type, sentence_features, filename): """Restore classifier from file""" if classifier_type is NEURAL_NET: self.classifier = NeuralNetwork(sentence_features, filename) else: self.classifier = NBClassifier(filename) #pylint: disable = R0204
def test_xor_gate(self): """Simulate XOR gate and ensure working""" inputs = [[1.0, 1.0], [1.0, 0.0], [0.0, 1.0], [0.0, 0.0]] output_vector = [[0.0], [1.0], [1.0], [0.0]] inputs = np.array(inputs, dtype='float32') output_vector = np.array(output_vector) net = NeuralNetwork(inputs, output_vector) net.train() output = net.feed(np.array([[0, 1]], dtype='float32'))[0][0] output = round(output, 3) self.assertAlmostEqual(output, 1) output = net.feed(np.array([[1, 0]], dtype='float32'))[0][0] output = round(output, 3) self.assertAlmostEqual(output, 1) output = net.feed(np.array([[0, 0]], dtype='float32'))[0][0] output = round(output, 3) self.assertAlmostEqual(output, 0) output = net.feed(np.array([[1, 1]], dtype='float32'))[0][0] output = round(output, 3) self.assertAlmostEqual(output, 0)
def main(): # load data _input = torch.tensor(data.training_input, dtype=torch.float) _output = torch.tensor(data.training_expected_output, dtype=torch.float) # This section is for plotting ############################## gene_array = [] loss_array = [] fig, ax = plt.subplots() ax.set(xlabel='generation', ylabel='mean sum squared error', title='Neural network, error loss after each generation') # This section is for plotting ############################## ANN = NeuralNetwork(i=45, o=10, h=5) # input,output,hidden layer size # weight training for i in range(15000): # mean sum squared error mean_error = torch.mean((_output - ANN(_input))**2).detach().item() print("Generation: " + str(i) + " error: " + str(mean_error)) gene_array.append(i) loss_array.append(mean_error) ANN.train(_input, _output) torch.save(ANN, "algo1.weights") ANN = torch.load("14_good.weights") test_trained_network(ANN) ax.plot(gene_array, loss_array) plt.show()
def resetParamServer(): global params, accruedGradients, history_S, history_Y, rho,batches_processed nn = NeuralNetwork(NNlayers) params = nn.get_weights() accruedGradients = np.zeros(sum(nn.sizes)) history_S = [] history_Y = [] rho = [] batches_processed = 0
def test_sigmoid_activation_fct_expected(self): test_vector = np.array([1.1, 0.4, 0.9, -0.7]) expected_vector = np.array([0.75, 0.6, 0.711, 0.33]) neural_net = NeuralNetwork(1000, 10) actual_vector = neural_net.sigmoid_activation_fct(test_vector) for expected, actual in zip(expected_vector, actual_vector): self.assertAlmostEqual(expected, actual, 2)
def __init__(self, board_size, brain=None): if brain == None: self.brain = NeuralNetwork( [NeuralLayer(16, 24), NeuralLayer(4, 16)]) else: self.brain = brain self.direction = "up" # TODO: Grow the snake by this value each time it picks up food self.growcountDefault = 3 self.growcount = self.growcountDefault self.death_cause = "None" self.board_size = board_size self.pos_x = self.board_size // 2 self.pos_y = self.board_size // 2 self.alive = True self.length = 5 self.food = Food(self.board_size) self.lifetime = 0 self.fitness = 0 self.tail = [[self.pos_x, self.pos_y - 4], [self.pos_x, self.pos_y - 3], [self.pos_x, self.pos_y - 2], [self.pos_x, self.pos_y - 1]] self.vector = [] self.left_to_live_start = 200 self.left_to_live = self.left_to_live_start #Make moves equal tail and then append current head position to it self.parts = [[self.pos_x, self.pos_y - 4], [self.pos_x, self.pos_y - 3], [self.pos_x, self.pos_y - 2], [self.pos_x, self.pos_y - 1], [self.pos_x, self.pos_y]] # Add food positions and lengths for each move self.move_history = { "fitness": self.fitness, "moves": self.parts, "food_position": [[self.food.pos_x, self.food.pos_y] for i in range(len(self.parts))], "length": [self.length for i in range(len(self.parts))] }
def main(): inputs = np.array([[0, 0], [0, 1], [1, 0], [1, 1]]) labels = np.array([[0], [1], [1], [0]]) architecture = (2, 3, 1) nn = NeuralNetwork(architecture, activation="sigmoid", cost="mse") costs = nn.train(inputs, labels, alpha=1, iterations=5000) print("\nCost always decreases:", all([costs[i + 1] < costs[i] for i in range(len(costs) - 1)])) print("Lowest cost:", min(costs)) print("\nResults:", "\n", np.round(nn.evaluate(inputs), 0)) plotCosts(costs) # GRAPHING plt.style.use(["dark_background"]) #plt.rc("grid", alpha=0.25) start, end = -0.5, 1.5 fidelity = 0.01 n = int((end - start) / fidelity) points = np.meshgrid(np.linspace(start, end, n + 1), np.linspace(start, end, n + 1)) values = np.zeros((n + 1, n + 1)) for i in range(n + 1): for j in range(n + 1): values[i, j] = nn.evaluate( np.array([points[0][i, j], points[1][i, j]])) x, y = points # RdYlGn plt.contourf(x, y, values, np.linspace(0, 1, 51), cmap="jet_r") plt.colorbar() plt.contour(x, y, values, 0.5, linewidths=2, linestyles="dashed", colors="black") plt.grid(color="black", alpha=0.25) plt.axhline(y=0, color="k", lw=2) plt.axvline(x=0, color="k", lw=2) plt.title("Neural Network XOR Boundary") plt.xlabel("X Axis") plt.ylabel("Y Axis") plt.show()
def __init__(self, board_size, brain=None): if brain == None: _input_nodes = 5 _output_nodes = 4 self.brain = NeuralNetwork([_input_nodes] + hidden_layers + [_output_nodes]) else: self.brain = brain self.direction = "up" self.growcount = 1 self.death_cause = "None" self.board_size = board_size self.x = self.board_size // 2 self.y = self.board_size // 2 self.alive = True self.length = 5 self.food = Food(self.board_size) self.lifetime = 0 self.fitness = 0 self.tail = [[self.x, self.y - 4], [self.x, self.y - 3], [self.x, self.y - 2], [self.x, self.y - 1]] self.vector = [] self.left_to_live_start = 200 self.left_to_live = self.left_to_live_start self.parts = [[self.x, self.y - 4], [self.x, self.y - 3], [self.x, self.y - 2], [self.x, self.y - 1], [self.x, self.y]] # Add food positions and lengths for each move self.move_history = { "fitness": self.fitness, "moves": self.parts, "food_position": [[self.food.x, self.food.y] for i in range(len(self.parts))], "length": [self.length for i in range(len(self.parts))] }
def __init__(self, brain=None): self.marker = None self.fitness = 0 if brain == None: inputNodes = 9 hiddenNodes = 7 outputNodes = 9 self.brain = NeuralNetwork([inputNodes, hiddenNodes, outputNodes]) else: self.brain = brain self.wins = 0 self.draws = 0 self.total_matches = 0
def test_forward_pass_with_weights_randomly_initialized(self): input_dim = 32 * 32 number_labels = 10 intermediate_neurons = 4000 intermediate_layers = 2 neural_net = NeuralNetwork(input_dim=input_dim, number_labels=number_labels, intermediate_neurons=intermediate_neurons, intermediate_layers=intermediate_layers) input_vector = np.random.uniform(0, 1, input_dim) forward_res = neural_net.forward_pass(input_vector) self.assertEqual(number_labels, len(forward_res))
def populate_missing_agents(self): #To fulfill the capacity of list, duplicate current best agent #and add as new agents while len(self.new_generation) < int(self.number_of_agents/2): #Create new agent and mutate its weights try: new_agent = copy.deepcopy(self.new_generation[0]) except Exception as exception: new_agent = NeuralNetwork() print(f"Exception occured: {exception}") print(f"New agent had to be created.") self.new_generation.append(new_agent) self.list_of_neural_nets = [] self.list_of_neural_nets = self.new_generation
def __init__(self, directors=None): super(NeuralNetWorkflow, self).__init__(workflow_name='neural_net_workflow') self.image_path = self.config.path.get('source_data', None) self.file_name = 'neural_net_workflow_scores.csv' self.directors = directors self.encoding = None self.base_dir = str() self.file = str() self.compressed_file = str() self.set_up() self.neural_net = NeuralNetwork(num_inputs=256, num_ouputs=5, classes=5, class_lables=['christopher_nolan', 'coen_brothers', 'david_lynch', 'spike_jonze', 'wes_anderson'])
def test_layer_shape_expected(self): input_dim = 32 * 32 number_labels = 10 intermediate_layers = 1 intermediate_neurons = 1000 neural_net = NeuralNetwork(input_dim=input_dim, number_labels=number_labels, intermediate_layers=intermediate_layers, intermediate_neurons=intermediate_neurons) self.assertEqual(len(neural_net.layers), 3) self.assertEqual(neural_net.layers[0].shape, (input_dim + 1, intermediate_neurons)) self.assertEqual(neural_net.layers[1].shape, (intermediate_neurons + 1, intermediate_neurons)) self.assertEqual(neural_net.layers[2].shape, (intermediate_neurons + 1, number_labels))
def test_errors_computed_correctly(self): # mock the layers just as in the forward pass case input_dim = 2 number_labels = 2 intermediate_neurons = 3 intermediate_layers = 1 neural_net = NeuralNetwork(input_dim=input_dim, number_labels=number_labels, intermediate_neurons=intermediate_neurons, intermediate_layers=intermediate_layers) # the layers in the neural net are randomly initialized # modify them to fixed numbers in order to test first_layer = np.array([[1, 1, 1], [2, 2, 2], [3, 3, 3]]) intermediate_layer = np.array([[1, 1, 1], [2, 2, 2], [3, 3, 3]]) intermediate_layer = np.vstack((intermediate_layer, np.array([1, 1, 1]).T)) last_layer = np.array([[0.5, 1], [0.5, 1], [0.5, 1], [1, 1]]) neural_net.layers = [first_layer, intermediate_layer, last_layer]
def main_menu(): run = True list_of_neural_nets = [] number_of_games = 2 while number_of_games > 0: win.fill((0, 0, 0)) draw_text_middle('Press whatever button', 60, (255, 255, 255), win) pygame.display.update() for event in pygame.event.get(): if event.type == pygame.QUIT: run = False if event.type == pygame.KEYDOWN: net = NeuralNetwork() net = main(win, net) list_of_neural_nets.append(net) number_of_games -= 1 return list_of_neural_nets
def main(mnist_path, output_path, activation, hl_sizes): f = gzip.open(mnist_path, 'rb') training_set, test_set = pickle.load(f, encoding='latin1') training_examples = transform_examples(training_set) test_examples = transform_examples(test_set) if activation == "sigmoid": activation = neural_net.sigmoid d_activation = neural_net.d_sigmoid elif activation == "relu": activation = neural_net.relu d_activation = neural_net.d_relu elif activation == "elu": activation = neural_net.elu d_activation = neural_net.d_elu network = NeuralNetwork([PIXEL_COUNT] + hl_sizes + [NUM_CHARACTERS], output_path, act_func=activation, act_func_deriv=d_activation) network.train(training_generator(training_examples), test_examples) pickle.dump(network, open(output_path, 'wb'))
def __init__(self, neuralNetLayers): self.neuralNet = NeuralNetwork(neuralNetLayers) self.currentParamsStep = None self.accruedGradients = np.zeros(sum(self.neuralNet.sizes)) self.isAvailable = True
def main(): # load the dataset from file dataset = pd.read_csv('WDBC_imbalanced.dat') # change M and B labels to numbers dataset.loc[dataset.diagnosis == 'M', 'diagnosis'] = 0 dataset.loc[dataset.diagnosis == 'B', 'diagnosis'] = 1 # Split the dataset into test and train datasets, 30% of datasets for testing train_X, test_X, train_Y, test_Y = train_test_split( dataset[dataset.columns[2:12]].values, dataset.diagnosis.values, test_size=0.3, ) # convert output data for making into tensors train_Y = train_Y.astype(np.float32) test_Y = train_Y.astype(np.float32) # scale the data sc = StandardScaler() train_X = sc.fit_transform(train_X) test_X = sc.fit_transform(test_X) # load data into tensor _input = torch.tensor(train_X, dtype=torch.float) _output = torch.tensor(train_Y, dtype=torch.long) # input,output,hidden layer size model = NeuralNetwork(i=10, h1=6, h2=2, o=2) # loss function and optimizer lossFunction = nn.CrossEntropyLoss() # learning rate and momentum optimizer = optim.SGD(model.parameters(), lr=0.002, momentum=0.9) # This section is for plotting ############################## gene_array = [] loss_array = [] fig, ax = plt.subplots() ax.set(xlabel='generation', ylabel='mean sum squared error', title='Neural network, error loss after each generation') # This section is for plotting ############################## for epoch in range(15000): # Forward Pass output = model(_input) # Loss at each oteration by comparing to target loss = lossFunction(output, _output) # Backpropogating gradient of loss optimizer.zero_grad() loss.backward() # Updating parameters(weights and bias) optimizer.step() _loss = loss.item() gene_array.append(epoch) loss_array.append(_loss) print("Epoch {}, Training loss: {}".format(epoch, _loss / len(_input))) torch.save(model, "algo1.weights") # model = torch.load("68_error.weights") test_trained_network(model, test_X, test_Y) ax.plot(gene_array, loss_array) plt.show()
def run(): df = pd.read_csv('spambase_data\\spambase.data', header=None) df = df.sample(frac=1).reset_index(drop=True) print(f'No. missing values: {df.isnull().sum().sum()}') X = df.drop(57, axis=1) y = df.loc[:, 57] # Feature selection abs_corr_w_target = X.apply( lambda col: col.corr(y)).abs().sort_values().to_frame() abs_corr = X.corr().abs() plotting_tools.plot_heatmap(abs_corr_w_target, title='Correlation with target', size=(8, 16), one_dim=True) plotting_tools.plot_heatmap(abs_corr, title='Correlation before feature selection', size=(10, 16)) to_drop = set() # Amount of variation variance = X.var(axis=0, ddof=1) to_drop.update(variance[variance < 0.01].index.values) # Correlation with target to_drop.update(abs_corr_w_target[abs_corr_w_target[0] < 0.01].index.values) # Pairwise correlation to_drop.update(preprocessing.find_correlated(abs_corr, abs_corr_w_target)) to_drop = list(to_drop) nr_dropped = len(to_drop) X.drop(to_drop, axis=1, inplace=True) abs_corr = X.corr().abs() plotting_tools.plot_heatmap(abs_corr, title='Correlation after feature selection', size=(10, 16)) print(f'Dropped features: {to_drop}') # Data standardization works better, use normalization only for tests # X = preprocessing.normalize_data(X) X = preprocessing.standardize_data(X) X = X.values y = y.values train_inputs, cv_inputs, test_inputs = np.split( X, [int(0.6 * len(df)), int(0.8 * len(df))]) train_outputs, cv_outputs, test_outputs = np.split( y, [int(0.6 * len(df)), int(0.8 * len(df))]) print(f'Training set size: {train_outputs.shape[0]}\n' f'Cross validation set size: {cv_outputs.shape[0]}\n' f'Test set size: {test_outputs.shape[0]}') model = NeuralNetwork([57 - nr_dropped, 32, 1], activation_function='sigmoid') # Only use this part for tuning hyperparameters, slows down the program significantly # lambdas = list(np.arange(0.5, 1.5, 0.1)) # model.plot_learning_curves(train_inputs, train_outputs, cv_inputs, cv_outputs, # learning_rate=1.5, epochs=500, lambda_=0.6) # model.plot_validation_curves(train_inputs, train_outputs, cv_inputs, cv_outputs, # learning_rate=1.5, epochs=1000, lambdas=lambdas) model.gradient_descent(train_inputs, train_outputs, 1.5, 4000, 0.6, gradient_check=False, plot_cost=False) train_predictions = np.where(model.predict(train_inputs) > 0.5, 1, 0) test_predictions = np.where(model.predict(test_inputs) > 0.5, 1, 0) train_columns = { 'Train predictions': train_predictions[:, 0], 'Train outputs': train_outputs } test_columns = { 'Test predictions': test_predictions[:, 0], 'Test outputs': test_outputs } train_results = pd.DataFrame(train_columns) test_results = pd.DataFrame(test_columns) train_correct = pd.value_counts(train_results['Train predictions'] == train_results['Train outputs'])[True] test_correct = pd.value_counts( test_results['Test predictions'] == test_results['Test outputs'])[True] test_positive_predictions = test_results[test_results['Test predictions'] == 1] test_negative_predictions = test_results[test_results['Test predictions'] == 0] test_is_positive_correct = pd.value_counts( test_positive_predictions['Test predictions'] == test_positive_predictions['Test outputs']) test_is_negative_correct = pd.value_counts( test_negative_predictions['Test predictions'] == test_negative_predictions['Test outputs']) test_true_positives = test_is_positive_correct[True] test_false_positives = test_is_positive_correct[False] test_true_negatives = test_is_negative_correct[True] test_false_negatives = test_is_negative_correct[False] test_precision = test_true_positives / (test_true_positives + test_false_positives) test_recall = test_true_positives / (test_true_positives + test_false_negatives) test_confusion_matrix = pd.DataFrame( [[test_true_positives, test_false_positives], [test_false_negatives, test_true_negatives]], columns=[1, 0], index=[1, 0]) train_acc = train_correct / len(train_outputs) test_acc = test_correct / len(test_outputs) print(f'train_acc = {train_acc}') print(f'test_acc = {test_acc}') print(f'test_precision = {test_precision}') print(f'test_recall = {test_recall}') plotting_tools.plot_cm(test_confusion_matrix, title='Confusion matrix')
def populate_list_of_neural_nets(self): for _ in range(self.number_of_agents): self.list_of_neural_nets.append(NeuralNetwork())
def main(): print("Fit pong screen into the window") print("Press 'up' or 'down' to start infering actions.") print("Press 'q' for quit.") infering = False #Load neural network nn = NeuralNetwork() nn.load() #Call function to clear buffer of pressed keys get_key_pressed() last_pos_h = 0 last_pos_v = 0 #Keeping getting track of the object locations and keys pressed while True: screen, obj_locations = get_screen_features() key_pressed = get_key_pressed() cv2.imshow("PilotoRobo - PythonJogaPong", screen) #Pass next frame every 10ms #Exit when 'q' is pressed if cv2.waitKey(1) == ord('q') or key_pressed == -1: cv2.destroyAllWindows() break #Calculate speed h_speed = obj_locations[0] - last_pos_h v_speed = obj_locations[1] - last_pos_v last_pos_h = obj_locations[0] last_pos_v = obj_locations[1] screen_features = np.insert(obj_locations, 2, [h_speed, v_speed]) #Check whether we are already saving data if infering: prediction_probs = nn.predict([screen_features])[0] prediction = np.argmax(prediction_probs) if prediction == 0: print(prediction_probs, "Nothing") ReleaseKey(0x48) ReleaseKey(0x50) elif prediction == 1: print(prediction_probs, "Up") ReleaseKey(0x50) PressKey(0x48) elif prediction == 2: print(prediction_probs, "Down") ReleaseKey(0x48) PressKey(0x50) elif key_pressed > 0: print("Infering") infering = True
temp_y[int(l)] = 1 # we can cast this because we know labels are ints and not a weird float ys.append(temp_y) y = np.asarray(ys) return x,y #data = np.array([[0,0,0],[0,1,1],[1,0,1],[1,1,0]],dtype=np.float64) rawData = np.loadtxt("iris.data",delimiter=",") # Labels must be floats np.random.shuffle(rawData) label_count = len(set(rawData[:,-1])) feature_count = len(rawData[0])-1 X, y = sliceData(rawData) dataSetSize = len(X) #######neural network ####################### NNlayers = [feature_count, 10, label_count] # nn = NeuralNetwork(NNlayers) # costFunction = nn.cost # ############################################# params = nn.get_weights() #weights accruedGradients = np.zeros(sum(nn.sizes)) old_gradients = None old_params = None maxHistory = 10 history_S = [] #s_k = x_kp1 - x_k history_Y = [] #y_k = gf_kp1 - gf_k rho = [] #rho_k = 1.0 / (s_k * y_k) batches_processed = 0 batch_size = 10
def __init__(self, config, N): # with tf.variable_scope("PathNet", reuse=tf.AUTO_REUSE) as self.var_scope: # first, we will instantiate the networks for each pathnet layer self.network_structure = [] self.x_train = None self.y_train = None self.x_test = None self.y_test = None data_dims = list(config.pop("datashape", None)) if data_dims is None: raise ValueError( "You must provide a datashape parameter to configure PathNet!") data_dims.insert(0, None) print(data_dims) self.M = 0 self.L = 0 self.N = N self.first_layer = None self.sums = [] for l, (layer_name, layer_structure) in enumerate(config.items()): new_layer = [] if 'conditioning' not in layer_structure: print(layer_name) if self.M == 0: self.M = layer_structure['num_modules'] self.first_layer = l self.L = len(config.items()) - l print("FIRST LAYER: {}".format(layer_name)) self.Pmat = tf.placeholder(tf.float32, [self.L, self.M], name="PathMatrix") print(self.Pmat.get_shape().as_list()) else: print("CONDITIONING: {}".format(layer_name)) with tf.variable_scope(layer_name): for i in range(layer_structure['num_modules']): # if it is the first module of the layer, we set the x_input to None for # assignment later; otherwise, we set it to the input of the first module temp_struct = copy.deepcopy( layer_structure['module_structure']) # for j in range(len(temp_struct)): # if 'name' in temp_struct[j]: # temp_struct[j]['name'] += "_{}_{}".format(layer_name, i+1) # # print(temp_struct[j]['name']) # We need to select the proper input for this network provided the other # networks/layers have been created. input_ref = None if i == 0 and self.first_layer is not None and l > self.first_layer: input_ref = self.sums[-1] elif i == 0 and self.first_layer is not None and l == self.first_layer: input_ref = self.network_structure[self.first_layer - 1][0].yhat elif i == 0 and self.first_layer is None and l > 0: input_ref = self.network_structure[l - 1].yhat elif i > 0 and self.first_layer is not None: input_ref = new_layer[0].x_input with tf.variable_scope("M" + str(i)): new_layer.append( NeuralNetwork( temp_struct, x_in=input_ref, x_in_shape=data_dims if l == 0 else self.network_structure[ l - 1][0].yhat.get_shape().as_list(), make_dataset=True if l == 0 else False, name="M" + str(i))) new_layer[-1].build_network() del temp_struct if 'conditioning' not in layer_structure and i == 0: sum_shape = new_layer[-1].yhat.get_shape().as_list( ) # self.sums[-1].get_shape().as_list() if l > self.first_layer else # with tf.variable_scope("sums_{}".format(layer_name), reuse=tf.AUTO_REUSE): s = tf.get_variable("sum", [*sum_shape[1:]], initializer=tf.zeros_initializer() ) #, validate_shape=False) # s = tf.get_variable("sum", initializer=tf.truncated_normal([*sum_shape[1:]], mean=0.0, stddev=0.0)) self.sums.append(s) if self.first_layer is not None: self.sums[-1] = self.sums[-1] + self.Pmat[ l - self.first_layer, i] * new_layer[-1].yhat # tf.get_variable_scope().reuse_variables() self.network_structure.append(new_layer) self.output = self.sums[ -1] # the main network output is the last sum layer self.data_layer = self.network_structure[0][ 0] # this makes it easy to access our datapipeline
# Step-size h = 0.4 # Numerical differentiation factor epsilon = 0.0001 # Learning rate tau = 2 # Tolerance for objective function TOL = 1 # Shrinking factor rho = 0.5 # Satisfactory descent rate beta = 0.95 # Time allowed for the algorithm to run (seconds) running_time = 1.1 x = [] correct = [] for i in range(0, 10): net = NeuralNetwork(M, h, epsilon, tau, TOL, running_time, beta, rho) net.learn(500) y = net.see(1000) x.append(i) correct.append(y) plt.plot(x, correct, 'K') plt.plot([0, 9], [98, 98], 'r', label="98 % correct") plt.plot([0, 9], [99, 99], 'b', label="99 % correct") plt.legend(fontsize=13) plt.title("Correct points after 1.1 second", fontsize=15) plt.xlabel("Try nr.") plt.show()
win = pygame.display.set_mode((s_width, s_height)) pygame.display.set_caption('Tetris') # neural_nets = main_menu() # start game #Number of agents in population number_of_agents = 5 #Number of generations number_of_generations = 5 #Generate neural networks list_of_neural_nets = [] for _ in range(number_of_agents): list_of_neural_nets.append(NeuralNetwork()) for generation in range(number_of_generations): print(f"\n---------- Current generation: {generation+1} -----------") #Let them play one by one for index, net in enumerate(list_of_neural_nets): print(f"\nCurrent agent: {index+1}") play_tetris(net) #Create new generation according to score new_generation = [] sorted_by_level = sorted(list_of_neural_nets, key=lambda x: x.level_score,
import matplotlib.pyplot as plt from sklearn.model_selection import train_test_split from sklearn.metrics import r2_score from sklearn.preprocessing import MinMaxScaler from neural_net import NeuralNetwork #1D artificial data X = np.arange(0, 20).reshape(20, 1) + np.random.randn(20, 1) y = (np.arange(0, 20) + np.random.randn(20)).reshape(20, 1) scaler = MinMaxScaler() X = scaler.fit_transform(X) y = scaler.fit_transform(y) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=101) plt.plot(X, y, '*', label='train data') plt.xlabel('features') plt.ylabel('labels') plt.title('DNN Regressor') nn = NeuralNetwork(mode='regression') nn.train(X_train, y_train, 1000) y_pred = nn.predict(X_test) print() r2 = r2_score(y_test, y_pred) print('The R^2 score is:', r2) plt.plot(X_test, y_pred, 'r*', label='test data') plt.legend()
import matplotlib.pyplot as plt # functions def n(): return input('Ingrese un numero: ') # input data inputs = np.array([[0, 1, 0], [0, 0, 0], [0, 1, 1], [0, 0, 0], [1, 0, 0], [1, 1, 1], [1, 0, 1]]) # output data outputs = np.array([[0], [0], [0], [0], [1], [1], [1]]) # create a neural network NeuralN = NeuralNetwork(inputs, outputs) NeuralN.train() # create two new examples to test and predict example1 = np.array([[1, 1, 0]]) example2 = np.array([[0, 1, 1]]) exampleUser = np.array([n(), n(), n()]) # print and predict the examples print(NeuralN.predict(example1), '- Correct: ', example1[0][0]) print(NeuralN.predict(example2), '- Correct: ', example2[0][0]) print(NeuralN.predict(exampleUser), '- Correct: ', exampleUser[0][0]) # plot the error over the entire training duration plt.figure(figsize=(15, 5)) plt.plot(NeuralN.iters_hist, NeuralN.costerror_hist)