Initial commit

.vscode/settings.json

@@ -0,0 +1,6 @@
+{
+	"[python]": {
+		"editor.defaultFormatter": "ms-python.autopep8"
+	},
+	"python.formatting.provider": "none"
+}

README.md

@@ -1,5 +1,5 @@
 ---
-title: Nn Scratch Mnist
+title: Simple MNIST Classifier
 emoji: 🏃
 colorFrom: indigo
 colorTo: pink
@@ -10,4 +10,8 @@ pinned: false
 license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+The model used is a Neural Network made with Python and Numpy only.
+Architecture is 784 input units, two hidden layers of 72 and 24 units and a 10 unit output.
+Training was done on the MNIST training dataset of 60000 images.
+
+Video (Portuguese-Brazil): https://www.youtube.com/watch?v=NhG8NsHW6fI

app.py

@@ -0,0 +1,32 @@
+import gradio as gr
+import pickle
+
+with open('model_91_7248.bin', 'rb') as f:
+    nn = pickle.load(f)
+
+
+def predict(input):
+    x = input.reshape((784, 1))
+    p = nn.feed_forward(x).reshape((10,))
+
+    return dict(enumerate(p))
+
+
+demo = gr.Interface(
+    fn=predict,
+    inputs=[
+        gr.Sketchpad(
+            shape=(28, 28),
+            brush_radius=1.2,
+        )
+    ],
+    outputs=[
+        gr.Label(
+            num_top_classes=3,
+            scale=2,
+        )
+    ],
+    live=True,
+    allow_flagging=False,
+
+).launch()

dataset.py

@@ -0,0 +1,63 @@
+import numpy as np
+
+
+def load_training():
+    images_file = open('./train-images-idx3-ubyte', 'rb')
+    labels_file = open('./train-labels-idx1-ubyte', 'rb')
+
+    images = load_images(images_file)
+    labels = load_labels(labels_file)
+
+    return images, labels
+
+
+def bytes_to_int(bytes):
+    return int.from_bytes(bytes, byteorder='big')
+
+
+def load_images(file, num=60000):
+    magic = bytes_to_int(file.read(4))
+    if (magic != 2051):
+        raise RuntimeError('Wrong file for images')
+
+    num_images = bytes_to_int(file.read(4))
+    num_rows = bytes_to_int(file.read(4))
+    num_cols = bytes_to_int(file.read(4))
+
+    images = []
+
+    for i in range(min(num_images, num)):
+        images.append([
+            bytes_to_int(file.read(1)) for p in range(num_rows * num_cols)
+        ])
+
+    return images
+
+
+def load_labels(file, num=60000):
+    magic = bytes_to_int(file.read(4))
+    if (magic != 2049):
+        raise RuntimeError('Wrong file for labels')
+
+    num_labels = bytes_to_int(file.read(4))
+
+    labels = [
+        bytes_to_int(file.read(1)) for l in range(min(num_labels, num))
+    ]
+
+    return labels
+
+
+def convert_label_to_output(label: int):
+    output = np.zeros((10, 1))
+    output[label][0] = 1.0
+
+    return output
+
+
+def convert_image_to_input(image: list):
+    return np.reshape(image, (784, 1))
+
+
+def convert_output_to_label(output: np.ndarray[np.float64]):
+    return np.argmax(output)

network.py

@@ -0,0 +1,73 @@
+import numpy as np
+
+class NeuralNetwork():
+    def __init__(self, neurons_per_layer):
+        self.num_layers = len(neurons_per_layer)
+        self.neurons_per_layer = neurons_per_layer
+
+        a = neurons_per_layer[1:]
+        b = neurons_per_layer[:-1]
+
+        self.weights = [
+            np.random.randn(current, previous) for current, previous in
+            zip(a, b)
+        ]
+
+        self.bias = [np.random.randn(y, 1) for y in a]
+
+    def activation_fn(self, x):
+        return 1.0 / (1.0 + np.exp(-x))
+
+    def cost_derivative(self, output, expected):
+        return output - expected
+
+    def activation_derivative(self, x):
+        return self.activation_fn(x) * (1 - self.activation_fn(x))
+
+    def feed_forward(self, x):
+        for w, b in zip(self.weights, self.bias):
+            z = np.dot(w, x) + b
+            x = self.activation_fn(z)
+
+        return x
+
+    def backprop(self, x, expected):
+        weight_gradients = [np.zeros(w.shape) for w in self.weights]
+        bias_gradients = [np.zeros(b.shape) for b in self.bias]
+
+        zs = []
+        activation = np.array(x)
+        activations = [np.array(x)]
+
+        for w, b in zip(self.weights, self.bias):
+            z = np.dot(w, activation) + b
+            zs.append(z)
+            activation = self.activation_fn(z)
+            activations.append(activation)
+
+        delta = self.cost_derivative(
+            activation, expected) * self.activation_derivative(zs[-1])
+
+        weight_gradients[-1] = np.dot(delta, activations[-2].T)
+        bias_gradients[-1] = delta
+
+        for layer in range(2, self.num_layers):
+            z = zs[-layer]
+            d = self.activation_derivative(z)
+            delta = np.dot(self.weights[-layer + 1].T, delta) * d
+
+            weight_gradients[-layer] = np.dot(delta, activations[-layer - 1].T)
+            bias_gradients[-layer] = delta
+
+        return (weight_gradients, bias_gradients)
+
+    def adjust(self, lr, weight_gradients, bias_gradients):
+        self.weights = [
+            w - lr * nw for w, nw in
+            zip(self.weights, weight_gradients)
+        ]
+
+        self.bias = [
+            b - lr * nb for b, nb in
+            zip(self.bias, bias_gradients)
+        ]

requirements.txt

@@ -0,0 +1 @@
+numpy==1.26.0