1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
| from random import random, seed
from math import exp
dataset = [
[2.7810836, 4.550537003, 0],
[3.396561688, 4.400293529, 0],
[1.38807019, 1.850220317, 0],
[3.06407232, 3.005305973, 0],
[7.627531214, 2.759262235, 1],
[5.332441248, 2.088626775, 1],
[6.922596716, 1.77106367, 1]
]
test_data = [
[1.465489372, 2.362125076, 0],
[8.675418651, -0.242068655, 1],
[7.673756466, 3.508563011, 1]
]
n_inputs = 2
n_outputs = 2
def initialize_network(n_inputs, n_hidden, n_outputs):
network = list()
hidden_layer = [{'weights': [random() for i in range(n_inputs + 1)]} for i in range(n_hidden)]
output_layer = [{'weights': [random() for i in range(n_hidden + 1)]} for i in range(n_outputs)]
network.append(hidden_layer)
network.append(output_layer)
return network
def activation(total_input):
return 1.0 / (1.0 + exp(-total_input))
def forward_propagate(network, row):
inputs = row[:-1]
for layer in network:
new_inputs = []
for neuron in layer:
total_input = neuron['weights'][-1]
for i in range(len(neuron['weights']) - 1):
total_input += neuron['weights'][i] * inputs[i]
neuron['output'] = activation(total_input)
new_inputs.append(neuron['output'])
inputs = new_inputs
return inputs
def cost_function(expected, outputs):
return sum([(expected[i] - outputs[i])**2 for i in range(len(expected))])
def backward_propagate(network, expected):
for i in reversed(range(len(network))):
layer = network[i]
errors = list()
if i == len(network) - 1:
for j in range(len(layer)):
neuron = layer[j]
errors.append(expected[j] - neuron['output'])
else:
for j in range(len(layer)):
error = 0.0
for neuron in network[i + 1]:
error += (neuron['weights'][j] * neuron['delta'])
errors.append(error)
for j in range(len(layer)):
neuron = layer[j]
neuron['delta'] = errors[j] * neuron['output'] * (1.0 - neuron['output'])
def update_weights(network, row, learning_rate):
for i in range(len(network)):
inputs = row[:-1]
if i != 0:
inputs = [neuron['output'] for neuron in network[i - 1]]
for neuron in network[i]:
for j in range(len(inputs)):
neuron['weights'][j] += learning_rate * neuron['delta'] * inputs[j]
neuron['weights'][-1] += learning_rate * neuron['delta']
def train_network(network, training_data, learning_rate, n_epoch, n_outputs):
for epoch in range(n_epoch):
sum_error = 0
for row in training_data:
outputs = forward_propagate(network, row)
expected = [0 for i in range(n_outputs)]
expected[row[-1]] = 1
sum_error += cost_function(expected, outputs)
backward_propagate(network, expected)
update_weights(network, row, learning_rate)
print('>epoch: %d, learning rate: %.3f, error: %.3f' % (epoch, learning_rate, sum_error))
network = initialize_network(n_inputs=2, n_hidden=1, n_outputs=2)
train_network(network, dataset, learning_rate=0.5, n_epoch=2000, n_outputs=2)
for row in test_data:
prediction = forward_propagate(network, row)
print(f"Expected={row[-1]}, Got={prediction}")
|
