SlideShare une entreprise Scribd logo
1  sur  6
Télécharger pour lire hors ligne
09/12/2023 13:55 TP_Réseaux_de_neurones.ipynb - Colaboratory
https://colab.research.google.com/github/RMoulla/Machine-learning/blob/main/TP_Réseaux_de_neurones.ipynb#scrollTo=XvCU0yrMnbJA&print… 1/6
Safae EL OMARI
Double-cliquez (ou appuyez sur Entrée) pour modifier
Dans ce TP, nous allons entraîner un réseau de neurones from scratch sur le dataset MNIST, qui
contient des images de chiffres manuscrits, pour une tâche de classification.
Le réseau de neurones utilisé est de type feedforward (sans récurrence). Il s'agit de l'architecture
la plus basique pour les réseaux de neurones.
Architecture du réseau de neurones
Le réseau de neurones utilisé est structuré de la manière suivante :
Couche d'Entrée : La couche d'entrée est composée de 784 neurones. Cette taille
correspond au nombre de pixels dans chaque image du dataset MNIST (28x28 pixels).
Chaque neurone de cette couche représente l'intensité d'un pixel de l'image en entrée.
Couche Cachée : Le réseau comprend une seule couche cachée. Dans cet exemple, elle est
composée de 100 neurones. Ce nombre n'est pas fixe et peut être ajusté en fonction des
besoins de complexité du modèle. La couche cachée permet au réseau d'apprendre des
représentations plus profondes et des motifs complexes dans les données.
Couche de Sortie : La couche de sortie contient 10 neurones, correspondant aux 10
classes possibles des chiffres (0 à 9) dans le dataset MNIST. Chaque neurone produit une
sortie qui représente la probabilité que l'image en entrée appartienne à l'une des 10
classes.
Fonction d'activation
La fonction d'activation utilisée dans ce réseau est la fonction sigmoid. Elle est appliquée à
chaque neurone de la couche cachée et de la couche de sortie. Cette fonction transforme les
valeurs d'entrée en une sortie comprise entre 0 et 1, ce qui est utile pour des problèmes de
classification binaire. Dans le cas de MNIST, bien que la classification soit multi-classes, la
fonction sigmoid est toujours applicable pour déterminer la probabilité d'appartenance à chaque
classe.
Propagation avant
Entrainement d'un réseau de neurones sur les données
MNIST
keyboard_arrow_down
09/12/2023 13:55 TP_Réseaux_de_neurones.ipynb - Colaboratory
https://colab.research.google.com/github/RMoulla/Machine-learning/blob/main/TP_Réseaux_de_neurones.ipynb#scrollTo=XvCU0yrMnbJA&print… 2/6
Le processus de propagation avant (feedforward) dans un réseau de neurones est une séquence
d'opérations linéaires et non-linéaires. Pour notre réseau avec une couche cachée, le processus
peut être décrit comme suit :
1. Entrée à la couche cachée :
Chaque neurone dans la couche cachée reçoit une combinaison linéaire des entrées :
où est le vecteur d'entrée (les pixels de l'image), est la
matrice des poids entre la couche d'entrée et la couche cachée, et est le vecteur
de biais de la couche cachée.
2. Activation de la couche cachée :
Ensuite, une fonction d'activation non-linéaire est appliquée à chaque élément du
vecteur résultant. Dans notre cas, nous utilisons la fonction sigmoid, définie par :
Ainsi, l'activation de la couche cachée est donnée par :
3. Entrée à la couche de sortie :
De manière similaire, les neurones de la couche de sortie reçoivent une combinaison
linéaire des activations de la couche cachée : où est la
matrice des poids entre la couche cachée et la couche de sortie, et est le vecteur
de biais de la couche de sortie.
4. Activation de la couche de sortie :
Finalement, la fonction sigmoid est appliquée à la sortie pour obtenir la prédiction
finale du réseau :
Ce processus transforme l'entrée brute (les pixels de l'image) en une prédiction de sortie, qui
dans le cas du dataset MNIST, est la probabilité que l'image corresponde à chacun des 10
chiffres (0 à 9).
Rétropropagation
Le processus de rétropropagation (backpropagation) dans un réseau de neurones est utilisé
pour mettre à jour les poids et biais du réseau en fonction de l'erreur de prédiction. Ce processus
peut être décrit mathématiquement comme suit :
1. Calcul de l'erreur de sortie :
L'erreur de sortie est la différence entre la sortie prédite du réseau et la sortie réelle
(valeur attendue). où est la sortie réelle et est la
sortie prédite par le réseau.
2. Gradient de l'erreur par rapport à la sortie :
h = x +
W
(1)
b
(1)
x W
(1)
b
(1)
σ
σ(z) =
1
1 + e
−z
= σ(h)
a
(1)
o = +
W
(2)
a
(1)
b
(2)
W
(2)
b
(2)
= σ(o)
ypred
= −
δ
(o)
yréel
ypred yréel
ypred
09/12/2023 13:55 TP_Réseaux_de_neurones.ipynb - Colaboratory
https://colab.research.google.com/github/RMoulla/Machine-learning/blob/main/TP_Réseaux_de_neurones.ipynb#scrollTo=XvCU0yrMnbJA&print… 3/6
Le gradient de l'erreur par rapport à la sortie est calculé en prenant en compte la
dérivée de la fonction d'activation (sigmoid dans notre cas). Ce gradient est utilisé
pour mettre à jour les poids de la couche de sortie. où est
la dérivée de la fonction sigmoid.
3. Erreur de la couche cachée :
L'erreur pour chaque neurone de la couche cachée est calculée en propageant l'erreur
de la couche de sortie en arrière à travers les poids. où
est la transposée de la matrice des poids entre la couche cachée et la couche de
sortie.
4. Gradient de l'erreur par eapport à la couche cachée :
De même, le gradient pour la couche cachée est calculé en utilisant la dérivée de la
fonction d'activation.
5. Mise à jour des poids et des biais :
Les poids et biais sont ensuite mis à jour en fonction des gradients calculés, en
utilisant un taux d'apprentissage .
où représente la somme sur tous échantillons.
Ce processus de rétropropagation est répété pour chaque exemple dans l'ensemble
d'entraînement, permettant ainsi au réseau de neurones d'apprendre et d'ajuster ses paramètres
pour minimiser l'erreur de prédiction.
Δo = ⋅ (o)
δ
(o)
σ
′
(o)
σ
′
= Δo ⋅
δ
(h)
W
(2)T
W
(2)T
Δh = ⋅ (h)
δ
(h)
σ
′
α = + α ⋅ ⋅ Δo
W
(2)
W
(2)
a
(1)T
= + α ⋅ ⋅ Δh
W
(1)
W
(1)
x
T
= + α ⋅ ∑ Δo
b
(2)
b
(2)
= + α ⋅ ∑ Δh
b
(1)
b
(1)
∑
09/12/2023 13:55 TP_Réseaux_de_neurones.ipynb - Colaboratory
https://colab.research.google.com/github/RMoulla/Machine-learning/blob/main/TP_Réseaux_de_neurones.ipynb#scrollTo=XvCU0yrMnbJA&print… 4/6
import numpy as np
import torch
from torchvision import datasets, transforms
# Définition des fonctions pour le réseau de neurones
def sigmoid(x):
return 1 / (1 + np.exp(-x))
def sigmoid_derivative(x):
return x * (1 - x)
def forward_propagate(X, weights, bias):
hidden_layer_input = np.dot(X, weights[0]) + bias[0]
hidden_layer_activation = sigmoid(hidden_layer_input)
output_layer_input = np.dot(hidden_layer_activation, weights[1]) + bias[1]
output = sigmoid(output_layer_input)
return hidden_layer_activation, output
def backward_propagate(X, Y, hidden_layer_activation, output, weights):
########### Compléter le code ##############
output_error = Y - output
output_delta = output_error * sigmoid_derivative(output)
hidden_error = np.dot(output_delta, weights[1].T)
hidden_delta = hidden_error *sigmoid_derivative(hidden_layer_activation)
############################################
return hidden_delta, output_delta
def update_weights(X, hidden_layer_activation, hidden_delta, output_delta, weights, bias,
X = X.reshape(1, -1) # Redimensionner X en une matrice à une ligne
########### Compléter le code ###############
weights[0] += learning_rate * np.dot(X.T, hidden_delta)
weights[1] += learning_rate * np.dot(hidden_layer_activation.T,output_delta)
bias[0] += learning_rate * np.sum(hidden_delta)
bias[1] += learning_rate * np.sum(output_delta)
############################################
return weights, bias
# Chargement et préparation des données MNIST avec PyTorch
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0
train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transf
test_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transf
train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=len(train_da
test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=len(test_datas
train_images, train_labels = next(iter(train_loader))
test_images, test_labels = next(iter(test_loader))
x_train = train_images.numpy().reshape(-1, 28*28)
y_train = np.eye(10)[train_labels.numpy()]
x_test = test_images.numpy().reshape(-1, 28*28)
y_test = np.eye(10)[test_labels.numpy()]
09/12/2023 13:55 TP_Réseaux_de_neurones.ipynb - Colaboratory
https://colab.research.google.com/github/RMoulla/Machine-learning/blob/main/TP_Réseaux_de_neurones.ipynb#scrollTo=XvCU0yrMnbJA&print… 5/6
# Paramètres du réseau
input_size = 784 # Images de 28x28 pixels
hidden_size = 100 # Taille de la couche cachée
output_size = 10 # 10 classes pour MNIST (0 à 9)
learning_rate = 0.1
epochs = 10
# Initialisation des poids et des biais
weights = [
np.random.randn(input_size, hidden_size) * np.sqrt(1. / input_size),
np.random.randn(hidden_size, output_size) * np.sqrt(1. / hidden_size)
]
bias = [np.zeros((1, hidden_size)), np.zeros((1, output_size))]
# Boucle d'entraînement
for epoch in range(epochs):
for i in range(len(x_train)):
X = x_train[i]
Y = y_train[i]
hidden_layer_activation, output = forward_propagate(X, weights, bias)
hidden_delta, output_delta = backward_propagate(X, Y, hidden_layer_activation, ou
weights, bias = update_weights(X, hidden_layer_activation, hidden_delta, output_d
print(f'Epoch {epoch+1}/{epochs} completed')
# Test du modèle (évaluation sommaire)
loss = 0
correct = 0
for i in range(len(x_test)):
_, output = forward_propagate(x_test[i], weights, bias)
loss += np.sum((y_test[i] - output) ** 2)
correct += int(np.argmax(output) == np.argmax(y_test[i]))
loss /= len(x_test)
accuracy = correct / len(x_test)
print(f'Test Loss: {loss:.4f}')
print(f'Test Accuracy: {accuracy:.4f}')
Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz
Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz to ./data/MNI
100%|██████████| 9912422/9912422 [00:00<00:00, 20220262.74it/s]
Extracting ./data/MNIST/raw/train-images-idx3-ubyte.gz to ./data/MNIST/raw
Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz
Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz to ./data/MNI
100%|██████████| 28881/28881 [00:00<00:00, 67598043.43it/s]
Extracting ./data/MNIST/raw/train-labels-idx1-ubyte.gz to ./data/MNIST/raw
Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz
Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz to ./data/MNIS
100%|██████████| 1648877/1648877 [00:00<00:00, 28161230.86it/s]
Extracting ./data/MNIST/raw/t10k-images-idx3-ubyte.gz to ./data/MNIST/raw
09/12/2023 13:55 TP_Réseaux_de_neurones.ipynb - Colaboratory
https://colab.research.google.com/github/RMoulla/Machine-learning/blob/main/TP_Réseaux_de_neurones.ipynb#scrollTo=XvCU0yrMnbJA&print… 6/6
Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz
Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz to ./data/MNIS
100%|██████████| 4542/4542 [00:00<00:00, 13183756.93it/s]Extracting ./data/MNIST/raw/
Epoch 1/10 completed
Epoch 2/10 completed
Epoch 3/10 completed
Epoch 4/10 completed
Epoch 5/10 completed
Epoch 6/10 completed
Epoch 7/10 completed
Epoch 8/10 completed
Epoch 9/10 completed
Epoch 10/10 completed
Test Loss: 0.0506
Test Accuracy: 0.9716

Contenu connexe

Similaire à TP_Réseaux_de_neurones_Safae_ElOmari.pdf

Mise en oeuvre des Frameworks de Machines et Deep Learning pour les Applicati...
Mise en oeuvre des Frameworks de Machines et Deep Learning pour les Applicati...Mise en oeuvre des Frameworks de Machines et Deep Learning pour les Applicati...
Mise en oeuvre des Frameworks de Machines et Deep Learning pour les Applicati...ENSET, Université Hassan II Casablanca
 
Fondements du machine learning
Fondements du machine learningFondements du machine learning
Fondements du machine learningFrederic Simard
 
Computer Vision - Classification automatique des races de chien à partir de p...
Computer Vision - Classification automatique des races de chien à partir de p...Computer Vision - Classification automatique des races de chien à partir de p...
Computer Vision - Classification automatique des races de chien à partir de p...FUMERY Michael
 
Machine Learning : comparing neural network methods
Machine Learning : comparing neural network methodsMachine Learning : comparing neural network methods
Machine Learning : comparing neural network methodsNichochar
 
Introduction to Machine learning
Introduction to Machine learningIntroduction to Machine learning
Introduction to Machine learningQuentin Ambard
 
Conférence: Catalyseurs de l'Intelligence Artificielle et Écosystème des Fram...
Conférence: Catalyseurs de l'Intelligence Artificielle et Écosystème des Fram...Conférence: Catalyseurs de l'Intelligence Artificielle et Écosystème des Fram...
Conférence: Catalyseurs de l'Intelligence Artificielle et Écosystème des Fram...ENSET, Université Hassan II Casablanca
 
Cours algorithmique et complexite complet
Cours algorithmique et complexite completCours algorithmique et complexite complet
Cours algorithmique et complexite completChahrawoods Dmz
 
Cours algorithmique et complexite
Cours algorithmique et complexite Cours algorithmique et complexite
Cours algorithmique et complexite Saddem Chikh
 
Cours algorithmique et complexite complet
Cours algorithmique et complexite completCours algorithmique et complexite complet
Cours algorithmique et complexite completChahrawoods Dmz
 
Algorithmes machine learning/ neural network / deep learning
Algorithmes machine learning/ neural network / deep learningAlgorithmes machine learning/ neural network / deep learning
Algorithmes machine learning/ neural network / deep learningBassem Brayek
 
Reconnaissance de panneaux de signalisation routière en utilisant la détectio...
Reconnaissance de panneaux de signalisation routière en utilisant la détectio...Reconnaissance de panneaux de signalisation routière en utilisant la détectio...
Reconnaissance de panneaux de signalisation routière en utilisant la détectio...Loghin Dumitru
 
Réseaux neuronaux profonds & intelligence artificielle
Réseaux neuronaux profonds & intelligence artificielleRéseaux neuronaux profonds & intelligence artificielle
Réseaux neuronaux profonds & intelligence artificielleOlivier Teytaud
 
Traitement des données massives (INF442, A4)
Traitement des données massives (INF442, A4)Traitement des données massives (INF442, A4)
Traitement des données massives (INF442, A4)Frank Nielsen
 
FLTauR - Construction de modèles de prévision sous r avec le package caret
FLTauR - Construction de modèles de prévision sous r avec le package caretFLTauR - Construction de modèles de prévision sous r avec le package caret
FLTauR - Construction de modèles de prévision sous r avec le package caretjfeudeline
 
Apprentissage supervisé.pdf
Apprentissage supervisé.pdfApprentissage supervisé.pdf
Apprentissage supervisé.pdfhanamettali
 

Similaire à TP_Réseaux_de_neurones_Safae_ElOmari.pdf (20)

Comparaison
ComparaisonComparaison
Comparaison
 
Mise en oeuvre des Frameworks de Machines et Deep Learning pour les Applicati...
Mise en oeuvre des Frameworks de Machines et Deep Learning pour les Applicati...Mise en oeuvre des Frameworks de Machines et Deep Learning pour les Applicati...
Mise en oeuvre des Frameworks de Machines et Deep Learning pour les Applicati...
 
Fondements du machine learning
Fondements du machine learningFondements du machine learning
Fondements du machine learning
 
Computer Vision - Classification automatique des races de chien à partir de p...
Computer Vision - Classification automatique des races de chien à partir de p...Computer Vision - Classification automatique des races de chien à partir de p...
Computer Vision - Classification automatique des races de chien à partir de p...
 
Machine Learning : comparing neural network methods
Machine Learning : comparing neural network methodsMachine Learning : comparing neural network methods
Machine Learning : comparing neural network methods
 
Réseaux de neurones
Réseaux de neurones Réseaux de neurones
Réseaux de neurones
 
Introduction to Machine learning
Introduction to Machine learningIntroduction to Machine learning
Introduction to Machine learning
 
Conférence: Catalyseurs de l'Intelligence Artificielle et Écosystème des Fram...
Conférence: Catalyseurs de l'Intelligence Artificielle et Écosystème des Fram...Conférence: Catalyseurs de l'Intelligence Artificielle et Écosystème des Fram...
Conférence: Catalyseurs de l'Intelligence Artificielle et Écosystème des Fram...
 
Cours algorithmique et complexite complet
Cours algorithmique et complexite completCours algorithmique et complexite complet
Cours algorithmique et complexite complet
 
Cours algorithmique et complexite
Cours algorithmique et complexite Cours algorithmique et complexite
Cours algorithmique et complexite
 
Cours algorithmique et complexite complet
Cours algorithmique et complexite completCours algorithmique et complexite complet
Cours algorithmique et complexite complet
 
Algorithmes machine learning/ neural network / deep learning
Algorithmes machine learning/ neural network / deep learningAlgorithmes machine learning/ neural network / deep learning
Algorithmes machine learning/ neural network / deep learning
 
Réseaux neurons
Réseaux neuronsRéseaux neurons
Réseaux neurons
 
Rapport MOGPL
Rapport MOGPLRapport MOGPL
Rapport MOGPL
 
Analyzing a churn data set
Analyzing a churn data set Analyzing a churn data set
Analyzing a churn data set
 
Reconnaissance de panneaux de signalisation routière en utilisant la détectio...
Reconnaissance de panneaux de signalisation routière en utilisant la détectio...Reconnaissance de panneaux de signalisation routière en utilisant la détectio...
Reconnaissance de panneaux de signalisation routière en utilisant la détectio...
 
Réseaux neuronaux profonds & intelligence artificielle
Réseaux neuronaux profonds & intelligence artificielleRéseaux neuronaux profonds & intelligence artificielle
Réseaux neuronaux profonds & intelligence artificielle
 
Traitement des données massives (INF442, A4)
Traitement des données massives (INF442, A4)Traitement des données massives (INF442, A4)
Traitement des données massives (INF442, A4)
 
FLTauR - Construction de modèles de prévision sous r avec le package caret
FLTauR - Construction de modèles de prévision sous r avec le package caretFLTauR - Construction de modèles de prévision sous r avec le package caret
FLTauR - Construction de modèles de prévision sous r avec le package caret
 
Apprentissage supervisé.pdf
Apprentissage supervisé.pdfApprentissage supervisé.pdf
Apprentissage supervisé.pdf
 

TP_Réseaux_de_neurones_Safae_ElOmari.pdf

  • 1. 09/12/2023 13:55 TP_Réseaux_de_neurones.ipynb - Colaboratory https://colab.research.google.com/github/RMoulla/Machine-learning/blob/main/TP_Réseaux_de_neurones.ipynb#scrollTo=XvCU0yrMnbJA&print… 1/6 Safae EL OMARI Double-cliquez (ou appuyez sur Entrée) pour modifier Dans ce TP, nous allons entraîner un réseau de neurones from scratch sur le dataset MNIST, qui contient des images de chiffres manuscrits, pour une tâche de classification. Le réseau de neurones utilisé est de type feedforward (sans récurrence). Il s'agit de l'architecture la plus basique pour les réseaux de neurones. Architecture du réseau de neurones Le réseau de neurones utilisé est structuré de la manière suivante : Couche d'Entrée : La couche d'entrée est composée de 784 neurones. Cette taille correspond au nombre de pixels dans chaque image du dataset MNIST (28x28 pixels). Chaque neurone de cette couche représente l'intensité d'un pixel de l'image en entrée. Couche Cachée : Le réseau comprend une seule couche cachée. Dans cet exemple, elle est composée de 100 neurones. Ce nombre n'est pas fixe et peut être ajusté en fonction des besoins de complexité du modèle. La couche cachée permet au réseau d'apprendre des représentations plus profondes et des motifs complexes dans les données. Couche de Sortie : La couche de sortie contient 10 neurones, correspondant aux 10 classes possibles des chiffres (0 à 9) dans le dataset MNIST. Chaque neurone produit une sortie qui représente la probabilité que l'image en entrée appartienne à l'une des 10 classes. Fonction d'activation La fonction d'activation utilisée dans ce réseau est la fonction sigmoid. Elle est appliquée à chaque neurone de la couche cachée et de la couche de sortie. Cette fonction transforme les valeurs d'entrée en une sortie comprise entre 0 et 1, ce qui est utile pour des problèmes de classification binaire. Dans le cas de MNIST, bien que la classification soit multi-classes, la fonction sigmoid est toujours applicable pour déterminer la probabilité d'appartenance à chaque classe. Propagation avant Entrainement d'un réseau de neurones sur les données MNIST keyboard_arrow_down
  • 2. 09/12/2023 13:55 TP_Réseaux_de_neurones.ipynb - Colaboratory https://colab.research.google.com/github/RMoulla/Machine-learning/blob/main/TP_Réseaux_de_neurones.ipynb#scrollTo=XvCU0yrMnbJA&print… 2/6 Le processus de propagation avant (feedforward) dans un réseau de neurones est une séquence d'opérations linéaires et non-linéaires. Pour notre réseau avec une couche cachée, le processus peut être décrit comme suit : 1. Entrée à la couche cachée : Chaque neurone dans la couche cachée reçoit une combinaison linéaire des entrées : où est le vecteur d'entrée (les pixels de l'image), est la matrice des poids entre la couche d'entrée et la couche cachée, et est le vecteur de biais de la couche cachée. 2. Activation de la couche cachée : Ensuite, une fonction d'activation non-linéaire est appliquée à chaque élément du vecteur résultant. Dans notre cas, nous utilisons la fonction sigmoid, définie par : Ainsi, l'activation de la couche cachée est donnée par : 3. Entrée à la couche de sortie : De manière similaire, les neurones de la couche de sortie reçoivent une combinaison linéaire des activations de la couche cachée : où est la matrice des poids entre la couche cachée et la couche de sortie, et est le vecteur de biais de la couche de sortie. 4. Activation de la couche de sortie : Finalement, la fonction sigmoid est appliquée à la sortie pour obtenir la prédiction finale du réseau : Ce processus transforme l'entrée brute (les pixels de l'image) en une prédiction de sortie, qui dans le cas du dataset MNIST, est la probabilité que l'image corresponde à chacun des 10 chiffres (0 à 9). Rétropropagation Le processus de rétropropagation (backpropagation) dans un réseau de neurones est utilisé pour mettre à jour les poids et biais du réseau en fonction de l'erreur de prédiction. Ce processus peut être décrit mathématiquement comme suit : 1. Calcul de l'erreur de sortie : L'erreur de sortie est la différence entre la sortie prédite du réseau et la sortie réelle (valeur attendue). où est la sortie réelle et est la sortie prédite par le réseau. 2. Gradient de l'erreur par rapport à la sortie : h = x + W (1) b (1) x W (1) b (1) σ σ(z) = 1 1 + e −z = σ(h) a (1) o = + W (2) a (1) b (2) W (2) b (2) = σ(o) ypred = − δ (o) yréel ypred yréel ypred
  • 3. 09/12/2023 13:55 TP_Réseaux_de_neurones.ipynb - Colaboratory https://colab.research.google.com/github/RMoulla/Machine-learning/blob/main/TP_Réseaux_de_neurones.ipynb#scrollTo=XvCU0yrMnbJA&print… 3/6 Le gradient de l'erreur par rapport à la sortie est calculé en prenant en compte la dérivée de la fonction d'activation (sigmoid dans notre cas). Ce gradient est utilisé pour mettre à jour les poids de la couche de sortie. où est la dérivée de la fonction sigmoid. 3. Erreur de la couche cachée : L'erreur pour chaque neurone de la couche cachée est calculée en propageant l'erreur de la couche de sortie en arrière à travers les poids. où est la transposée de la matrice des poids entre la couche cachée et la couche de sortie. 4. Gradient de l'erreur par eapport à la couche cachée : De même, le gradient pour la couche cachée est calculé en utilisant la dérivée de la fonction d'activation. 5. Mise à jour des poids et des biais : Les poids et biais sont ensuite mis à jour en fonction des gradients calculés, en utilisant un taux d'apprentissage . où représente la somme sur tous échantillons. Ce processus de rétropropagation est répété pour chaque exemple dans l'ensemble d'entraînement, permettant ainsi au réseau de neurones d'apprendre et d'ajuster ses paramètres pour minimiser l'erreur de prédiction. Δo = ⋅ (o) δ (o) σ ′ (o) σ ′ = Δo ⋅ δ (h) W (2)T W (2)T Δh = ⋅ (h) δ (h) σ ′ α = + α ⋅ ⋅ Δo W (2) W (2) a (1)T = + α ⋅ ⋅ Δh W (1) W (1) x T = + α ⋅ ∑ Δo b (2) b (2) = + α ⋅ ∑ Δh b (1) b (1) ∑
  • 4. 09/12/2023 13:55 TP_Réseaux_de_neurones.ipynb - Colaboratory https://colab.research.google.com/github/RMoulla/Machine-learning/blob/main/TP_Réseaux_de_neurones.ipynb#scrollTo=XvCU0yrMnbJA&print… 4/6 import numpy as np import torch from torchvision import datasets, transforms # Définition des fonctions pour le réseau de neurones def sigmoid(x): return 1 / (1 + np.exp(-x)) def sigmoid_derivative(x): return x * (1 - x) def forward_propagate(X, weights, bias): hidden_layer_input = np.dot(X, weights[0]) + bias[0] hidden_layer_activation = sigmoid(hidden_layer_input) output_layer_input = np.dot(hidden_layer_activation, weights[1]) + bias[1] output = sigmoid(output_layer_input) return hidden_layer_activation, output def backward_propagate(X, Y, hidden_layer_activation, output, weights): ########### Compléter le code ############## output_error = Y - output output_delta = output_error * sigmoid_derivative(output) hidden_error = np.dot(output_delta, weights[1].T) hidden_delta = hidden_error *sigmoid_derivative(hidden_layer_activation) ############################################ return hidden_delta, output_delta def update_weights(X, hidden_layer_activation, hidden_delta, output_delta, weights, bias, X = X.reshape(1, -1) # Redimensionner X en une matrice à une ligne ########### Compléter le code ############### weights[0] += learning_rate * np.dot(X.T, hidden_delta) weights[1] += learning_rate * np.dot(hidden_layer_activation.T,output_delta) bias[0] += learning_rate * np.sum(hidden_delta) bias[1] += learning_rate * np.sum(output_delta) ############################################ return weights, bias # Chargement et préparation des données MNIST avec PyTorch transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0 train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transf test_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transf train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=len(train_da test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=len(test_datas train_images, train_labels = next(iter(train_loader)) test_images, test_labels = next(iter(test_loader)) x_train = train_images.numpy().reshape(-1, 28*28) y_train = np.eye(10)[train_labels.numpy()] x_test = test_images.numpy().reshape(-1, 28*28) y_test = np.eye(10)[test_labels.numpy()]
  • 5. 09/12/2023 13:55 TP_Réseaux_de_neurones.ipynb - Colaboratory https://colab.research.google.com/github/RMoulla/Machine-learning/blob/main/TP_Réseaux_de_neurones.ipynb#scrollTo=XvCU0yrMnbJA&print… 5/6 # Paramètres du réseau input_size = 784 # Images de 28x28 pixels hidden_size = 100 # Taille de la couche cachée output_size = 10 # 10 classes pour MNIST (0 à 9) learning_rate = 0.1 epochs = 10 # Initialisation des poids et des biais weights = [ np.random.randn(input_size, hidden_size) * np.sqrt(1. / input_size), np.random.randn(hidden_size, output_size) * np.sqrt(1. / hidden_size) ] bias = [np.zeros((1, hidden_size)), np.zeros((1, output_size))] # Boucle d'entraînement for epoch in range(epochs): for i in range(len(x_train)): X = x_train[i] Y = y_train[i] hidden_layer_activation, output = forward_propagate(X, weights, bias) hidden_delta, output_delta = backward_propagate(X, Y, hidden_layer_activation, ou weights, bias = update_weights(X, hidden_layer_activation, hidden_delta, output_d print(f'Epoch {epoch+1}/{epochs} completed') # Test du modèle (évaluation sommaire) loss = 0 correct = 0 for i in range(len(x_test)): _, output = forward_propagate(x_test[i], weights, bias) loss += np.sum((y_test[i] - output) ** 2) correct += int(np.argmax(output) == np.argmax(y_test[i])) loss /= len(x_test) accuracy = correct / len(x_test) print(f'Test Loss: {loss:.4f}') print(f'Test Accuracy: {accuracy:.4f}') Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz to ./data/MNI 100%|██████████| 9912422/9912422 [00:00<00:00, 20220262.74it/s] Extracting ./data/MNIST/raw/train-images-idx3-ubyte.gz to ./data/MNIST/raw Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz to ./data/MNI 100%|██████████| 28881/28881 [00:00<00:00, 67598043.43it/s] Extracting ./data/MNIST/raw/train-labels-idx1-ubyte.gz to ./data/MNIST/raw Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz to ./data/MNIS 100%|██████████| 1648877/1648877 [00:00<00:00, 28161230.86it/s] Extracting ./data/MNIST/raw/t10k-images-idx3-ubyte.gz to ./data/MNIST/raw
  • 6. 09/12/2023 13:55 TP_Réseaux_de_neurones.ipynb - Colaboratory https://colab.research.google.com/github/RMoulla/Machine-learning/blob/main/TP_Réseaux_de_neurones.ipynb#scrollTo=XvCU0yrMnbJA&print… 6/6 Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz to ./data/MNIS 100%|██████████| 4542/4542 [00:00<00:00, 13183756.93it/s]Extracting ./data/MNIST/raw/ Epoch 1/10 completed Epoch 2/10 completed Epoch 3/10 completed Epoch 4/10 completed Epoch 5/10 completed Epoch 6/10 completed Epoch 7/10 completed Epoch 8/10 completed Epoch 9/10 completed Epoch 10/10 completed Test Loss: 0.0506 Test Accuracy: 0.9716