XOR_Neural_Network/NeuralNetwork.py at master · CodeS42/XOR_Neural_Network · GitHub

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
import numpy as np
import calculations
from XOR import XOR

class NeuralNetwork:
    def __init__(self):
        self.hidden_weights = np.random.randn(2, 2)
        self.hidden_bias = np.random.randn(2)
        self.output_hidden_weights = np.random.randn(2)
        self.output_bias = 0.0
        self.z_hidden = np.zeros((2))
        self.z_output = None
        self.a_hidden = np.zeros((2))
        self.a_output = None
        self.learning_rate = 1

    def forward_propagation(self, inputs):
        self.z_hidden = calculations.linear_activation(inputs, self.hidden_weights, self.hidden_bias)
        self.a_hidden = calculations.sigmoid(self.z_hidden)

        self.z_output = calculations.linear_activation(self.a_hidden, self.output_hidden_weights, self.output_bias)
        self.a_output = calculations.sigmoid(self.z_output)

    def back_propagation(self, inputs, output):
        output_error = calculations.derivative_loss_function(self.a_output, output)
        output_delta = calculations.compute_output_delta(output_error, self.z_output)
        hidden_delta = calculations.backpropagate_error_to_hidden(output_delta, self.output_hidden_weights, self.z_hidden)
        self.output_hidden_weights -= calculations.update_output_hidden_weights(self.learning_rate, output_delta, self.a_hidden)
        self.hidden_weights -= calculations.update_hidden_weights(self.learning_rate, hidden_delta, inputs)
        self.output_bias -= calculations.update_bias(self.learning_rate, output_delta)
        self.hidden_bias -= calculations.update_bias(self.learning_rate, hidden_delta)

    def train(self):
        for inputs, output in zip(XOR.inputs, XOR.outputs):
            self.forward_propagation(inputs)
            self.back_propagation(inputs, output)

    def print_predictions(self):
        for inputs in XOR.inputs:
            self.forward_propagation(inputs)
            prediction = int(self.a_output >= 0.5)
            print(inputs, " = ", prediction)
            # print(inputs, " = ", self.a_output)