Upload New File

mlp.py

+import numpy as np
+from read_cifar import read_cifar, split_dataset
+import matplotlib.pyplot as plt
+import os
+
+# Question 10: Implémentation avec MSE
+def learn_once_mse(w1, b1, w2, b2, data, targets, learning_rate):
+    
+    # On code la Forward pass: propagation des données à travers le réseau
+    a0 = data  # Couche d'entrée
+    z1 = np.matmul(a0, w1) + b1  # Première couche cachée (pré-activation)
+    a1 = 1 / (1 + np.exp(-z1))   # Activation sigmoid
+    z2 = np.matmul(a1, w2) + b2  # Couche de sortie (pré-activation)
+    a2 = 1 / (1 + np.exp(-z2))   # Activation sigmoid finale
+    predictions = a2
+
+    # On calcul l'erreur quadratique moyenne
+    loss = np.mean(np.square(predictions - targets))
+
+    # On code ensuite la Backward pass: calcul des gradients et mise à jour des poids
+    dC_da2 = 2 * (predictions - targets) / targets.shape[0]  # Dérivée par rapport à la sortie
+    dC_dz2 = dC_da2 * (a2 * (1 - a2))  # Dérivée de la sigmoid
+    dC_dw2 = np.matmul(a1.T, dC_dz2)   # Gradient pour w2
+    dC_db2 = np.mean(dC_dz2, axis=0)   # Gradient pour b2
+
+    # On propage l'erreur vers la première couche
+    dC_da1 = np.matmul(dC_dz2, w2.T)
+    dC_dz1 = dC_da1 * (a1 * (1 - a1))  # Dérivée de la sigmoid
+    dC_dw1 = np.matmul(a0.T, dC_dz1)   # Gradient pour w1
+    dC_db1 = np.mean(dC_dz1, axis=0)   # Gradient pour b1
+
+    # On met à jour les poids et biais avec le gradient descent
+    w1 = w1 - learning_rate * dC_dw1
+    b1 = b1 - learning_rate * dC_db1
+    w2 = w2 - learning_rate * dC_dw2
+    b2 = b2 - learning_rate * dC_db2
+
+    return w1, b1, w2, b2, loss
+
+# Question 11: One-hot encoding
+def one_hot(labels):
+    n_classes = 10  # CIFAR-10 a 10 classes
+    return np.eye(n_classes)[labels]
+
+# Question 12: Implémentation avec la Cross-Entropy
+def learn_once_cross_entropy(w1, b1, w2, b2, data, labels, learning_rate):
+    batch_size = data.shape[0]
+    
+    # On implemente la Forward pass
+    a0 = data
+    z1 = np.matmul(a0, w1) + b1
+    a1 = 1 / (1 + np.exp(-z1))
+    z2 = np.matmul(a1, w2) + b2
+    
+    # On implemente notre sofmax
+    z2 = z2 - np.max(z2, axis=1, keepdims=True)
+    exp_z2 = np.exp(z2)
+    a2 = exp_z2 / np.sum(exp_z2, axis=1, keepdims=True)
+    
+    # One-hot encoding
+    y = one_hot(labels)
+    
+    # Cross entropy loss avec réduction correcte
+    loss = -np.sum(y * np.log(a2 + 1e-15)) / batch_size
+    
+    # Backward pass avec normalisation correcte
+    dC_dz2 = (a2 - y) / batch_size
+    dC_dw2 = np.matmul(a1.T, dC_dz2)
+    dC_db2 = np.mean(dC_dz2, axis=0)
+    dC_da1 = np.matmul(dC_dz2, w2.T)
+    dC_dz1 = dC_da1 * (a1 * (1 - a1))
+    dC_dw1 = np.matmul(a0.T, dC_dz1)
+    dC_db1 = np.mean(dC_dz1, axis=0)
+    
+    # Update weights and biases
+    w1 = w1 - learning_rate * dC_dw1
+    b1 = b1 - learning_rate * dC_db1
+    w2 = w2 - learning_rate * dC_dw2
+    b2 = b2 - learning_rate * dC_db2
+    
+    return w1, b1, w2, b2, loss
+# Question 13: Training function
+def train_mlp(w1, b1, w2, b2, data_train, labels_train, learning_rate, num_epoch):
+    train_accuracies = []
+    batch_size = 128  # Taille de batch raisonnable
+    
+    for epoch in range(num_epoch):
+        # ON mélange aléatoirement les données à chaque époque
+        indices = np.random.permutation(len(data_train))
+        data_train = data_train[indices]
+        labels_train = labels_train[indices]
+        
+        epoch_losses = []
+        
+        # On réalise l'entrainement par batch
+        for i in range(0, len(data_train), batch_size):
+            # On récupère notre batch de données + les labels
+            batch_data = data_train[i:i+batch_size]
+            batch_labels = labels_train[i:i+batch_size]
+            
+            # On réalise l'entrainement avec la fonction précédement définit sur le batch
+            w1, b1, w2, b2, loss = learn_once_cross_entropy(
+                w1, b1, w2, b2, batch_data, batch_labels, learning_rate)
+            epoch_losses.append(loss)
+        
+        # On calcul finalement la précision de notre entrainement
+        predictions = predict_mlp(w1, b1, w2, b2, data_train) # fonction définit en dessous
+        # Pour l'accuracy on peut directement faire la moyenne du tableau contenant True si
+        # la prédiction est vrai (si prediction = label) le mean sur [True,False] renvois 0.5
+        accuracy = np.mean(predictions == labels_train)
+        train_accuracies.append(accuracy)
+        
+        # On affiche l'évolution de l'entrainement dans la console
+        if (epoch + 1) % 10 == 0:
+            print(f"Epoch {epoch+1}/{num_epoch}, Loss: {np.mean(epoch_losses):.4f}, Accuracy: {accuracy:.4f}")
+    
+    return w1, b1, w2, b2, train_accuracies
+
+def predict_mlp(w1, b1, w2, b2, data):
+    # On Forward pass jusqu'à la prédiction (on avait des soucis sans le faire)
+    z1 = np.matmul(data, w1) + b1
+    a1 = 1 / (1 + np.exp(-z1))
+    z2 = np.matmul(a1, w2) + b2
+    exp_z2 = np.exp(z2 - np.max(z2, axis=1, keepdims=True))
+    a2 = exp_z2 / np.sum(exp_z2, axis=1, keepdims=True)
+    return np.argmax(a2, axis=1)
+
+# Question 14: La fonction pour le test (comme a la fin de notre fonction train_mlp)
+# On la mise aussi dans la fonction du dessus pour avoir un suivit de la loss
+def test_mlp(w1, b1, w2, b2, data_test, labels_test):
+    predictions = predict_mlp(w1, b1, w2, b2, data_test)
+    return np.mean(predictions == labels_test)
+
+# Question 15: La fonction pour l'entrainement complet
+def run_mlp_training(data_train, labels_train, data_test, labels_test, d_h, learning_rate, num_epoch):
+    # On initialise tailles, poids ...
+    d_in = data_train.shape[1]
+    d_out = 10  # CIFAR-10 classes
+    w1 = 2 * np.random.rand(d_in, d_h) - 1
+    b1 = np.zeros((1, d_h))
+    w2 = 2 * np.random.rand(d_h, d_out) - 1
+    b2 = np.zeros((1, d_out))
+    
+    # On passe a l'entrainement 
+    w1, b1, w2, b2, train_accuracies = train_mlp(
+        w1, b1, w2, b2, data_train, labels_train, learning_rate, num_epoch)
+    
+    # On passe ensuite au test
+    test_accuracy = test_mlp(w1, b1, w2, b2, data_test, labels_test)
+    return train_accuracies, test_accuracy
+
+# Question 16: Fonction pour plot notre courbe d'entrainement
+def plot_learning_curve(train_accuracies, test_accuracies):
+    plt.figure(figsize=(10, 6))
+    plt.plot(range(1, len(train_accuracies) + 1), train_accuracies, label='Training Accuracy')
+    plt.plot(range(1, len(test_accuracies) + 1), test_accuracies, label='Test Accuracy', linestyle='--')
+    plt.xlabel('Epoch')
+    plt.ylabel('Accuracy')
+    plt.title('MLP Learning Curve')
+    plt.legend()
+    plt.grid(True)
+    
+    # On sauvegarder le graphique
+    os.makedirs('results', exist_ok=True)
+    plt.savefig('results/mlp.png')
+    plt.close()
+
+
+if __name__ == "__main__":
+    # On charge les données
+    cifar_dir = "data/cifar-10-batches-py"
+    all_data, all_labels = read_cifar(cifar_dir)
+    
+    # On normalise les données (pixel codé sur 8 bit)
+    all_data = all_data / 255.0
+    
+    # On split nos datas
+    data_train, labels_train, data_test, labels_test = split_dataset(all_data, all_labels, split=0.9)
+    
+    # On initialise les paramètres, ils sont fournit dans le sujet
+    d_h = 64
+    learning_rate = 0.1
+    num_epoch = 100
+    
+    # On démarre le training
+    train_accuracies, test_accuracy = run_mlp_training(
+        data_train, labels_train, data_test, labels_test,
+        d_h, learning_rate, num_epoch
+    )
+    
+    print(f"\nPrécision finale sur le test : {test_accuracy:.4f}")
+    plot_learning_curve(train_accuracies, test_accuracy)