République Algérienne Démocratique et Populaire

Ministère de l’Enseignement Supérieur et de la Recherche

Scientifique
Université des Sciences et de la Technologie Houari
Boumediene

Faculté de Génie Électrique

Spécialité Electronique des systèmes embarqués

COMPTE RENDU TP3

Réseaux De
Neurones
Module: Intelligence Artificielle Embarqué
Section : ESE B SGRP 03

Présenté par :

SERHANE IKRAM 202031043270

Sarah Bounab 191931061617

Mouaad Yaici 191931039562

Dr. Khidar
L’objectif de ce TP est de
➢ Définir un modèle de réseau de neurones à propagation avant adapte à la
classification .
➢ Evaluer les performances d’un réseau de neurones en utilisant des métriques
telles que la précision et la perte .
➢ Exploitation du modèle pour prédire des chiffres manuscrits à partir de
nouvelles images .

1-Partie Théorique

R1 : le réseau de neurones à propagation avant utilise des

neurones artificiels organisés en couches pour effectuer des
calculs en utilisant des fonctions d'activation et des poids. Les
couches cachées permettent l'extraction de caractéristiques,
tandis que la couche de sortie produit la sortie finale.
L'apprentissage se fait par ajustement itératif des poids à
l'aide de l'algorithme de rétropropagation du gradient.

R2 :
la fonction sigmoïde est une fonction d'activation qui permet de modéliser
des probabilités dans les réseaux de neurones à propagation avant. Elle
transforme les entrées en valeurs comprises entre 0 et 1, représentant ainsi
la probabilité d'activation d'un neurone ou la probabilité d'appartenance à
une classe spécifique.

R3 :
la fonction de coût mesure l'écart entre la sortie réelle et la sortie
souhaitée du réseau pour les exemples d'entraînement. Elle est
utilisée pour guider l'ajustement des poids et des biais du réseau afin
de minimiser l'erreur globale. La régularisation est une technique
utilisée pour prévenir le surajustement et favoriser une meilleure
généralisation du réseau.
2- Partie pratique
2.1/jeu de données :
Dans cette partie l'ensemble d'apprentissage est un vecteur a 5000
dimensions contient des labels de l'ensemble d'apprentissage. Pour
rendre les choses plus conformes à l'indexation MATLAB, où il n'y a
pas d'index zéro, nous avons associé le chiffre zéro à la valeur dix.
Le programme

clear ; close all; clc

size_couche_entree=400;
size_couche_cachee=25;
num_labels=10;

2.2 /affichage data :

Le programme
%% Initialization
clear ; close all; clc
%% Fixez les parametres a utiliser pour ce TP.
size_couche_entree=400;
size_couche_cahee=25;
num_labels=10;
%% Affichage des données
load('TP3data.mat');
m=size(X,1);
ch=randperm(size(X,1));
ch=ch(1:100);
traceData(X(ch, :));

«affichage des données

2.3/ représentation du modèle :
Le programme :
load('TP3poids.mat');
nn_params=[Theta1(:);Theta2(:)]

R1 :
dimensions theta1 et theta2 :

size(Theta1)= 25 lignes 401 colonnes

size(Theta2) = 10 lignes 26 colonnes

2.4/ RN A PROPAGATION AVANT EEDFORWARD) ET FONCTION DE COUT

(F Le programme de la fonction

unction g =sigmoid (z)

g = 1./(1 +exp (-z));

end

Et ajoute dans le programme :

z=[-10:10];
g = sigmoid(z)
plot(z,g)
 « Le tracé de la fonction sigmoid »
Remarque :
Le graphique montre une courbe en forme de S qui est
caractéristique de la fonction sigmoid. La courbe commence près de z
= -infini où elle s'approche de zéro, puis elle monte rapidement pour
atteindre une valeur de 0,5 lorsque z = 0. Après cela, la courbe
continue de monter plus lentement jusqu'à atteindre une valeur
proche de 1 lorsque z tend vers l'infini.
La fonction cout
Le programme :

function [J ] =
nnCost(nn_params,size_couche_entree,size_couche_cachee,num_labels,X, y,
lambda) % Le reseau de neurones Feedforward et le retour du cout dans la
variable J. % Transformer nn_params en parametres Theta1 et Theta2
Theta1 = reshape(nn_params(1:size_couche_cachee * (size_couche_entree +
1)),...
size_couche_cachee, (size_couche_entree + 1));
Theta2 = reshape(nn_params((1 + (size_couche_cachee *
(size_couche_entree + 1))):end),... num_labels,(size_couche_cachee +1))
% Definir quelques variables utiles
m = size(X, 1);
J = 0;
% ====================== Votre code ici ======================
% Construire la matrice Y des resultats
y_matrix = recode(y, num_labels);
%Effectuer une propagation en avant
a1=[ones(m,1) X];
z2=a1*Theta1';
a2=sigmoid(z2);
a2=[ones(m,1) a2];
z3=a2*Theta2';
a3=sigmoid(z3);
h_theta=a3;
J= -(1/m) * sum (sum(y_matrix.*log(h_theta)+(1-y_matrix).*log(1-
h_theta)))
 R2 : On obtient une fonction de coût J=0.2876

On obtient une fonction de coût

J=6.9315

On obtient une fonction de coût

J=234.0001

R3 :
La fonction de coût J représente l'erreur du modèle de réseau de neurones sur un
ensemble de données d'entraînement donné.

Si tous les poids des paramètres Theta1 et Theta2 sont initialisés à la même valeur, alors tous les
neurones dans le réseau produiront les mêmes sorties pour toutes les entrées. Par conséquent, la
fonction de coût J sera élevée, car le modèle ne sera pas en mesure de faire des prédictions précises
pour les données d'entrée.

2.5/afficher la couche cache :

R1:
Affichage l’image de première unité cache : 400 entrée
avec 25 couche donc chaque coche 16 entrée : Pour
afficher la 1ere unité cache :

Le programme :

figure(1) traceData(Theta1(1,2:end))%l'image correspendante a la

premiere unitee cachee figure(2)
traceData(Theta1(5,2:end))%l'image correspendante ae la 5eme
unitee cachee
figure(3) « Le tracé des données d'entraînement en 2D »
traceData(Theta1(:,2:end))%l'image correspendante a tous les
unitee
cachee de theta 1
2.6/prédiction :

La fonction prédicat

Le programme :
function p = predict(Theta1, Theta2, X)
m = size (X, 1);
num_labels = size ( Theta2 , 1);
p = zeros ( size (X, 1) , 1);
X =[zeros(m, 1) X];
h1 = sigmoid(X * Theta1');
h1 = [ones(m, 1) h1];
h2 = sigmoid(h1 * Theta2');
z3 = h1 * Theta2';
h2 = sigmoid(z3);
[~, p] = max (h2 , [], 2);
end

■Appelle à la fonction prédicat

%% predict
ind=randi(m)
Xp=X(ind,:)
Yp=y(ind);
traceData(Xp);
pred=predict(Theta1, Theta2, X);
fprintf('\nprediction du reseau de neurones:%d (digit %d
\n)',mod(pred,10),mod(Yp,10));

R1:

Calcule de la valeur de prédiction et visualiser la sortie : H = 97.52 %

R2:

sortie visualiser:

Prédiction du réseau de neurones: neurones: 3 (digit 3)

 ➢ précision
Le programme :
%% precision :
Yp=predict(Theta1, Theta2, X);
Yp=recode(Yp,10);
Yy=recode(y,10)
plotconfusion(Yy',Yp')

Conclusion
Un modèle de réseau de neurones à propagation avant est un outil puissant pour la
classification d'images. Il peut être entraîné sur un ensemble de données étiquetées
pour apprendre à reconnaître des motifs et des caractéristiques spécifiques dans les
images. Les performances du modèle peuvent être évaluées à l'aide de métriques telles
que la précision et la perte. Une fois entraîné, le modèle peut être utilisé pour prédire la
classe de nouvelles images, telles que des chiffres manuscrits, en utilisant la
propagation avant à travers le réseau.