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