Université de Bouira

Faculté des sciences

Département de Informatique

Apprentissage par réseaux de neurones profonds

Introduction
BENAISSI Sellami s.benaissi@univ-bouira.dz
1
Introduction
 TP1

Dans ce TP : Nous comprendrons comment fonctionnent les

réseaux de neurones tout en en implémentant un à partir de
zéro en Python.

1 Introduction 3 Deep learning

 TP1

1 Introduction 4 Deep learning

 TP1

1 Introduction 5 Deep learning

 TP1

1 Introduction 6 Deep learning

2
!‫هيا بنا نبدأ‬
Commençons!
Let's begin!
 1. Building Blocks: Neurons
Éléments constitutifs : les neurones
Tout d’abord, nous devons parler des neurones, l’unité de base d’un réseau neuronal.
Un neurone reçoit des entrées, effectue des calculs avec elles et produit une sortie .
Voici à quoi ressemble un neurone à 2 entrées :

1 TP1 8 Deep learning

 3 choses se passent ici. 1. Building Blocks: Neurons
Éléments constitutifs : les neurones
1) Tout d’abord, chaque entrée est multipliée par un poids :

1 TP1 9 Deep learning

 3 choses se passent ici. 1. Building Blocks: Neurons
Éléments constitutifs : les neurones
2) Ensuite, toutes les entrées pondérées sont additionnées avec un biais b :

1 TP1 10 Deep learning

 3 choses se passent ici. 1. Building Blocks: Neurons
Éléments constitutifs : les neurones
2) Enfin, la somme passe par une fonction d'activation :

La fonction d'activation est utilisée pour transformer une entrée illimitée en une sortie ayant
une forme agréable et prévisible.

1 TP1 11 Deep learning

 3 choses se passent ici. 1. Building Blocks: Neurons
Éléments constitutifs : les neurones
2) Enfin, la somme passe par une fonction d'activation :

Une fonction d’activation couramment utilisée est la fonction sigmoïde :

La fonction sigmoïde ne produit que des nombres compris dans la plage ( 0 ,1 ).

- Vous pouvez considérer cela comme une compression (− ∞ ,+ ∞ ) à ( 0 ,1 )
- les gros nombres négatifs deviennent ~0, et les grands nombres positifs deviennent ~1

1 TP1 12 Deep learning

 1. Building Blocks: Neurons
Un exemple simple Éléments constitutifs : les neurones
Supposons que nous ayons un neurone à 2 entrées qui utilise la fonction d'activation
sigmoïde et possède les paramètres suivants :

W = [ 0 ,1 ]
b = 4
w=[ 0 ,1 ] c'est juste une façon d'écrire w1= 0 ,w2=1 sous forme vectorielle.

b​
x1 w1

 ( ) y​
x2 w2

1 TP1 13 Deep learning

 1. Building Blocks: Neurons
Un exemple simple Éléments constitutifs : les neurones
Maintenant, donnons au neurone une entrée de X = [ 2 ,3 ].

4​
2​ 0​

 f() y​
3​ 1

1 TP1 14 Deep learning

 1. Building Blocks: Neurons
Un exemple simple Éléments constitutifs : les neurones
Nous utiliserons le produit scalaire pour écrire les choses de manière plus concise :

Les sorties du neurone 0,999 étant donné les entrées X=[ 2 ,3 ]. C'est ça! Ce processus
consistant à transmettre des entrées pour obtenir une sortie est connu sous le nom de
feedforward .
feedforward

1 TP1 15 Deep learning

 1. Building Blocks: Neurons
Codage d'un neurone Éléments constitutifs : les neurones
Il est temps de mettre en œuvre (to implement) un neurone !
Nous utiliserons NumPy , une bibliothèque populaire et puissante pour Python, pour
nous aider à faire des mathématiques :

allons y

1 TP1 16 Deep learning

 1. Building Blocks: Neurons
Codage d'un neurone Éléments constitutifs : les neurones
import numpy as np

def sigmoid(x):
# Our activation function: f(x) = 1 / (1 + e^(-x))
return 1 / (1 + np.exp(-x))

class Neuron:
def __init__(self, weights, bias):
self.weights = weights
self.bias = bias

def feedforward(self, inputs):

# Weight inputs, add bias, then use the activation function
total = np.dot(self.weights, inputs) + self.bias
return sigmoid(total)

weights = np.array([0, 1]) # w1 = 0, w2 = 1

bias = 4 # b = 4
n = Neuron(weights, bias)

x = np.array([2, 3]) # x1 = 2, x2 = 3
print(n.feedforward(x)) # 0.9990889488055994

1 TP1 17 Deep learning

 2. Combining Neurons into a Neural Network
Combiner des neurones dans un réseau neuronal
Un réseau de neurones n’est rien d’autre qu’un ensemble de neurones connectés entre eux.
Voici à quoi pourrait ressembler un simple réseau de neurones :

Ce réseau possède :
- 2 entrées (X1 et X2 ) ,
- une couche cachée avec 2 neurones (ℎ1 et ℎ2 ) , et
- une couche de sortie avec 1 neurone (O1 ).

Notez que les entrées pour O1 sont les sorties de ℎ1 et ℎ2 - c'est ce qui en fait un réseau.

1 TP1 18 Deep learning

 2. Combining Neurons into a Neural Network
Combiner des neurones dans un réseau neuronal
Un réseau de neurones n’est rien d’autre qu’un ensemble de neurones connectés entre eux.
Voici à quoi pourrait ressembler un simple réseau de neurones :

Ce réseau possède :
- 2 entrées (X1 et X2 ) ,
- une couche cachée avec 2 neurones (ℎ1 et ℎ2 ) , et
- une couche de sortie avec 1 neurone (O1 ).

Notez que les entrées pour O1 sont les sorties de ℎ1 et ℎ2 - c'est ce qui en fait un réseau.

1 TP1 19 Deep learning

 2. Combining Neurons into a Neural Network
Combiner des neurones dans un réseau neuronal

A hidden layer is any layer between the input (first) layer and output (last) layer.
There can be multiple hidden layers

Une couche cachée est n’importe quelle couche située entre la couche
d’entrée (premiere) et la couche de sortie (derniere). Il peut y avoir
plusieurs couches cachées

1 TP1 20 Deep learning

Un exemple de : Feedforward 2. Combining Neurons into a Neural Network
Combiner des neurones dans un réseau neuronal
Utilisons le réseau illustré ci-dessous et supposons que tous les neurones ont le même poids
Dans w=[0,1] , le même parti pris b=0, et la même fonction d'activation sigmoïde. Laisser
ℎ1,ℎ2,O1 désignent les sorties des neurones qu’ils représentent.

Que se passe-t-il si nous passons l'entrée X=[ 2 ,3 ]?

1 TP1 21 Deep learning

Un exemple de : Feedforward 2. Combining Neurons into a Neural Network
Combiner des neurones dans un réseau neuronal

La sortie du réseau de neurones pour l'entrée X=[ 2 ,3 ]est 0,7216.

Assez simple, non ?
1 TP1 22 Deep learning
 2. Combining Neurons into a Neural Network
Combiner des neurones dans un réseau neuronal

Un réseau de neurones peut avoir n’importe quel nombre de couches

contenant n’importe quel nombre de neurones . L'idée de base reste
la même : transmettre la ou les entrées via les neurones du réseau
pour obtenir la ou les sorties à la fin.

1 TP1 23 Deep learning

Codage d’un RN : Feedforward 2. Combining Neurons into a Neural Network
Combiner des neurones dans un réseau neuronal
Implémentons le feedforward pour notre réseau neuronal:
import numpy as np
# ... code from previous section here
class OurNeuralNetwork:
''' A neural network with:
- 2 inputs
- a hidden layer with 2 neurons (h1, h2)
- an output layer with 1 neuron (o1)
Each neuron has the same weights and bias:
- w = [0, 1]
- - b = 0
'‘’
def __init__(self):
weights = np.array([0, 1])
bias = 0

# The Neuron class here is from the previous section

self.h1 = Neuron(weights, bias)
self.h2 = Neuron(weights, bias)
self.o1 = Neuron(weights, bias)

def feedforward(self, x):

out_h1 = self.h1.feedforward(x)
out_h2 = self.h2.feedforward(x)

# The inputs for o1 are the outputs from h1 and h2

out_o1 = self.o1.feedforward(np.array([out_h1, out_h2]))
return out_o1

network = OurNeuralNetwork()
x = np.array([2, 3])
print(network.feedforward(x)) # 0.7216325609518421

1 TP1 24 Deep learning

3
‫تدريب شبكة عصبية‬
Training a Neural Network
Entraînement d'un réseau de neurones
 3. Training a Neural Network
Entraînement d'un réseau de neurones
Disons que nous avons les mesures suivantes :

Entraîneons notre réseau à prédire le sexe d'une personne en fonction de son

poids et de sa taille :

1 TP1 26 Deep learning

Nous représenterons : 3. Training a Neural Network
- Male avec un 0 et
Entraînement d'un réseau de neurones
- Femme avec un 1
et nous déplacerons également les données pour les rendre plus faciles à utiliser :

J'ai arbitrairement choisi les montants des décalages (135 et 66 ) pour que les
chiffres soient jolis. Normalement, vous décaleriez par la moyenne.

1 TP1 27 Deep learning

 Perte Loss 3. Training a Neural Network
Entraînement d'un réseau de neurones
Avant de former notre réseau, nous avons besoin d'un moyen de quantifier ses
performances afin qu'il puisse essayer de faire « mieux ». C'est ça la perte .
Nous utiliserons la perte de MSE (the mean squared error ):

Décomposons cela :

• est le nombre d’échantillons, qui est 4 (Alice, Bob, Charlie, Diana).

• représente la variable prédite, à savoir le sexe.

• ​est la vraie valeur de la variable (la « bonne réponse »).

Par exemple, dans Alice serait 1(Femelle).

• est la valeur prédite de la variable. Cela dépend des résultats de notre réseau.

1 TP1 28 Deep learning

 Perte Loss 3. Training a Neural Network
Entraînement d'un réseau de neurones

Nous utiliserons la perte de MSE (the mean squared error ):

est connue sous le nom d’ erreur quadratique (squared error ).

Notre fonction de perte prend simplement la moyenne de toutes les erreurs
quadratiques (d'où le nom d' erreur quadratique moyenne). Plus nos prévisions sont
bonnes, plus nos pertes seront faibles !.

Meilleures prédictions = Pertes inférieures.

Training a network = trying to minimize its loss
1 TP1 29 Deep learning
Un exemple de calcul de perte 3. Training a Neural Network
Entraînement d'un réseau de neurones
Disons que notre réseau produit toujours 0- en d'autres termes, c'est sûr que tous les
humains sont des hommes. Quelle serait notre perte ?

1 TP1 30 Deep learning

Code: MSE Loss 3. Training a Neural Network
Entraînement d'un réseau de neurones
Voici un code pour calculer la perte pour nous :

import numpy as np

def mse_loss(y_true, y_pred):

# y_true and y_pred are numpy arrays of the same length.
return ((y_true - y_pred) ** 2).mean()

y_true = np.array([1, 0, 0, 1])

y_pred = np.array([0, 0, 0, 0])

print(mse_loss(y_true, y_pred)) # 0.5

1 TP1 31 Deep learning

4
2‫تدريب شبكة عصبية‬
Training a Neural Network 2
Entraînement d'un réseau de neurones2
Minimiser la perte 3. Training a Neural Network
Entraînement d'un réseau de neurones
Nous avons désormais un objectif clair : minimiser la perte du réseau neuronal.
Nous savons que nous pouvons modifier les poids (pondérations) et les biais du réseau pour
influencer ses prévisions, mais

comment pouvons-nous le faire de manière à réduire les pertes ?

1 TP1 33 Deep learning

Minimiser la perte 3. Training a Neural Network
Entraînement d'un réseau de neurones
Pour plus de simplicité, supposons que nous n'ayons qu'Alice dans notre ensemble de données :

Ensuite, la perte d'erreur quadratique moyenne est simplement l'erreur quadratique d'Alice :

1 TP1 34 Deep learning

Minimiser la perte 3. Training a Neural Network
Entraînement d'un réseau de neurones
Une autre façon d’envisager la perte est de la considérer en fonction des poids et des biais.
Étiquetons chaque poids et biais de notre réseau :

Ensuite, nous pouvons écrire la perte sous forme de fonction multivariable :

1 TP1 35 Deep learning

Minimiser la perte 3. Training a Neural Network
Entraînement d'un réseau de neurones

Imaginez que nous voulions modifier w1 . Comment la perte L changerait-elle si nous

changions w1 ?

C'est une question de dérivée partielle peut répondre.

Comment le calcule-t-on ?

1 TP1 36 Deep learning

Minimiser la perte 3. Training a Neural Network
Entraînement d'un réseau de neurones

Pour commencer, réécrivons la dérivée partielle en termes de

au lieu de :

Cela fonctionne grâce à la règle de la chaîne.

Nous pouvons calculer parce que nous avons calculé

au-dessus :

1 TP1 37 Deep learning

Minimiser la perte 3. Training a Neural Network
Entraînement d'un réseau de neurones
Voyons maintenant quoi faire avec

Comme précédemment, soit les sorties des neurones qu'ils représentent.

Alors

f est la fonction d'activation sigmoïde, vous vous souvenez ?

Puisque w1 n’affecte que h1 (pas h2 ), on peut écrire

1 TP1 38 Deep learning

Minimiser la perte 3. Training a Neural Network
Entraînement d'un réseau de neurones
Nous faisons la même chose pour

x1 le poids, et x2 est la hauteur. C'est la deuxième fois que nous voyons f'( x )(le dérivé de la
fonction sigmoïde) maintenant ! Dérivons-le :

Nous utiliserons ce joli formulaire pour f '( x ) plus tard.

1 TP1 39 Deep learning
Minimiser la perte 3. Training a Neural Network
Entraînement d'un réseau de neurones
Avaient fini! Nous avons réussi à nous effondrer en plusieurs parties on
peut calculer :

Ce système de calcul des dérivées partielles en travaillant à rebours est connu

sous le nom de rétropropagation , ou « backprop ».

Backpropagation Rétropropagation ‫االنتشار العكسي‬

1 TP1 40 Deep learning

Exemple : calcul de la dérivée
3. Training a Neural Network
partielle Entraînement d'un réseau de neurones

Nous allons continuer à faire comme si seule Alice était dans notre ensemble de données :

Initialisons tous les poids à 1 et tous les biais envers 0. Si nous effectuons une transmission
anticipée à travers le réseau, nous obtenons :

1 TP1 41 Deep learning

Exemple : calcul de la dérivée
3. Training a Neural Network
partielle Entraînement d'un réseau de neurones
Les sorties du réseau ypred =0,524 , ce qui ne favorise pas fortement les
hommes (0) ou Femme (1). Calculons ​:

Nous l'avons fait! Cela nous indique que si nous devions augmenter w1, L augmenterait un peu
en conséquence.
1 TP1 42 Deep learning
Training: Stochastic Gradient
3. Training a Neural Network
Descent Entraînement d'un réseau de neurones
Nous disposons désormais de tous les outils dont nous avons besoin pour former un
réseau de neurones ! Nous utiliserons un algorithme d'optimisation appelé descente de
gradient stochastique (SGD) qui nous indique comment modifier nos pondérations et nos
biais pour minimiser les pertes. Il s'agit essentiellement de cette équation de mise à jour :

1 TP1 43 Deep learning

Training: Stochastic Gradient
3. Training a Neural Network
Descent Entraînement d'un réseau de neurones

est une constante appelée taux d'apprentissage qui contrôle la vitesse à laquelle nous nous
entraînons. Tout ce que nous faisons c'est soustraire ​de :

•Si est positif, diminuer, ce qui fait L diminuer.

•Si est négatif, augmenter, ce qui fait L diminuer.

Si nous faisons cela pour chaque poids et biais du réseau, la perte diminuera
lentement et notre réseau s'améliorera.

1 TP1 44 Deep learning

Training: Stochastic Gradient
3. Training a Neural Network
Descent Entraînement d'un réseau de neurones

Notre processus de formation (Entraînement) ressemblera à ceci :

1) Choisissez un échantillon dans notre ensemble de données. C'est ce qui en fait une

descente de gradient stochastique : nous n'opérons que sur un échantillon à la fois.

2) Calculer toutes les dérivées partielles de perte par rapport aux poids ou aux biais

(par exemple ​, etc).

3) Utilisez l'équation de mise à jour pour mettre à jour chaque poids et biais.

4) Revenez à l'étape 1.

1 TP1 45 Deep learning

code : un réseau neuronal complet 3. Training a Neural Network
Entraînement d'un réseau de neurones
Il est enfin temps de mettre en œuvre un réseau de neurones complet :

1 TP1 46 Deep learning

 code : un réseau neuronal complet 3. Training a Neural Network
Entraînement d'un réseau de neurones
import numpy as np
def sigmoid(x):
# Sigmoid activation function: f(x) = 1 / (1 + e^(-x))
return 1 / (1 + np.exp(-x))
def deriv_sigmoid(x):
# Derivative of sigmoid: f'(x) = f(x) * (1 - f(x))
fx = sigmoid(x)
return fx * (1 - fx)

def mse_loss(y_true, y_pred):

# y_true and y_pred are numpy arrays of the same length.
return ((y_true - y_pred) ** 2).mean()

class OurNeuralNetwork:
''' A neural network with:
2 inputs
- a hidden layer with 2 neurons (h1, h2)
- an output layer with 1 neuron (o1)

*** DISCLAIMER ***: The code below is intended to be simple and educational, NOT optimal. Real neural net code looks
nothing like this. DO NOT use this code. Instead, read/run it to understand how this specific network works. '‘’
def __init__(self):
# Weights
self.w1 = np.random.normal()
self.w2 = np.random.normal()
self.w3 = np.random.normal()
self.w4 = np.random.normal()
self.w5 = np.random.normal()
self.w6 = np.random.normal()

# Biases
self.b1 = np.random.normal()
self.b2 = np.random.normal()
self.b3 = np.random.normal()

1 TP1 47 Deep learning

code : un réseau neuronal complet 3. Training a Neural Network
Entraînement d'un réseau de neurones
def feedforward(self, x):
# x is a numpy array with 2 elements.
h1 = sigmoid(self.w1 * x[0] + self.w2 * x[1] + self.b1)
h2 = sigmoid(self.w3 * x[0] + self.w4 * x[1] + self.b2)
o1 = sigmoid(self.w5 * h1 + self.w6 * h2 + self.b3)
return o1

def train(self, data, all_y_trues):

''' - data is a (n x 2) numpy array, n = # of samples in the dataset. - all_y_trues is a numpy array with n
elements. Elements in all_y_trues correspond to those in data. '‘’
learn_rate = 0.1 epochs = 1000 # number of times to loop through the entire dataset
for epoch in range(epochs):
for x, y_true in zip(data, all_y_trues):
# --- Do a feedforward (we'll need these values later)
sum_h1 = self.w1 * x[0] + self.w2 * x[1] + self.b1
h1 = sigmoid(sum_h1)

sum_h2 = self.w3 * x[0] + self.w4 * x[1] + self.b2

h2 = sigmoid(sum_h2)

sum_o1 = self.w5 * h1 + self.w6 * h2 + self.b3

o1 = sigmoid(sum_o1)
y_pred = o1

# --- Calculate partial derivatives.

# --- Naming: d_L_d_w1 represents "partial L / partial w1"
d_L_d_ypred = -2 * (y_true - y_pred)

# Neuron o1
d_ypred_d_w5 = h1 * deriv_sigmoid(sum_o1)
d_ypred_d_w6 = h2 * deriv_sigmoid(sum_o1)
d_ypred_d_b3 = deriv_sigmoid(sum_o1)
d_ypred_d_h1 = self.w5 * deriv_sigmoid(sum_o1)
d_ypred_d_h2 = self.w6 * deriv_sigmoid(sum_o1)

1 TP1 48 Deep learning

code : un réseau neuronal complet 3. Training a Neural Network
Entraînement d'un réseau de neurones
# Neuron h1
d_h1_d_w1 = x[0] * deriv_sigmoid(sum_h1)
d_h1_d_w2 = x[1] * deriv_sigmoid(sum_h1)
d_h1_d_b1 = deriv_sigmoid(sum_h1)

# Neuron h2
d_h2_d_w3 = x[0] * deriv_sigmoid(sum_h2)
d_h2_d_w4 = x[1] * deriv_sigmoid(sum_h2)
d_h2_d_b2 = deriv_sigmoid(sum_h2)

# --- Update weights and biases

# Neuron h1
self.w1 -= learn_rate * d_L_d_ypred * d_ypred_d_h1 * d_h1_d_w1
self.w2 -= learn_rate * d_L_d_ypred * d_ypred_d_h1 * d_h1_d_w2
self.b1 -= learn_rate * d_L_d_ypred * d_ypred_d_h1 * d_h1_d_b1

# Neuron h2
self.w3 -= learn_rate * d_L_d_ypred * d_ypred_d_h2 * d_h2_d_w3
self.w4 -= learn_rate * d_L_d_ypred * d_ypred_d_h2 * d_h2_d_w4
self.b2 -= learn_rate * d_L_d_ypred * d_ypred_d_h2 * d_h2_d_b2

# Neuron o1
self.w5 -= learn_rate * d_L_d_ypred * d_ypred_d_w5
self.w6 -= learn_rate * d_L_d_ypred * d_ypred_d_w6
self.b3 -= learn_rate * d_L_d_ypred * d_ypred_d_b3

# --- Calculate total loss at the end of each epoch

if epoch % 10 == 0:
y_preds = np.apply_along_axis(self.feedforward, 1, data)
loss = mse_loss(all_y_trues, y_preds)
print("Epoch %d loss: %.3f" % (epoch, loss))

1 TP1 49 Deep learning

code : un réseau neuronal complet 3. Training a Neural Network
Entraînement d'un réseau de neurones
# Define dataset
data = np.array([ [-2, -1], # Alice
[25, 6], # Bob
[17, 4], # Charlie
[-15, -6], # Diana ])
all_y_trues = np.array([ 1, # Alice
0, # Bob
0, # Charlie
1, # Diana ])

# Train our neural network!

network = OurNeuralNetwork()
network.train(data, all_y_trues)

Notre perte diminue régulièrement à mesure que le réseau apprend :

1 TP1 50 Deep learning

code : un réseau neuronal complet 3. Training a Neural Network
Entraînement d'un réseau de neurones
Nous pouvons désormais utiliser le réseau pour prédire les sexes :

# Make some predictions

emily = np.array([-7, -3]) # 128 pounds, 63 inches
frank = np.array([20, 2]) # 155 pounds, 68 inches
print("Emily: %.3f" % network.feedforward(emily)) # 0.951 - F
print("Frank: %.3f" % network.feedforward(frank)) # 0.039 - M

1 TP1 51 Deep learning