Multi layer perceptron

.vscode/settings.json

@@ -17,7 +17,6 @@
   "files.autoSave": "afterDelay",
   "screencastMode.onlyKeyboardShortcuts": true,
   "terminal.integrated.fontSize": 18,
-  "workbench.activityBar.visible": true,
   "workbench.colorTheme": "Visual Studio Dark",
   "workbench.fontAliasing": "antialiased",
   "workbench.statusBar.visible": true,

main.py

@@ -0,0 +1,84 @@
+import numpy as np
+
+class Perceptron:
+    def __init__(self, inputs, bias=1.0):
+        self.weights = (np.random.rand(inputs + 1) * 2) - 1
+        self.bias = bias
+
+    def run(self, x):
+        x_with_bias = np.append(x, self.bias)
+        x_sum = np.dot(x_with_bias, self.weights)
+        return self.sigmoid(x_sum)
+
+    def set_weights(self, w_init):
+        self.weights = np.array(w_init)
+
+    def sigmoid(self, x):
+        return 1 / (1 + np.exp(-x))
+
+class MultiLayerPerceptron:
+    def __init__(self, layers, bias=1.0, eta=0.5):
+        self.layers = np.array(layers, dtype=object)
+        self.bias = bias
+        self.eta = eta
+        self.network = []
+        self.values = []
+        self.d = []
+
+        for i in range(len(self.layers)):
+            self.values.append([0.0 for j in range(self.layers[i])])
+            self.d.append([0.0 for j in range(self.layers[i])])
+            if i > 0:
+                layer = [Perceptron(inputs=self.layers[i-1], bias=self.bias) for j in range(self.layers[i])]
+                self.network.append(layer)
+
+        self.network = np.array([np.array(x) for x in self.network], dtype=object)
+        self.values = np.array([np.array(x) for x in self.values], dtype=object)
+        self.d = np.array([np.array(x) for x in self.d], dtype=object)
+
+    def run(self, x):
+        self.values[0] = x
+        for i in range(1, len(self.network) + 1):
+            for j in range(self.layers[i]):
+                self.values[i][j] = self.network[i-1][j].run(self.values[i-1])
+        return self.values[-1]
+
+    def bp(self, x, y):
+        outputs = self.run(x)
+        error = (y - outputs)
+
+        # Calculate output layer error terms (deltas)
+        self.d[-1] = outputs * (1 - outputs) * error
+
+        # Calculate error terms for hidden layers
+        for i in reversed(range(1, len(self.network))):
+            for h in range(len(self.network[i-1])):
+                fwd_error = 0.0
+                for k in range(self.layers[i+1]):
+                    fwd_error += self.network[i][k].weights[h] * self.d[i+1][k]
+                self.d[i][h] = self.values[i][h] * (1 - self.values[i][h]) * fwd_error
+
+        # Update weights
+        for i in range(1, len(self.network) + 1):
+            for j in range(self.layers[i]):
+                for k in range(self.layers[i-1] + 1):
+                    if k == self.layers[i-1]:
+                        delta = self.eta * self.d[i][j] * self.bias
+                    else:
+                        delta = self.eta * self.d[i][j] * self.values[i-1][k]
+                    self.network[i-1][j].weights[k] += delta
+        return sum(error**2)
+
+# Training
+mlp = MultiLayerPerceptron(layers=[2, 2, 1])
+print("Training Neural Network as an XOR Gate...\n")
+for i in range(5000):
+    mse = (mlp.bp([0,0],[0]) + mlp.bp([0,1],[1]) + mlp.bp([1,0],[1]) + mlp.bp([1,1],[0])) / 4
+    if i % 500 == 0:
+        print(f"MSE: {mse:.6f}")
+
+print("\nFinal XOR Results:")
+print(f"0 0 = {mlp.run([0,0])[0]:.4f}")
+print(f"0 1 = {mlp.run([0,1])[0]:.4f}")
+print(f"1 0 = {mlp.run([1,0])[0]:.4f}")
+print(f"1 1 = {mlp.run([1,1])[0]:.4f}")