DEEP LEARNING
Au lieu de développer l'un des modèles qu'on a vu plus tôt(arbre de décision, etc) on développe un
réseau de neurones.
1)À son invention,À l'intérieur de chaque fonction(neurone) on trouve 2 étapes:
--L'aggregation: où obtient une fonction de la forme : f=w1x1+w2x2+w3x3+...+b étant le biais
--Activation: y=1 si f≥0 ou y=0
2)plus tard un autre inventa le perception ,qui y ajouta un algorithme d'apprentissage capable d'ajourner
les valeurs des paramètres w pour une [Link] perceptron est enfaite un model linéaire dû à sa
fonction d'agrégation f(une droite),est donc n'est pas suffisant.
3) Puis des années plus tard a été inventé le perceptron multicouche composé de trois neurones (les
deux premiers donne des sorties y1 et y2) et le troisième calcul une fonction d'agrégation à partir de ces
valeurs qui n'est plus un model liné[Link] il y a donc deux couches
Pour entraîner ce model multi-couche(c'est-à-dire déterminer les bons paramètres pour chaque
fonction) l'une des techniques est la back-propagation qui consiste à déterminer comment la sortie du
model varie en fonction des paramètres(W,b) dans chaque [Link] cela on calcule une suite de
gradients qui nous permet de savoir comment la sortie varie en fonction de la dernière couche,
comment la dernière couche varie en fonction de l'avant dernière et ainsi de [Link]âce aux gradients
on peut alors mettre à jour les paramètres(W,b) de telle sorte qu'il minimise l'erreur entre la sortie et la
réponse attendue
En résumé voici le cycle utilisé pour développer des réseaux de neurones artificiels:
1) forward propagation (on obtient une sortie)
2) On calcule une fonction de coût (Cost function)
3)Backward propagation
4) Gradient descent. Puis on recommence avec des paramètres optimisés
PERCEPTRON
Il est unité de base des réseaux de [Link] s'agit d'un modèle de classification binaire capable de
séparer linéairement deux classes de [Link] fonction d'activation la plus simple étant la fonction
sigmoïde(logistique) nous permet d'accompagner chaque prédiction d'une probabilité d'appartenir a la
classe 1(plus c'est proche de la frontière plus la probabilité est basse) dont l'expression est
a(z)= 1/(1+e^(-z)) , z étant la sortie.
Le but:Maximiser la vraisemblance L en minimisant la fonction -log(L).
Descente de Gradient
minimiser la Fonction Coût (Log Loss).
Consiste à ajuster les paramètres W et b de façon à minimiser les erreurs du modèle, c'est-à-dire à
Pour ça, il faut déterminer comment est-ce que cette fonction varie en fonction des différents
paramètres.
Descente de Gradient
minimiser la Fonction Coût (Log Loss).
Consiste à ajuster les paramètres W et b de façon à minimiser les erreurs du modèle, c'est-à-dire à
Pour ça, il faut déterminer comment est-ce que cette fonction varie en fonction des différents
paramètres.
C'est pourquoi on calcule le Gradient (ou la dérivée) de la Fonction Coût.
Descente de Gradient**
Formule :
Wt+1 = Wt - α ∂L/∂Wt*
- Wt+1 :Paramètre W à l'instant t+1
- Wt :Paramètre W à l'instant t
- α :Pas d'apprentissage positif
∂L/∂Wt : Gradient à l'instant t
Fonction Convexe :
RESEAUX DE NEURONES ARTIFICIELS
Qui ne contient qu'un seul minimum.
Au lieu de faire du feature engineering,on va améliorer le model en y ajoutant
d'autres neurones.L'idée est de laisser la machine apprendre à faire son propre
feature engineering,en lui allouant des neurones dédiés à cela
Wij: paramètre associé au neurone i (Zi/Ai)et en prévenance du l'entrée j( xj)
bi: biais associé au neurone i
d'où:
z1[1]=w11[1]x1+w12x2[1]+b1[1]
a1[1]=1/(1+e^(-z1[1]))
et
z2[1]=w21[1]x1+w22[1]x2+b2[1]
a2[1]=1/(1+e^(-z2[1])) ce qui est entre crochets indique le numéro de la couche
NB: Dans Cette couche,on peut mettre autant de neurone qu'on le veut,plus on en
mettra plus le model sera puissant mais il sera aussi plus lent à entraîner
Pour la deuxième couche les entrées serons remplacées par les fonctions
d'activation de la première couche
Z1[2]= w11a1[1]+w12a2[1]+b1[2]
A1[2]=1/(1+e^(-Z1[2]))
On peut ajouter plus de neurones sur la deuxième couche et même ajouter plus de
couches juste en prenant les activations de la couche précédente en entré[Link] le
réseau est profond plus il est capable d'apprendre des choses compliquées mais il
est en même temps plus long à entraîner d'où il faut trouver le juste équilibre.
Pour implémenter de tels modèles il n'est pas pratique d'écrire les équations de
chaque [Link] va donc vectoriser ces équations afin de représenter chaque
couche par une matrice.
Z[1]=W[1] . X + b[1]
W: matrice contenant les paramteres w a pour dimension(nombre de neurones
dans la couche n[1] * nombre d'entree n[0])
X: matrice contenant les entrees a pour dimension (m*n)
b: vecteur de biais a pour dimensions(nombre de neurones n[1]*1)
A[1]=1/(1+e-Z[1]) de dimension nombre de neurones n[1] * n[0]( meme dimension que
Z[1],d'ou le les deux fonctions du neurones ont les memes dimensions)
Z[2]=W[2] .A[1]+b[2]
W[2]: dimension nombre de neurones dans la couche 2 n[2] * nombre de neurones
dans la couche 1 n[1]
b[2]: dimension nombre de neurones dans la couche 2 n[2] * 1
et ainsi de suite
si on veut ajouter un neurone dans une couche suuffit de modifier W et b
Tous ca c'est qu'on appelle la forward propagation
BACK PROPAGATION
On doit transposer nos datasets avant de travailler pour que ce soit adapter a cette
demarche(qui est plus belle)
Consite a reracer comment la fonction cout evolue de la dernierre equation jusqu'a
l premiere
1. Définir une fonction coût
L = - (1/m) Σ [ y × log(A²) + (1 - y) × log(1 - A²) ]
2. Calculer les dérivées partielles
En retracant en arriere ca donne (A² ,Z² ,A¹,Z¹)
Formules principales :
∂L/∂W� = ∂L/∂A� � ∂A�/∂Z� � ∂Z�/∂W�
∂L/∂b� = ∂L/∂A� � ∂A�/∂Z� � ∂Z�/∂b�
∂L/∂W� = ∂L/∂A� � ∂A�/∂Z� � ∂Z�/∂A� � ∂A�/∂Z� � ∂Z�/∂W�
∂L/∂b� = ∂L/∂A� � ∂A�/∂Z� � ∂Z�/∂A� � ∂A�/∂Z� � ∂Z�/∂b�
3. Mettre � jour les param�tres W et b
Mise � jour des poids :
W� = W� - α (∂L/∂W�)
W� = W� - α (∂L/∂W�)
Mise � jour des biais :
b� = b� - α (∂L/∂b�)
b� = b� - α (∂L/∂b�)
4. Calcul interm�diaire des d�riv�es
�tapes interm�diaires :
dZ� = ∂L/∂A� � ∂A�/∂Z�
∂L/∂W� = dZ� � ∂Z�/∂W�
∂L/∂b� = dZ� � ∂Z�/∂b�
dZ� = dZ� � ∂Z�/∂A� � ∂A�/∂Z�
∂L/∂W� = dZ� � ∂Z�/∂W�
∂L/∂b� = dZ� � ∂Z�/∂b�
FORMULES FINALES
dZ2 = A[2] - y
∂L/∂W[2] = (1/m) * dZ2 * A[1]^T
∂L/∂b[2] = (1/m) * Σ dZ2
dZ1 = W[2]^T * dZ2 * A[1] * (1 - A[1])
∂L/∂W[1] = (1/m) * dZ1 * X^T
∂L/∂b[1] = (1/m) * Σ dZ1
D'OU ON TIRE LES FORMULES GENERALES:
Ne pas oubliez de transposez les matrices X et y(notre dataset) avant de
commencer
1)l'initialisation des parametres
W[C] dimension n[c],n[c-1]
b[c] dimension n[c],1
2) forward propagation
Z[C]= W[C].A[C-1]+b[c]
A[C]=1/(1+e-Z[C]) on pose A[0]=X
3) La back propagation( calcul des gradients)
dZ[C FINAL]=A[C FINAL]- y
dW[C]= 1/m * dZ[C].A[C-1].T
db[c]=1/m * ∑ dZ[C] somme sur l'axe1
dZ[C-1]= W[C].T . dZ[C] * A[C-1](1-A[C-1])
4) Mise a jour des parametres
W[C]= W[C]- alpha *dW[C]
b[c] = b[c]-alpha * db[c]
import numpy as np
# Fonction d'initialisation des paramètres
parametres = {}
C = len(dimensions) # Nombre de couches (y compris entrée et sortie)
for c in range(1, C):
parametres['W' + str(c)] = [Link](dimensions[c], dimensions[c -
1])
parametres['b' + str(c)] = [Link](dimensions[c], 1)
return parametres
# Fonction de propagation avant
def forward_propagation(X, parametres):
activations = {'A0': X}
C = len(parametres) // 2 # Nombre de couches cachées
for c in range(1, C + 1):
Z = parametres['W' + str(c)].dot(activations['A' + str(c - 1)]) + parametres['b'
+ str(c)]
activations['A' + str(c)] = 1 / (1 + [Link](-Z)) # Fonction d'activation
sigmoïde
return activations
# Fonction de rétropropagation
def back_propagation(y, activations, parametres):
m = [Link][1]
C = len(parametres) // 2
dZ = activations['A' + str(C)] - y
gradients = {}
for c in reversed(range(1, C + 1)):
gradients['dW' + str(c)] = 1 / m * [Link](dZ, activations['A' + str(c - 1)].T)
gradients['db' + str(c)] = 1 / m * [Link](dZ, axis=1, keepdims=True)
if c > 1:
dZ = [Link](parametres['W' + str(c)].T, dZ) * activations['A' + str(c - 1)] *
(1 - activations['A' + str(c - 1)])
return gradients
# Fonction de mise à jour des paramètres
def update(gradients, parametres, learning_rate):
C = len(parametres) // 2
for c in range(1, C + 1):
parametres['W' + str(c)] = parametres['W' + str(c)] - learning_rate *
gradients['dW' + str(c)]
parametres['b' + str(c)] = parametres['b' + str(c)] - learning_rate *
gradients['db' + str(c)]
return parametres
import numpy as np
import [Link] as plt
from [Link] import accuracy_score
def neural_network(X, y, hidden_layers=(32, 32, 32), learning_rate=0.1,
n_iter=1000):
[Link](0)
# Initialisation des dimensions et des paramètres
dimensions = list(hidden_layers)
[Link](0, [Link][0]) # Ajouter la dimension d'entrée
[Link]([Link][0]) # Ajouter la dimension de sortie
parameters = initialization(dimensions)
train_loss = []
train_acc = []
for i in range(n_iter):
# Propagation avant
activations = forward_propagation(X, parameters)
# Rétropropagation
gradients = back_propagation(y, activations, parameters)
# Mise à jour des paramètres
parameters = update(gradients, parameters, learning_rate)
if i % 10 == 0: # Enregistrer les métriques toutes les 10 itérations
C = len(parameters) // 2
train_loss.append(log_loss(y, activations["A" + str(C)]))
y_pred = predict(X, parameters)
current_accuracy = accuracy_score([Link](), y_pred.flatten())
train_acc.append(current_accuracy)
# Visualisation des résultats
fig, ax = [Link](nrows=1, ncols=2, figsize=(18, 4))
ax[0].plot(train_loss, label="train_loss")
ax[0].legend()
ax[1].plot(train_acc, label="train_acc")
ax[1].legend()
visualisation(X, y, parameters, ax)
[Link]()
return parameters
