def test_network_sizes_when_add_layer_method_used_and_compile_method_called( self): # given network = Network(inputs_n=5) network.add_layer(Layer(3, Sigmoid)) network.add_layer(Layer(1, Sigmoid)) network.compile() # then expected_n_layers = 2 expected_n_neurons_in_layers = [3, 1] expected_first_layer_biases_n = 3 expected_second_layer_biases_n = 1 expected_first_layer_weights_n = 5 expected_second_layer_weights_n = 3 expected_first_layer_inputs_n = 5 expected_second_layer_inputs_n = 3 self.assertEqual(network.n_layers, expected_n_layers) self.assertEqual(network.n_neurons_in_layers, expected_n_neurons_in_layers) self.assertEqual(len(network.weights[0]), expected_first_layer_weights_n) self.assertEqual(len(network.weights[1]), expected_second_layer_weights_n) self.assertEqual(len(network.biases[0]), expected_first_layer_biases_n) self.assertEqual(len(network.biases[1]), expected_second_layer_biases_n) self.assertEqual(network.layers[0].inputs_n, expected_first_layer_inputs_n) self.assertEqual(network.layers[1].inputs_n, expected_second_layer_inputs_n)
def test_network_sizes_when_add_layer_method_used_without_calling_compile( self): # given network = Network(inputs_n=5) network.add_layer(Layer(3, Sigmoid)) network.add_layer(Layer(1, Sigmoid)) expected_n_layers = 2 expected_n_neurons_in_layers = [3, 1] expected_first_layer_inputs_n = 5 expected_second_layer_inputs_n = 3 # then self.assertEqual(network.n_layers, expected_n_layers) self.assertEqual(network.n_neurons_in_layers, expected_n_neurons_in_layers) self.assertEqual(network.layers[0].inputs_n, expected_first_layer_inputs_n) self.assertEqual(network.layers[1].inputs_n, expected_second_layer_inputs_n) # because compile method not called self.assertRaises(KeyError, lambda: network.weights[0]) self.assertRaises(KeyError, lambda: network.weights[1]) self.assertRaises(KeyError, lambda: network.biases[0]) self.assertRaises(KeyError, lambda: network.biases[0])
def __createLayer(self, neurons, weights, function, momentum=0.1): layer = Layer() i = 0 while i < neurons: layer.add_neuron(Neuron(weights=weights, function=function, momentum=momentum)) i += 1 self.__layers.append(layer)
def __createLayer(self, neurons, weights, function, momentum=0.1): layer = Layer() i = 0 while i < neurons: layer.add_neuron( Neuron(weights=weights, function=function, momentum=momentum)) i += 1 self.__layers.append(layer)
def test_backward_propagate(self): # given self.network = Network(inputs_n=4) self.network.add_layer(Layer(neurons_n=3, activation_f=Sigmoid)) self.network.add_layer(Layer(neurons_n=1, activation_f=Sigmoid)) self.network.compile() iris = load_iris() X = iris.data # Create a variable for the target data y = iris.target X_train, X_test, y_train, y_test = \ train_test_split(X[:100], y[:100], test_size=0.2, shuffle=True) # when # for epoch in range(50): for epoch in range(112): for i in range(y_train.size): inputs_x = X_train[i].T # 1 set of inputs desired_output = y_train[i] self.network.set_inputs(np.reshape(inputs_x, (4, 1))) self.network.set_desired_outputs( np.reshape(desired_output, (1, 1))) self.network.forward_propagate() self.network.backward_propagate() print('a') correct_predictions = 0 for i in range(y_test.size): inputs_x = X_test[i].T # 1 set of inputs desired_output = y_test[i] self.network.set_inputs(np.reshape(inputs_x, (4, 1))) self.network.set_desired_outputs(np.reshape( desired_output, (1, 1))) self.network.forward_propagate() predicted = convert_output_to_prediction( self.network.get_actual_outputs()) if predicted == y_test[i]: correct_predictions += 1 # print("inputs: ", self.network.inputs_x) print("output predicted: ", self.network.get_actual_outputs()) print("predicted: ", predicted) print("actual: ", y_test[i], "\n") print("correct predictions: ", correct_predictions)
def test_forward_propagate_linear_activation(self): # given inputs_x = [[1], [2]] # 1 set of inputs self.network = Network(inputs_n=2) self.network.add_layer(Layer(neurons_n=3, activation_f=Sigmoid)) self.network.add_layer(Layer(neurons_n=1, activation_f=Sigmoid)) self.network.compile() self.network.set_inputs(inputs_x) # set weights to 1 - so calculations are easy to do by hand self.network.set_all_weights_to_one() # when self.network.forward_propagate() # then expected_output = Sigmoid.value(3 * Sigmoid.value(4) + 1) self.assertEqual(self.network.get_actual_outputs(), expected_output)
def test_forward_propagate_linear_activation(self): # given inputs_x = [[1], [2]] # 1 set of inputs self.network = Network(inputs_n=2) self.network.add_layer(Layer(neurons_n=3, activation_f=Linear)) self.network.add_layer(Layer(neurons_n=1, activation_f=Linear)) self.network.compile() self.network.set_inputs(inputs_x) # set weights to 1 - so calculations are easy to do by hand self.network.set_all_weights_to_one() # when self.network.forward_propagate() # then # [layer][example_nr][neuron_nr] self.assertEqual(self.network.z[0][0][0], 4.0) self.assertEqual(self.network.z[1][0][0], 13.0) self.assertEqual(self.network.actual_outputs_a, 13)
def add_layer(self, n_neurons, f): n_neurons_previous_layer = self.layers[-1].n_neurons new_layer = Layer(n_neurons_previous_layer, n_neurons, f) self.layers.append(new_layer) self.n_layers += 1 self.last_layer = self.layers[self.n_layers - 1]
def add_input_layer(self, n_inputs): input_layer = Layer(n_inputs, n_inputs, Linear) self.layers.append(input_layer)
def setUp(self): self.network = Network(inputs_n=3) self.network.add_layer(Layer(neurons_n=2, activation_f=Sigmoid)) self.network.add_layer(Layer(neurons_n=1, activation_f=Sigmoid)) self.network.compile()
def read_layer_txt(name: str) -> Layer: example = None if name == "game of life": example = name name = "Examples/Game of Life/text/layer1.txt" elif name == "Langton ant": example = name name = "Examples/Langton Ant/text/layer1.txt" elif name == "wireworld": example = name name = "Examples/Wire World/text/layer1.txt" with open(name) as reader: name = reader.readline().strip() size = reader.readline().strip().split() height = int(size[1]) width = int(size[0]) cells = [[0 for _ in range(width)] for _ in range(height)] cells_states = [] neighbourhood = reader.readline().strip() # read grid reader.readline() for y in range(height): line = reader.readline().strip() for x in range(width): cells[y][x] = int(line[x]) # read cells states reader.readline() line = reader.readline() cells_states.append(("nothing", "white")) while line != "": line = line.strip().split() cells_states.append((line[0], line[1])) line = reader.readline() # read cells values line = reader.readline() values = list() while line != "": line = line.strip() values.append(float(line)) line = reader.readline() # Create layer with all parameters cells_class: List = list() i = 0 for y in range(height): cells_class.append(list()) for x in range(width): # Check if values have been declared if len(values) == 0: cells_class[y].append(Cell(cells[y][x], example=example)) else: # Check if current cell had value declared if cells[y][x] != 0: cells_class[y].append(Cell(cells[y][x], value=values[i], example=example)) i += 1 else: cells_class[y].append(Cell(cells[y][x], example=example)) layer = Layer(name, cells_class, neighbourhood, cells_states) return layer
def read_layer_excel(name: str) -> List[Layer]: example = None if name == "forest fire": example = name name = "Examples/Forest Fire/excel/example.xlsx" elif name == "game of life": example = name name = "Examples/Game of Life/excel/example.xlsx" elif name == "Langton ant": example = name name = "Examples/Langton Ant/excel/example.xlsx" elif name == "wireworld": example = name name = "Examples/Wire World/excel/example.xlsx" workbook = load_workbook(filename=name) sheets_names = workbook.get_sheet_names() layers: List[Layer] = list() for sheet_name in sheets_names: sheet = workbook.get_sheet_by_name(sheet_name) name = sheet_name height = int(sheet["B1"].value) width = int(sheet["A1"].value) neighbourhood = sheet["A2"].value cells_states = [] cells = [[tuple() for _ in range(width)] for _ in range(height)] # read cell types cells_states.append(("nothing", "white")) for row in range(height + 5, sheet.max_row + 1): if sheet.cell(row, 1).value is None: break type_name = str(sheet.cell(row, 1).value) color_hex = sheet.cell(row, 1).fill.start_color.value color_hex = "#" + color_hex[2:] cells_states.append((type_name, color_hex)) # read cell value and type for row in range(4, sheet.max_row): if sheet.cell(row, 1).value is None: break for col in range(1, sheet.max_column + 1): if sheet.cell(row, col).value is None: break cell_value = float(sheet.cell(row, col).value) color_hex = sheet.cell(row, col).fill.start_color.value color_hex = "#" + color_hex[2:] cells[row - 4][col - 1] = (cell_value, color_hex) # Create cell objects cells_class: List[List[Cell]] = list(list()) for y in range(height): cells_class.append(list()) for x in range(width): cells_class[y].append(Cell(0, value=cells[y][x][0], example=example)) for typee in range(len(cells_states)): if cells_states[typee][1] == cells[y][x][1]: cells_class[y][x].current_state = typee layer = Layer(name, cells_class, neighbourhood, cells_states) layers.append(layer) # Reading sliding window rules - optional rules = [] rule_size = int((sheet.max_row - (height + 3 + len(cells_states))) / 4) for i in range(rule_size): match, result = [], [] if neighbourhood == "von_neumann": match = read_von_neumann_excel(sheet, height + 7 + i * 4, 0, cells_states) result = read_von_neumann_excel(sheet, height + 7 + i * 4, 5, cells_states) elif neighbourhood == "moore": match = read_moore_excel(sheet, height + 7 + i * 4, 1, cells_states) result = read_moore_excel(sheet, height + 7 + i * 4, 5, cells_states) rule = (match, result) rules.append(rule) layer.rules = rules return layers