Intelligence artificielle

1 Prof KHALD Anisse

▶6
2Hard clustering
Les Algorithmes
▶ 0 Soft ou fuzzy clustering

▶ K-Means
▶ Groupement
hiérarchiques
▶ Règles d’association
▶ Les algorithmes d’a priori

Naive Bayes
Régression logistique
K-NN
Arbres de décision
Random Forest
Support Vector Machine Les réseaux de
neurones
3 Concepts

Il y a le neurone
… puis un réseau de neurones

C’est quoi alors le Deep ?

Et où est l’apprentissage dans tout ça ?

4 Un neurone
 5 Histoire
1943 : (Mc Culloch (neuro-physiologiste) et Pitts (logicien)) proposent les
premi`eres notions de neurone formel.
1959 : (Rosenblatt) définit un réseau de neurones avec une couche d’entrée et une
sortie.
1960 : (Widrow et Hoff) ADALINE
1969 : (Minsky, Papert) Problème XOR
1986 : (Rumelhart et. al) MLP et backpropagation
1992 : (Vapnik et. al) SVM
1998 : (LeCun et. al) LeNet
2010 : (Hinton et. al) Deep Neural Networks
2012 : (Krizhevsky, Hinton et. al) AlexNet, ILSVRC’2012, GPU - 8 couches 2014
GoogleNet - 22 couches
2015 : Inception (Google) - Deep Dream
2016 : ResidualNet (Microsoft/Facebook) - 152 couches
6 Histoire
7 Perceptron

Un perceptron est une unité fondamentale d'un réseau de neurones artificiels. Il a été
introduit par Frank Rosenblatt en 1957. Un perceptron prend plusieurs entrées
pondérées, effectue une somme pondérée de ces entrées, ajoute un biais, et applique
ensuite une fonction d'activation pour produire une sortie.

f (x1, . . . , xn) = a1 x1 + a2 x2 + · · · + an xn
8 Missions

L'idée principale derrière un perceptron est de modéliser

une décision binaire (0 ou 1) en ajustant les poids et le biais
pendant l'apprentissage.
Un seul perceptron est limité dans sa capacité à résoudre
des problèmes complexes, mais en combinant plusieurs
perceptrons dans des couches multiples, on obtient un
réseau de neurones plus puissant, capable d'apprendre des
tâches complexes.
 9 entraîner un perceptron, c'est-à-dire apprendre les poids de connexion, nous allons
Pour
chercher à minimiser l'erreur de prédiction sur le jeu d'entraînement.
Nous pourrions faire ça de manière explicite, comme dans le cas de la méthode des
moindres carrés pour la régression linéaire ; cependant ce n'est vraisemblablement pas
comme ça qu'un réseau de neurones biologiques fonctionne.
10 principes

Le principe du perceptron linéaire est de prendre des valeurs en entrées, de faire un

calcul simple et de renvoyer une valeur en sortie. Les calculs dépendent de
paramètres propres à chaque perceptron.
Le calcul effectué par un perceptron se décompose en deux phases : un calcul par une
fonction linéaire f , suivi d’une fonction d’activation.
Exemple :
Voici un perceptron à deux entrées. Il est défini par les poids a = 2 et b = 3.

f (x , y) = 2x + 3 y.
Exemple
11

Evaluation :
Utilisons ce perceptron comme une fonction. Que
renvoie le perceptron pour la valeur d’entrée (x ,
y) = (4, −1) ? On calcule f (x , y) = 2x + 3 y = 5.
Comme f (x , y) ⩾ 0, alors la valeur de sortie est
donc F (x , y) = 1.
Recommençons avec (x , y) = (−3, 1). Cette
fois f (x , y) = −3 < 0 donc F (x , y) = 0.
L’entrée (x , y) = (6, −4) est « à la limite » car
f (x , y) = 0 (0 est l’abscisse critique pour la
fonction marche de Heaviside). On a F (x , y)
= 1.
12 Exemple

Trouver le perceptron qui sépare les cercles bleus et

les carrées rouges.
Il s’agit donc de trouver les deux poids a et b d’un
perceptron, dont la fonction associée F vérifie F (x ,
y) = 1 pour les coordonnées des carrés et F (x , y) = 0
pour les ronds.
13 Biais – Perceptron affine

Pour l’instant notre perceptron à deux entrées sépare le plan en deux parties selon une droite passant
par l’origine. Nous allons plus loin avec le perceptron affine.
On modifie la définition du perceptron, sans changer le nombre d’entrées, mais en ajoutant un poids
supplémentaire. Dans le cas de n entrées il y a donc n + 1 poids :
• les coefficients a1, . . . , an ∈ R,
• et le biais a0 ∈ R,
qui définissent la fonction affine :
f (x1, . . . , xn) = a1 x1 + a2 x2 + · · · + an xn + a0
Perceptron affine ou neurone artificiel
14

Un perceptron affine à deux entrées

sépare donc le plan en deux parties,
la frontière étant la droite d’équation

ax + b y + c = 0. D’un côté de cette

droite la fonction F vaut 1, de l’autre
elle vaut 0.
15 Résumé
❑ le perceptron linéaire ou neurone artificiel, a un biais qui vaut 0, à la différence du
perceptron affine pour lequel le biais est un réel quelconque ;
❑ les poids (weights) ou paramètres sont les coefficients a1, . . . , an auxquels s’ajoute le
biais (bias) (dans ce livre le biais est l’un des poids, ce qui n’est pas toujours le cas dans la
littérature) ;
❑ un perceptron est la donnée des poids et d’une fonction d’activation ;
❑ chaque perceptron définit une fonction F qui est la composée d’une fonction affine f et
d’une fonction d’activation H ; la fonction d’activation la plus utilisée dans ce chapitre est
la fonction marche de Heaviside (step function) ;
❑ on utilise un perceptron lors d’une évaluation :
❑ pour une entrée (input) (x1, . . . , xn) ∈ Rn, on calcule la sortie (output)
❑ F (x1, . . . , xn) ∈ R (qui vaut 0 ou 1 dans le cas de la fonction marche de Heaviside).
16 Résumé
 17 Exercice N° 2 : régression linéaire (Rappel)
model = SGDRegressor(max_iter=100, random_state=42)
import numpy as np
errors =[]
import [Link] as plt
A=[]
X = 4* [Link](500,1)
b=[]
Y= 3 * X + 2 + 5* [Link](500,1)
for i in range(100):
[Link](X,Y)
model.partial_fit(X_train, y_train.flatten())
from sklearn.linear_model import SGDRegressor y_pred = [Link](X_test)
from sklearn.model_selection import train_test_split eqm= mean_squared_error(y_test, y_pred)
from [Link] import mean_squared_error [Link](eqm)
[Link](model.coef_[0])
[Link](model.intercept_)
[Link](errors)
Données [Link](b)
[Link](A)
[Link](X,Y, cmap='summer')
[Link](X, A*X +b, lw=3, c='y')

A erreur
b
18
19 Exercice N°1 :

Rappel : La fonction d’activation ReLU

La fonction Rectified Linear Unit (ReLU) est une fonction d'activation couramment utilisée
dans les réseaux de neurones artificiels, notamment dans les couches cachées. La fonction
ReLU est définie comme suit :
ReLU(x)=max(0,x) En d'autres termes, pour une valeur d'entrée x, la fonction ReLU
renvoie x si x est positif, sinon elle renvoie 0.
Graphiquement, cela ressemble à une ligne droite pour les valeurs positives de x, et à 0
pour les valeurs négatives.
La fonction ReLU est préférée dans de nombreux cas en raison de sa simplicité et de sa
capacité à introduire une non-linéarité dans le modèle, ce qui est crucial pour permettre
aux réseaux de neurones d'apprendre des motifs complexes.
20 Exercice N°1 : (suite)

Voici un réseau de neurones à deux couches : 2 neurones (perceptrons linéaires) sur la

première couche (ayant pour fonction d’activation la fonction ReLU), 1 neurone
(perceptron affine) sur la seconde couche (de fonction d’activation H).
21 Exercice N°1 : (suite)

Si x = 4 et y = 7 alors on calcule la sortie de chaque neurone de la première couche.

Ces sorties sont les entrées du neurone de la seconde couche. Pour le premier
neurone, on effectue le calcul 2 · 4 + (−1) · 7 = 1 ⩾ 0, le réel étant positif la fonction
ReLU le garde inchangé : le premier neurone renvoie la valeur s1 = 1.
Le second neurone effectue le calcul (−3) · 4 + 2 · 7 = 2 ⩾ 0 et renvoie s2 = 2. Le
neurone de la couche de sortie reçoit en entrées s1 et s2 et effectue le calcul 4 · 1 + 5 ·
2 − 1 = 13 ⩾ 0. La fonction d’activation étant H, ce neurone renvoie 1. Ainsi F (4, 7) =
1.
22 Travail à faire :
Pour le réseau de neurones représenté ci-dessous, calculer les valeurs de sortie (Y1, Y2) pour
chacune des entrées (x , y, z) suivantes :
(0, 0, 0) (1, 0, 0) (1, −1, 1) (3, 2, 1)
23 Le perceptron linéaire : inconvénients

Le perceptron linéaire ne peut apprendre que des fonctions linéaires. Cela signifie qu'il est
limité dans sa capacité à modéliser des relations non linéaires entre les entrées et les
sorties. Des problèmes plus complexes peuvent nécessiter des modèles plus sophistiqués.
=> linéarité
Le perceptron linéaire n'a pas de couches cachées, ce qui limite sa capacité à apprendre
des représentations hiérarchiques des données. Les réseaux de neurones profonds avec
des couches cachées sont souvent plus adaptés pour capturer des caractéristiques
complexes. => Absence de couches cachées

Ces limitations ont conduit au développement de modèles de réseaux de neurones plus

complexes, tels que les réseaux de neurones multicouches (MLP) avec des fonctions
d'activation non linéaires, qui peuvent surmonter certains des inconvénients du
perceptron linéaire.
 Le perceptron multi couches
24
MLP
Le25perceptron multicouche
MLP

Un réseau de neurones artificiel permet de

développer un modèle en utilisant un algorithme
d’optimisation pour minimiser les erreurs entre
le modèle et les données.
Un MLP est un type de réseau de neurones
artificiels composé de plusieurs couches de
neurones, chacune connectée à la couche
suivante.
Chaque couche, à l'exception de la dernière, est
composée de neurones qui utilisent une fonction
d'activation non linéaire.
26 Les fonctions d’activations
Apporte une non-linéarité dans le réseau
Situé à l’interne, ou en sortie
Considérations :
difficulté d’entraînement (son gradient)
comportement se rapproche
de ce que l’on cherche à prédire (probabilités, onehot
vector, angles, déplacements, etc.)
action particulière (gating)
temps de calcul
27 Les fonctions d’activations
28 Caractéristique des AF

Monotones
Non linéaires
Squashing Functions
La
29 minimisation d’erreur
30 Exercice 2 : un perceptron
Erreur + minimisation
31

Démonstration
32

minimisation

La fonction calcul d’erreur

normalisation
 Pseudo-code
33
 34

Initialisation

Construction du modèle

Calculer l’erreur

La descente de gradient

La mise à jour des poids et biais

35
Fonctions
36
37
38

Frontière de décision
39 Travail à faire :
Charger la base de données IRIS à l’aide de sklearn
Afficher les 10 première lignes de la base de données
Afficher les détails de cette base de données (moyenne, variance, les
colonnes, …)
Créer un perceptron linéaire.
Construire un modèle d’apprentissage en se basant sur ce réseau.
Réaliser le test sur 20% de cette BD
Afficher le graphe de la minimisation d’erreur et le taux de la bonne
classification.
Tracer la matrice de confusion (heatmap)
Calculer la valeur de F1 score et le facteur R2.
40 Les algorithmes d’apprentissage
- performance-
Les algorithmes de machine learning sont nombreux.
Vous avez peut-être déjà entendu parler de régression linéaire, de
kNN (algorithme des k plus proches voisins), de réseaux de
neurones ou de random forests (forêts aléatoires).
La plupart de ces algorithmes ont des hyperparamètres, comme le
nombre k de voisins dans le kNN, et la pente et le biais de la
régression linéaire qu’il faut se fixer.
41 Un modèle d’apprentissage
Ce que vous voulez vraiment, c’est construire un modèle qui vous donne de bons résultats. Mais
qu’est-ce que ça veut dire, exactement ?

Un bon modèle de machine learning, c’est un modèle qui généralise.

La généralisation, c’est la capacité d’un modèle à faire des prédictions non seulement sur les
données que vous avez utilisées pour le construire, mais surtout sur de nouvelles données : c’est
bien pour ça que l’on parle d’apprentissage !

Évaluer un modèle sur le jeu de données sur lequel on l’a construit ne nous permet donc pas du tout
de savoir comment il se comportera sur de nouvelles données, celles sur lesquelles il est vraiment
intéressant de faire de la prédiction.
42 Overfitting

Un modèle qui sur-apprend est un modèle

qui est trop complexe par rapport à la
réalité qu’il essaie de représenter.

Nous avons tendance à préférer des

modèles simples ; c’est le principe du
rasoir d’Ockham (ou Occam), selon lequel
les hypothèses suffisantes les plus simples
sont les plus vraisemblables
43 Underfitting

Il faut néanmoins aussi éviter les modèles

trop simples, qui ne parviendront pas à
bien représenter le phénomène qui nous
intéresse, et qui ne feront pas de bonnes
prédictions.

On parle dans ce cas de

"sous-apprentissage".
44

Ce modèle fait des erreurs sur le jeu

d’apprentissage, mais il va probablement
mieux généraliser
 • Faible nombre de paramètres
• Moins de risque d'overfittings
• Moins de sensibilité aux fluctuations des données
45 • Facilité d'interprétation

Compromis biais-variance : biais-variance trade-off

Un modèle simple (variance faible) risque le
sous-apprentissage (biais élevé y compris sur les
données d’entraînement).
Un modèle complexe (variance élevée) risque le
sur-apprentissage (biais faible sur les données
d’entraînement mais élevé sur de nouvelles
données).
On souhaite trouver un modèle intermédiaire, vers
le creux de la courbe orange, là où le biais de
prédiction est le plus faible et la généralisation la
meilleure.
46 Résumé

• En apprentissage supervisé, le but est de produire des modèles qui généralisent, c’est-
à-dire qui sont capables de faire de bonnes prédictions sur de nouvelles données
• De bonnes performances sur le jeu d’entraînement ne garantissent pas que le modèle
sera capable de généraliser !
• On cherche à développer un modèle qui soit suffisamment complexe pour bien capturer
la nature des données (et éviter ainsi le sous-apprentissage), mais suffisamment simple
pour éviter le sur-apprentissage.
• Attention aux contraintes de temps de calcul et aux ressources en mémoire !
47

Comment peut-on mesurer la performance

d’un modèle sur des données inconnues ?
Jeux
48 d’entraînement
et de test

On sépare le jeu de données en

un jeu d’entraînement et un jeu
de test.
Le jeu de test n’est pas utilisé
pour entraîner le modèle, mais
uniquement pour l’évaluer.
Ici les deux jeux font la même
taille mais ce n’est pas
obligatoire !

X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.2)

La
49 validation

croisée
Une cross-validation à 5 folds :
Chaque point appartient à 1 des
5 jeux de test (en blanc) et aux 4
autres jeux d’entraînements (en
orange)

stratified_kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=42)

cross_val_scores = cross_val_score(rf_classifier, X, y, cv=stratified_kfold, scoring='accuracy')
50

Si l’on ne répartit pas les points

positifs de manière équilibrée
entre les différents folds, les jeux
d’entraînement et de test auront
des proportions différentes de
positifs et négatifs, ce qui peut
biaiser les résultats

Dans scikit-learn, la méthode model_selection.StratifiedKFold permet de créer les folds d’une validation croisée
stratifiée.

stratified_kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=42)

51

stratified_kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=42)

cross_val_scores = cross_val_score(model, X, y, cv=stratified_kfold, scoring='accuracy')

for train_index, test_index in stratified_kfold.split(X, y):

X_train, X_test = X[train_index], X[test_index]
y_train, y_test = y[train_index],y[test_index]
stratified_kfoldprint("Moyenne des scores de la validation croisée:", cross_val_scores.mean())
52 Matrice de confusion

On classe les résultats en 4 catégories :

•True Positive (TP) : la prédiction et la valeur réelle sont positives.

Exemple : Une personne malade et prévu malade.

•True Negative (TN) : la prédiction et la valeur réelle sont négatives.

Exemple : Une personne saine et prévu saine.

•False Positive (FP) : la prédiction est positive alors que la valeur réelle est négative.
Exemple : Une personne saine et prévu malade.

•False Negative (FN) : la prédiction est négative alors que la valeur réelle est négative.
•Exemple : Une personne malade et prévu saine.
Matrice
53 de confusion
Exemple 1

Bien évidemment, on peut

ajouter des lignes et des
colonnes à cette matrice dans
des cas plus complexes.
Application
54

IRIS DB
55 Précision & Rappel
La précision est le nombre de documents pertinents retrouvés
rapporté au nombre de documents total proposé pour une
requête donnée

Le rappel est défini par le nombre de documents pertinents

retrouvés au regard du nombre de documents pertinents que
possède la base de données.
56
Problème
57 de KNN
58
59
60
61
62
63
64
65
66
ROC
67 curve
Le
68 seuil
Exemple
69 du chois
de seuil
70
71
 72 Résumé

• De nombreux modèles de classification retournent des valeurs réelles, qui peuvent souvent être
interprétées comme la probabilité que le point appartient à la classe positive.
• Dans ce cas, il faut se fixer un seuil sur cette valeur réelle pour séparer les négatifs des positifs.
• La courbe ROC permet de visualiser comment la spécificité et la sensibilité d’un modèle évolue en fonction
de ce seuil.
• L’AUROC permet de résumer la courbe ROC en un seul nombre : l’aire sous cette courbe.

[Link]
s
Comparaison
73 entre
algorithmes de
classification
Jeu de données
74

Voitures d’occasion et voitures

neuves.
Dans la situation 1, les voitures
neuves sont difficiles à distinguer
des voitures d’occasion.
Dans la situation 2, les voitures
neuves sont toutes des voitures
de sport et les voitures
d’occasion sont toutes des
citadines

C'est ce qu'on appelle parfois un "jeu de

données faciles" : tous les algorithmes
classiques donnent de bonnes
performances.
 Exemple
75 : IRIS DB
from sklearn import datasets
from sklearn.model_selection import train_test_split
from [Link] import precision_score, confusion_matrix, r2_score, f1_score
from sklearn.neural_network import MLPClassifier
from [Link] import DecisionTreeClassifier
from sklearn.naive_bayes import GaussianNB

iris = datasets.load_iris()
X = [Link]
y = [Link]

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

models = {
"réseau de neurones": MLPClassifier(max_iter=1000),
"arbre de décision": DecisionTreeClassifier(),
"classification bayésienne": GaussianNB()
}
 # Entraîner chaque modèle et calculer les métriques d'évaluation
for name, model in [Link]():
[Link](X_train, y_train)
76 y_pred = [Link](X_test)

print(f"Modèle: {name}")
print(f"Précision: {precision_score(y_test, y_pred, average='weighted')}")
print(f"Matrice de confusion:\n {confusion_matrix(y_test, y_pred)}")
print(f"R2: {r2_score(y_test, y_pred)}")
print(f"F1-score: {f1_score(y_test, y_pred, average='weighted')}\n")

Modèle: arbre de décision

Précision: 1.0
Matrice de confusion:
[[10 0 0]
Modèle: classification bayésienne
[ 0 9 0]
Précision: 1.0
Modèle: réseau de neurones [ 0 0 11]]
Matrice de confusion:
Précision: 1.0 R2: 1.0
[[10 0 0]
Matrice de confusion: F1-score: 1.0
[ 0 9 0]
[[10 0 0] [ 0 0 11]]
[ 0 9 0] R2: 1.0
[ 0 0 11]] F1-score: 1.0
R2: 1.0
F1-score: 1.0
77
Quiz
5 questions
78 Question 1 :

Vous devez implémenter un algorithme de détection de transactions

frauduleuses. Les transactions frauduleuses que votre algorithme ne détectera
pas coûteront plus cher à la banque que le coût de traitement d'une transaction
non frauduleuse prédite comme fraude.
Dans la mesure du raisonnable, vous devez donc minimiser le taux de :
∙ Vrai négatif
∙ Faux négatif
∙ Faux positif
∙ Vrai positif
79 Question 2

Un algorithme de classification binaire naïf retourne toujours la classe

"positif". On l'évalue sur un jeu de données contenant 80% de "positif" et 20%
de "négatif".
Quelles seront sa précision et son recall ?

∙ précision = 100%,recall = 100%

∙ précision = 80%,recall = 20%
∙ précision = 100%,recall = 20%
∙ précision = 80%,recall = 100%
Question
80 3:

On évalue deux modèles dont le but est de classer des baies entre celles qui sont comestibles et celles qui ne le
sont pas. On obtient les deux matrices de confusion suivantes :

Algorithme 1 : Algorithme 2 :
comestible non comestible comestible non comestible

prédit comestible 100 3 prédit comestible 96 0

prédit non comestible 0 97 prédit non 4 100

comestible

Quel est selon-vous l'algorithme le plus intéressant ?

∙ Algo 1
∙ Algo 2
Question
81 4:
D'après la courbe ROC ci-dessous,
quel est le taux de faux négatif le plus
bas que l'on puisse avoir si on veut
une spécificité au moins égale à 0.8 ?
0.7
0.3
0
Question
82 5:

D'après la courbe Précision-Rappel ci-dessous,

quel est le taux de faux négatif le plus bas que
l'on puisse avoir si on veut une précision au
moins égale à 0.4 ?
0.4
1
0.6
83
Reconnaissance de chiffres
TensorFlow
84 Exemples
 85

La base est formée de 60 000 données

d’apprentissage et de 10 000 données de test.
Chaque donnée est de la forme : [une image, le
chiffre attendu].
Chaque image est de taille 28 × 28 pixels, chaque
pixel contenant un des 256 niveaux de gris
(numérotés de 0 à 255).
Ces données sont accessibles très simplement
avec tensorflow/keras :
from [Link] import mnist
(X_train_data,Y_train_data),(X_test_data,Y_test_data) = mnist.load_data()
86 Le chiffre 5
87

Donnée d’entrée. En entrée du réseau de neurones, nous devons

avoir un vecteur. Au départ chaque image est un tableau de taille
28 × 28 ayant des entrées entre 0 et 255. Nous la transformons en
un vecteur de taille 784 = 282 et nous normalisons les données
dans l’intervalle [0, 1] (en divisant par 255).
88

Donnée de sortie. Notre réseau de neurones ne va pas renvoyer le chiffre attendu, mais
une liste de 10 probabilités. Ainsi chaque chiffre doit être codé par une liste de 0 et de 1.
0 est codé par (1, 0, 0, 0, 0, 0, 0, 0, 0, 0),
1 est codé par (0, 1, 0, 0, 0, 0, 0, 0, 0, 0),
2 est codé par (0, 0, 1, 0, 0, 0, 0, 0, 0, 0),
...
9 est codé par (0, 0, 0, 0, 0, 0, 0, 0, 0, 1).
89

Fonction. Nous cherchons une fonction F : R784 → R10, qui à un

vecteur-image associe une liste de probabilités, telle que F (Xi) ≃ Yi pour
nos données transformées (Xi , Yi ), i = 1, . . . , 60 000.
Par exemple la fonction F , évaluée sur un vecteur-image X peut renvoyer

Dans ce cas, le nombre le plus élevé est 0 .61 au rang 6, cela signifie que
notre fonction F prédit le chiffre 6 avec une probabilité de 61%, mais cela
pourrait aussi être le chiffre 5 qui est prédit à 22%. Les autres chiffres
sont peu probables.
90
91 Programme

Voici le code complet du programme qui sera commenté plus loin.

92
93 Relu

La fonction d'activation de l'unité linéaire rectifiée (ReLU) introduit la propriété de la non-linéarité à un

modèle d'apprentissage profond et résout le problème des gradients de fuite.
Il interprète la partie positive de son argumentation. C'est l'une des fonctions d'activation les plus
populaires dans l'apprentissage profond.
94 Problèmes résolus par ReLU

• Problème de disparition de gradient : L’algorithme progresse vers les couches inférieures

du réseau, rendant les gradients de plus en plus petits. La mise à jour donc par descente
de gradient ne modifie que très peu les poids des connexions de la couche inférieur,
empêchant une bonne convergence de l’entrainement vers la solution.

• Problème d’explosion du gradient : Dans ce cas-ci, les gradients deviennent de plus en

plus grands. Les couches reçoivent alors de trop gros poids, faisant diverger l’algorithme.
 95 Performance

•Robustesse : Certaines méthodes peuvent être plus

robustes aux hyperparamètres, comme le taux
d'apprentissage, que d'autres. Par exemple, Adam a
tendance à être moins sensible au choix du taux
d'apprentissage.

•Complexité : Les méthodes plus sophistiquées,

comme Adam, peuvent être plus complexes à mettre
en œuvre et à ajuster, mais peuvent offrir de
meilleures performances dans certaines situations.
96 Adam
97 L’erreur

La fonction de perte permet de calculer l’erreur entre les prédictions de ton modèle et les
valeurs réelles.
Plus la perte baisse, plus le modèle est performant !
Pendant l’entraînement, cela permet au modèle de savoir s’il avance dans la bonne
direction ou non.
L’objectif étant que perte soit le plus proche possible de zéro.
Cependant, il y a plusieurs manière de calculer l’erreur entre les prédictions et les valeurs
réelles.
98 Binary Cross Entropy

L’entropie croisée est une mesure qui peut être utilisée pour refléter la précision des
prévisions probabilistes. L’entropie croisée est étroitement liée à l’estimation de la
vraisemblance maximale.
La fonction de perte Cross Entropy est sûrement celle dont tu auras le plus besoin. Elle est
utilisée en classification Binaire ET en classification multi-classes !

Chaque image est représentée ainsi : [1, 0] pour les chats et [0, 1] pour les chiens.
• Si une de tes images représente un chien et que ton modèle prédit que c’est un chien avec
0.85% de confiance, le calcul de la perte est le suivant :

• Binary Cross Entropy = -(0 x log(0.15) + 1 x log(0.85)) = 0.07

99
100 Apprentissage
101
102
103

Matrice de confusion
104
105
106 Questions

Pourquoi évaluer le modèle sur les données de test?

Que signifie la fonction Flatten() ?
Pourquoi utiliser la fonction Softmax dans la couche de sortie?
Quelle est la différence entre précision et accuracy?
Que représentent les valeurs dans la diagonale de la matrice de confusion ?
 Les Réseaux de neurones
107
Convolutifs
108

Les ensembles de données d'analyse comparative de l'apprentissage

automatique tels que la base de données MNIST de chiffres manuscrits
conviennent à la plupart des formes d'ANN, en raison de sa dimensionnalité
d'image relativement petite de seulement 28 × 28.
Avec cet ensemble de données, un seul neurone dans la première couche
cachée contiendra 784 poids ( 28 × 28 × 1 où 1 sachez que MNIST est normalisé
à des valeurs en noir et blanc uniquement), ce qui est gérable pour la plupart
des formes d'ANN.
109
Si vous considérez une entrée d'image colorée plus substantielle de64 × 64,
le nombre de poids sur un seul neurone de la première couche augmente
sensiblement à 12288.
Donc, le réseau ANN doit être beaucoup plus grand que celui utilisé pour
classer les chiffres MNIST.

Lena
(a) red channel a besoin de 4096 neurones;
(b) green channel a besoin de 4096 neurones;
(c) blue channel a besoin de 4096 neurones;
______________________________________
Total 12288 neurones
110
Pourrions nous augmenter le nombre neurones et le nombre de couches cachées dans notre
réseau ? La réponse à cette question est non.

Ceci est dû à deux raisons:

1) Le problème le réseaux devient énormes et ne peut pas avoir une puissance et le temps de calcul devient
illimité.
2) L'arrêt ou la réduction des effets du surajustement. Le surapprentissage est essentiellement lorsqu'un
réseau est incapable d'apprendre efficacement en raison d'un certain nombre de les raisons. C'est un
concept important de tous les algorithmes d'apprentissage automatique, et il est important que toutes les
précautions soient prises pour réduire ses effets.

nombre de couches cachées

le nombre neurones
111
•Si nos modèles devaient montrer des signes de surajustement, nous
pourrions voir une réduction de capacité à identifier les fonctionnalités
généralisées non seulement pour notre ensemble de données
d'entraînement, mais également nos ensembles de test et de prédiction.
•C'est la raison principale de la réduction de la complexité de nos réseaux
de neurones artificiels.
•Le moins paramètres requis pour s'entraîner, améliore le mieux les
performances prédictives du modèle.
•Les neurones de la couche convolutive sont connectés aux régions locales
de l'entrée par le calcul du produit scalaire entre leurs poids et la région
connectée d'entrée.
112

Exemple de réseau de neurones convolutif

113

convolution

En mathématiques, le produit de convolution est un opérateur bilinéaire et

un produit commutatif, généralement noté « ∗ », qui, à deux fonctions f et g sur un
même domaine infini, fait correspondre une autre fonction « f ∗ g » sur ce domaine,
qui en tout point de celui-ci est égale à l'intégrale sur l'entièreté du domaine (ou
la somme si celui-ci est discret) d'une des deux fonctions autour de ce point, pondérée
par l'autre fonction autour de l'origine - les deux fonctions étant parcourues en sens
contraire l'une de l'autre.

Représente la convolution
114

Simple convolution d’une matrice (5x5) avec un noyau (3x3)

Convolution
115

Convolution d’une image 3 canaux RGB avec un noyau 3x3x3

116 Chaque filtre a un travail; certains d'entre eux détectent les bords certains d'entre eux
ne détectent que les lignes horizontales. La tâche du filtre devient plus complexe dans
les couches profondes du réseau évolutionnel.

Par exemple, la
première couche du
réseau peut détecter
uniquement les lignes
horizontales

Tandis que ce filtre

supprime tous sauf les
lignes vérticales
 Pourquoi le ReLU?
117
✔Le ReLU est est l'activation par défaut lors du développement de Perceptron
multicouche et de réseaux de neurones convolutifs.

Limitations sigmoid et tanh : produisent un mauvais apprentissage pour les

réseaux profonds à cause d’un problème connu sous le nom Vanishing Gradient
Problem ou erreur de chute.
Aussi; demande un calcul coûteux.

Comme on peut l'observer, lorsque la valeur de la fonction sigmoïde est trop élevée
ou trop faible, la dérivée (ligne orange) devient très petite, c'est-à-dire << 1.
 pourquoi le ReLU?
118
Avantages
✔N’est couteux en temps de calcul.
✔Presque linéaire.
✔Assure la non-linéairité dans les réseaux profonds.

✔La dérivée de ReLU (orange) est rétro-propagée, il n'y aura pas de dégradation du signal d'erreur,
car 1 x 1 x 1 x 1… = 1. Cependant, l'activation ReLU conserve toujours une caractéristique de
non-linéarité ou de «mise en marche» qui lui permet de se comporter de manière analogue à un
neurone biologique.
119

maxpooling
Pourquoi utilisons-nous le pooling?
▪Pour gagner en robustesse lors de l'extraction de caractéristiques, le
pooling empêche le modèle de surentraîner en supprimant les
données inutiles par rapport à la valeur sélectionnée.
▪Accélérer le calcul; Réduire la taille de la représentation pour
augmenter la vitesse du calcul.
120
121
pooling

L’image à droite est ¼ de l’image à gauche

Les caractéristiques sont conservées et même sont améliorées
 Flattening
122
Cette étape est simple.
Après avoir terminé les deux étapes précédentes, nous sommes censés avoir une carte des
fonctionnalités regroupées maintenant. Aplatir notre carte d'entités regroupées dans une
colonne comme dans l'image.

La raison pour laquelle

nous faisons cela est que
nous allons devoir insérer
ces données dans un
réseau neuronal artificiel
plus tard.
123 Full Connection
C'est là que les réseaux de neurones artificiels et les réseaux de neurones convolutifs se
heurtent lorsque nous ajoutons les premiers à nos seconds. C'est ici que le processus de
création d'un réseau neuronal convolutif commence à prendre un tour plus complexe
et sophistiqué.
 Full Connection
124
125 La couche softmax
▪zi sont les éléments du vecteur d'entrée et peuvent prendre n'importe quelle
valeur réelle
▪K est le nombre de classes dans le classifieur multi-classes.

Le softmax

Dans ce cas K=2

La couche
soft max
126

ANN vs CNN
ANN CNN
•Utilise des couches entièrement connectées. •Utilise des couches partiellement connectées.
ANN ne peut être utilisé que pour les petites La taille de la connexion dépend de la taille du
images. filtre. Le CNN peut être utilisé pour n'importe
quelle image.
•Nombre de paramètres très élevé, Pour 28 * •Le nombre de paramètres dans le CNN sera
28 image et la couche a 32 neurones; le très inférieur par rapport à ANN. Pour une
nombre de paramètres pour une couche sera image 28 * 28 et si le calque a 32 filtres de
28 * 29 * 32 = 25088. Par conséquent, le taille (5 * 5), le nombre de paramètres pour
temps de calcul dans l’ANN est très couteux. ce calque sera (5 * 5 * 1 * 1) * 32 = 832. Par
conséquent, le temps de calcul du CNN est
nettement inférieur à celui de l’ANN.
•Pas très efficace pour les images malgré leur •Très efficace pour les images et moins
coût. couteux comparé à l’ANN.
 ANN CNN
127
•Pas d’apprentissage du modèle dans la •Apprentissage hiérarchique spatiale des pattens, c'est-à-dire que les couches
hiérarchie spatiale, c'est-à-dire que les supérieures de CNN sont formées en combinant des couches inférieures. Cela
couches supérieures de l’ANN ne aide à identifier les modèles plus efficacement que l’ANN.
combine pas les sorties des couches Les filtres de convolutions différentes tailles (3x3 et 5x5) pour capturer
inférieures. l'espace informations à différentes échelles.
La caractéristique intéressante de CNN est sa capacité à exploiter la
corrélation spatiale ou temporelle des données. La topologie de CNN est
divisée en plusieurs étapes d'apprentissage composées d'une combinaison
des couches convolutives, des unités de traitement non linéaires et des
couches de sous-échantillonnage.

•N’est pas invariant par translation, une •Invariant par translation. Une fois que le CNN a appris à reconnaître un motif
fois qu'un ANN a appris à reconnaître à un emplacement, il peut le reconnaître à n'importe quel autre
un modèle à un emplacement, il ne emplacement. En bref, l'apprentissage (poids) peut être réutilisé même si
peut le reconnaître qu'à cet l'image est pivotée ou décalée. De plus, le CNN est invariant aux petites
emplacement particulier. En bref, nous déformations.
devons entraîner à nouveau l'image (ne
peut pas réutiliser les poids
précédents) si elle est pivotée ou
décalée.
128
129
130
131
132
133
134
135
136 Réferences

[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link] ([Link])
Exponential expressivity in deep neural networks through transient chaos ([Link])
137 Travaux futurs : CIFAR-100