Réseau de neurones à 4 couches sans TensorFlowRéseau de neurones à 4 couches sans TensorFlow

import numpy as np

class NeuralNetwork:

    def __init__(self, n_inputs, n_hidden_1, n_hidden_2, 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_outputs)
        self.b3 = 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 = sigmoid(z3)
        return a3

    def backward(self, X, y, a3):
        # Propagation arrière
        d3 = a3 - y
        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.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):
            a3 = self.forward(X)
            self.backward(X, y, a3)

    def predict(self, X):
        # Prédiction
        a3 = self.forward(X)
        return np.argmax(a3, 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 = 300
n_hidden_2 = 100
n_outputs = 10

# Initialisation du réseau
nn = NeuralNetwork(n_inputs, n_hidden_1, n_hidden_2, n_outputs)

# Chargement et préparation des données
# ...

# Entraînement du réseau
nn.train(X_train, y_train, epochs=10, learning_rate=0.01)

# Prédiction sur les données de test
predictions = nn.predict(X_test)

# Évaluation des performances
# ...