Réseau de neurones à 5 couches sans TensorFlow

import numpy as np

class NeuralNetwork:

    def __init__(self, n_inputs, n_hidden_1, n_hidden_2, n_hidden_3, n_hidden_4, n_outputs):
        # Initialisation des poids et biais
        self.w1 = np.random.randn(n_inputs, n_hidden_1)
        self.b1 = np.zeros((n_hidden_1,))
        self.w2 = np.random.randn(n_hidden_1, n_hidden_2)
        self.b2 = np.zeros((n_hidden_2,))
        self.w3 = np.random.randn(n_hidden_2, n_hidden_3)
        self.b3 = np.zeros((n_hidden_3,))
        self.w4 = np.random.randn(n_hidden_3, n_hidden_4)
        self.b4 = np.zeros((n_hidden_4,))
        self.w5 = np.random.randn(n_hidden_4, n_outputs)
        self.b5 = np.zeros((n_outputs,))

    def forward(self, X):
        # Propagation avant
        z1 = X.dot(self.w1) + self.b1
        a1 = np.tanh(z1)
        z2 = a1.dot(self.w2) + self.b2
        a2 = np.tanh(z2)
        z3 = a2.dot(self.w3) + self.b3
        a3 = np.tanh(z3)
        z4 = a3.dot(self.w4) + self.b4
        a4 = np.tanh(z4)
        z5 = a4.dot(self.w5) + self.b5
        a5 = sigmoid(z5)
        return a5

    def backward(self, X, y, a5):
        # Propagation arrière
        d5 = a5 - y
        z4 = a3.dot(self.w4) + self.b4
        d4 = (d5.dot(self.w5.T)) * (1 - a4**2)
        z3 = a2.dot(self.w3) + self.b3
        d3 = (d4.dot(self.w4.T)) * (1 - a3**2)
        z2 = a1.dot(self.w2) + self.b2
        d2 = (d3.dot(self.w3.T)) * (1 - a2**2)
        z1 = X.dot(self.w1) + self.b1
        d1 = (d2.dot(self.w2.T)) * (1 - a1**2)

        # Mise à jour des poids et biais
        self.w5 -= self.learning_rate * a4.T.dot(d5)
        self.b5 -= self.learning_rate * d5
        self.w4 -= self.learning_rate * a3.T.dot(d4)
        self.b4 -= self.learning_rate * d4
        self.w3 -= self.learning_rate * a2.T.dot(d3)
        self.b3 -= self.learning_rate * d3
        self.w2 -= self.learning_rate * a1.T.dot(d2)
        self.b2 -= self.learning_rate * d2
        self.w1 -= self.learning_rate * X.T.dot(d1)
        self.b1 -= self.learning_rate * d1

    def train(self, X, y, epochs, learning_rate):
        # Entraînement du réseau
        for epoch in range(epochs):
            a5 = self.forward(X)
            self.backward(X, y, a5)

    def predict(self, X):
        # Prédiction
        a5 = self.forward(X)
        return np.argmax(a5, axis=1)

# Fonction d'activation sigmoïde
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

# Exemple d'utilisation
n_inputs = 784 # 28x28 images
n_hidden_1