L Intelligence Artificielle Dans Le Monde Du Business

L'intelligence articielle dans le monde
de l'entreprise
Résoudre les problèmes réels de l'entreprise avec des solutions d'IA
par Hadelin de Ponteves, Kirill Eremenko, et Charles Bordet

L'IA dans l'entreprise Résoudre les problèmes de l'entreprise avec des solutions d'IA
Table des matières

1 Partie 1 - Optimisation des processus 3
1.1 Étude de cas : Optimisation des ux dans un entrepôt e-commerce . . . . . . . . . . . . . . . 3
1.1.1 Problème à résoudre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.1.2 Environnement à dénir . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2 Solutions d'IA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.2.1 Processus décisionnels de Markov . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.2.2 Le Q-Learning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.2.3 L'algorithme Q-Learning complet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.3 Implémentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2 Partie 2 - Minimiser les coûts 24

2.1 Étude de cas : consommation d'énergie d'un Data center - minimiser les coûts . . . . . . . . . 24
2.2 Solutions d'IA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.2.1 Du Q-Learning au Deep Learning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.2.2 L'Experience Replay . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.2.3 Le cerveau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
2.2.4 L'algorithme Deep Q-Learning complet . . . . . . . . . . . . . . . . . . . . . . . . . . 32
2.3 Implémentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
2.3.1 Étape 1 : Créer l'environnement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
2.3.2 Étape 2 : Développer le cerveau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
2.3.3 Étape 3 : Implémentation de l'algorithme du Deep Reinforcement Learning . . . . . . 42
2.3.4 Étape 4 : Formation de l'IA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
2.3.5 Étape 5 : Tester l'IA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
2.3.6 Récapitulatif : Le cadre général de l'IA / Plan directeur . . . . . . . . . . . . . . . . . 48
3 Partie 3 - Optimiser les revenus 49

3.1 Étude de cas : Optimiser les revenus d'une entreprise e-commerce . . . . . . . . . . . . . . . . 49
3.2 Solutions d'IA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
3.3 Implémentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
4 Annexe 1 : Réseaux de neurones articiels 63

4.1 Le neurone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
4.2 La fonction d'activation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
4.2.1 La fonction d'activation à seuil . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
4.2.2 La fonction d'activation sigmoïde . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
4.2.3 La fonction d'activation ReLU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
4.2.4 La fonction d'activation tangente hyperbolique . . . . . . . . . . . . . . . . . . . . . . 71
4.3 Comment fonctionnent les réseaux de neurones ? . . . . . . . . . . . . . . . . . . . . . . . . . 74
4.4 Comment les réseaux de neurones apprennent-ils ? . . . . . . . . . . . . . . . . . . . . . . . . 75
4.5 Propagation et Rétropropagation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
4.6 Descente de gradient . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
4.6.1 Introduction à la Descente de Gradient . . . . . . . . . . . . . . . . . . . . . . . . . . 77
4.6.2 L'intuition de la Descente de Gradient . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
4.7 Descente de gradient par batch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
Page 1 of 103
4.8 Descente de gradient stochastique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84

4.9 Descente de gradient par mini-batch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
4.10 Optimiseurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
4.10.1 Optimiseur Momentum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
4.10.2 L'Optimiseur de gradient accéléré de Nesterov . . . . . . . . . . . . . . . . . . . . . . 88
4.10.3 L'Optimiseur AdaGrad (gradients adaptatifs) . . . . . . . . . . . . . . . . . . . . . . . 88
4.10.4 L'Optimiseur AdaDelta . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
4.10.5 L'Optimiseur Adam (Adaptive Moment Estimation) . . . . . . . . . . . . . . . . . . . 89
5 Annexe 2 : Trois modèles supplémentaires d'IA 90

5.1 Le Deep Convolutional Q-Learning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
5.2 Le modèle Asynchronous Actor-Critic Agents (A3C) . . . . . . . . . . . . . . . . . . . . . . . 91
5.2.1 L'intuition du modèle A3C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
5.2.2 Le processus A3C complet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
5.3 Le modèle Augmented Random Search . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
5.3.2 Solution d'IA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
6 Annexe 3 : Questions et réponses 100

6.1 Q&Rs sur la partie 1 - Optimisation des processus . . . . . . . . . . . . . . . . . . . . . . . . 100
6.2 Q&Rs sur la partie 2 - Minimiser les coûts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
6.3 Q&Rs sur la Partie 3 - Optimiser les revenus . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
Page 2 of 103
Introduction
Ce livre va de pair avec notre cours "L'Intelligence Articielle pour le Business" (lien ici). Il présente trois
études de cas dans le monde réel de l'entreprise que nous allons résoudre avec trois solutions diérentes d'IA
:
Partie Étude de cas Solutions d'IA

1 - Optimisation des processus Optimisation des ux dans un entrepôt e-commerce Q-Learning
2 - Minimiser les coûts Minimiser les coûts d'énergie d'un data center Deep Q-Learning
3 - Optimisation des revenus Optimisation des revenus d'une activité e-commerce Échantillonnage Thompson
Nous suivrons dans chacune de ces parties le même processus en 3 étapes :
1. Étude de cas. Nous commencerons par exposer le problème que nous devons résoudre et nous
construirons à partir de zéro l'environnement de notre travail.
2. Solutions d'IA. Nous vous donnerons non seulement le concept, mais aussi tous les détails mathé-
matiques du modèle d'IA qui résoudra l'étude de cas.
3. Implémentation. Nous implémenterons la solution d'IA en Python, nous entrerons en production et

améliorerons l'IA en complétant deux exercices pratiques.
Merci à tous ! Nous vous souhaitons un voyage passionnant dans l'univers de l'IA et l'entreprise !
1 Partie 1 - Optimisation des processus

Nous voici avec notre première étude de cas et notre premier modèle d'IA. Espérons que vous êtes prêts !
1.1 Étude de cas : Optimisation des ux dans un entrepôt e-commerce

1.1.1 Problème à résoudre
Le problème à résoudre est d'optimiser les ux dans l'entrepôt suivant :
Page 3 of 103
L'entrepôt appartient à une entreprise e-commerce qui vend des produits à une clientèle variée. Les produits
sont stockés à l'intérieur dans 12 emplacements diérents, identiés par les lettres suivantes de A à L :
Alors que les commandes sont eectuées par les clients en ligne, un robot autonome se déplace dans l'entrepôt
an de collecter les produits pour les livraisons ultérieures. Voici à quoi ça ressemble :
Figure 1: Robot d'entrepôt autonome
Les 12 emplacements sont tous reliés à un système informatique qui indexe en temps réel les priorités de
Page 4 of 103
collecte des produits pour ces 12 emplacements. Par exemple, à un temps donné t, il donnera le classement
suivant :
Niveau de priorité Emplacement

1 G
2 K
3 L
4 J
5 A
6 I
7 H
8 C
9 B
10 D
11 F
12 E
L'emplacement G a la priorité 1 (priorité absolue), car il contient un produit qui doit être collecté et livré
immédiatement. Notre robot d'entrepôt autonome doit se déplacer vers l'emplacement G par l'itinéraire le
plus court selon l'endroit où il se trouve. Notre objectif est de développer une IA indiquant l'itinéraire le
plus court où que se trouve le robot. Toutefois, les emplacements K et L gurent parmi les trois premières
priorités. Par conséquent, nous voulons intégrer une option pour passer par des emplacements intermédiaires
avant d'atteindre l'emplacement nal.
La façon dont le système calcule les priorités des emplacements n'entre pas dans le cadre de cette étude.
La raison est qu'il peut y avoir de nombreuses approches, des règles ou algorithmes simples aux calculs
déterministes ou en s'aidant du Machine Learning. Mais la plupart d'elles ne seraient pas l'IA de nos jours.
Ce qui nous intéresse vraiment, c'est l'IA qui englobe le Q-Learning, le Deep Q-Learning, et les autres
branches de Machine Learning. Ainsi, nous dirons simplement par exemple que l'emplacement G est la
priorité absolue parce que l'un des clients premium de l'entreprise a passé une commande urgente d'un
produit stocké à l'emplacement G qui doit donc être livré le plus rapidement possible.
Enn, notre mission est de créer une IA qui prend toujours l'itinéraire le plus court vers l'emplacement le
plus prioritaire quel que soit le point de départ, et qui peut passer par un emplacement intermédiaire qui est
dans les 3 priorités principales.
1.1.2 Environnement à dénir

Lors de la création d'une IA, la première chose que nous devons toujours faire est de dénir l'environnement.
Cela nécessite les trois éléments suivants :
• Dénir les états
• Dénir les actions
• Dénir les récompenses
Dénissons ces trois éléments.
Dénir les états.
Page 5 of 103
Commençons par les états. L'état d'entrée est simplement l'emplacement où se trouve notre Robot d'Entrepôt
Autonome à un temps déni t. Cependant, puisque nous implémenterons notre IA avec des équations, nous
encoderons les noms d'emplacement (A, B, C,...) avec des numéros d'index selon le schéma suivant :
Emplacement état
A 0
B 1
C 2
D 3
E 4
F 5
G 6
H 7
I 8
J 9
K 10
L 11
Il y a une raison spécique pour laquelle nous encodons les états avec des index de 0 à 11 au lieu d'autres
nombres entiers. La raison est que nous travaillons avec des matrices. Une matrice de récompenses et une
matrice de Q-Values. Chaque ligne/colonne de ces matrices correspond à un emplacement spécique, p. ex.
la 1re ligne de chaque matrice qui a l'index 0 correspond à l'emplacement A ; la 2e ligne/colonne qui a l'index
1 correspond à l'emplacement B, etc. Nous reviendrons sur l'importance des matrices en détails.
Dénir les actions.

Dénissons maintenant les actions possibles à exécuter. Les actions sont simplement les mouvements po-
tentiels du robot pour aller d'un emplacement à l'autre, p. ex. disons que le robot est à l'emplacement J,
les actions possibles à exécuter sont I, F ou K. Et comme nous allons travailler avec des équations mathé-
matiques, nous allons encoder ces actions avec les mêmes index que pour les états. Ainsi, en suivant notre
exemple où le robot se trouve à l'emplacement J à un temps précis, les actions possibles du robot sont,
d'après notre précédent schéma : 5, 8 et 10. En eet, l'index 5 correspond à F, l'index 8 correspond à I et
l'index 10 correspond à K. Par conséquent, la liste totale des actions que l'IA peut exécuter globalement est
la suivante :
actions = [0,1,2,3,4,5,6,7,8,9,10,11]
Évidemment, quand le robot est dans un emplacement précis, il y a certaines actions que l'IA ne peut pas
exécuter. Suivant l'exemple précédent, si le robot se trouve à l'emplacement J, il peut exécuter les actions
5, 8 et 10, mais pas les autres. Nous veillerons à attribuer une récompense de 0 aux actions qu'il ne peut
pas exécuter et une récompense de 1 aux actions qu'il peut exécuter. Cela nous amène aux récompenses.
Dénir les récompenses.
Page 6 of 103
La dernière chose qui reste pour créer notre environnement est de dénir un système de récompenses. Plus
précisément, une fonction de récompense R qui prend comme entrées un état s et une action a, et génère
une récompense numérique que l'IA obtiendra en exécutant l'action a dans l'état s :
R : (état, action) 7→ r ∈ R
Alors, comment concevoir une telle fonction pour notre étude de cas ? Ici, c'est simple. Puisqu'il y a un
nombre discret et ni d'états (index 0 à 11) ainsi qu'un nombre discret et ni d'actions (mêmes index 0 à
11), la meilleure façon de concevoir notre fonction de récompense R est de faire une matrice. Notre fonction
de récompense sera exactement une matrice de 12 lignes et 12 colonnes dont les lignes correspondent aux
états et les colonnes correspondent aux actions. Ainsi, dans notre fonction "R : (s, a) 7→ r ∈ R", s sera
l'index de ligne de la matrice, a sera l'index de colonne de la matrice et r sera la cellule d'index (s, a) dans
la matrice.
Par conséquent, pour dénir notre fonction de récompense, nous devons simplement remplir cette matrice
avec les récompenses numériques. Comme indiqué ci-dessus, nous devons d'abord attribuer pour chacun des
12 emplacements une récompense : 0 aux actions que le robot ne peut pas exécuter et 1 aux actions que le
robot peut exécuter. En faisant cela pour chacun des 12 emplacements, nous obtiendrons une matrice de
récompenses. Nous allons la créer étape par étape en commençant par l'emplacement A.
Lorsque le robot se trouve à l'emplacement A, il ne peut se rendre qu'à l'emplacement B. Puisque l'emplacement
re e
A a l'index 0 (1 ligne de la matrice) et l'emplacement B a l'index 1 (2 colonne de la matrice), la 1re ligne
e
de la matrice de récompenses aura un 1 dans la 2 colonne et un 0 dans toutes les autres :
Page 7 of 103
Passons maintenant à l'emplacement B. Lorsque le robot se trouve à l'emplacement B, il ne peut se rendre

e
qu'à trois emplacements diérents : A, C et F. Puisque B a l'index 1 (2 ligne) et A, C, F ont les index
re e e e
respectifs 0, 2, 5 (1 , 3 et 6 colonne), alors la 2 ligne de la matrice de récompenses aura 1 sur les colonnes
1, 3, 6 et 0 sur toutes les autres colonnes. Ainsi, nous obtenons :
Ensuite, C (de l'index 2) n'est connecté qu'à B et G (des index 1 et 6) donc la 3e ligne de la matrice de
récompenses est :
Page 8 of 103
En faisant ainsi pour tous les autres emplacements, nous obtenons notre matrice de récompenses nale :
Félicitations ! Nous venons de dénir les récompenses en créant cette matrice de récompenses. Généralement,
c'est la façon dont nous dénissons le système de récompenses lorsque nous faisons du Q-Learning avec un
nombre ni d'entrées et d'actions. Dans l'étude de cas 2, nous allons procéder très diéremment.
Nous avons presque terminé, il nous reste l'attribution des récompenses élevées aux emplacements prioritaires
par le biais d'un système informatique qui restitue les priorités de collecte des produits pour chacun des 12
emplacements. Par conséquent, puisque l'emplacement G est la priorité absolue, le système informatique
mettra à jour la matrice de récompenses en attribuant une récompense élevée dans la cellule (G,G) :
C'est ainsi que le système de récompenses fonctionnera avec le Q-Learning. Nous attribuons la récompense
la plus élevée (ici 1000) à l'emplacement de priorité supérieure G. Ensuite, vous verrez dans les vidéos
comment attribuer une récompense élevée inférieure au deuxième emplacement de priorité supérieure K
pour faire passer notre robot par cet emplacement intermédiaire, optimisant ainsi les ux d'entrepôt.
Page 9 of 103
1.2 Solutions d'IA

La solution d'IA qui résoudra le problème décrit ci-dessus est un modèle Q-Learning. Puisque ce dernier est
basé sur les processus décisionnels de Markov (MDPs). Nous commencerons par une dénition, puis nous
passerons à l'intuition et aux détails mathématiques derrière le modèle Q-Learning.
1.2.1 Processus décisionnels de Markov

Un processus décisionnel de Markov est un tuple (S, A, T, R) où :
• S est l'ensemble des diérents états. Par conséquent, dans notre étude de cas :
S = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}
• A est l'ensemble des actions qui peuvent être exécutées à chaque temps t. Dans notre étude de cas :
A = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}
• T s'appelle la règle de transition :
T : (st ∈ S, st+1 ∈ S, at ∈ A) 7→ P(st+1 |st , at )
où P(st+1 |st , at ) est la probabilité d'atteindre l'état futur st+1 en exécutant l'action at dans l'état st .
Donc T est la distribution de probabilité des états futurs au temps t + 1 étant donné l'état actuel et
l'action exécutée au temps t. Par conséquent, nous pouvons prévoir l'état futur st+1 en faisant un
tirage aléatoire dans cette distribution T :
st+1 ∼ T (st , ., at )
Dans notre étude de cas, vous verrez à travers notre application que cette distribution T de notre IA
sera simplement la distribution uniforme, ce qui est un choix classique de distribution qui fonctionne
très bien en faisant du Q-Learning.
• R est la fonction de récompense :
R : (st ∈ S, at ∈ A) 7→ rt ∈ R
où rt est la récompense obtenue après avoir exécuté l'action at dans l'état st . Dans notre étude de cas,
cette fonction de récompense est exactement la matrice que nous avons créée précédemment.
Après avoir déni les processus décisionnels de Markov, il est maintenant important de rappeler qu'il repose
sur l'hypothèse suivante : la probabilité de l'état futur st+1 dépend uniquement de l'état actuel st et de
l'action at , et ne dépend d'aucun des états et actions précédents. C'est à dire :
P(st+1 |s0 , a0 , s1 , a1 , ..., st , at ) = P(st+1 |st , at )
En d'autres termes, un processus décisionnel de Markov n'a pas de mémoire.
Page 10 of 103
Récapitulons maintenant ce qui se passe en ce qui concerne les processus décisionnels de Markov. À chaque
temps t :
1. L'IA observe l'état actuel st .
2. L'IA exécute l'action at .
3. L'IA reçoit la récompense rt = R(st , at ).
4. L'IA passe à l'état suivant st+1 .
Donc maintenant la question est :
Comment l'IA sait-elle quelle action exécuter à chaque temps t ?

Pour répondre à cette question, nous devons introduire la fonction de stratégie. La fonction de stratégie π
est exactement la fonction qui, étant donné l'état st , indique l'action at :
π : st ∈ S 7→ at ∈ A
Désignons par Π l'ensemble de toutes les fonctions de stratégie possibles. Le choix des meilleures actions à
exécuter devient alors une question d'optimisation. En eet, il s'agit de trouver la stratégie optimale π∗ qui
maximise la récompense accumulée :
X
π ∗ = argmax R(st , π(st ))
π∈Π
t≥0
Par conséquent, la question est la suivante :
Comment trouver cette stratégie optimale π∗ ?

C'est là que le Q-Learning intervient.
1.2.2 Le Q-Learning
Avant d'entamer les détails du Q-Learning, nous devons expliquer le concept de la Q-value.
La Q-Value
À chaque couple d'état et action (s, a), nous allons associer une valeur numérique Q(s, a) :
Q : (s ∈ S, a ∈ A) 7→ Q(s, a) ∈ R
Nous dirons que Q(s, a) est "la Q-value de l'action a exécutée dans l'état s".
Pour comprendre l'objectif de cette "Q-Value", nous devons introduire la Diérence temporelle.
la Diérence temporelle
Au début t = 0, toutes les Q-values sont initialisées à 0 :
∀s ∈ S, a ∈ A, Q(s, a) = 0
Page 11 of 103
Supposons maintenant que nous soyons au temps t, dans un certain état st . Nous exécutons une action
aléatoire at , ce qui nous amène à l'état st+1 t et nous obtenons la récompense R(st , at ).
Nous pouvons maintenant introduire la Diérence temporelle qui est au c÷ur du Q-Learning. La Diérence
temporelle au temps t, désignée par T Dt (st , at ), est la diérence entre :
• R(st , at ) + γmax(Q(st+1 , a)), soit la récompense R(st , at ) obtenue en exécutant l'action at dans l'état
a
st , plus la Q-Value de la meilleure action exécutée dans l'état futur st+1 , actualisée par un facteur
γ ∈ [0, 1], appelé facteur de réduction.
• et Q(st , at ), soit la Q-Value de l'action at exécutée dans l'état st ,
ce qui mène à :
T Dt (st , at ) = R(st , at ) + γmax(Q(st+1 , a)) − Q(st , at )

a
OK super, mais quel est le but exact de cette diérence temporelle T Dt (st , at ) ?
Répondons à cette question pour nous donner une meilleure compréhension de l'IA. T Dt (st , at ) est comme
une récompense intrinsèque. L'IA apprendra les Q-values de manière à ce que :
• Si T Dt (st , at ) est élevée, l'IA obtient une "bonne surprise".
• Si T Dt (st , at ) est petite, l'IA obtient une "frustration".
Dans cette mesure, l'IA va itérer certaines mises à jour de Q-Values (par une équation appelée équation de
Bellman) vers des diérences temporelles plus élevées.
Par conséquent, dans la dernière étape de l'algorithme du Q-Learning, nous utilisons la diérence temporelle
pour renforcer les couple (état, action) du temps t−1 au temps t, selon l'équation suivante :
Qt (st , at ) = Qt−1 (st , at ) + αT Dt (st , at )
où α∈R est le taux d'apprentissage qui détermine la vitesse à laquelle l'apprentissage des Q-Values se fait,
ou l'importance des mises à jour des Q-Values. Sa valeur est généralement un nombre réel choisi entre 0 et
1, comme 0.01, 0.05, 0.1 ou 0.5. Plus sa valeur est faible, plus les mises à jour des Q-Values seront petites et
plus le Q-Learning sera long. Plus sa valeur est élevée, plus les mises à jour des Q-Values seront importantes
et plus le Q-Learning sera rapide.
Cette équation ci-dessus est l'équation de Bellman. C'est le pilier du Q-Learning.
Ainsi, les Q-Values mesurent l'accumulation de surprise ou de frustration associées au couple action et état
(st , at ). Dans le cas de surprise, l'IA est renforcée et dans le cas de la frustration, l'IA est aaiblie. C'est
pourquoi nous voulons apprendre les Q-Values qui donneront à l'IA le maximum de "bonne surprise".
Par conséquent, la décision de l'action à exécuter dépend principalement de la Q-value Q(st , at ). Si l'action
at exécutée dans l'état st est associée à une Q-Value élevée Q(st , at ), l'IA aura plus tendance à choisir at .
Page 12 of 103
Par contre si l'action at exécutée dans l'état st est associée à une petite Q-value Q(st , at ), l'IA aura moins
tendance à choisir at .
Il y a plusieurs façons de choisir la meilleure action à exécuter. lorsque nous sommes dans un état st , nous
pourrions simplement prendre l'action at qui maximise la Q-Value Q(st , at ) :
at = argmax(Q(st , a))
a
Cette solution est la méthode Argmax.
Une autre excellente solution, qui s'avère être meilleure pour résoudre les problèmes complexes, est la méthode
Softmax.
La méthode Softmax consiste à considérer pour chaque état s la distribution suivante :
exp(Q(s, a))τ
Ws : a ∈ A 7→ P 0 τ
avec τ ≥0
a0 exp(Q(s, a ))
Ensuite, nous choisissons l'action a à exécuter en eectuant un tirage au sort dans cette distribution :
a ∼ Ws (.)
Cependant, le problème que nous allons résoudre dans l'étude de cas 1 sera assez simple avec la méthode
Argmax, c'est donc ce que nous allons choisir.
1.2.3 L'algorithme Q-Learning complet

Résumons les diérentes étapes de l'ensemble du processus de Q-Learning :
Initialisation :
Pour tous les couples d'états s et d'actions a, les Q-Values sont initialisées à 0 :
∀s ∈ S, a ∈ A, Q0 (s, a) = 0
Nous commençons dans l'état initial s0 . Nous exécutons une action aléatoire pour atteindre le 1er état s1 .
Ensuite, pour chaque t ≥ 1, nous répéterons un nombre de fois (1000 fois dans notre code) ce qui suit :
1. Nous sélectionnons un état aléatoire st parmi nos 12 états possibles :
st = random(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)
2. Nous exécutons une action aléatoire at qui peut mener à un futur état possible, c.-à-d. R(st , at ) > 0 :
at = random(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11) s.t. R(st , at ) > 0
3. Nous atteignons l'état suivant st+1 et nous obtenons la récompense R(st , at )
4. Nous évaluons la diérence temporelle T Dt (st , at ):
T Dt (st , at ) = R(st , at ) + γmax(Q(st+1 , a)) − Q(st , at )

a
Page 13 of 103
5. Nous mettons à jour la Q-value en appliquant l'équation de Bellman :
Qt (st , at ) = Qt−1 (st , at ) + αT Dt (st , at )
Page 14 of 103
1.3 Implémentation
Maintenant expliquons l'implémentation complète de ce modèle Q-Learning, la solution de notre problème
d'optimisation des ux de stockage.
Tout d'abord, nous commençons par importer les modules qui seront utilisées dans cette implémentation.
Seule NumPy ore des outils pratiques avec des tableaux et des opérations mathématiques :
# Importing the libraries

import numpy as np
Ensuite, nous dénissons les paramètres de notre modèle. Il s'agit du facteur de réduction γ et du taux
d'apprentissage α qui sont, suivant la section 1.2, les seuls paramètres de l'algorithme du Q-Learning :
# Setting the parameters gamma and alpha for the Q-Learning

gamma = 0.75
alpha = 0.9
Les deux sections de code précédentes n'étaient que des sections d'introduction avant de commencer vraiment
à créer notre modèle d'IA. La prochaine étape consiste à entamer la 1re partie de notre implémentation :
Partie 1 - Dénir l'environnement. Et pour cela bien sûr, nous commençons par dénir les états avec un
dictionnaire indiquant les noms des emplacements (lettres de A à L) dans les états (index de 0 à 11) :
# PART 1 - DEFINING THE ENVIRONMENT
# Defining the states

location_to_state = {’A’: 0,
5 ’B’: 1,
’C’: 2,
’D’: 3,
’E’: 4,
’F’: 5,
10 ’G’: 6,
’H’: 7,
’I’: 8,
’J’: 9,
’K’: 10,
15 ’L’: 11}
Ensuite nous dénissons les actions avec une simple liste d'index de 0 à 11. Rappelez-vous que chaque index
d'action correspond à l'état suivant (emplacement suivant) où cette action conduit à :
# Defining the actions

actions = [0,1,2,3,4,5,6,7,8,9,10,11]
Finalement, nous dénissons les récompenses en créant une matrice dont les lignes correspondent aux états
actuels st , les colonnes aux actions at menant à l'état suivant st+1 et les cellules contiennent les récompenses
R(st , at ). Si une cellule (st , at ) a 1, cela signie que nous pouvons exécuter l'action at depuis l'état actuel st
Page 15 of 103
pour atteindre l'état suivant st+1 . Si une cellule (st , at ) a 0, cela signie que nous ne pouvons pas exécuter
l'action at depuis l'état actuel st pour atteindre l'état suivant st+1 . Nous allons mettre manuellement
une récompense élevée (1000) dans la cellule correspondant à l'emplacement G, car c'est l'emplacement
prioritaire où le robot autonome doit récupérer les produits. Puisque l'emplacement G a encodé l'état avec
l'index 6, nous avons mis une récompense de 1000 dans la cellule de la ligne 6 et de la colonne 6. Ensuite,
nous développerons notre solution en implémentant un système automatique pour aller à l'emplacement
prioritaire sans avoir à mettre à jour manuellement la matrice de récompenses et en la laissant initialisée
avec 0 et 1 comme elle devrait l'être. Voici notre matrice de récompenses incluant la mise à jour manuelle :
# Defining the rewards

R = np.array([[0,1,0,0,0,0,0,0,0,0,0,0],
[1,0,1,0,0,1,0,0,0,0,0,0],
[0,1,0,0,0,0,1,0,0,0,0,0],
5 [0,0,0,0,0,0,0,1,0,0,0,0],
[0,0,0,0,0,0,0,0,1,0,0,0],
[0,1,0,0,0,0,0,0,0,1,0,0],
[0,0,1,0,0,0,1000,1,0,0,0,0],
[0,0,0,1,0,0,1,0,0,0,0,1],
10 [0,0,0,0,1,0,0,0,0,1,0,0],
[0,0,0,0,0,1,0,0,1,0,1,0],
[0,0,0,0,0,0,0,0,0,1,0,1],
[0,0,0,0,0,0,0,1,0,0,1,0]])
Voilà qui conclut cette première partie. Commençons la deuxième partie : Partie 2 - Développer la solution
d'IA avec le Q-Learning. Pour ce faire, nous allons utiliser l'algorithme de Q-Learning exactement tel qu'il
a été fourni dans la section 1.2. Nous commençons donc par initialiser toutes les Q-Values en créant notre
matrice de Q-Values contenant des zéros (dans laquelle les lignes correspondent aux états actuels st , les
colonnes aux actions at menant aux états suivants st+1 et les cellules contiennent les Q-Values Q(st , at )) :
# PART 2 - BUILDING THE AI SOLUTION WITH Q-LEARNING
# Initializing the Q-Values

Q = np.array(np.zeros([12,12]))
Ensuite, nous implémentons le processus de Q-Learning avec une boucle pour plus de 1000 itérations, répétant
1000 fois les étapes du processus de Q-Learning fournies à la n de la section 1.2 :
# Implementing the Q-Learning process

for i in range(1000):
current_state = np.random.randint(0,12)
playable_actions = []
5 for j in range(12):
i f R[current_state, j] > 0:
playable_actions.append(j)
next_state = np.random.choice(playable_actions)
TD = R[current_state, next_state] + gamma*Q[next_state, np.argmax(Q[next_state,])]
10 - Q[current_state, next_state]
Q[current_state, next_state] = Q[current_state, next_state] + alpha*TD
Page 16 of 103
Facultatif : à ce stade du code, notre matrice de Q-Values est prête. Nous pouvons y jeter un coup d'÷il en
exécutant le code que nous avons implémenté jusqu'à présent et en entrant le print suivant dans la console :
print ("Q-Values:")
print (Q.astype( int ))
Et nous obtenons la matrice suivante de Q-Values :
Pour plus de clarté, vous pouvez même vérier la matrice des Q-Values directement dans Variable Explorer
en double-cliquant sur Q. Ensuite, pour obtenir les Q-Values en tant qu'entiers, vous pouvez cliquer sur
"Format" et à l'intérieur entrer un oat formatting de "%.0f". Vous obtiendrez ceci, ce qui est un peu plus
clair puisque vous pouvez voir les index de lignes et de colonnes dans votre matrice Q :
Maintenant que nous avons notre matrice, nous pouvons donc passer à la 3e partie de l'implémentation,
Partie 3 - Mise en production, dans laquelle nous calculerons le chemin optimal de n'importe quel point de
départ à n'importe quel point nal de priorité absolue. L'idée est de mettre en place une fonction "route"
qui prendra comme entrées le point de départ où se trouve notre robot autonome à un temps donné et
le point d'arrivée où il doit aller en priorité absolue, et qui donnera comme sortie le chemin le plus court
dans une liste. Cependant, puisque nous voulons entrer les emplacements avec leurs noms (en lettres), par
opposition à leurs états (en index), nous aurons besoin d'un dictionnaire qui associe les états (en index) aux
emplacements (en lettres). Et c'est la première chose que nous allons faire ici en utilisant une technique
pour inverser notre dictionnaire précédent "location_to_state", puisque nous voulons simplement obtenir
le mapping inverse exact à partir de ce dictionnaire :
Page 17 of 103
# PART 3 - GOING INTO PRODUCTION
# Making a mapping from the states to the locations

state_to_location = {state: location for location, state in location_to_state.items()}
Ainsi intervient la section la plus importante du code. Nous sommes sur le point d'implémenter la fonction
nale "route()" qui aura comme entrées les emplacements de départ et d'arrivée, et qui donne l'itinéraire
optimal entre ces deux emplacements. Pour expliquer exactement ce que fera cette fonction route, nous
allons énumérer les diérentes étapes du processus, en allant de l'emplacement E à l'emplacement G :
1. Nous commençons à notre emplacement de départ E.
2. Nous obtenons l'état de l'emplacement E (d'après notre mapping location_to_state) est s0 = 4.
3. Sur la ligne d'index s0 = 4 dans notre matrice de Q-Values, nous trouvons la colonne qui a la Q-Value
maximale (703).
4. Cette colonne a l'index 8, donc nous exécutons l'action de l'index 8 qui mène à l'état suivant st+1 = 8.
5. Nous obtenons l'emplacement de l'état 8, qui selon notre mapping state_to_location est I. AInsi, notre
prochain emplacement est I qui est annexé à notre liste contenant le chemin optimal.
6. Nous répétons les 5 étapes précédentes à partir de notre nouveau point de départ I jusqu'à ce que nous
atteignions notre destination nale, le point G.
Par conséquent, comme nous ne savons pas combien d'emplacements nous devrons traverser entre le point
de départ et d'arrivée, nous devons faire une boucle while qui répétera le processus en 5 étapes décrites
ci-dessus, et qui s'arrêtera dès que nous atteindrons l'emplacement nal de priorité supérieure :
# Making the final function that will return the optimal route
def route(starting_location, ending_location):
route = [starting_location]
next_location = starting_location
5 while (next_location != ending_location):
starting_state = location_to_state[starting_location]
next_state = np.argmax(Q[starting_state,])
next_location = state_to_location[next_state]
route.append(next_location)
10 starting_location = next_location
return route
Félicitation, l'outil est prêt ! Quand on le teste pour passer de E à G, on obtient les deux itinéraires optimaux
possibles après la dénition de l'itinéraire nal en exécutant le code complet plusieurs fois :
# Printing the final route

print (’Route:’)
route(’E’, ’G’)
5 Route:
Out[1]: [’E’, ’I’, ’J’, ’F’, ’B’, ’C’, ’G’]
Out[2]: [’E’, ’I’, ’J’, ’K’, ’L’, ’H’, ’G’]
Page 18 of 103
Bien, nous avons une première version du modèle pratique. Mais nous pouvons l'améliorer de deux façons.
Tout d'abord, en automatisant l'attribution de récompense à l'emplacement prioritaire an que nous n'ayons
pas à le faire manuellement. Deuxièmement, en ajoutant une fonction qui nous donne la possibilité de passer
par un emplacement intermédiaire avant d'aller à l'emplacement prioritaire. Cet emplacement intermédiaire
devrait bien sûr gurer parmi les 3 premiers emplacements prioritaires. Dans notre classement des emplace-
ments prioritaires, le deuxième est K. Par conséquent, an d'optimiser encore plus les ux de stockage, notre
robot autonome doit passer par l'emplacement K pour récupérer les produits en route vers l'emplacement
prioritaire G. Pour ce faire, il est possible de passer par tout emplacement intermédiaire dans le cadre de notre
fonction "route()". Et c'est exactement ce que nous allons mettre en ÷uvre comme deuxième amélioration.
Mais d'abord, mettons en ÷uvre la première amélioration qui automatise l'attribution des récompenses.
Il faut d'abord faire une copie de notre matrice de récompenses (appelée R_new) dans laquelle la fonc-
tion route() mettra automatiquement à jour la récompense dans la cellule de l'emplacement nal. En eet,
l'emplacement nal est l'une des entrées de la fonction route(), donc en utilisant notre dictionnaire loca-
tion_to_state, nous pouvons très facilement trouver cette cellule et mettre à jour sa récompense à 1000.
Deuxièmement, nous devons inclure l'algorithme complet du Q-Learning (y compris l'étape d'initialisation)
dans la fonction route, juste après la mise à jour de la récompense dans notre copie. Dans notre implémenta-
tion précédente, le processus de Q-Learning se déroule dans la version originale de la matrice de récompenses
qui est maintenant censée rester telle quelle, c.-à-d. initialisée à 1 et 0 seulement. Par conséquent, nous
devons inclure le processus de Q-Learning dans la fonction route et le reproduire dans notre copie R_new
de la matrice de récompenses au lieu de l'originale R. Ainsi, notre implémentation devient la suivante :
# Artificial Intelligence for Business

# Optimizing Warehouse Flows with Q-Learning

5 import numpy as np

gamma = 0.75
alpha = 0.9
10

15 ’B’: 1,
’C’: 2,
’D’: 3,
’E’: 4,
’F’: 5,
20 ’G’: 6,
’H’: 7,
’I’: 8,
’J’: 9,
’K’: 10,
25 ’L’: 11}

actions = [0,1,2,3,4,5,6,7,8,9,10,11]
Page 19 of 103
30 # Defining the rewards

R = np.array([[0,1,0,0,0,0,0,0,0,0,0,0],
[1,0,1,0,0,1,0,0,0,0,0,0],
[0,1,0,0,0,0,1,0,0,0,0,0],
[0,0,0,0,0,0,0,1,0,0,0,0],
35 [0,0,0,0,0,0,0,0,1,0,0,0],
[0,1,0,0,0,0,0,0,0,1,0,0],
[0,0,1,0,0,0,1,1,0,0,0,0],
[0,0,0,1,0,0,1,0,0,0,0,1],
[0,0,0,0,1,0,0,0,0,1,0,0],
40 [0,0,0,0,0,1,0,0,1,0,1,0],
[0,0,0,0,0,0,0,0,0,1,0,1],
[0,0,0,0,0,0,0,1,0,0,1,0]])

45
# Making the final function that will return the route

50 def route(starting_location, ending_location):
R_new = np.copy(R)
ending_state = location_to_state[ending_location]
R_new[ending_state, ending_state] = 1000
55 for i in range(1000):
for j in range(12):
i f R_new[current_state, j] > 0:
60 playable_actions.append(j)
TD = R_new[current_state, next_state]
+ gamma * Q[next_state, np.argmax(Q[next_state,])]
- Q[current_state, next_state]
65 Q[current_state, next_state] = Q[current_state, next_state] + alpha * TD
while (next_location != ending_location):
70 next_state = np.argmax(Q[starting_state,])
starting_location = next_location
return route
75

80 route(’E’, ’G’)
En exécutant ce nouveau code plusieurs fois, on obtient les deux mêmes itinéraires optimaux possibles.
Page 20 of 103
Passons maintenant à la deuxième amélioration. Il y a trois façons d'ajouter l'option de passer par l'emplacement
intermédiaire K, le deuxième emplacement prioritaire :
1. Nous donnons une récompense élevée à l'action menant de l'emplacement J à K. Cette récompense
élevée doit être supérieure à 1, et inférieure à 1000. En eet, elle doit être supérieure à 1 pour que
le processus de Q-Learning favorise l'action menant de J à K, par opposition à l'action menant de J
à F qui a la récompense 1. Et elle doit être inférieure à 1000, de sorte que nous devons conserver
la récompense la plus élevée dans l'emplacement prioritaire. Ainsi, p. ex., dans notre matrice, nous
pouvons donner une récompense élevée de 500 à la cellule dans la ligne de l'index 9 et la colonne de
l'index 10, puisque cette cellule correspond eectivement à l'action menant de l'emplacement J (index
9) à K (index 10). De cette façon, notre robot autonome passera toujours par l'emplacement K pour
se rendre à G. Voici comment se présente la matrice de récompenses dans ce cas :

R = np.array([[0,1,0,0,0,0,0,0,0,0,0,0],
[1,0,1,0,0,1,0,0,0,0,0,0],
[0,1,0,0,0,0,1,0,0,0,0,0],
5 [0,0,0,0,0,0,0,1,0,0,0,0],
[0,0,0,0,0,0,0,0,1,0,0,0],
[0,1,0,0,0,0,0,0,0,1,0,0],
[0,0,1,0,0,0,1,1,0,0,0,0],
[0,0,0,1,0,0,1,0,0,0,0,1],
10 [0,0,0,0,1,0,0,0,0,1,0,0],
[0,0,0,0,0,1,0,0,1,0,500,0],
[0,0,0,0,0,0,0,0,0,1,0,1],
[0,0,0,0,0,0,0,1,0,0,1,0]])
2. Nous donnons une faible récompense à l'action menant de l'emplacement J à F. Elle doit juste être
inférieure à 0. En eet, en sanctionnant cette action avec une faible récompense, le processus de Q-
Learning ne favorisera jamais cette action menant de J à F. p. ex., dans notre matrice de récompenses
nous pouvons donner une mauvaise récompense de -500 à la cellule de la ligne de l'index 9 et la colonne
de l'index 5, car cette cellule correspond à l'action allant de l'emplacement J (index 9) vers F (index
5). De cette façon, notre robot autonome ne passera jamais par l'emplacement F pour se rendre à G.
Voici comment se présente la matrice de récompenses dans ce cas :

R = np.array([[0,1,0,0,0,0,0,0,0,0,0,0],
[1,0,1,0,0,1,0,0,0,0,0,0],
[0,1,0,0,0,0,1,0,0,0,0,0],
5 [0,0,0,0,0,0,0,1,0,0,0,0],
[0,0,0,0,0,0,0,0,1,0,0,0],
[0,1,0,0,0,0,0,0,0,1,0,0],
[0,0,1,0,0,0,1,1,0,0,0,0],
[0,0,0,1,0,0,1,0,0,0,0,1],
10 [0,0,0,0,1,0,0,0,0,1,0,0],
[0,0,0,0,0,-500,0,0,1,0,1,0],
[0,0,0,0,0,0,0,0,0,1,0,1],
[0,0,0,0,0,0,0,1,0,0,1,0]])
3. Nous créons une fonction supplémentaire best_route() qui aura comme entrées les trois emplacements
suivants : départ, intermédiaire, nal. Elle appellera notre précédente fonction route() 2 fois, une 1re
fois depuis l'emplacement de départ à l'emplacement intermédiaire, et une 2e fois depuis l'emplacement
intermédiaire à l'emplacement nal.
Page 21 of 103
Les deux premières idées sont faciles à implémenter manuellement, mais très délicates automatiquement. Il
est facile de trouver automatiquement l'index de l'emplacement intermédiaire, mais très dicile d'obtenir
l'index qui mène à cet emplacement, car cela dépend de l'emplacement initial et nal. Vous pouvez essayer
de mettre en ÷uvre la 1re ou la 2e idée, vous verrez ce que nous voulons dire. En conséquence, nous allons
e
mettre en ÷uvre la 3 idée qui peut être codée en seulement deux lignes supplémentaires de code :
# Making the final function that returns the optimal route

def best_route(starting_location, intermediary_location, ending_location):
return route(starting_location, intermediary_location)
+ route(intermediary_location, ending_location)[1:]
Le code nal incluant cette amélioration majeure pour l'optimisation des ux de nos entrepôt devient :

# Optimizing Warehouse Flows with Q-Learning


gamma = 0.75
alpha = 0.9
10

15 ’B’: 1,
’C’: 2,
’D’: 3,
’E’: 4,
’F’: 5,
20 ’G’: 6,
’H’: 7,
’I’: 8,
’J’: 9,
’K’: 10,
25 ’L’: 11}

actions = [0,1,2,3,4,5,6,7,8,9,10,11]
30 # Defining the rewards

R = np.array([[0,1,0,0,0,0,0,0,0,0,0,0],
[1,0,1,0,0,1,0,0,0,0,0,0],
[0,1,0,0,0,0,1,0,0,0,0,0],
[0,0,0,0,0,0,0,1,0,0,0,0],
35 [0,0,0,0,0,0,0,0,1,0,0,0],
[0,1,0,0,0,0,0,0,0,1,0,0],
[0,0,1,0,0,0,1,1,0,0,0,0],
[0,0,0,1,0,0,1,0,0,0,0,1],
Page 22 of 103
[0,0,0,0,1,0,0,0,0,1,0,0],
40 [0,0,0,0,0,1,0,0,1,0,1,0],
[0,0,0,0,0,0,0,0,0,1,0,1],
[0,0,0,0,0,0,0,1,0,0,1,0]])

45
# Making a function that returns the shortest route from a starting to ending location
50 def route(starting_location, ending_location):
R_new = np.copy(R)
ending_state = location_to_state[ending_location]
R_new[ending_state, ending_state] = 1000
55 for i in range(1000):
for j in range(12):
i f R_new[current_state, j] > 0:
60 playable_actions.append(j)
TD = R_new[current_state, next_state]
+ gamma * Q[next_state, np.argmax(Q[next_state,])]
- Q[current_state, next_state]
65 Q[current_state, next_state] = Q[current_state, next_state] + alpha * TD
while (next_location != ending_location):
70 next_state = np.argmax(Q[starting_state,])
starting_location = next_location
return route
75
# Making the final function that returns the optimal route

def best_route(starting_location, intermediary_location, ending_location):
80 return route(starting_location, intermediary_location)
+ route(intermediary_location, ending_location)[1:]

85 best_route(’E’, ’K’, ’G’)
En exécutant ce nouveau code plusieurs fois, nous obtiendrons toujours le même résultat attendu :
Best Route:
Out[1]: [’E’, ’I’, ’J’, ’K’, ’L’, ’H’, ’G’]
Page 23 of 103
2 Partie 2 - Minimiser les coûts

Félicitations pour avoir terminé la première étude de cas ! Passons à une IA toute nouvelle et avancée.
2.1 Étude de cas : consommation d'énergie d'un Data center - minimiser les
coûts
En 2016, DeepMind a réduit la facture d'énergie de Google Data Center de 40% en utilisant son modèle
DQN AI (Deep Q-Learning). Dans cette étude de cas, nous dénirons notre propre environnement de
serveur et nous développerons une IA qui contrôlera le refroidissement et le réchauement du serveur an
qu'il reste dans une plage de températures optimale tout en économisant le maximum d'énergie. Et tout
comme DeepMind, notre objectif sera d'atteindre au moins 40% d'économie d'énergie.

Avant de dénir les états, les actions et les récompenses, nous devons expliquer comment le serveur fonctionne.
Tout d'abord, nous allons lister tous les paramètres et variables de l'environnement par lesquels le serveur
est contrôlé. Ensuite, nous établirons l'hypothèse essentielle du problème sur laquelle notre IA s'appuiera
pour trouver une solution. Puis, nous préciserons comment nous allons simuler l'ensemble du processus. Et
nalement, nous expliquerons le fonctionnement global du serveur et comment l'IA fonctionne.
Paramètres:
• la température atmosphérique moyenne mensuelle
• la plage optimale de températures du serveur qui sera [18◦ C, 24◦ C]
• la température minimale du serveur en dessous de laquelle il est défaillant qui sera −20◦ C
• la température maximale du serveur au-dessus de laquelle il est défaillant qui sera 80◦ C
• le nombre minimum d'utilisateurs dans le serveur qui sera de 10
• le nombre maximum d'utilisateurs dans le serveur qui sera de 100
• le nombre maximum d'utilisateurs dans le serveur qui peut monter ou descendre par minute, soit 5
• le taux minimum de transmission de données dans le serveur qui sera de 20
• le taux maximum de transmission de données dans le serveur qui sera de 300
• le taux maximum de transmission de données qui peut augmenter ou diminuer par minute, soit 10
Variables :
• la température du serveur chaque minute
• le nombre d'utilisateurs dans le serveur chaque minute
• le taux de transmission des données chaque minute
• l'énergie dépensée par l'IA sur le serveur (pour le refroidir ou le réchauer) chaque minute
• l'énergie dépensée par le système de refroidissement intégré qui ramène automatiquement la tempéra-
ture du serveur à la plage optimale lorsque la température dépasse cette plage optimale
Page 24 of 103
Tous ces paramètres et variables feront partie de notre environnement de serveur et inuenceront les actions
de l'IA sur le serveur.
Ensuite, donnons et expliquons ci-dessous les deux principales hypothèses de l'environnement. Il est impor-
tant de comprendre que ces hypothèses ne sont pas liées à l'IA, mais simplement utilisées pour simplier
l'environnement an que nous puissions nous concentrer au maximum sur la solution d'IA.
Hypothèses :
Nous nous appuierons sur les deux principales hypothèses suivantes :
Hypothèses 1 : La température du serveur peut être approchée par Régression Linéaire Mul-
tiple, par une fonction linéaire de la température atmosphérique, le nombre d'utilisateurs et
la vitesse de transmission des données :
bre
température du serveur = b0 +b1 ×température atmosphérique+b2 ×n d'utilisateurs+b3 ×taux de transmission de données
où b0 ∈ R, b1 > 0, b2 > 0 et b3 > 0.
La raison d'être de cette hypothèse et la nalité pour laquelle b1 > 0, b2 > 0 et b3 > 0 sont intuitifs. En eet,
il est logique que lorsque la température atmosphérique augmente, la température du serveur augmente. De
plus, plus il y a d'utilisateurs actifs dans le serveur, plus le serveur doit dépenser d'énergie, et donc plus la
température du serveur sera élevée. Enn, plus il y a de données transmises dans le serveur, plus le serveur
doit dépenser d'énergie pour les traiter, et donc plus la température du serveur sera élevée. Et pour ces
raisons, nous supposons simplement que ces corrélations sont linéaires. Cependant, vous pouvez exécuter
la même simulation en supposant qu'elles sont quadratiques ou logarithmiques. N'hésitez pas à faire des
ajustements.
Supposons qu'après avoir eectué cette régression linéaire multiple, nous avons obtenu les valeurs suivantes
des coecients : b0 = 0, b1 = 1, b2 = 1.25 et b3 = 1.25. Par conséquent :
re
température du serveur = température atmosphérique+1.25×n d'utilisateurs+1.25×taux de transmission de données
Hypothèse 2 : L'énergie dépensée par un système (notre IA ou le système de refroidissement

intégré du serveur) qui modie la température du serveur de Tt à Tt+1 en 1 unité de temps
(ici 1 minute), peut être rapprochée de nouveau par régression par une fonction linéaire de la
variation absolue de température du serveur :
Et = α|∆Tt | + β = α|Tt+1 − Tt | + β
où :



 Et est l'énergie dépensée par le système sur le serveur entre les temps t et t + 1 minute

∆Tt est le changement de la température du serveur causé par le système entre les temps t t

et + 1 minute





T est la température du serveur au temps t
t


 Tt+1 est la température du serveur au temps t + 1 minute

α>0





β ∈ R

Page 25 of 103
Expliquons pourquoi il est intuitivement logique de faire cette supposition avec α > 0. C'est simplement
parce que plus l'IA se réchaue ou se refroidit sur le serveur, plus elle dépense d'énergie pour eectuer ce
transfert thermique. P. ex., imaginez que le serveur est soudainement en surchaue et qu'il vient d'atteindre
80◦ C, après une unité de temps (1 minute) l'IA aura besoin de plus d'énergie pour remettre le serveur à sa
température optimale 24◦ C que de le ramener à 50◦ C p. ex. Encore une fois, nous supposons simplement
que ces corrélations sont linéaires. Aussi (au cas où vous vous poseriez la question), pourquoi prenons-nous
la valeur absolue ? C'est simplement parce que quand l'IA refroidit le serveur, Tt+1 < Tt , donc ∆T < 0. Et
bien sûr, une énergie est toujours positive, nous devons donc prendre la valeur absolue de ∆T .
Enn, par souci de simplicité, nous supposerons également que les résultats de la régression sont α=1 et
β = 0, pour obtenir l'équation nale suivante, basée sur l'hypothèse 2 :
(
Tt+1 − Tt if Tt+1 > Tt , c.-à-d. si le serveur est en surchaue
Et = |∆Tt | = |Tt+1 − Tt | =
Tt − Tt+1 if Tt+1 < Tt , c.-à-d. si le serveur est en refroidissement
Expliquons maintenant comment simuler le serveur des utilisateurs et de données entrantes et sortantes.
Simulation :
Le nombre d'utilisateurs et le taux de transmission de données uctueront au hasard pour simuler un serveur
réel. Cela conduit à une température aléatoire et l'IA doit comprendre le degré de froid ou de chaleur qu'elle
doit transférer an de ne pas détériorer les performances du serveur et en même temps, dépenser le moins
d'énergie possible en optimisant son transfert thermique.
Maintenant que nous avons une vision complète, expliquons le fonctionnement global du serveur et de l'IA
dans cet environnement.
Fonctionnement général :
Dans un data center, nous opérons avec un serveur spécique qui est contrôlé par les paramètres et variables
énumérés ci-dessus. Chaque minute, de nouveaux utilisateurs se connectent ou se déconnectent du serveur,
mettant ainsi à jour le nombre d'utilisateurs actifs. De même, chaque minute, de nouvelles données sont
transmises à l'intérieur ou à l'extérieur du serveur, mettant ainsi à jour le taux de transmission de données.
Ainsi, sur la base de l'hypothèse 1 ci-dessus, la température du serveur est mise à jour chaque minute.
Maintenant, concentrez-vous, parce que c'est là que vous comprendrez le rôle énorme de l'IA dans le serveur.
Deux systèmes possibles permettent de réguler la température du serveur : l'IA ou le système de refroidisse-
ment intégré. Le système de refroidissement intégré est un système inintelligent qui remet automatiquement
le serveur à sa température optimale. Expliquons cela plus en détail : lorsque la température est mise à
◦ ◦
jour toutes les minutes, le serveur peut soit rester dans la plage des températures optimales ([18 C, 24 C])
ou sortir de cette plage. Si il sort de la plage optimale, p. ex. 30◦ C, le système de refroidissement intégré
remettra automatiquement la température à la limite la plus proche de la plage optimale, à savoir 24◦ C.
Cependant, le système de refroidissement intégré ne le fera que lorsque l'IA n'est pas activée. Si l'IA est
activée, le système de refroidissement intégré est alors désactivé et c'est l'IA elle-même qui met à jour la
température. Mais l'IA le fait après quelques prévisions préalables, pas d'une manière déterministe comme
avec le système de refroidissement intégré. Avant qu'il y ait une mise à jour du nombre d'utilisateurs et
du taux de transmission de données entraînant une modication de la température du serveur, l'IA prédit
s'il faut refroidir le serveur, ne rien faire ou le réchauer. Puis le changement de température se produit
et l'IA le répète. Et comme ces deux systèmes sont complémentaires, nous les évaluerons séparément pour
comparer leurs performances.
Page 26 of 103
Cela nous amène à l'énergie. N'oubliez pas qu'un des principaux objectifs de l'IA est d'économiser l'énergie
dépensée dans ce serveur. Par conséquent, notre IA doit dépenser moins d'énergie que le système de re-
froidissement inintelligent. Sur la base de l'hypothèse 2 ci-dessus, l'énergie dépensée sur le serveur (par
n'importe quel système) est proportionnelle au changement de température dans une unité de temps :
(
Et = |∆Tt | = α|Tt+1 − Tt | =
alors cela signie que l'énergie économisée par l'IA à chaque itération t (chaque minute) est en fait la
diérence de changements absolus de température dans le serveur entre le système de refroidissement intégré
inintelligent et l'IA depuis t et t+1 :
Énergie économisée par l'IA entre t et t + 1 = |∆TtSystème de refroidissement intégré | − |∆TtAI |

= |∆TtnoAI | − |∆TtAI |
où :
∆TtnoAI est le changement de température que le système de refroidissement



 intégré provoquerait


sans l'IA sur le serveur pendant l'itération t, c'est-à-dire de t à t + 1 minute


∆TtAI est le changement de température causé par l'IA dans le serveur pendant l'itération t,

t t+1

c'est-à-dire de à minute
Notre objectif sera d'économiser le maximum d'énergie chaque minute, donc d'économiser le maximum
d'énergie sur une année complète de simulation et économiser le maximum de coûts dans la facture d'électricité/chauage.
Êtes-vous prêt ?
Génial ! Maintenant que nous comprenons parfaitement comment fonctionne notre environnement de serveur,
il est temps de procéder avec ce qui doit absolument être fait lors de la dénition d'un environnement d'IA :
• Dénir les états
• Dénir les actions
• Dénir les récompenses
Dénir les états.

L'état initial st au temps t est composé des trois éléments suivants :
1. La température du serveur au temps t.
2. Le nombre d'utilisateurs dans le serveur au temps t.
3. Le taux de transmission des données dans le serveur au temps t.
Donc l'état initial sera un vecteur d'entrée de ces trois éléments. Notre future IA prendra ce vecteur comme
entrée, et indique l'action à un temps donné t.
Page 27 of 103
Dénir les actions.

Les actions sont simplement les changements de température que l'IA peut provoquer dans le serveur an
de le réchauer ou le refroidir. pour rendre nos actions discrètes, nous considérerons 5 changements de
◦
température possibles de −3 C à +3◦ C, de sorte que l'on se retrouve avec les 5 actions possibles suivantes
que l'IA peut exécuter pour réguler la température du serveur :
Action Eet
0 L'IA refroidit le serveur de 3◦ C
1 L'IA refroidit le serveur de 1.5◦ C
2 L'IA ne transfère pas de chaleur au serveur (pas de changement de température)
3 L'IA réchaue le serveur de 1.5◦ C
4 L'IA réchaue le serveur de 3◦ C
Dénir les récompenses.

Après avoir lu le paragraphe "Fonctionnement général" ci-dessus, vous pouvez deviner quelle sera la récom-
pense. Bien sûr, la récompense à l'itération t est l'énergie dépensée sur le serveur que l'IA économise par
rapport au système de refroidissement intégré, c'est-à-dire la diérence entre l'énergie que le système de
refroidissement inintelligent dépenserait si l'IA était désactivée et celle que l'IA dépense sur le serveur :
Récompenset = EtnoAI − EtAI

Et puisque (Hypothèse 2) l'énergie dépensée est égale au changement de température provoqué sur le serveur
(par tout système, y compris l'IA ou le système de refroidissement inintelligent) :
(
Et = |∆Tt | = α|Tt+1 − Tt | =
on constate alors que la récompense obtenue au temps t est en fait la diérence de changement de température
provoquée dans le serveur entre le système de refroidissement inintelligent (c.-à-d. sans IA) et l'IA :
Récompenset = Énergie économisée par l'IA entre t et t+1

= EtnoAI − EtAI
= |∆T noAI | − |∆T AI |
t t
Où :
∆TtnoAI est le changement de température que le système de refroidissement



 intégré provoquerait


sans l'IA dans le serveur pendant l'itération t, c.-à-d. de t à t + 1 minute


 ∆TtAI est le changement de température causé par l'IA dans le serveur pendant l'itération t,

t t+1

c.-à-d. de à minute
Remarque importante : il faut comprendre que les systèmes (l'IA et le système de refroidissement du
serveur) seront évalués séparément pour calculer les récompenses. Et comme leurs actions mènent à des
températures diérentes, nous devrons garder une traçabilité séparée de ces deux températures TtAI et TtnoAI .
Maintenant, pour terminer cette section, nous allons faire une petite simulation de 2 itérations (c'est-à-dire
2 minutes), comme un exemple qui clariera tout.
Page 28 of 103
Exemple de simulation nale.

Disons que nous sommes au temps t = 4 : 00 p.m. et que la température du serveur est Tt = 28◦ C avec
et sans IA. À ce temps précis, l'IA prédit l'action 0, 1, 2, 3 ou 4. Puisque la température du serveur n'est
pas dans la plage de température optimale [18◦ C, 24◦ C], l'IA prédira probablement les actions 0, 1 ou 2.
Supposons qu'elle prédit 1, ce qui correspond au refroidissement du serveur de 1.5◦ C. Par conséquent, entre
t = 4 : 00 p.m. AI = 28◦ C à T AI = 26.5◦ C.
et t + 1 = 4 : 01 p.m., l'IA change la température du serveur de Tt t+1
∆TtAI = Tt+1
AI − T AI
t
= 26.5 − 27
= −1.5◦ C
Ainsi, sur la base de l'hypothèse 2, l'énergie dépensée par l'IA dans le serveur est la suivante :
EtAI = |∆TtAI |
= 1.5 Joules
Bon ! Il ne manque plus qu'une seule info pour calculer la récompense : c'est l'énergie que le système de
refroidissement intégré aurait dépensée si l'IA avait été désactivée entre 16 h et 16 h 01. Rappelez-vous que
ce système de refroidissement inintelligent ramène automatiquement la température du serveur à la limite la
plus proche de la plage de température optimale [18◦ C, 24◦ C]. Donc depuis t = 4 : 00 p.m. la température
◦
était Tt = 28 C, alors la limite la plus proche de la plage de température optimale à ce temps-là était
24◦ C. Ainsi, le système de refroidissement intégré aurait réduit la température du serveur de Tt = 28◦ C à
Tt+1 = 24◦ C, et donc le changement de température qui se serait produit s'il n'y avait pas eu d'IA est le
suivant :
∆TtnoAI = Tt+1
noAI − T noAI
t
= 24 − 28
= −4◦ C
Ainsi, sur la base de l'hypothèse 2, l'énergie que le système de refroidissement inintelligent aurait dépensée
s'il n'y avait pas eu d'IA est la suivante :
EtnoAI = |∆TtnoAI |
=4 Joules
En conclusion, la récompense obtenue après l'exécution de cette action au temps t = 4 : 00 p.m. est :
Récompense = EtnoAI − EtAI

= 4 − 1.5
= 2.5
Page 29 of 103
Puis, entre t = 4 : 00 p.m. et t + 1 = 4 : 01 p.m., d'autres actions se produisent : de nouveaux utilisateurs

se connectent au serveur, des utilisateurs actuels se déconnectent, de nouvelles données sont transmises à
l'intérieur et d'autres données existantes à l'extérieur du serveur. En se basant sur l'hypothèse 1, ces facteurs
modient la température du serveur. Supposons qu'elles augmentent la température de 5◦ C :
∆t Température intrinsèque = 5◦ C
Rappelez-vous maintenant que nous évaluons deux systèmes séparément : notre IA et le système de re-
froidissement intégré du serveur. Par conséquent, nous devons calculer séparément les deux températures
que nous obtiendrions avec ces deux systèmes à t + 1 = 4 : 01 p.m. Commençons par l'IA.
La température que nous obtenons à t + 1 = 4 : 01 p.m. quand l'IA est activée est :
AI = T AI + ∆T AI + ∆t
Tt+1 Température intrinsèque
t t
= 28 + (−1.5) + 5
= 31.5◦ C
Et la température que nous obtenons à t + 1 = 4 : 01 p.m. quand l'IA n'est pas activée est :
noAI = T noAI + ∆T noAI + ∆t

Tt+1 Température intrinsèque
t t
= 28 + (−4) + 5
= 29◦ C
Parfait ! nous avons nos deux températures séparées qui sont

AI = 29.5◦ C
Tt+1 lorsque l'IA est activée, et
T noAI = 27◦ C
t+1 lorsque l'IA n'est pas activée.
Maintenant, simulons ce qui se passe entre t + 1 = 4 : 01 p.m. et t + 2 = 4 : 02 p.m. Encore une fois, notre
IA fera une prédiction, et puisque le serveur se réchaue, disons qu'il prédit l'action 0, ce qui correspond au
refroidissement du serveur de
AI = 28.5◦ C .
3◦ C , le ramenant à Tt+2 Par conséquent, l'énergie dépensée par
l'IA entre t + 1 = 4 : 01 p.m. et t + 2 = 4 : 02 p.m., est :
AI = |∆T AI |
Et+1 t+1
= |28.5 − 31.5|
=3 Joules
En ce qui concerne le système de refroidissement intégré du serveur (c.-à-d. sans l'IA), depuis t + 1 = 4 : 01
p.m. nous avions
noAI = 29◦ C ,
Tt+1 alors la limite la plus proche de la plage optimale de températures est
toujours 24◦ C , et donc l'énergie que le système de refroidissement inintelligent du serveur dépenserait entre
t + 1 = 4 : 01 p.m. et t + 2 = 4 : 02 p.m., est :
noAI = |∆T noAI |

Et+1 t+1
= |24 − 29|
=5 Joules
Ainsi, la récompense obtenue entre t + 1 = 4 : 01 p.m. et t + 2 = 4 : 02 p.m. est :
Page 30 of 103
Récompense
noAI − E AI
= Et+1 t+1
=5−3
=2
Et enn, la récompense totale obtenue entre t = 4 : 00 p.m. et t + 2 = 4 : 02 p.m. est :
Récompense totale = (Récompense obtenue entre t et t + 1) + (Récompense obtenue entre t+1 et t + 2)

= 2.5 + 2
= 4.5
C'est un exemple de tout le processus qui s'est déroulé en deux minutes. Dans notre implémentation, nous
exécuterons le même processus sur 1000 époques de 5 mois pour l'apprentissage, puis, une fois notre IA
intégrée, nous exécuterons le même processus sur 1 an complet de simulation pour les tests. La préparation
se fera avec Deep Q-Learning, et c'est ici que la section suivante entre en ligne.
2.2 Solutions d'IA

La solution d'IA qui résoudra le problème décrit ci-dessus est un modèle Deep Q-Learning. Donnons
l'intuition et les équations mathématiques que cela implique.
2.2.1 Du Q-Learning au Deep Learning

Le Deep Q-Learning consiste à combiner le Q-Learning à un réseau de neurones articiel. Les entrées sont
des vecteurs codés, chacune dénissant un état de l'environnement. Ces entrées intègrent un réseau où la
sortie est l'action à exécuter. Disons que le processus d'exécution a n actions possibles, la couche de sortie
est composée de n neurones de sortie, chacun correspondant aux Q-value de chaque action exécutée dans
l'état courant. Ensuite, l'action exécutée est celle associée au neurone de sortie qui a la Q-value la plus élevée
(argmax), ou celle rendue par la méthode softmax. Dans notre cas, nous utiliserons argmax. Comme les
Q-values sont des nombres réels, notre système est donc un réseau neuronal de régression.
Ainsi, dans chaque état st :
• la prédiction est la Q-value Q(st , at ) où at est choisi par argmax ou softmax
• la cible est rt + γmax(Q(st+1 , a))

a
• l'erreur de perte entre la prédiction et la cible est le carré de la diérence temporelle :
1 2 1
La perte = rt + γmax(Q(st+1 , a)) − Q(st , at ) = T Dt (st , at )2
2 a 2
Ensuite, cette erreur de perte est rétropropagée dans le réseau, et les poids sont mis à jour en fonction de
leur contribution à l'erreur.
2.2.2 L'Experience Replay

Nous remarquons que jusqu'ici, nous n'avons considéré que les transitions d'un seul état st à l'état suivant
st+1 . Le problème, c'est que st est la plupart du temps en corrélation avec st+1 . Ainsi, le réseau n'apprend
pas grand-chose. Cela pourrait être amélioré si, au lieu d'examiner cette transition précédente seulement,
nous avons examiné les dernières transitions m où m est un grand nombre. Ce pack de dernières transitions m
est ce qu'on appelle l'Experience Replay. Ensuite, à partir de ce retour d'expérience, nous prenons quelques
lots de transitions aléatoires pour faire nos mises à jour.
Page 31 of 103
2.2.3 Le cerveau
Le cerveau, ou plus précisément le Deep Neural Network de notre IA, sera un réseau de neurones entièrement
connecté, composé de deux couches cachées, la première ayant 64 neurones et la seconde 32 neurones.
Rappelons que ce réseau a comme entrée les états de l'environnement et comme sortie les Q-Values pour
chacune des 5 actions. Ce cerveau articiel sera examiné avec une perte d'"Erreur quadratique moyenne" et
l'optimiseur Adam.
Voici à quoi ressemble ce cerveau articiel :
Figure 2: Le cerveau articiel : Un réseau de neurones entièrement connecté
Ce cerveau articiel semble complexe à créer, mais nous le concevons très facilement grâce au module Keras.
Voici un aperçu de l'implémentation complète contenant la partie qui permet de développer ce cerveau :
# Building the Brain
class Brain(object):
5 def __init__(self, learning_rate = 0.001, number_actions = 11):

self.learning_rate = learning_rate
states = Input(shape = (3,))
x = Dense(units = 64, activation = ’sigmoid’)(states)
y = Dense(units = 32, activation = ’sigmoid’)(x)
10 q_values = Dense(units = number_actions, activation = ’softmax’)(y)
self.model = Model(inputs = states, outputs = q_values)
self.model.compile(loss = ’mse’, optimizer = Adam(lr = self.learning_rate))
Comme nous pouvons le voir clairement, il n'a fallu que quelques lignes de code.
2.2.4 L'algorithme Deep Q-Learning complet
Résumons les diérentes étapes de tout le processus du Deep Q-Learning :
Page 32 of 103
Initialisation :
La mémoire de l'Experience Replay est initialisée sur une liste vide M.
Nous choisissons une taille de mémoire. Dans notre étude de cas : une taille maximale de 100 transitions.
Nous commençons dans un premier état, correspondant à un temps spécique durant l'année.
Dans chaque temps t, nous répétons le processus suivant, jusqu'à la n de l'époque (5 mois
dans notre implémentation) :
1. Nous prédisons les Q-Values de l'état actuel st .
2. Nous exécutons l'action qui correspond au maximum de ces Q-Values (méthode argmax) :
at = argmaxQ(st , a)
a
3. Nous obtenons la récompense :
rt = EtnoAI − EtAI
4. Nous arrivons à l'état suivant st+1 .
5. Nous annexons la transition (st , at , rt , st+1 ) à M.
6. Nous prenons un lot de transitions aléatoire B ⊂ M. Pour toutes les transitions (stB , atB , rtB , stB +1 )
du lot aléatoire B :
• Nous obtenons les prédictions :
Q(stB , atB )
• Nous obtenons les cibles :
rtB + γmax(Q(stB +1 , a))

a
• Nous calculons la perte entre les prédictions et les cibles sur l'ensemble du lot B :
1 X 2 1X
La perte = rtB + γmax(Q(stB +1 , a)) − Q(stB , atB ) = T DtB (stB , atB )2
2 a 2
B B
• Nous retransmettons cette erreur de perte dans le réseau de neurones. Par la descente de gradient
stochastique, nous mettrons à jour les poids en fonction de leur contribution à l'erreur.
Page 33 of 103
2.3 Implémentation
Cette implémentation sera divisée en 5 parties, chaque partie ayant son propre chier Python. Ces 5 parties
constituent le cadre général ou plan directeur de l'IA qui doit être suivi chaque fois que nous créerons un
environnement pour résoudre un problème d'entreprise avec le Deep Reinforcement Learning.
Les voici, de l'étape 1 à l'étape 5 :
1. Étape 1 : Créer l'environnement.
2. Étape 2 : Développer le cerveau.
3. Étape 3 : Implémenter l'algorithme du Deep Reinforcement Learning (dans notre cas, ce sera le
modèle DQN).
4. Étape 4 : Former l'IA.
5. Étape 5 : Tester l'IA.
Ce sont les principales étapes (dans le même ordre) du cadre général de l'IA. Implémentons donc notre IA
pour notre étude de cas en suivant ce plan directeur dans les cinq sections suivantes correspondant à ces cinq
étapes principales. Par ailleurs, à chaque étape, nous distinguerons les sous-étapes qui font encore partie du
cadre général de l'IA des sous-étapes propres à notre étude de cas en écrivant les titres des sections de code
en majuscules pour toutes les sous-étapes du cadre général d'IA, et en minuscules pour toutes les sous-étapes
propres à notre étude de cas. Cela signie que chaque fois que vous voyez une nouvelle section de code dont
le titre est écrit en majuscules, il s'agit de la prochaine sous-étape du cadre général de l'IA que vous devriez
également suivre lorsque vous créez une IA pour votre propre problème d'entreprise.
Et maintenant, c'est le début du voyage : Étape 1 - Créer l'environnement.
C'est le plus gros chier d'implémentation Python de cette étude de cas et du cours en général. Alors
n'oubliez pas de vous reposer avant, de recharger vos batteries pour avoir une bonne réserve d'énergie, et
dès que vous êtes prêt, nous allons attaquer ensemble !
Nous commençons à la page suivante.
Page 34 of 103
2.3.1 Étape 1 : Créer l'environnement

Dans cette première étape, nous allons créer l'environnement dans une classe. Pourquoi une classe ? Parce
que nous aimerions avoir notre environnement comme un objet que nous pouvons créer facilement avec
n'importe quelle valeur de certains paramètres que nous choisissons. p. ex., nous pouvons créer un objet
pour un serveur qui a un certain nombre d'utilisateurs connectés et un certain taux de données à un temps
précis, et un autre objet pour un autre serveur qui a un nombre diérent d'utilisateurs connectés et un
taux diérent de données à un autre temps précis. Grâce à cette structure avancée de classe, nous pouvons
facilement connecter et exécuter les objets de l'environnement que nous créons sur diérents serveurs qui ont
leurs propres paramètres, régulant ainsi leur température avec plusieurs diérentes IAs, de sorte que nous
nissons par minimiser la consommation énergétique d'un data center entier, tout comme DeepMind a fait
avec son algorithme DQN pour Google data center.
Cette classe suit les sous-étapes ci-dessous, qui font partie du cadre général de l'IA de l'étape 1 - Créer
l'environnement :
1. Étape 1-1: Introduire et initialiser tous les paramètres et variables de l'environnement.
2. Étape 1-2: Créer une méthode qui actualise l'environnement après l'exécution d'une action par l'IA.
3. Étape 1-3: Créer une méthode qui réinitialise l'environnement.
4. Étape 1-4: Créer une méthode qui nous donne à tout moment l'état actuel, la dernière récompense
obtenue et si le processus d'exécution est terminé.
Vous trouverez l'implémentation complète de cette classe Environnement dans les quatre pages suivantes.
N'oubliez pas le plus important : toutes les sections de code dont le titre est écrit en majuscules sont les
étapes du cadre général de l'IA, et toutes les sections de code dont le titre est écrit en minuscules sont propres
à notre étude de cas.
Ci-dessous se trouve l'implémentation complète de notre premier chier Python. Les titres des sections de
code et les noms des variables choisies sont susamment clairs pour comprendre ce code, mais si vous avez
besoin de plus d'explications, je vous encourage à regarder nos tutoriels vidéo où nous expliquons tout à
partir de zéro, étape par étape, en dénissant chaque ligne de code. Nous y voilà :
# Artificial Intelligence for Business - Case Study 2

# Building the Environment

# BUILDING THE ENVIRONMENT IN A CLASS
class Environment(object):
10
# INTRODUCING AND INITIALIZING ALL THE PARAMETERS AND VARIABLES OF THE ENVIRONMENT
def __init__(self,
optimal_temperature = (18.0, 24.0),
15 initial_month = 0,
initial_number_users = 10,
initial_rate_data = 60):
self.monthly_atmospheric_temperatures = [1.0, 5.0, 7.0, 10.0, 11.0, 20.0,
Page 35 of 103
23.0, 24.0, 22.0, 10.0, 5.0, 1.0]

20 self.initial_month = initial_month
self.atmospheric_temperature = \
self.monthly_atmospheric_temperatures[initial_month]
self.optimal_temperature = optimal_temperature
self.min_temperature = -20
25 self.max_temperature = 80
self.min_number_users = 10
self.max_number_users = 100
self.max_update_users = 5
self.min_rate_data = 20
30 self.max_rate_data = 300
self.max_update_data = 10
self.initial_number_users = initial_number_users
self.current_number_users = initial_number_users
self.initial_rate_data = initial_rate_data
35 self.current_rate_data = initial_rate_data
self.intrinsic_temperature = self.atmospheric_temperature
+ 1.25 * self.current_number_users
+ 1.25 * self.current_rate_data
self.temperature_ai = self.intrinsic_temperature
40 self.temperature_noai = (self.optimal_temperature[0]
+ self.optimal_temperature[1]) / 2.0
self.total_energy_ai = 0.0
self.total_energy_noai = 0.0
self.reward = 0.0
45 self.game_over = 0
self.train = 1
# MAKING A METHOD THAT UPDATES THE ENVIRONMENT RIGHT AFTER THE AI PLAYS AN ACTION
50
def update_env(self, direction, energy_ai, month):
# GETTING THE REWARD
55 # Computing the energy spent by the server’s cooling system when there is no AI
energy_noai = 0
i f (self.temperature_noai < self.optimal_temperature[0]):
energy_noai = self.optimal_temperature[0] - self.temperature_noai
self.temperature_noai = self.optimal_temperature[0]
60 elif (self.temperature_noai > self.optimal_temperature[1]):
energy_noai = self.temperature_noai - self.optimal_temperature[1]
self.temperature_noai = self.optimal_temperature[1]
# Computing the Reward
self.reward = energy_noai - energy_ai
65 # Scaling the Reward
self.reward = 1e-3 * self.reward
# GETTING THE NEXT STATE
70 # Updating the atmospheric temperature

self.atmospheric_temperature = self.monthly_atmospheric_temperatures[month]
Page 36 of 103
# Updating the number of users

self.current_number_users += np.random.randint(-self.max_update_users,
self.max_update_users)
75 i f (self.current_number_users > self.max_number_users):
self.current_number_users = self.max_number_users
elif (self.current_number_users < self.min_number_users):
self.current_number_users = self.min_number_users
# Updating the rate of data
80 self.current_rate_data += np.random.randint(-self.max_update_data,
self.max_update_data)
i f (self.current_rate_data > self.max_rate_data):
self.current_rate_data = self.max_rate_data
elif (self.current_rate_data < self.min_rate_data):
85 self.current_rate_data = self.min_rate_data
# Computing the Delta of Intrinsic Temperature
past_intrinsic_temperature = self.intrinsic_temperature
self.intrinsic_temperature = self.atmospheric_temperature
90 + 1.25 * self.current_rate_data
delta_intrinsic_temperature = self.intrinsic_temperature
- past_intrinsic_temperature
# Computing the Delta of Temperature caused by the AI
i f (direction == -1):
95 delta_temperature_ai = -energy_ai
elif (direction == 1):
delta_temperature_ai = energy_ai
# Updating the new Server’s Temperature when there is the AI
self.temperature_ai += delta_intrinsic_temperature + delta_temperature_ai
100 # Updating the new Server’s Temperature when there is no AI
self.temperature_noai += delta_intrinsic_temperature
# GETTING GAME OVER
105 i f (self.temperature_ai < self.min_temperature):

i f (self.train == 1):
self.game_over = 1
else :
self.total_energy_ai += self.optimal_temperature[0]
110 - self.temperature_ai
self.temperature_ai = self.optimal_temperature[0]
elif (self.temperature_ai > self.max_temperature):
i f (self.train == 1):
self.game_over = 1
115 else :
self.total_energy_ai += self.temperature_ai
- self.optimal_temperature[1]
self.temperature_ai = self.optimal_temperature[1]
120 # UPDATING THE SCORES
# Updating the Total Energy spent by the AI

self.total_energy_ai += energy_ai
# Updating the Total Energy spent by the alternative system when there is no AI
Page 37 of 103
125 self.total_energy_noai += energy_noai
# SCALING THE NEXT STATE
scaled_temperature_ai = (self.temperature_ai - self.min_temperature)

130 / (self.max_temperature - self.min_temperature)
scaled_number_users = (self.current_number_users - self.min_number_users)
/ (self.max_number_users - self.min_number_users)
scaled_rate_data = (self.current_rate_data - self.min_rate_data)
/ (self.max_rate_data - self.min_rate_data)
135 next_state = np.matrix([scaled_temperature_ai,
scaled_number_users,
scaled_rate_data])
# RETURNING THE NEXT STATE, THE REWARD, AND GAME OVER

140
return next_state, self.reward, self.game_over
# MAKING A METHOD THAT RESETS THE ENVIRONMENT
145 def reset (self, new_month):

self.atmospheric_temperature = self.monthly_atmospheric_temperatures[new_month]
self.initial_month = new_month
self.current_number_users = self.initial_number_users
self.current_rate_data = self.initial_rate_data
150 self.intrinsic_temperature = self.atmospheric_temperature
+ 1.25 * self.current_rate_data
self.temperature_ai = self.intrinsic_temperature
self.temperature_noai = (self.optimal_temperature[0]
155 + self.optimal_temperature[1]) / 2.0
self.total_energy_ai = 0.0
self.total_energy_noai = 0.0
self.reward = 0.0
self.game_over = 0
160 self.train = 1
# MAKING A METHOD THAT GIVES US AT ANY TIME THE STATE, THE REWARD AND GAMEOVER
def observe(self):
165 scaled_temperature_ai = (self.temperature_ai - self.min_temperature)
/ (self.max_temperature - self.min_temperature)
scaled_number_users = (self.current_number_users - self.min_number_users)
/ (self.max_number_users - self.min_number_users)
scaled_rate_data = (self.current_rate_data - self.min_rate_data)
170 / (self.max_rate_data - self.min_rate_data)
current_state = np.matrix([scaled_temperature_ai,
scaled_number_users,
scaled_rate_data])
return current_state, self.reward, self.game_over
Félicitations pour l'implémentation de l'étape 1 - Créer l'environnement. Passons maintenant à l'étape 2 -

Développer le cerveau.
Page 38 of 103
2.3.2 Étape 2 : Développer le cerveau

Dans cette étape 2, nous allons développer le cerveau articiel de notre IA, qui n'est rien d'autre qu'un
réseau de neurones entièrement connecté. Le revoilà :
Figure 3: Le cerveau articiel : Un réseau de neurones entièrement connecté
Encore une fois, nous allons développer ce cerveau articiel dans une classe, pour la même raison permettant
de développer plusieurs cerveaux articiels pour diérents serveurs dans un data center. En eet, certains
serveurs auront peut-être besoin de cerveaux articiels avec des hyperparamètres diérents. Grâce à cette
structure avancée de classe / objet Python, nous pouvons facilement passer d'un cerveau à un autre pour
réguler la température d'un nouveau serveur qui nécessite une IA avec diérents paramètres de réseaux.
Nous développons ce cerveau articiel grâce au module Keras. Nous utilisons la Dense() class pour créer
nos deux couches cachées entièrement connectées, la première ayant 64 neurones cachés et la seconde 32
neurones. Nous utilisons à nouveau la Dense() class pour donner les Q-Values qui sont les sorties des réseaux
neuronaux articiels. Plus tard dans la formation et les chiers de test, nous utiliserons la méthode argmax
pour sélectionner l'action qui a la Q-Value maximale. Ensuite, nous assemblons tous les composants du
cerveau y compris les entrées et les sorties en le développant comme un objet Model() class (très utile pour
sauvegarder et charger un modèle avec des poids spéciques). Nous nissons par le compiler avec une erreur
de perte quadratique moyenne et l'optimiseur Adam. Voici les nouvelles étapes :
1. Étape 2-1 : Développer la couche d'entrée composée des états d'entrée.
2. Étape 2-2 : Développer les couches cachées avec un nombre déni et des neurones à l'intérieur de
chacune d'elles, entièrement connectés à la couche d'entrée et entre elles.
3. Étape 2-3 : Développer la couche de sortie, entièrement connectée à la dernière couche cachée.
4. Étape 2-4 : Assembler l'architecture complète à l'intérieur d'un objet modèle.
5. Étape 2-5 : Compiler avec une fonction d'erreur de perte quadratique moyenne et un optimiseur.
Nous y voilà avec l'implémentation :
Page 39 of 103


5 from keras.layers import Input, Dense
from keras.models import Model
from keras.optimizers import Adam
# BUILDING THE BRAIN

10
# BUILDING A FULLY CONNECTED NEURAL NETWORK DIRECTLY INSIDE THE INIT METHOD

# BUILDIND THE INPUT LAYER COMPOSED OF THE INPUT STATE

20
# BUILDING THE FULLY CONNECTED HIDDEN LAYERS
25 # BUILDING THE OUTPUT LAYER, FULLY CONNECTED TO THE LAST HIDDEN LAYER
q_values = Dense(units = number_actions, activation = ’softmax’)(y)
# ASSEMBLING THE FULL ARCHITECTURE INSIDE A MODEL OBJECT

30
# COMPILING THE MODEL WITH A MEAN-SQUARED ERROR LOSS AND A CHOSEN OPTIMIZER
self.model.compile(loss = ’mse’, optimizer = Adam(lr = learning_rate))
Le Dropout.
J'ai pensé qu'il est utile d'ajouter une technique plus puissante dans votre boîte à outils : le Dropout.
Le Dropout est une technique de régularisation qui permet d'éviter le surapprentissage. Il consiste simplement
à désactiver un certain taux de neurones aléatoires à chaque étape de propagation et rétropropagation. De
cette façon, tous les neurones évoluent diéremment, ce qui empêche le surapprentissage des données par le
réseau de neurones.
Voici comment implémenter le Dropout :
1. Premièrement, importer le Dropout :
from keras.layers:from keras.layers import Input, Dense, Dropout
2. Ensuite, activer le Dropout dans la première couche cachée x, avec un taux de 0.1, ce qui signie que
10% des neurones seront désactivés de manière aléatoire :
Page 40 of 103

x = Dropout(rate = 0.1)(x)
3. Enn, activez le Dropout dans la deuxième couche cachée y, avec un taux de 0.1, ce qui signie que
10% des neurones seront désactivés de manière aléatoire :

y = Dropout(rate = 0.1)(y)
Félicitations ! Vous avez implémenté le Dropout. C'était très simple, encore une fois grâce à Keras.
Ci-dessous la toute nouvelle implémentation de Brain.py avec le Dropout :


5 from keras.layers import Input, Dense, Dropout

10


20
# BUILDING THE FIRST FULLY CONNECTED HIDDEN LAYER WITH DROPOUT ACTIVATED
x = Dropout(rate = 0.1)(x)
25 # BUILDING THE SECOND FULLY CONNECTED HIDDEN LAYER WITH DROPOUT ACTIVATED
y = Dropout(rate = 0.1)(y)
# BUILDING THE OUTPUT LAYER, FULLY CONNECTED TO THE LAST HIDDEN LAYER
30 q_values = Dense(units = number_actions, activation = ’softmax’)(y)

35 # COMPILING THE MODEL WITH A MEAN-SQUARED ERROR LOSS AND A CHOSEN OPTIMIZER
Passons à l'étape suivante de notre cadre général de l'IA : Étape 3 - Implémenter l'algorithme DQN.
Page 41 of 103
2.3.3 Étape 3 : Implémentation de l'algorithme du Deep Reinforcement Learning

Dans ce nouveau chier Python, nous n'avons qu'à suivre l'algorithme du Deep Q-Learning fourni précédem-
ment. Cette implémentation suit donc les sous-étapes suivantes qui font partie du cadre général de l'IA :
1. Étape 3-1 : Introduction et initialisation de tous les paramètres et variables du modèle DQN.
2. Étape 3-2 : Créer une méthode qui génère la mémoire dans l'Experience Replay.
3. Étape 3-3 : Créer une méthode qui construit et donne deux lots de 10 entrées et 10 cibles.
Voici le code qui suit cette nouvelle partie du plan directeur de l'IA :

# Implementing Deep Q-Learning with Experience Replay

# IMPLEMENTING DEEP Q-LEARNING WITH EXPERIENCE REPLAY
class DQN(object):
10
# INTRODUCING AND INITIALIZING ALL THE PARAMETERS AND VARIABLES OF THE DQN
def __init__(self, max_memory = 100, discount = 0.9):
self.memory = list()
self.max_memory = max_memory
15 self.discount = discount
# MAKING A METHOD THAT BUILDS THE MEMORY IN EXPERIENCE REPLAY

def remember(self, transition, game_over):
self.memory.append([transition, game_over])
20 i f len(self.memory) > self.max_memory:
del self.memory[0]
# MAKING A METHOD THAT BUILDS TWO BATCHES OF INPUTS AND TARGETS

def get_batch(self, model, batch_size = 10):
25 len_memory = len(self.memory)
num_inputs = self.memory[0][0][0].shape[1]
num_outputs = model.output_shape[-1]
inputs = np.zeros((min(len_memory, batch_size), num_inputs))
targets = np.zeros((min(len_memory, batch_size), num_outputs))
30 for i, idx in enumerate(np.random.randint(0, len_memory,
size = min(len_memory, batch_size))):
current_state, action, reward, next_state = self.memory[idx][0]
game_over = self.memory[idx][1]
inputs[i] = current_state
35 targets[i] = model.predict(current_state)[0]
Q_sa = np.max(model.predict(next_state)[0])
i f game_over:
targets[i, action] = reward
else :
40 targets[i, action] = reward + self.discount * Q_sa
return inputs, targets
Page 42 of 103
2.3.4 Étape 4 : Formation de l'IA

Maintenant que notre IA a un cerveau pleinement fonctionnel, il est temps de la former. C'est exactement
ce que nous ferons dans ce quatrième chier Python. Le processus est long, mais très simple : on commence
par régler tous les paramètres, puis on crée l'environnement en créant un objet Environment() class, puis on
développe le cerveau de l'IA en créant un objet Brain() class, puis on construit le modèle Deep Q-Learning
en créant un objet DQN() class. Enn on lance la formation reliant tous ces objets ensemble, plus de 1000
époques dans une période de 5 mois. Vous remarquerez dans la boucle de formation que nous faisons aussi
un peu d'exploration en exécutant les actions. Cela consiste à exécuter des actions aléatoires d'un temps
à un autre. Dans notre étude de cas, cela se fera à 30% du temps, puisque nous utilisons un paramètre
d'exploration = 0.3, et puis nous exécutons une action aléatoire en choisissant une valeur aléatoire entre
0 et 1 qui est en dessous de = 0.3). La raison pour laquelle nous faisons de l'exploration est que cela
améliore le processus du Deep Reinforcement Learning. Cela s'appelle : "Exploration vs. Exploitation".
Ensuite, vous remarquerez également que nous utilisons une technique d'arrêt anticipé, qui assurera l'arrêt
de formation s'il y a amélioration des performances.
Soulignons ces nouvelles étapes qui font toujours partie de notre cadre général de l'IA / plan directeur :
1. Étape 4-1 : Créer l'environnement en créant un objet Environment class.
2. Étape 4-2 : Créer le cerveau articiel en créant un objet Brain class.
3. Étape 4-3 : Créer le modèle DQN en créant un objet DQN class.
4. Étape 4-4 : Choisir le mode de formation.
5. Étape 4-5 : Commencer la formation avec une boucle pour plus de 100 époques dans 5 mois.
6. Étape 4-6 : Pendant chaque étape, nous répétons tout le processus du Deep Q-Learning, tout en
faisant aussi de l'exploration 30% du temps.
Et maintenant, implémentons cette nouvelle partie de notre plan directeur, Étape 4 - Former l'IA. Ci-dessous
se trouve l'implémentation complète de ce quatrième chier Python. Encore une fois, les titres des sections
de code et les noms des variables choisis sont susamment clairs pour comprendre ce code. Et voilà ! C'est
parti !

# Training the AI
# Installing Keras
5 # conda install -c conda-forge keras
# Importing the libraries and the other python files

import os
import numpy as np
10 import random as rn
import environment
import brain
import dqn
15 # Setting seeds for reproducibility

os.environ[’PYTHONHASHSEED’] = ’0’
np.random.seed(42)
Page 43 of 103
rn.seed(12345)
20 # SETTING THE PARAMETERS

epsilon = .3
number_actions = 5
direction_boundary = (number_actions - 1) / 2
number_epochs = 100
25 max_memory = 3000
batch_size = 512
temperature_step = 1.5
# BUILDING THE ENVIRONMENT BY SIMPLY CREATING AN OBJECT OF THE ENVIRONMENT CLASS

30 env = environment.Environment(optimal_temperature = (18.0, 24.0),
initial_month = 0,
initial_rate_data = 30)
35 # BUILDING THE BRAIN BY SIMPLY CREATING AN OBJECT OF THE BRAIN CLASS

brain = brain.Brain(learning_rate = 0.00001, number_actions = number_actions)
# BUILDING THE DQN MODEL BY SIMPLY CREATING AN OBJECT OF THE DQN CLASS
dqn = dqn.DQN(max_memory = max_memory, discount = 0.9)
40
# CHOOSING THE MODE
train = True
# TRAINING THE AI
45 env.train = train
model = brain.model
early_stopping = True
patience = 10
best_total_reward = -np.inf
50 patience_count = 0
i f (env.train):
# STARTING THE LOOP OVER ALL THE EPOCHS (1 Epoch = 5 Months)
for epoch in range(1, number_epochs):
# INITIALIAZING ALL THE VARIABLES OF BOTH THE ENVIRONMENT AND THE TRAINING LOOP
55 total_reward = 0
loss = 0.
new_month = np.random.randint(0, 12)
env. reset (new_month = new_month)
game_over = False
60 current_state, _, _ = env.observe()
timestep = 0
# STARTING THE LOOP OVER ALL THE TIMESTEPS (1 Timestep = 1 Minute) IN ONE EPOCH
while ((not game_over) and timestep <= 5 * 30 * 24 * 60):
# PLAYING THE NEXT ACTION BY EXPLORATION
65 i f np.random.rand() <= epsilon:
action = np.random.randint(0, number_actions)
i f (action - direction_boundary < 0):
direction = -1
else :
70 direction = 1
Page 44 of 103
energy_ai = abs(action - direction_boundary) * temperature_step
# PLAYING THE NEXT ACTION BY INFERENCE

else :
75 q_values = model.predict(current_state)
action = np.argmax(q_values[0])
direction = -1
else :
80 direction = 1
# UPDATING THE ENVIRONMENT AND REACHING THE NEXT STATE
next_state, reward, game_over = env.update_env(direction,
energy_ai,
85 int (timestep / (30*24*60)))
total_reward += reward
# STORING THIS NEW TRANSITION INTO THE MEMORY
dqn.remember([current_state, action, reward, next_state], game_over)
# GATHERING IN TWO SEPARATE BATCHES THE INPUTS AND THE TARGETS
90 inputs, targets = dqn.get_batch(model, batch_size = batch_size)
# COMPUTING THE LOSS OVER THE TWO WHOLE BATCHES OF INPUTS AND TARGETS
loss += model.train_on_batch(inputs, targets)
timestep += 1
current_state = next_state
95 # PRINTING THE TRAINING RESULTS FOR EACH EPOCH
print ("\n")
print ("Epoch: {:03d}/{:03d}".format(epoch, number_epochs))
print ("Total Energy spent with an AI: {:.0f}".format(env.total_energy_ai))
print ("Total Energy spent with no AI: {:.0f}".format(env.total_energy_noai))
100 # EARLY STOPPING
i f (early_stopping):
i f (total_reward <= best_total_reward):
patience_count += 1
elif (total_reward > best_total_reward):
105 best_total_reward = total_reward
patience_count = 0
i f (patience_count >= patience):
print ("Early Stopping")
break
110 # SAVING THE MODEL
model.save("model.h5")
Après l'exécution du code, nous constatons déjà une bonne performance de notre IA pendant la forma-
tion, dépensant la plupart du temps moins d'énergie que le système alternatif, c'est-à-dire le système de
refroidissement intégré du serveur. Mais ce n'est que la formation, il faut maintenant voir si nous obtenons
aussi de bonnes performances dans une nouvelle simulation d'un an. C'est là que notre prochain et dernier
chier Python intervient.
Page 45 of 103
2.3.5 Étape 5 : Tester l'IA

Nous devons maintenant tester la performance de notre IA dans une nouvelle situation. Nous eectuerons
une simulation d'un an en mode inférence. Donc, il n'y aura aucune formation. Notre IA ne donnera
les prédictions que sur une année complète de simulation. Ensuite, avec notre objet Environment, nous
obtiendrons nalement l'énergie totale dépensée par l'IA au cours de l'année complète ainsi que l'énergie
totale dépensée par le système de refroidissement intégré. Finalement, nous comparerons ces deux énergies
dépensées en calculant simplement leur diérence relative (en %), ce qui nous donnera exactement l'énergie
totale économisée par l'IA. Nous vous dévoilerons les résultats à la n de cette partie 2 !
En ce qui concerne le plan directeur de l'IA et l'implémentation des tests, nous avons presque la même chose
qu'avant, sauf que cette fois, nous n'avons pas besoin de créer un objet Brain ou DQN, et nous ne devons
pas exécuter le Deep Q-Learning durant certaines époques de la formation. Cependant, nous devons créer
un nouvel objet Environment, et au lieu de créer un cerveau, nous chargerons notre cerveau articiel avec
les poids prédénis à la formation précédente eectuée à l'étape 4 - Former l'IA. Donnons donc les dernières
sous-étapes de cette dernière partie du cadre / plan directeur de l'IA :
1. Étape 5-1 : Créer un nouvel environnement en créant un objet Environment class.
2. Étape 5-2 : Charger le cerveau articiel avec les poids prédénis de la formation précédente.
3. Étape 5-3 : Choisir le mode d'inférence.
4. Étape 5-4 : Commencer la simulation d'un an.
5. Étape 5-5 : À chaque itération (chaque minute), notre IA n'exécute que l'action qui résulte de sa
prédiction, et aucune exploration ou formation Deep Q-Learning n'a lieu.
Et maintenant, implémentons cette cinquième et dernière partie, Étape 5 - Tester l'IA. Encore une fois,
ci-dessous l'implémentation complète de notre premier chier Python. Les titres des sections de code et les
noms des variables choisis sont susamment clairs pour comprendre le code, mais si vous avez besoin de
plus d'explications, je vous encourage à regarder nos tutoriels vidéo où nous expliquons tout à partir de zéro
en dénissant chaque ligne de code. On y va !

# Testing the AI
# Installing Keras
5 # conda install -c conda-forge keras
# Importing the libraries and the other python files

import os
import numpy as np
10 import random as rn
from keras.models import load_model
import environment
# Setting seeds for reproducibility

15 os.environ[’PYTHONHASHSEED’] = ’0’
np.random.seed(42)
rn.seed(12345)
# SETTING THE PARAMETERS
Page 46 of 103
20 number_actions = 5
direction_boundary = (number_actions - 1) / 2
temperature_step = 1.5
# BUILDING THE ENVIRONMENT BY SIMPLY CREATING AN OBJECT OF THE ENVIRONMENT CLASS

25 env = environment.Environment(optimal_temperature = (18.0, 24.0),
initial_month = 0,
initial_rate_data = 30)
30 # LOADING A PRE-TRAINED BRAIN

model = load_model("model.h5")
# CHOOSING THE MODE

train = False
35
# RUNNING A 1 YEAR SIMULATION IN INFERENCE MODE
env.train = train
current_state, _, _ = env.observe()
for timestep in range(0, 12 * 30 * 24 * 60):
40 q_values = model.predict(current_state)
action = np.argmax(q_values[0])
direction = -1
else :
45 direction = 1
next_state, reward, game_over = env.update_env(direction,
energy_ai,
int (timestep / (30*24*60)))
50 current_state = next_state
# PRINTING THE TRAINING RESULTS FOR EACH EPOCH

print ("\n")
print ("Total Energy spent with an AI: {:.0f}".format(env.total_energy_ai))
55 print ("Total Energy spent with no AI: {:.0f}".format(env.total_energy_noai))
print ("ENERGY SAVED: {:.0f} %".format((env.total_energy_noai - env.total_energy_ai)
/ env.total_energy_noai * 100))
Enn, nous obtenons que l'énergie totale économisée par l'IA est... :
Énergie totale économisée par l'IA = 39 % !

Exactement comme Google DeepMind en 2016 ! Si vous tapez sur Google : "DeepMind réduit la facture
d'énergie de Google", vous verrez que le résultat obtenu est de 40 %. Très proche du nôtre !
Par conséquent, ce que nous avons conçu est certainement excellent pour nos entreprises clientes, car notre
IA leur permettra d'économiser les dépenses ! En eet, n'oubliez pas que grâce à notre structure orientée
vers l'objet (travailler avec des classes et des objets), nous pouvons très facilement prendre nos objets créés
dans cette implémentation que nous avons faite pour un serveur, puis les introduire dans d'autres serveurs
pour nalement économiser l'énergie totale consommée par un data center entier ! C'est ainsi que Google a
économisé des milliards de dollars grâce à son modèle DQN conçu par DeepMind.
Page 47 of 103
2.3.6 Récapitulatif : Le cadre général de l'IA / Plan directeur

Récapitulons et fournissons l'ensemble du plan directeur de l'IA, an que vous puissiez l'imprimer et le
mettre sur votre mur.
Étape 1 : Créer l'environnement

1. Étape 1-1 : Introduire et initialiser tous les paramètres et variables de l'environnement.
2. Étape 1-2 : Créer une méthode qui actualise l'environnement après l'exécution d'une action par l'IA.
3. Étape 1-3 : Créer une méthode qui réinitialise l'environnement.
4. Étape 1-4 : Créer une méthode qui nous donne à tout moment l'état actuel, la dernière récompense
obtenue et si le processus d'exécution est terminé.
Étape 2 : Développer le cerveau

1. Étape 2-1 : Créer la couche d'entrée composée des états d'entrée.
2. Étape 2-2 : Créer les couches cachées avec un nombre déni et des neurones à l'intérieur de chacune
d'elles, entièrement connectés à la couche d'entrée et entre elles.
3. Étape 2-3 : Créer la couche de sortie, entièrement connectée à la dernière couche cachée.
4. Étape 2-4 : Assembler l'architecture complète à l'intérieur d'un objet modèle.
5. Étape 2-5 : Compiler avec une fonction d'erreur de perte quadratique moyenne et un optimiseur.
Étape 3 : Implémenter l'algorithme du Deep Reinforcement Learning

1. Étape 3-1 : Introduction et initialisation de tous les paramètres et variables du modèle DQN.
2. Étape 3-2 : Créer une méthode qui génère la mémoire dans l'Experience Replay.
3. Étape 3-3 : Créer une méthode qui construit et donne deux lots de 10 entrées et 10 cibles
Étape 4: Former l'IA

1. Étape 4-1 : Créer l'environnement en créant un objet Environment class (étape 1).
2. Étape 4-2 : Créer le cerveau articiel en créant un objet Brain class (étape 2).
3. Étape 4-3 : Créer le modèle DQN en créant un objet DQN class (étape 3).
4. Étape 4-4 : Choisir le mode de formation.
5. Étape 4-5 : Commencer la formation avec une boucle for sur un nombre déni d'époques.
6. Étape 4-6 : Pendant chaque époque, nous répétons tout le processus du Deep Q-Learning, tout en
faisant aussi de l'exploration 30% du temps.
Step 5: Tester l'AI

1. Étape 5-1 : Créer un nouvel environnement en créant un objet Environment class (étape 1).
2. Étape 5-2 : Charger le cerveau articiel avec les poids prédénis de la formation précédente.
3. Étape 5-3 : Choisir le mode d'inférence.
4. Étape 5-4 : Commencer la simulation d'un an.
5. Étape 5-5 : À chaque itération (chaque minute), notre IA n'exécute que l'action qui résulte de sa
prédiction, et aucune exploration ou formation Deep Q-Learning n'a lieu.
Page 48 of 103
3 Partie 3 - Optimiser les revenus

Félicitations pour avoir achevé la première et la deuxième étude de cas ! Passons maintenant à un tout autre
type d'IA qui a une ecacité énorme pour les entreprises et que vous devez absolument connaître.
3.1 Étude de cas : Optimiser les revenus d'une entreprise e-commerce

Imaginez une entreprise e-commerce qui compte des millions de clients. Ces clients ne sont que des personnes
qui achètent certains produits sur le site Web de temps en temps étant livrés à domicile. Les aaires vont bien,
mais le conseil d'administration a décidé d'exécuter un plan d'action pour optimiser davantage les revenus.
Cela consiste à orir aux clients la possibilité de souscrire à un plan premium, ce qui leur permettra de
bénécier de certains avantages tels que des prix réduits, des ores spéciales, etc. Ce plan premium est oert
à un prix annuel de 100 $. L'objectif de cette entreprise est bien sûr de convaincre le maximum de clients pour
souscrire à ce plan premium. Faisons quelques calculs rapides pour nous donner une certaine motivation
pour développer une IA an d'optimiser les revenus de cette entreprise. Disons que cette entreprise e-
commerce compte 100 millions de clients. Considérons maintenant deux stratégies pour essayer de convertir
les clients au plan premium : une mauvaise avec un taux de conversion de 1%, et une bonne avec un
taux de conversion de 11%. Si l'entreprise déploie la mauvaise stratégie, elle réalisera en un an un chire
d'aaires total supplémentaire provenant de l'abonnement au plan premium : 100, 000, 000 × 0.01 × 100 =
100, 000, 000$. En revanche, si l'entreprise déploie la bonne stratégie, elle réalisera en un an un chire
d'aaires de 100, 000, 000×0.11×100 = 1, 100, 000, 000$. Ainsi, en trouvant la bonne stratégie de déploiement,
l'entreprise a optimisé ses revenus supplémentaires en réalisant 1 milliard de dollars supplémentaires.
Dans l'exemple précédent, nous n'avions que deux stratégies, et en plus, nous connaissions leurs taux de
conversion. Cependant, dans notre étude de cas, nous serons confrontés à 9 stratégies diérentes et notre
IA n'aura aucune idée de laquelle est la meilleure, aucune information préalable sur aucun de leurs taux de
conversion. Cependant, nous supposons que chacune de ces 9 stratégies a un taux de conversion xe. Ces
stratégies ont été soigneusement élaborées par l'équipe marketing, chacune d'entre elles a le même objectif
qui est adhérer le maximum de clients au plan premium. Elles sont toutes diérentes et elles ont des formes,
des forfaits, des publicités et des ores spéciales diérents pour convaincre les clients de souscrire au plan
premium. Bien sûr, l'équipe marketing n'a aucune idée de laquelle de ces 9 stratégies est la meilleure, mais
elle veut découvrir le plus tôt possible et en économisant le maximum de coûts laquelle a le taux de conversion
le plus élevé, car elle sait que déployer la meilleure stratégie peut maximiser considérablement les revenus.
De plus, les experts en marketing choisissent de ne pas envoyer d'e-mails à leurs 100 millions clients, car
cela serait coûteux et ils risqueraient de spammer les clients. Au lieu de cela, ils cherchent subtilement la
meilleure stratégie à travers l'Online Learning. Qu'est-ce que l'Online Learning ? Il consiste à déployer une
stratégie à chaque fois qu'un client navigue sur le site Web de l'entreprise pour consulter ou acheter certains
produits. Puis, au fur et à mesure, il reçoit une annonce pop-up lui proposant de souscrire au plan premium.
Pour chaque client naviguant sur le site, une seule des 9 stratégies sera déployée. Ensuite, le client choisira
d'agir ou non et de souscrire au plan premium. Si le client s'abonne, c'est un succès, sinon c'est un échec.
Plus nous avons de clients, plus nous recevons de retours d'information, et mieux nous pouvons nous faire
une idée de la meilleure stratégie. Mais bien sûr, nous n'y parviendrons pas manuellement, visuellement ou à
l'aide de quelques calculs simples. Au lieu de cela, nous voulons implémenter l'algorithme le plus intelligent
qui permettra de déterminer quelle est la meilleure stratégie dans le moins de temps possible. Et cela pour
les deux mêmes raisons : d'abord parce que le déploiement de chaque stratégie a un coût (par exemple en
provenance de la publicité pop-up), et ensuite parce que l'entreprise veut ennuyer le moins possible les clients
avec sa publicité.
Page 49 of 103
Résumons les diérences entre les caractéristiques de ces 9 stratégies de la manière suivante :
Simulation.
An de simuler cette étude de cas, nous supposerons que ces stratégies ont ces taux de conversion :
Cependant, assurez-vous de comprendre que dans une situation réelle, nous n'aurions aucune idée de ce que
seraient ces taux de conversion. Nous ne les connaissons ici qu'à des ns de simulation, juste pour pouvoir
vérier que notre IA parvient à trouver la meilleure stratégie, qui selon le tableau ci-dessus, est la stratégie
numéro 7 (taux de conversion le plus élevé).

L'Online Learning est une branche spéciale de l'IA où il n'est pas nécessaire de dénir les états et les actions.
Ici, un état serait simplement un client spécique sur lequel nous déployons une stratégie, et l'action serait
simplement la stratégie choisie. Mais vous verrez dans l'algorithme de l'IA que nous n'avons pas les états
Page 50 of 103
comme entrées et les actions comme sorties tel que dans nos deux études de cas précédentes, parce que cette
fois nous ne faisons ni de Q-Learning ni de Deep Q-Learning. Nous faisons de l'Online Learning. Cependant,
nous devons dénir les récompenses, car nous devrons à nouveau créer une matrice de récompenses où
chaque ligne correspond à une stratégie déployée sur un utilisateur, et chaque colonne correspond à l'une
des 9 stratégies. Par conséquent, puisque nous allons eectivement exécuter l'Online Learning sur 10.000
clients, cette matrice de récompenses aura 10.000 lignes et 9 colonnes. Ensuite, chaque cellule recevra soit
un 0 si le client ne souscrit pas au plan premium après avoir été approché par la stratégie choisie, soit un 1
si le client souscrit au plan premium. Les valeurs dans la cellule sont exactement les récompenses.
Maintenant, il est très important de comprendre que la matrice de récompenses n'existe que pour la sim-
ulation, et dans la vraie vie, nous n'aurions pas de matrice de récompenses. Nous simulerons simplement
10 000 clients abordés successivement par l'une des 9 stratégies, et grâce à la matrice de récompenses, nous
simulerons la décision du client de souscrire ou non au plan premium. Si la cellule correspondant à un client
spécique et à une stratégie spécique sélectionnée a un 1, cela simulera une conversion du client au plan
premium, et si la cellule a un 0, cela simulera un rejet. Voici, à titre d'exemple, les premières lignes d'une
matrice de récompenses simulée :
Selon cette simulation, toutes les données de la matrice de récompenses sont mentionnées ci-dessus :
1. Le premier client (ligne de l'index 0) ne souscrirait pas au plan premium après avoir été approché par
une stratégie dénie.
2. Le deuxième client (ligne de l'index 1) souscrirait au plan premium après avoir été approché par la
stratégie 5 ou la stratégie 7 uniquement.
3. Le troisième client (ligne de l'index 2) ne souscrirait pas au plan premium après avoir été approché par
une stratégie dénie.
L'Échantillonnage Thompson recueillera les retours d'information pour savoir si chacun de ces clients souscrit
ou non au plan premium l'un après l'autre, et déterminera rapidement grâce à son puissant algorithme, la
stratégie ayant le taux de conversion le plus élevé, c.-à-d. la meilleure à déployer sur les millions de clients,
optimisant ainsi les rentes de l'entreprise grâce à ce nouveau ux de revenus.
3.2 Solutions d'IA

La solution d'IA qui permettra de trouver la meilleure stratégie s'appelle "l'Échantillonnage Thompson".
C'est de loin le meilleur modèle pour ce genre de problèmes dans cette branche d'IA. Pour résumer, chaque
Page 51 of 103
fois qu'un nouveau client se connecte sur le site, c'est une nouvelle phase n et nous sélectionnons une de nos
9 stratégies pour une tentative de conversion (abonnement au plan premium). L'objectif est de sélectionner
la meilleure stratégie à chaque phase. Voici comment l'Échantillonnage Thompson s'y prendra :
Pour chaque phase n, répétez, sur plus de 1000 phases, les trois étapes suivantes :
1. Étape 1. Pour chaque stratégie i, nous procédons à un tirage à partir de la distribution suivante :
θi (n) ∼ β(Ni1 (n) + 1, Ni0 (n) + 1)
où :
(
Ni1 (n) est le nombre de fois que la stratégie i a reçu 1 récompense dans la phase n,
Ni0 (n) est le nombre de fois que la stratégie i a reçu une récompense de 0 dans la phase n.
2. Étape 2. Nous sélectionnons la stratégie s(n) qui a le plus grand θi (n) :
s(n) = argmax (θi (n))

i∈{1,...,9}
3. Étape 3. Nous mettons à jour

1
Ns(n) (n) et
0
Ns(n) (n) selon les conditions suivantes :
• Si la stratégie sélectionnée s(n) a reçu 1 récompense :
1 1
Ns(n) (n) := Ns(n) (n) + 1
• Si la stratégie sélectionnée s(n) a reçu 0 récompense :
0 0
Ns(n) (n) := Ns(n) (n) + 1
Intuition. Chaque stratégie a sa propre distribution bêta. Au cours des phases, la distribution bêta de
la stratégie ayant le taux de conversion le plus élevé sera progressivement déplacée vers la droite, et les
distributions bêta des stratégies ayant des taux de conversion inférieurs vers la gauche (étapes 1 et 3). Par
conséquent, suivant l'étape 2, la stratégie ayant le taux de conversion le plus élevé sera de plus en plus
choisie. Le graphique ci-dessous présente trois distributions bêta de trois stratégies :
Page 52 of 103
3.3 Implémentation
Procédons à l'implémentation complète de l'Échantillonnage Thompson pour cette étude de cas spécique,
en suivant la même simulation donnée ci-dessus.
Tout en intégrant l'Échantillonnage Thompson, nous implémentons également l'algorithme de sélection aléa-
toire qui sélectionnera simplement une stratégie à chaque phase. Ce sera notre point de référence pour
évaluer le rendement de notre modèle d'Échantillonnage Thompson. Bien sûr, l'Échantillonnage Thompson
et l'algorithme de sélection aléatoire seront en concurrence sur la même simulation, c'est-à-dire sur la même
matrice de récompenses. Et à la n, une fois la simulation terminée, nous évaluerons la performance de
l'Échantillonnage Thompson en calculant le rendement relatif, déni par la formule suivante :
(Récompense de l'Échantillonnage Thompson) − (Récompense de la sélection aléatoire)

Rendement relatif = ×100
Récompense de la sélection aléatoire
Nous allons également représenter l'histogramme des pubs sélectionnées, juste pour vérier que la stratégie
avec le taux de conversion le plus élevé (Stratégie 7) était celle qui a été la plus sélectionnée.
Donc si vous êtes prêt, c'est parti !
Tout d'abord, nous importons les modules nécessaires et nous dénissons les paramètres (N = 10000 clients
et d=9 stratégies) :

# Maximizing the Revenues of an Online Retail Business with Thompson Sampling

import matplotlib.pyplot as plt
import random
# Setting the parameters

10 N = 10000
d = 9
Ensuite, nous créons la simulation en développant la matrice de récompenses de 10000 lignes correspondant
aux clients, et 9 colonnes correspondant aux stratégies. À chaque phase et pour chaque stratégie, nous tirons
au sort un nombre aléatoire entre 0 et 1, et si ce nombre aléatoire est inférieur au taux de conversion de la
stratégie, la récompense sera 1. De cette façon, nous simulerons les taux de conversion énumérés ci-dessus
pour nos 9 stratégies :
# Creating the simulation

# conversion_rates = [0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9]
conversion_rates = [0.05,0.13,0.09,0.16,0.11,0.04,0.20,0.08,0.01]
X = np.array(np.zeros([N,d]))
5 for i in range(N):
for j in range(d):
i f np.random.rand() <= conversion_rates[j]:
X[i,j] = 1
Page 53 of 103
Ensuite, nous bouclerons les 10000 lignes (ou phases) de cette matrice de récompenses, et à chaque phase,
nous obtiendrons deux sélections de stratégies distinctes : une de l'algorithme de sélection aléatoire, et une
de l'Échantillonnage Thompson. Nous suivons les stratégies choisies par chacun de ces deux algorithmes et
nous calculons la récompense totale accumulée au cours des phases par chacun d'eux. L'Échantillonnage
Thompson est implémenté suivant exactement les étapes 1, 2 et 3 fournies ci-dessus :
# Implementing a Random Strategy and Thompson Sampling

strategies_selected_rs = []
strategies_selected_ts = []
total_reward_rs = 0
5 total_reward_ts = 0
numbers_of_rewards_1 = [0] * d
for n in range(0, N):
# Random Strategy
10 strategy_rs = random.randrange(d)
strategies_selected_rs.append(strategy_rs)
reward_rs = X[n, strategy_rs]
total_reward_rs = total_reward_rs + reward_rs
# Thompson Sampling
15 strategy_ts = 0
max_random = 0
for i in range(0, d):
random_beta = random.betavariate(numbers_of_rewards_1[i] + 1,
numbers_of_rewards_0[i] + 1)
20 i f random_beta > max_random:
max_random = random_beta
strategy_ts = i
reward_ts = X[n, strategy_ts]
i f reward_ts == 1:
25 numbers_of_rewards_1[strategy_ts] = numbers_of_rewards_1[strategy_ts] + 1
else :
numbers_of_rewards_0[strategy_ts] = numbers_of_rewards_0[strategy_ts] + 1
strategies_selected_ts.append(strategy_ts)
total_reward_ts = total_reward_ts + reward_ts
Ensuite, nous calculons le résultat nal qui est le rendement relatif de l'Échantillonnage Thompson par
rapport à notre point de référence, soit la sélection aléatoire :
# Computing the Relative Return

relative_return = (total_reward_ts - total_reward_rs) / total_reward_rs * 100
print ("Relative Return: {:.0f} %".format(relative_return))
Attachez votre ceinture ! en exécutant ce code nous obtenons un rendement relatif nal, de...:
Rendement relatif = 91 % !
En d'autres termes, l'Échantillonnage Thompson a presque doublé la performance de notre sélection aléatoire
de référence.
Page 54 of 103
Enn, nous traçons l'histogramme des stratégies sélectionnées pour vérier que la stratégie 7 (de l'index 6)
était bien celle qui a été la plus sélectionnée, puisque c'est celle qui a le taux de conversion le plus élevé :
# Plotting the Histogram of Selections

plt.hist(strategies_selected_ts)
plt.title(’Histogram of Selections’)
plt.xlabel(’Strategy’)
5 plt.ylabel(’Number of times the strategy was selected’)
plt.show()
En exécutant ce code nal, on obtient l'histogramme suivant :
Ainsi, c'est la stratégie de l'index 6 (stratégie 7) qui a été la plus sélectionnée. L'Échantillonnage Thompson a
rapidement pu l'identier. Si nous exécutons le même code, mais avec 1000 clients seulement, nous réalisons
que l'Échantillonnage Thompson est toujours capable d'identier la stratégie 7 comme étant la meilleure.
Par conséquent, l'Échantillonnage Thompson a sûrement fait un travail incroyable pour cette entreprise e-
commerce. Non seulement il a été capable d'identier rapidement la meilleure stratégie en quelques phases,
c.-à-d. avec quelques clients, ce qui a permis d'économiser les coûts de publicité et autres dépenses associées,
mais il a été en mesure de dénir clairement la stratégie ayant le taux de conversion le plus élevé. Ainsi, si
cette entreprise a 100 millions de clients et si le plan premium a un prix de 100 $ par an, alors le déploiement
de cette stratégie qui a un taux de conversion de 20 % permettrait de générer un revenu supplémentaire de...:
Revenu supplémentaire = 100000000 × 0.2 × 100 = 2 milliards $ !!
En d'autres termes, l'Échantillonnage Thompson a clairement et rapidement optimisé les revenus de cette
entreprise tout en économisant sur les coûts, maximisant ainsi également la rentabilité.
Page 55 of 103
Courbe de Regret.
La Courbe de Regret d'un modèle (Stratégie aléatoire ou Échantillonnage Thompson) est le schéma de la
diérence entre la meilleure stratégie et le modèle déployé par rapport aux phases.
La meilleure stratégie est calculée en obtenant simplement, à chaque phase, le maximum de récompenses ac-
cumulées dans toutes les diérentes stratégies. Par conséquent, dans notre implémentation, nous obtiendrons
la meilleure stratégie de la manière suivante :
rewards_strategies = [0] * d
# Best Strategy
5 rewards_strategies[i] = rewards_strategies[i] + X[n, i]
total_reward_bs = max(rewards_strategies)
Ensuite, le Regret de l'Échantillonnage Thompson est simplement calculé comme la diérence entre la
meilleure stratégie et le modèle de l'Échantillonnage Thompson :
# Regret of Thompson Sampling

total_reward_ts = 0
total_reward_bs = 0
5 numbers_of_rewards_1 = [0] * d
regret = []
10 # Thompson Sampling
strategy_ts = 0
max_random = 0
15 numbers_of_rewards_0[i] + 1)
i f random_beta > max_random:
strategy_ts = i
20 i f reward_ts == 1:
else :
25 total_reward_ts = total_reward_ts + reward_ts
# Best Strategy
rewards_strategies[i] = rewards_strategies[i] + X[n, i]
30 # Regret
regret.append(total_reward_bs - total_reward_ts)
Page 56 of 103
De même, le regret de la stratégie aléatoire est simplement calculé comme la diérence entre la meilleure
stratégie et l'algorithme de sélection aléatoire :
# Regret of the Random Strategy

total_reward_rs = 0
total_reward_bs = 0
5 numbers_of_rewards_1 = [0] * d
regret = []
10 # Random Strategy
strategy_rs = random.randrange(d)
reward_rs = X[n, strategy_rs]
15 # Best Strategy
rewards_strategies[i] = rewards_strategies[i] + X[n, i]
# Regret
20 regret.append(total_reward_bs - total_reward_rs)
Finalement, nous traçons les courbes de regrets des phases avec ce code simple (nous n'avons pas besoin de
spécier les coordonnées x dans la fonction plt.plot() car les phases sont déjà des index de 0 à N) :
# Plotting the Regret Curve

plt.plot(regret)
plt.title(’Regret Curve’)
plt.xlabel(’Round’)
5 plt.ylabel(’Regret’)
plt.show()
Examinons les résultats à la page suivante, tant pour la stratégie aléatoire que pour l'Échantillonnage Thomp-
son.
Page 57 of 103
Si nous représentons la Courbe de Regrets de la stratégie aléatoire, nous obtenons ce qui suit :
Et bien sûr, nous n'observons absolument aucune convergence de la stratégie aléatoire avec la meilleure
stratégie.
Page 58 of 103
Cependant, si nous représentons maintenant la Courbe de Regret du modèle d'Échantillonnage Thompson,

nous obtenons le schéma suivant :
Et évidemment, l'Échantillonnage Thompson converge avec la meilleure stratégie.
Page 59 of 103
En conclusion, voici le code nal incluant la Courbe de Regret de l'Échantillonnage Thompson :
# Thompson Sampling

import numpy as np
5 import matplotlib.pyplot as plt
import random
# Setting the parameters

N = 10000
10 d = 9
# Creating the simulation

# conversion_rates = [0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9]
conversion_rates = [0.05,0.13,0.09,0.16,0.11,0.04,0.20,0.08,0.01]
15 X = np.array(np.zeros([N,d]))
for i in range(N):
for j in range(d):
i f np.random.rand() <= conversion_rates[j]:
X[i,j] = 1
20
# Implementing a Random Strategy and Thompson Sampling with Regret Curve
total_reward_rs = 0
25 total_reward_ts = 0
total_reward_bs = 0
30 regret = []
# Random Strategy
strategy_rs = random.randrange(d)
35 reward_rs = X[n, strategy_rs]
# Thompson Sampling
strategy_ts = 0
max_random = 0
40 for i in range(0, d):
numbers_of_rewards_0[i] + 1)
i f random_beta > max_random:
45 strategy_ts = i
i f reward_ts == 1:
else :
50 numbers_of_rewards_0[strategy_ts] = numbers_of_rewards_0[strategy_ts] + 1
Page 60 of 103
total_reward_ts = total_reward_ts + reward_ts

# Best Strategy
55 rewards_strategies[i] = rewards_strategies[i] + X[n, i]
# Regret
regret.append(total_reward_bs - total_reward_ts)
60 # Computing the Absolute and Relative Return

absolute_return = total_reward_ts - total_reward_rs
relative_return = (total_reward_ts - total_reward_rs) / total_reward_rs * 100
print ("Absolute Return: {:.0f} $".format(absolute_return))
print ("Relative Return: {:.0f} %".format(relative_return))
65
# Plotting the Histogram of Selections
plt.hist(strategies_selected_ts)
plt.title(’Histogram of Selections’)
plt.xlabel(’Strategy’)
70 plt.ylabel(’Number of times the strategy was selected’)
plt.show()
plt. close ()
# Plotting the Regret Curve

75 plt.plot(regret)
plt.title(’Regret Curve’)
plt.xlabel(’Round’)
plt.ylabel(’Regret’)
plt.show()
Page 61 of 103
Conclusion
Merci encore une fois de vous être joints à ce cours, et félicitations pour l'avoir complété ! Nous vous
recommandons fortement de garder ce livre près de vous chaque fois que vous développez une IA pour
résoudre un problème d'entreprise. Ou du moins, essayez de conserver le cadre général de l'IA. De notre
côté, ce fut un plaisir de faire ce cours et d'écrire ce livre. N'hésitez pas à laisser un commentaire dans le
cours si vous le souhaitez. D'ici là, protez de l'IA dans le monde de l'entreprise !
Page 62 of 103
4 Annexe 1 : Réseaux de neurones articiels

Dans cette partie annexe, vous trouverez la dénition de la théorie des réseaux de neurones articiels, qui
sont au c÷ur du modèle Deep Q-Learning que nous avons développé dans la partie 2 - Minimiser les coûts.
Voici le plan pour étudier les réseaux de neurones articiels :
1. Le neurone
2. La fonction d'activation
3. Comment les réseaux de neurones fonctionnent-ils ?
4. Comment les réseaux de neurones apprennent-ils ?
5. Propagation et rétropropagation
6. Descente de gradient
7. Descente de gradient par batchs et descente de gradient stochastique
4.1 Le neurone
Le neurone est l'élément de base des réseaux neuronaux articiels. Les images ci-dessous montrent des
neurones réels qui ont été étalés sur du verre, colorés un peu et observés au microscope :
Ainsi, ils ont la structure d'un corps avec beaucoup de branches diérentes. Mais la question est : comment
peut-on recréer cela dans une machine ? En eet, nous avons vraiment besoin de le recréer dans une machine,
car le but du Deep Learning est d'imiter le fonctionnement du cerveau humain dans l'espoir de créer quelque
chose d'incroyable : une infrastructure puissante pour que les machines soient capables d'apprendre.
Pourquoi espérons-nous cela ? Parce que le cerveau humain est l'un des outils d'apprentissage les plus
puissants de la planète. Nous pensons que si nous le recréons, nous aurons quelque chose d'aussi génial que
Page 63 of 103
cela. Donc notre dé actuel est notre toute première étape pour créer des réseaux de neurones articiels :
recréer un neurone.
Alors, comment va-t-on faire ? Eh bien, tout d'abord, regardons de plus près ce qu'est un neurone. L'image
ci-dessous a été créée par un neuroscientique espagnol et Chagga Ramon Yi Kajal en 1899 :
Ce neuroscientique a teint des neurones dans des tissus cérébraux réels et les a examinés au microscope.
Il a dessiné ce qu'il a vu, ce qui est exactement ce que nous voyons sur l'image ci-dessus. Aujourd'hui, la
technologie a beaucoup progressé, ce qui nous permet d'examiner les neurones de beaucoup plus près, de
façon plus détaillée et voir ce à quoi ils ressemblent.
Page 64 of 103
Au-dessus se trouve un neurone. Ce neurone échange des signaux avec les neurones voisins. Les dendrites
sont les récepteurs du signal et les axones sont les émetteurs du signal. Voici une image de la façon dont
tout cela fonctionne sur un plan conceptuel :
Nous pouvons voir que les dendrites du neurone sont reliées aux axones des autres neurones au-dessus de
lui. Puis le signal traverse l'axone et passe aux dendrites du neurone suivant. C'est ainsi qu'ils sont reliés et
qu'un neurone fonctionne. Il est donc temps de passer des neurosciences à la technologie.
Voici comment un neurone est représenté à l'intérieur d'un réseau de neurones articiel :
Tout comme un neurone humain, il reçoit des signaux d'entrée et il a un signal de sortie. La èche bleue
reliant les signaux d'entrée au neurone, et le neurone au signal de sortie, sont comme les synapses du neurone
humain. Mais ici, dans le neurone articiel, quels seront exactement ces signaux d'entrée et de sortie ? Eh
bien, les signaux d'entrée seront les variables indépendantes composant les états de l'environnement, qui
Page 65 of 103
sont, selon l'étude de cas : la température du serveur, le nombre d'utilisateurs et le taux de transmission de
données. Le signal de sortie sera les valeurs de sortie, qui dans le modèle Deep Q-Learning sont toujours les
Q-Values. Ainsi, nous obtenons la représentation générale d'un neurone articiel :
Et maintenant pour nir avec le neurone, ajoutons les derniers éléments manquants dans cette représentation,
mais aussi les plus importants : les poids. Chaque synapse (èche bleue) se verra attribuer un poids. Plus
le poids est grand, plus le signal sera fort à travers la synapse. Il est essentiel de comprendre que ces poids
seront ce que la machine mettra à jour au l du temps pour améliorer les prédictions. Représentons-les sur
le graphique précédent, pour nous permettre de bien les visualiser :
Page 66 of 103
4.2 La fonction d'activation

La fonction d'activation est φ fonctionnant à l'intérieur du neurone, qui prendra comme entrées la somme
linéaire des valeurs d'entrée multipliée par leurs poids associés, et qui donnera la valeur de sortie :
de sorte que :
m
!
X
y=φ w i xi
i=1
Maintenant, quelle sera exactement la fonction φ ?
Il peut y en avoir beaucoup, mais donnons les quatre plus utilisées, y compris bien sûr celle que nous avons
utilisée dans la Partie 2 - Minimiser les coûts :
1. La fonction d'activation à seuil
2. La fonction d'activation sigmoïde
3. La fonction d'activation ReLU
4. La fonction d'activation tangente hyperbolique
Examinons-les un par un.
Page 67 of 103
4.2.1 La fonction d'activation à seuil
La fonction d'activation à seuil est simplement dénie par les éléments suivants :
(
1 if x≥0
φ(x) =
0 if x<0
de sorte d'obtenir la courbe suivante :
Cela signie que le signal traversant le neurone sera discontinu et ne sera activé que si :
m
X
wi xi ≥ 0
i=1
Voyons maintenant la fonction d'activation suivante : la fonction d'activation sigmoïde.
La fonction d'activation sigmoïde est la plus ecace et la plus utilisée dans les réseaux de neurones articiels,
mais surtout à l'intérieur de la dernière couche cachée (si nous avons aaire à un réseau neuronal profond
composé de plusieurs couches cachées) transmettant le signal à la couche de sortie.
Page 68 of 103
4.2.2 La fonction d'activation sigmoïde
La fonction d'activation sigmoïde est dénie par ce qui suit :
1
φ(x) =
1 + e−x
Pm
Cela signie que le signal traversant le neurone sera continu et sera toujours activé. Et plus i=1 wi xi est
élevé, plus ce signal sera puissant.
Voyons maintenant une autre fonction d'activation largement utilisée : la fonction d'activation ReLU.
Vous la trouverez dans la plupart des réseaux de neurones profonds, mais surtout à l'intérieur des couches
cachées, par opposition à la fonction sigmoïde qui est plutôt utilisée pour la couche de sortie.
Page 69 of 103
4.2.3 La fonction d'activation ReLU
La fonction d'activation ReLU est simplement dénie par les éléments suivants :
φ(x) = max(x, 0)
Cela signie que le signal traversant le neurone sera continu et ne sera activé que si :
m
X
wi xi ≥ 0
i=1
Pm
Et plus i=1 wi xi est au-dessus de 0, plus le signal sera puissant.
Voyons maintenant la fonction d'activation suivante : la fonction d'activation tangente hyperbolique.
La fonction d'activation tangente hyperbolique est moins utilisée, bien qu'elle puisse parfois être le choix
plus pertinent dans certains réseaux neuronaux articiels, en particulier lorsque les entrées sont normalisées.
Page 70 of 103
4.2.4 La fonction d'activation tangente hyperbolique
La fonction d'activation tangente hyperbolique est dénie comme suit :
1 − e−2x
φ(x) =
1 + e−2x
Pm
Cela signie que le signal traversant le neurone sera continu et sera toujours activé. Plus i=1 w i xi est
Pm
supérieur à 0, plus le signal sera puissant. Plus i=1 wi xi est inférieur à 0, plus le signal sera faible.
Page 71 of 103
Cela pose donc la question : quelle fonction d'activation choisir ou plus fréquemment demandé, comment
sait-on laquelle choisir ?
Bonne nouvelle ! la réponse est simple. Essayons de la présenter dans un petit schéma détaillé.
Cela dépend en fait de ce qui est rendu comme variable dépendante. S'il s'agit d'un résultat binaire 0 ou 1,
alors un bon choix serait la fonction d'activation à seuil. Si ce que vous voulez obtenir est la probabilité que
la variable dépendante soit 1, alors l'excellent choix est la fonction d'activation sigmoïde, puisque sa courbe
sigmoïde est parfaitement adaptée aux probabilités du modèle.
Voici ce petit schéma mis en évidence dans cette diapositive :
Mais quand dois-je utiliser les deux autres fonctions d'activation, à savoir la fonction ReLU et la fonction
tangente hyperbolique ?
Facile encore une fois ! les fonctions ReLU et tangente hyperbolique doivent être utilisées dans les couches
cachées d'un Deep Neural Network (avec plus d'une couche cachée), sauf la dernière couche cachée menant
à la couche de sortie pour laquelle il est recommandé d'utiliser la fonction sigmoïde.
Page 72 of 103
Récapitulons cela à nouveau dans la diapositive suivante :
Enn, comment choisir entre la fonction ReLU et la fonction tangente hyperbolique dans les couches cachées
? Toujours facile ! Vous devriez envisager d'utiliser la fonction ReLU lorsque les entrées sont normalisées
(échelle entre 0 et 1), et la fonction d'activation tangente hyperbolique lorsque les entrées sont normalisées
(échelle entre -1 et +1) :
Passons maintenant à la section suivante pour expliquer comment fonctionnent les réseaux de neurones.
Page 73 of 103
4.3 Comment fonctionnent les réseaux de neurones ?

Pour expliquer cela, examinons le problème de la prévision des prix de l'immobilier. Nous avons quelques
variables indépendantes que nous allons utiliser pour prédire le prix des maisons et des appartements. Par
souci de simplicité et pour pouvoir tout représenter dans un graphique, disons que nos variables indépendantes
(nos prédicteurs) sont les suivantes :
1. Supercie (pieds carrés)
2. Nombre de chambres
3. Distance de la ville (Miles)
4. Age
Ensuite, notre variable dépendante est bien sûr le prix prévisionnel de l'appartement.
On attribue un poids à chacune des variables indépendantes, de telle sorte que plus le poids est élevé,
plus la variable indépendante aura d'eet sur la variable dépendante, c.-à-d. plus elle sera prédictive de la
variable dépendante. Ainsi, dès que de nouvelles entrées entrent dans le réseau de neurones, les signaux sont
propagés vers l'avant à partir de chacune des entrées, atteignant les neurones de la couche cachée. Ensuite,
dans chaque neurone de la couche cachée, la fonction d'activation est appliquée, de sorte que plus le poids
de l'entrée est faible, plus la fonction d'activation bloquera le signal provenant de cette entrée, et plus le
poids de cette entrée est élevé, plus l'activation laisse passer ce signal. Enn, tous les signaux provenant
des neurones cachés, plus ou moins bloqués par les fonctions d'activation, sont retransmis vers la couche de
sortie pour rendre le résultat nal, c.-à-d. la prévision du prix.
Représentons cela dans le graphique suivant :
Page 74 of 103
4.4 Comment les réseaux de neurones apprennent-ils ?

Pour faire court, les réseaux de neurones apprennent en mettant à jour, dans de nombreuses itérations, les
poids de toutes les entrées et des neurones cachés (lorsqu'il y a plusieurs couches cachées), vers toujours le
même objectif : réduire la perte entre les prédictions et les valeurs réelles.
En eet, pour que les réseaux de neurones puissent apprendre, nous avons besoin des valeurs réelles que
l'on appelle aussi les cibles. Dans l'exemple ci-dessus sur les prix de l'immobilier, les valeurs réelles sont les
prix réels des maisons et des appartements en vente. Ces prix réels dépendent des variables indépendantes
énumérées ci-dessus (supercie, nombre de chambres, distance de la ville et âge), et le réseau de neurones
apprendra à mieux prévoir ces prix, en suivant le processus suivant :
1. Le réseau de neurones propage vers l'avant d'abord les signaux provenant des variables indépendantes
de l'entrée x1 , x2 , x3 et x4 .
2. Puis il obtient le prix prévu ŷ dans la couche de sortie.
3. Ensuite, il calcule l'erreur de perte C entre le prix prévisionnel ŷ (prévision) et le prix réel y (cible) :
1
C= (ŷ − y)2
2
4. Ensuite, cette erreur de perte est propagée en arrière dans le réseau de neurones, de droite à gauche
dans notre représentation.
5. Ensuite, dans chaque neurone, le réseau exécute une technique appelée Descente de Gradient (dont
nous parlerons dans la section suivante), pour mettre à jour les poids dans la direction de la réduction
des pertes, c.-à-d. dans de nouveaux poids qui réduisent l'erreur de perte C.
6. Ensuite, tout ce processus est répété plusieurs fois, avec à chaque fois de nouvelles entrées et de
nouvelles cibles, jusqu'à obtenir la performance souhaitée (arrêt anticipé) ou la dernière itération
(nombre d'itérations choisies dans l'implémentation).
Représentons les deux phases principales, la propagation et la rétropropagation de tout ce processus dans
les deux graphiques suivants (voir la page suivante) :
Page 75 of 103
4.5 Propagation et Rétropropagation
Phase 1 : Propagation
Phase 2 : Rétropropagation
Page 76 of 103
4.6 Descente de gradient

4.6.1 Introduction à la Descente de Gradient
Quand on parle de Machine Learning ou du Deep Learning, on parle surtout des algorithmes. Pourquoi
certains algorithme sont-ils considérés comme des algorithmes de Machine Learning ou de Deep Learning et
pourquoi d'autres ne le sont pas ? Quelle est la technique fondamentale qui les relie ?
La réponse à la première question est assez évidente : ces algorithmes sont conçus pour apprendre leurs
paramètres par eux-mêmes. Cette propriété n'était pas très courante auparavant et la plupart des algorithmes
étaient paramétrés manuellement par les ingénieurs pour obtenir une spécication/objectif requis.
Mais alors la descente de gradient est arrivée sur scène et la plupart des algorithmes qui ne fonctionnaient
pas jusque-là avaient soudainement un sens et ont commencé à s'optimiser eux-mêmes.
Alors, la descente de gradient est-elle magique ? Pour certains : oui ! mais pour nous c'est un algorithme
mathématique qui est utilisé pour optimiser un modèle qui a ses paramètres internes (poids), ou pour être
plus technique, voyons ce que Wikipedia en dit :
C'est un algorithme d'optimisation itératif de premier ordre pour trouver le minimum d'une fonction.
C'est une dénition correcte mais dicile à avaler, et pour quelqu'un qui ne fait que commencer, c'est celle
qui fait peur aussi ! On va la décomposer :
Algorithme - En termes simples, il s'agit d'un plan directeur sur la façon de résoudre un problème. Un
exemple quotidien d'algorithme serait une recette de cuisine.
Itératif - On utilise une sorte de boucle (for-loops ou while-loops) pour eectuer des étapes. Chaque étape
utilise les valeurs calculées précédemment comme entrée pour l'étape en cours. Maintenant, une question se
pose : "Quelle est notre valeur initiale ?". Nous répondrons ultérieurement par des exemples.
Optimisation - On essaie de trouver les meilleures solutions en fonction de certains critères conduisant à
plusieurs solutions alternatives, mais une seule est considérée comme la meilleure.
Premier ordre - La descente de gradient utilise la première dérivée d'une fonction de critère (coût, perte)
an de trouver la meilleure solution à un problème donné.
Par conséquent, lorsque nous mettons tout ensemble dans des mots simples, nous obtenons ce qui suit :
La descente de gradient est un plan pour trouver la meilleure solution à un problème où plus d'une solution
est possible. Elle utilise une cible pour déterminer à quel point nous sommes de la meilleure solution.
Jusqu'à présent, nous avons tout expliqué, sauf la fonction de coût.
Le coût est l'indicateur que nous suivons pendant le processus d'optimisation. Sur la base de cet indicateur,
nous pouvons dire à quel point nous sommes loin de la valeur optimale d'une fonction. Un bon exemple du
coût est l'erreur quadratique moyenne que nous avons vue précédemment dans ce livre :
n
1X
MSE = (yi − ŷi )
n i=1
où :
Page 77 of 103

ŷi est la prédiction du modèle


yi est la cible (la valeur réelle)


n est le nombre d'échantillons dans un dataset
Chaque algorithme qui utilise la descente de gradient comme technique d'optimisation a des paramètres
(poids) qui changent pendant le processus d'optimisation. Lorsque nous disons que nous recherchons le
minimum de la fonction de perte, nous voulons dire en fait que nous recherchons les valeurs des poids dont
la perte a la valeur la plus faible possible.
Par conséquent, pour répondre à notre deuxième question depuis le début, la technique qui relie tous les
algorithmes de Machine Learning de la régression linéaire aux réseaux de neurones les plus complexes est
bien la descente de gradient.
4.6.2 L'intuition de la Descente de Gradient
Comme nous l'avons vu, la descente de gradient est une technique d'optimisation qui nous aide à trouver le
minimum d'une fonction de coût. Maintenant, visualisons-la de la façon la plus intuitive possible, comme la
balle suivante dans un bol (avec une petite pluie de maths par-dessus) :
Imaginez qu'il s'agit d'une section transversale d'un bol, à l'intérieur de laquelle nous laissons tomber une
petite balle rouge et la laissons descendre jusqu'au fond du bol. Après un certain temps, elle s'arrêtera
puisqu'elle a trouvé le bon endroit au fond du bol.
Vous pouvez penser à la descente de gradient de la même manière. Elle commence quelque part dans le bol
(valeurs initiales des paramètres) et essaie de trouver le fond (le minimum d'une fonction de coût).
Prenons l'exemple de l'image ci-dessus. Les valeurs initiales des paramètres ont réglé notre balle à la position
indiquée. Sur cette base, nous obtenons des prédictions que nous comparons à nos valeurs cibles. La diérence
entre ces deux ensembles sera notre perte pour l'ensemble des paramètres actuels.
Page 78 of 103
Ensuite, nous calculons la première dérivée de la fonction de coût relativement aux paramètres. C'est de là
que vient le nom Gradient. Ici, cette première dérivée nous donne l'inclinaison de la tangente à la courbe
où se trouve la balle. Si l'inclinaison est négative comme sur la photo ci-dessus, on passe à l'étape suivante
à droite. Si l'inclinaison est positive, nous passons à l'étape suivante à gauche.
Le nom Descente vient donc du fait que nous prenons toujours la prochaine étape qui pointe vers le bas de
l'inclinaison, comme le montre le graphique suivant :
À cette position, notre balle a une inclinaison positive, donc la prochaine étape sera à gauche.
Éventuellement, en répétant les mêmes étapes, la balle se retrouvera au fond du bol :

Et c'est tout ! C'est ainsi que la descente de gradient fonctionne dans une dimension (un paramètre).
Maintenant, vous vous dites peut-être : "Super, mais quelle est cette échelle ?" Nous avons vu un exemple
d'optimisation unidimensionnelle, qu'en est-il des deux, voire des trois dimensions ?
Page 79 of 103
Excellente question. La descente de gradient garantit que cette approche s'échelonne sur autant de dimensions
que nécessaire, à condition que la fonction de coût soit convexe. En fait, si la fonction de coût est convexe,
la descente de gradient trouvera le minimum absolu de la fonction de coût. Voici un exemple en 2D :
Cependant, si la fonction de coût n'est pas convexe, elle ne trouvera qu'un minimum local. Voici un exemple
en 3 Dimensions :
Maintenant que nous comprenons ce qu'est la descente de gradient, il est temps d'étudier ces versions les
plus avancées et les plus ecaces :
1. Descente de Gradient par batch
2. Descente de Gradient par mini-batch
3. Descente de Gradient stochastique
Page 80 of 103
4.7 Descente de gradient par batch

"Descente de gradient", "Descente de gradient par batch", "Descente de Gradient par mini-batch", "Descente
de gradient stochastique".. Il y a tellement de termes, et un débutant peut être très confus.
La principale diérence entre toutes ces versions de descente de gradient réside dans la façon dont nous
introduisons nos données dans un modèle et la fréquence de mise à jour de nos paramètres (poids) pour
déplacer notre petite balle rouge. Commençons par expliquer la descente de gradient par batch.
La descente de gradient par batch est exactement ce que nous avons fait dans la Partie 2 - Minimiser les
coûts, où nous avons eu une batch d'entrées alimentant le réseau de neurones, les propageant vers l'avant
pour obtenir à la n une batch de prédictions qui sont comparées à une batch de cibles. L'erreur de perte
globale entre les prédictions et les cibles des deux batchs est ensuite calculée comme la somme des erreurs
de perte entre chaque prédiction et sa cible associée. Cette perte globale est reproduite dans le réseau de
neurones où la descente de gradient ou la descente de gradient stochastique est eectuée pour mettre à jour
tous les poids en fonction de la mesure dans laquelle ils sont responsables de cette erreur de perte globale.
Dans la page suivante, vous trouverez un exemple de descente de gradient par batch. Le problème à résoudre
consiste à prédire le résultat (de 0 à 100 %) que les élèves obtiennent à un examen en fonction du temps
passé à étudier et du temps passé à dormir :
Page 81 of 103
Il est important de noter sur le graphique ci-dessus qu'il ne s'agit pas de réseaux de neurones multiples, mais
d'un seul réseau représenté par des mises à jour de poids séparées. Encore une fois, comme nous pouvons
le remarquer dans cet exemple de descente de gradient par batch, nous fournissons toutes nos données au
modèle en une seule fois. Ceci produira des mises à jour collectives des poids et une optimisation rapide du
réseau. Cependant, il y a aussi le mauvais côté de la situation. Il est possible de rester bloqué à un minimum
local, comme on peut le voir dans le graphique ci-dessous :
Page 82 of 103
La raison pour laquelle cela se produit est expliquée précédemment : c'est parce que la fonction de coût
dans le graphique ci-dessus n'est pas convexe. Et ce type d'optimisation (descente de gradient simple) exige
que la fonction de coût soit convexe. Si ce n'est pas le cas, nous pouvons nous retrouver bloqués dans un
minimum local et ne jamais trouver le minimum global ayant les paramètres optimaux. D'autre part, voici
un exemple de fonction de coût convexe, la même que celle que nous avons vue ci-dessus :
Ainsi, une fonction est convexe si elle n'a qu'un seul minimum global. Le graphique d'une fonction convexe
a la forme d'un bol.
Cependant, dans la plupart des problèmes, y compris les problèmes d'entreprise, la fonction de coût ne
sera pas convexe (comme dans ce même exemple graphique en 3D ci-dessous), ce qui ne permettra pas une
performance de descente de gradient simple. C'est ici que la descente de gradient stochastique intervient.
Page 83 of 103
4.8 Descente de gradient stochastique

La descente de gradient stochastique (SGD) vient sauver la journée. En eet, elle fournit de meilleurs
résultats, empêchant l'algorithme de s'enliser dans un minimum local. Cependant, comme son nom l'indique,
elle est stochastique, ou en d'autres termes : aléatoire. Grâce à cette propriété, peu importe le nombre de fois
que vous exécutez l'algorithme, le processus sera toujours légèrement diérent. Et cela, indépendamment de
l'initialisation.
La descente de gradient stochastique ne fonctionne pas sur l'ensemble des données en une seule fois, mais
plutôt entrée par entrée. Par conséquent, le processus se déroule comme suit :
1. Entrer une seule observation
2. Obtenir la prédiction unique
3. Calculer l'erreur de perte entre la prédiction et la cible
4. Rétropropagation de l'erreur de perte dans le réseau de neurones.
5. Mettre à jour les poids avec la descente de gradient
6. Répéter les étapes 1. à 5. pour toutes les données
Représentons les trois premières itérations dans les trois premières entrées individuelles pour le même exemple
donné ci-dessus (la prédiction des résultats d'un examen) :
Première ligne d'entrée de l'observation :
Page 84 of 103
Deuxième ligne d'entrée de l'observation :
Troisième ligne d'entrée de l'observation :
Chacun des trois graphiques ci-dessus est un exemple d'une mise à jour de poids eectuée par la descente
de gradient stochastique. Chaque fois que nous n'entrons qu'une seule ligne d'observation de notre dataset
dans le réseau de neurones, nous mettons alors à jour les poids et passons à la ligne suivante.
Il semble que la descente de gradient stochastique est lente, car nous saisissons chaque ligne séparément,
mais en réalité, elle est beaucoup plus rapide, car il n'est pas nécessaire de charger l'ensemble de données
dans la mémoire ni d'attendre que les données passe dans le modèle pour actualiser les poids.
Pour terminer cette section, récapitulons la diérence entre la descente de gradient par batch et la descente
de gradient stochastique avec le graphique suivant :
Page 85 of 103
4.9 Descente de gradient par mini-batch

La descente de gradient par Mini-batch combine la descente de gradient par batch avec la descente de gradient
stochastique. Pour ce faire, on alimente le réseau de neurones avec des batchs de données au lieu d'alimenter
des lignes d'observations une par une ou l'ensemble des données en une seule entrée.
Cette approche est plus rapide que la descente de gradient stochastique classique et évite de s'enliser dans
le minimum local. Elle est également utile lorsqu'on n'a pas assez de ressources informatiques pour charger
l'ensemble des données dans la mémoire ou assez de puissance de traitement pour recourir à la descente de
gradient stochastique.
4.10 Optimiseurs
L'optimiseur est exactement l'outil qui va mettre à jour les poids du réseau de neurones grâce à la descente
de gradient stochastique. Jusqu'à présent, nous n'avons mentionné que l'optimiseur Adam (voir Partie
2 - Minimiser les coûts) qui est l'optimiseur le plus utilisé pour les modèles de Deep Learning et Deep
Reinforcement Learning. Néanmoins, il y a beaucoup plus d'optimiseurs qui ont leurs propres avantages et
applications.
Parcourons les optimiseurs de descente de gradient les plus célèbres et les plus utilisés.
Page 86 of 103
4.10.1 Optimiseur Momentum
La descente de gradient stochastique classique a de très grandes oscillations, ce qui laisse place à l'amélioration.
L'optimiseur Momentum gère ces grandes oscillations en ajoutant des fractions de directions calculées dans
l'étape précédente à l'étape actuelle. Ceci amplie la vitesse de la mise à jour de la direction actuelle. Dans
le graphique ci-dessous, nous pouvons voir et comparer la descente de gradient stochastique classique et avec
Momentum :
Les avantages de l'Optimiseur Momentum sont les suivants :
• Une convergence plus rapide
• Moins d'oscillations
Mais l'Optimiseur Momentum a aussi des inconvénients qui sont les suivants :
• Tendance à dépasser le minimum global de la fonction de coût en raison du momentum.
• Moins fréquent dans les modules de Deep Learning, ce qui nécessite donc un savoir-faire pour son
implémentation.
Page 87 of 103
4.10.2 L'Optimiseur de gradient accéléré de Nesterov

Yuri Nesterov a résolu le problème de la dynamique de dépassement minimum en inversant l'ordre de calcul
dans la formule de mise à jour :
4.10.3 L'Optimiseur AdaGrad (gradients adaptatifs)

L'idée d'adapter nos mises à jour selon l'inclinaison de la fonction d'erreur, provenant de l'optimiseur Nes-
terov, est reprise et appliquée dans l'Optimiseur AdaGrad tout en maximisant aussi le taux d'apprentissage.
Ainsi, dans l'Optimiseur AdaGrad, nous avons le même principe, appliqué non seulement sur les gradients
mais aussi sur le taux d'apprentissage.
Voici les avantages de cet optimiseur :
• L'optimiseur AdaGrad permet de faire des mises à jour importantes à des paramètres peu fréquents.
• Et il permet de faire de petites mises à jour à des paramètres fréquents.
Et voici les inconvénients :
• Le taux d'apprentissage est toujours en baisse, ce qui peut mener à de très petites mises à jour, le cas
échéant.
• Moins fréquent dans les modules de Deep Learning, ce qui nécessite un savoir-faire pour son implé-
mentation.
4.10.4 L'Optimiseur AdaDelta

L'Optimiseur AdaDelta a été inventé pour résoudre ce problème de diminution du taux d'apprentissage de
l'Optimiseur AdaGrad (premier inconvénient). Pas besoin d'entrer dans les détails, il susait d'introduire
l'Optimiseur AdaDelta et sa particularité pour comprendre la force de l'optimiseur le plus utilisé et le plus
ecace : l'Optimiseur Adam.
Page 88 of 103
4.10.5 L'Optimiseur Adam (Adaptive Moment Estimation)

L'Optimiseur Adam est une amélioration faite par rapport à l'Optimiseur AdaDelta. L'idée derrière tout cela
est de stocker dans une mémoire les modications de momentum, car nous calculons le taux d'apprentissage
pour chaque paramètre séparément.
Rappelez-vous maintenant les avantages de l'Optimiseur Adam, qui doivent être pris en compte lors de la
création d'un réseau de neurones.
• C'est l'un des optimiseurs les plus performants.
• Il est toujours implémenté dans les modules de Deep Learning (Keras, TensorFlow, PyTorch). Vous
ne le manquerez pas.
Bien sûr, c'est ce que nous utilisons pour construire le cerveau articiel de notre IA dans la Partie 2 -
Minimiser les coûts. Fournissons de nouveau le code qui construit ce cerveau articiel et notons, à la
dernière ligne de code, la simplicité de la sélection de l'Optimiseur d'Adam :


5 from keras.layers import Input, Dense

10


20
# BUILDING THE FULLY CONNECTED HIDDEN LAYERS
25 # BUILDING THE OUTPUT LAYER, FULLY CONNECTED TO THE LAST HIDDEN LAYER
q_values = Dense(units = number_actions, activation = ’softmax’)(y)

30
# COMPILING THE MODEL WITH AN MSE LOSS FUNCTION AND THE ADAM OPTIMIZER
Page 89 of 103
5 Annexe 2 : Trois modèles supplémentaires d'IA

Dans cette section, nous vous proposons trois modèles supplémentaires d'IA. Ils ne sont pas nécessairement
adaptés pour résoudre des problèmes d'entreprises, mais plutôt pour des tâches spéciques comme jouer aux
jeux ou apprendre à un robot virtuel comment marcher. Nous allons étudier trois modèles performants, dont
deux dans le Deep Reinforcement Learning et un dans la Policy Gradient (Gradient de Stratégie) :
1. Le Deep Convolutional Q-Learning (Deep RL)
2. Le modèle A3C (Deep RL)
3. Le modèle Augmented Random Search (Policy Gradient)
5.1 Le Deep Convolutional Q-Learning

Dans la section précédente, nos entrées étaient des valeurs codées par des vecteurs dénissant les états de
l'environnement. Mais comme un vecteur codé ne préserve pas la structure spatiale d'une image, ce n'est
pas la meilleure forme pour décrire un état. La structure spatiale est en eet importante parce qu'elle nous
donne plus d'informations pour prédire l'état suivant. Prédire l'état suivant est bien sûr essentiel pour que
notre IA sache quel est le bon mouvement suivant. Par conséquent, nous devons préserver la structure
spatiale et pour ce faire, nos entrées doivent être des images 3D (2D pour le tableau de pixels plus une
dimension supplémentaire pour les couleurs). Dans ce cas, les entrées sont simplement les images de l'écran
lui-même, exactement comme ce qu'un humain voit en jouant au jeu. Suivant cette analogie, l'IA agit
comme un humain : elle observe les images d'entrée à l'écran en jouant au jeu, les images d'entrée sont
transmises dans un réseau de neurones convolutionnel (le cerveau pour un humain) qui va détecter l'état
dans chaque image. Cependant, ce réseau de neurones convolutionnel ne contient pas de couches de pooling,
car elles perdraient l'emplacement des objets à l'intérieur de l'image, et bien sûr l'IA doit garder la trace des
objets. Par conséquent, nous ne conservons que les couches convolutionnelles, puis en les aplatissant dans
un vecteur unidimensionnel, nous obtenons l'entrée de notre précédent réseau Deep Q-Learning. Ensuite, le
même processus est exécuté de nouveau.
Par conséquent, le Deep Convolutional Q-Learning est donc identique au Deep Q-Learning, avec la seule
diérence que les entrées sont maintenant des images et un réseau de neurones convolutionnel est ajouté au
début du réseau Deep Q-Learning pour détecter les états (ou simplement les objets) des images.
Figure 4: Deep Convolutional Q-Learning
Page 90 of 103
5.2 Le modèle Asynchronous Actor-Critic Agents (A3C)

5.2.1 L'intuition du modèle A3C
Jusqu'à présent, l'action exécutée à chaque fois a été le résultat d'un réseau de neurones, comme si un seul
agent décidait de la stratégie à adopter pour jouer au jeu. Ce ne sera plus le cas avec l'A3C. Cette fois-ci,
nous allons avoir plusieurs agents, chacun interagissant avec sa propre copie de l'environnement. Disons qu'il
y a n agents A1 , A2 ,..., An .
Chaque agent partage deux réseaux : l'acteur et le critique. Le critique évalue les états actuels, tandis que
l'acteur évalue les valeurs possibles dans l'état actuel. L'acteur est habitué à prendre des décisions. À chaque
époque de formation, l'agent prend la dernière version des réseaux partagés et il utilise l'acteur pendant n
étapes an de prendre une décision. Au cours des n étapes, on recueille tous les nouveaux états observés,
les valeurs de ces nouveaux états, les récompenses, etc.... Après les n étapes, l'agent utilise les observations
recueillies pour mettre à jour les modèles partagés. Les temps des époques, donc les temps de mise à jour
du réseau partagé par l'agent ne sont pas synchrones, d'où le nom (Asynchronous).
De cette façon, si un agent malchanceux commence à être bloqué dans une stratégie relative mais attrayante,
il atteindra cet état parce que d'autres agents ont également mis à jour la stratégie partagée avant que
l'agent soit bloqué - et continuera une exploration eective.
An d'expliquer les règles de mise à jour de l'acteur et du critique, voyons les réseaux comme des fonctions
qui dépendent de vecteurs de paramètres θ (pour l'acteur) et θv (pour le critique).
5.2.2 Le processus A3C complet

L'algorithme A3C ociel est celui du journal Google DeepMind, "Asynchronous Methods for Deep Reinforce-
ment Learning"(https://arxiv.org/pdf/1602.01783.pdf ). Dans cet article, vous le trouverez dans l'algorithme
S3 suivant :
Figure 5: A3C algorithm (https://arxiv.org/pdf/1602.01783.pdf)
Page 91 of 103
Figure 6: A3C
Dans la gure ci-dessus, nous pouvons clairement voir les trois As de l'AC3 :
• Asynchronous (Asynchrone) : Il y a plusieurs agents, chacun ayant sa propre copie de l'environnement,

et tous désynchronisés (jouant au jeu à des temps diérents).
• Advantage (Avantage) : L'avantage est la diérence entre la prédiction de l'acteur, Q(s, a), et la
prédiction du critique, V (s):
A = Q(s, a) − V (s)
• Actor-Critic (Acteur-Critique) : Bien sûr, nous pouvons voir l'acteur et le critique qui génèrent
donc deux pertes diérentes : la perte de stratégie et la perte de valeur. La perte de stratégie est la
perte liée aux prédictions de l'acteur. La perte de valeur est la perte liée aux prédictions du critique.
Au cours de plusieurs époques de formation, ces deux pertes seront rétropropagées dans le réseau de
neurones, puis réduites avec un optimiseur de descente de gradient stochastique.
Page 92 of 103
5.3 Le modèle Augmented Random Search

Nous voulons développer et former une IA qui marche ou court dans un champ. Le champ est un terrain
plat qui ressemble à ceci :
Dans ce même champ, vous pouvez voir un mi-guépard. Ce sera l'un des agents que nous formerons pour
marcher sur ce terrain. Le terrain et l'agent forment ce que nous appelons un environnement, qui appartient à
PyBullet, l'interface ocielle Python pour Bullet Physics SDK, développée par Erwin Coumans et spécialisée
dans la simulation robotique et le Reinforcement Learning. Pour plus d'informations, cliquez ici. Vous pouvez
également consulter la page GitHub sur ce lien.
5.3.2 Solution d'IA

La solution à notre problème est un modèle d'IA très récent appelé ARS, ou Augmented Random Search.
Le rapport de recherche connexe est publié par Horia Mania, Aurelia Guy et Benjamin Recht le 20 mars
2018. Vous pouvez trouver le rapport de recherche complet ici.
Le modèle ARS est basé sur une branche particulière de l'IA appelée Stratégies d'Évolution (Evolution
Strategies). La diérence est que l'ES utilise des réseaux de neurones profonds parallélisés de plusieurs
couches, tandis que l'ARS utilise une stratégie linéaire simple, qui est un Perceptron (un réseau de neurones
peu profond d'une couche composée de plusieurs neurones). L'ARS est également légèrement similaire à
PPO - Proximal Policy Optimization, en ce sens que l'ARS vise à optimiser une stratégie (une fonction
des états qui remettent les actions en exécution) qui eectue les meilleures actions permettant à l'IA de
marcher. Cependant, la technique est diérente. Si vous souhaitez en savoir plus sur la PPO, vous pouvez
consulter le document de recherche ici.
Maintenant, approfondissons la notion de l'ARS.
Le concept est assez simple. Nous avons une stratégie qui prend comme entrées les états de l'environnement
et donne comme sorties les actions à exécuter pour marcher et courir dans un champ. Avant de commencer
à dénir l'algorithme, décrivons plus en détail les entrées, les sorties et la stratégie.
Page 93 of 103
Les entrées.
L'entrée est un vecteur qui encode les états de l'environnement. D'abord, expliquons ce qu'est exactement
un état de l'environnement : c'est la situation exacte qui se produit à un temps déni t, p. ex. :
On peut voir le guépard, les pattes arrières en l'air, les pattes avant échies, sur le point d'atterrir sur le sol.
Tout cela est encodé dans un vecteur. Comment ? En rassemblant simplement assez de valeurs pour décrire
ce qui se passe. Le vecteur codé contiendra donc les coordonnées des points angulaires du guépard ainsi que
les angles de rotation autour des rotors et plus de valeurs comme la vitesse. Par conséquent, à chaque temps
t, un vecteur de même format encode exactement ce qui se passe dans l'environnement. Ce vecteur codé est
ce que nous appelons l'état d'entrée de l'environnement. Il sera l'entrée de notre stratégie.
Les sorties.
Les sorties, résultant de notre stratégie, est un ensemble d'actions exécutées par l'agent. Ces actions sont
les diérentes impulsions musculaires, p. ex., l'une des actions sera l'intensité du muscle qui pousse la
jambe arrière au niveau du pied. Le plus important ici, c'est davantage le fait que la stratégie donne un
groupe d'actions plutôt qu'une seule action. En eet, une pratique courante dans le Reinforcement Learning
consiste à rendre une action discrète à chaque temps t. Ici, non seulement nous représentons un groupe
d'actions, mais chacune de ces actions est continue. En eet, pour qu'un agent puisse marcher dans un
champ, il doit déplacer toutes les parties de son corps à chaque temps t au lieu d'une seule jambe p. ex. Et
les actions sont continues parce que les impulsions des muscles sont mesurées par des valeurs continues. Par
conséquent, la sortie est aussi un vecteur de plusieurs valeurs continues, tout comme l'état d'entrée.
Page 94 of 103
La stratégie.
Entre les entrées et les sorties, nous avons une stratégie qui n'est rien d'autre qu'une fonction, prenant
comme entrées les états d'entrée, et donnant comme sorties les actions à exécuter, c.-à-d. les impulsions
musculaires. Cette stratégie sera linéaire, puisqu'en eet elle sera un perceptron qui est un simple réseau de
neurones d'une couche et plusieurs neurones :
La couche cachée au milieu contient les diérents neurones du perceptron. À chaque couple de (valeur
d'entrée, valeur de sortie) est attribué un poids. Par conséquent, nous avons un nombre_d'_entrées ×
nombre_de_poids des sorties. Tous ces poids sont rassemblés dans une matrice, qui n'est autre que la
matrice de notre stratégie linéaire. Dans cette matrice, les lignes correspondent aux valeurs de sortie (les
actions) et les colonnes correspondent aux valeurs d'entrée (des états). Ainsi, cette matrice de poids, appelée
Θ, est composée de n = nombre_de_lignes de sortie et m = nombre_de_colonnes d'entrée :
··· ···

(input 1, output 1) (input 2, output 1) (input m, output 1)
 
θ1,1 θ2,1 θm,1

(input 1, output 2) (input 2, output 2) ··· (input m, output 2)
  θ1,2
  θ2,2 ··· θm,2 
Θ= = .
 
. . .. . . .. . 
. . . .   .. . . . 
 . . . . .
(input 1, output n) (input 2, output n) ··· (input m, output n) θ1,n θ2,n ··· θm,n
Page 95 of 103
L'algorithme ARS.
Initialisation.
Au tout début, tous les poids θi,j de notre politique linéaire sont initialisés à zéro :
∀i, j ∈ {1, n} × {1, m}, θi,j = 0
Appliquer des perturbations aux poids.

Ensuite, nous allons appliquer quelques petites perturbations à chacun de ces poids, en ajoutant de très
petites valeurs δi,j à chacun des θi,j dans notre matrice de poids :
··· ···

θ1,1 θ2,1 θm,1
 
θ1,1 + δ1,1 θ2,1 + δ2,1 θm,1 + δm,1

 θ1,2 θ2,2 ··· θm,2   θ1,2 + δ1,2 θ2,2 + δ2,2 ··· θm,2 + δm,1 
.  −→ 
   
 . . .. . . .. .
 .. . .  . . .

. . .  . . . . 
θ1,n θ2,n ··· θm,n θ1,n + δ1,n θ2,n + δ2,n ··· θm,n + δm,n
Nous l'appellerons : "Appliquer quelques perturbations dans une direction positive" +∆k , où ∆k est la
matrice de perturbations suivante :
···

δ1,1 δ2,1 δm,1

 δ1,2 δ2,2 ··· δm,2 
∆k =  .
 
. .. . 
 .. .
. . . 
.
δ1,n δ2,n ··· δm,n
"Positive" vient du fait que nous ajoutons les petites valeurs δi,j à nos poids θi,j . Ces petites perturbations
δi,j sont échantillonnés à partir d'une distribution gaussienne N (0, σ) (l'écart-type σ est ce que nous appelons
"bruit" dans le modèle ARS.
Et chaque fois que nous faisons cela, nous allons appliquer exactement les mêmes perturbations δi,j à nos
poids θi,j , mais dans la direction opposée −∆k , en soustrayant simplement cette fois exactement la même
chose δi,j :
··· θ1,1 − δ1,1 θ2,1 − δ2,1 ··· θm,1 − δm,1


θ1,1 θ2,1 θm,1
  
 θ1,2 θ2,2 ··· θm,2 

 θ1,2 − δ1,2
 θ2,2 − δ2,2 ··· θm,2 − δm,1 
.  −→ 
 
 . . .. . . .. .
 .. . .  . . .

. . .  . . . . 
θ1,n θ2,n ··· θm,n θ1,n − δ1,n θ2,n − δ2,n ··· θm,n − δm,n
Nous appellerons cela : "Appliquer certaines perturbations dans une direction négative" −∆k .
En conclusion, nous échantillonnons une matrice spécique de perturbations ∆k avec quelques valeurs δi,j
proche de zéro et nous mettons à jour les poids de notre matrice Θ dans la direction positive +∆k et la
direction négative −∆k :
Direction positive : Θ → Θ + ∆k
Direction négative : Θ → Θ − ∆k
Page 96 of 103
Et en fait, à chaque étape complète, nous allons appliquer ces perturbations positives et négatives dans de
nombreuses directions diérentes ∆1 , ∆ 2 , ∆3 , etc. Nous le ferons pour 16 directions diérentes :
Directions positives : Θ → Θ + ∆1 , Θ → Θ + ∆2 , ... , Θ → Θ + ∆16

Directions négatives : Θ → Θ − ∆1 , Θ → Θ − ∆2 , ... , Θ → Θ − ∆16
Maintenant, il est temps de se demander : pourquoi faisons-nous cela ?
La raison est en fait simple. Nous voulons mettre à jour les poids dans ces diérentes directions pour trouver
ceux qui augmenteront le plus la récompense totale à travers les diérents épisodes. Nous voulons savoir
quelles mises à jour des poids permettront d'obtenir les récompenses les plus élevées. En eet, augmenter
la récompense totale accumulée au cours d'un épisode est notre objectif ultime, puisque plus la récompense
est élevée, plus l'agent aura la capacité de marcher.
Maintenant une autre question moins évidente : Pourquoi voulons-nous, pour chaque direction, choisir
positive et négative ?
C'est parce qu'une fois que nous aurons déterminé les directions qui augmentent le plus les récompenses
(en obtenant simplement la récompense accumulée dans l'épisode complet pour chaque direction et en les
triant par les plus élevées), nous ferons une étape de descente de gradient pour actualiser les poids dans ces
meilleures directions. Cependant, nous n'avons pas de fonction de récompense pour les poids, donc nous ne
pouvons pas appliquer directement la descente de gradient. En eet, pour appliquer la descente de gradient,
nous aurons besoin d'une fonction de récompense des poids, r(Θ), à diérencier par rapport aux poids :
∂r(Θ)
∂Θ
puis faites cette étape de descente de gradient pour mettre à jour les poids :
∂r(Θ)
Θ(nouveau) := Θ(ancien) + dΘ
∂Θ
Mais nous ne pouvons pas le faire parce que nous n'avons pas d'expression explicite de la récompense en ce
qui concerne les poids. Donc, au lieu de calculer directement ce gradient, nous allons l'approximer. Et c'est
là que la particularité des directions positives & négative intervient avec la méthode des diérences nies.
Descente de gradient approximative avec la méthode des diérences nies.

Nous comprenons maintenant que nous devons faire une étape de descente de gradient pour mettre à jour
les poids dans les directions qui augmentent le plus la récompense, et que pour cela, nous n'avons d'autre
choix que d'approximer le gradient des récompenses par rapport aux poids. Plus précisément, nous devons
approximer :
∂r(Θ)
dΘ
∂Θ
Avec ce que nous avons fait avant d'appliquer les perturbations dans les directions positives et négatives, nous
serons en mesure d'en faire une approximation facile. Puisque la valeur de chaque perturbation δ est un très
petit nombre proche de zéro, alors la diérence entre la récompense r+ obtenue en appliquant la perturbation
Page 97 of 103
dans la direction positive (Θ → Θ + ∆) et la récompense r− obtenue en appliquant la perturbation dans la

direction négative (Θ → Θ − ∆) est approximativement égal à ce gradient :
∂r(Θ)
r+ − r− ≈
∂Θ
pour obtenir l'approximation suivante :
∂r(Θ)
(r+ − r− )∆ ≈ dΘ
∂Θ
Cette approximation est le résultat de la méthode des diérences nies qui nous permet de faire cette étape
de descente de gradient approximative.
Ensuite, nous choisissons un certain nombre de meilleures directions que nous voulons garder comme étant
celles qui mènent aux récompenses les plus élevées et nous faisons cette étape de descente de gradient ap-
proximative sur toutes ces meilleures directions. Comment savons-nous quelles sont les principales directions
qui augmentent le plus les récompenses ? Disons que nous voulons garder les 16 meilleures directions, nous
appliquons simplement les perturbations positives et négatives pour chacune de toutes nos directions dans un
épisode complet, nous stockons les quelques récompenses (r+ , r− ) obtenues pour chacune de ces directions,
et nalement nous gardons les 16 les plus élevées de r+ et r− . Ces 16 meilleures récompenses correspondent
à nos 16 meilleures directions.
Ensuite, nous faisons la moyenne de nos gradients approximatifs sur ces 16 meilleures directions pour mettre
à jour toute la matrice de poids Θ :
16
1 X
Θ(nouveau) = Θ(ancien)+ [r+ (k th meilleure direction)−r− (k
th
meilleure direction)]∆kth meilleure direction
16
k=1
(1)
Juste après cette mise à jour, l'étape de descente de gradient est appliquée à toute la matrice de poids Θ, de
sorte que les poids de notre stratégie sont mis à jour dans les directions supérieures qui augmentent le plus
la récompense accumulée.
Le Training loop.
Enn, nous répétons tout ce processus (en dehors de l'initialisation des poids à zéro) pour un certain nombre
d'étapes (par ex. 1000 étapes).
Nous pouvons améliorer le rendement des ARS grâce aux trois mesures suivantes :
1. Normalisation des états
2. Mise à l'échelle par l'écart-type de la récompense
3. Réglage du taux d'apprentissage
Jetons un coup d'÷il à chacune de ces solutions à la page suivante.
Page 98 of 103
Normalisation des états.

Dans le rapport de recherche, nous avons le choix entre V1 et V2 (voir page 6). V1 est l'algorithme ci-dessus
sans normalisation des états d'entrée, et V2 est l'ARS avec des états d'entrée normalisés.
La normalisation des états améliore nettement les performances.
Mise à l'échelle par l'écart-type de la récompense.

On peut mettre à l'échelle en divisant la somme précédente de l'équation (1) par l'écart-type σr de la
récompense pour obtenir :
16
1 X
th
16σr
k=1
(2)
Réglage du taux d'apprentissage.

Pour des besoins d'ajustement, nous pouvons ajouter un facteur de taux d'apprentissage dans l'équation (2)
( dénoté par α dans le rapport) :
16
α X
th
16σr
k=1
Page 99 of 103
6 Annexe 3 : Questions et réponses

6.1 Q&Rs sur la partie 1 - Optimisation des processus
Quels sont le plan et la stratégie ?
Le plan est le processus de création de l'environnement des états d'entrée, et la stratégie est la fonction qui
prend les états d'entrée dénis par le plan comme entrées et donne les actions à exécuter comme sorties.
Donc, dans l'étude de cas, tout le processus que nous suivons pour dénir l'environnement de l'entrepôt est
notre plan, et la stratégie est notre IA. Jetez un coup d'÷il aux liens suivants, car ils pourraient vous aider
à mieux comprendre le contexte :
1. Lien 1
2. Lien 2
Qui détermine le facteur de réduction dans l'équation de Bellman et comment ?

Il est déterminé par le développeur de l'IA par l'expérimentation. Vous essayez d'abord avec 1 (pas de
remise), puis vous diminuez un peu et observez si vous obtenez de meilleurs résultats. Et en répétant ceci,
vous trouverez une valeur optimale.
D'autres questions et leurs réponses seront ajoutées ici, dès que des questions pertinentes seront posées dans
le cours.
Page 100 of 103

6.2 Q&Rs sur la partie 2 - Minimiser les coûts

Dans le Deep Reinforcement Learning. Quand utiliser Argmax ou Softmax ?
Vous utiliseriez Argmax pour des problèmes pas trop complexes (comme les problèmes d'entreprise), et
Softmax pour des problèmes complexes comme jouer à des jeux ou faire marcher un robot. En eet, pour
les problèmes complexes, il faut faire de l'exploration plutôt que de l'exploitation, et c'est exactement ce
que Softmax vous permet de faire. Cependant, les problèmes d'entreprise ne sont pas trop complexes, vous
n'avez donc pas besoin de faire beaucoup d'exploration, et donc une méthode Argmax est bien susante.
Y a-t-il une raison spécique pour choisir deux couches de 64 et 32 neurones pour l'architecture
du cerveau ? Faut-il alors faire attention au surapprentissage ?
Ce qu'il faut faire, c'est commencer par quelques architectures classiques que l'on retrouve dans les documents
(ImageNet, ResNet, Inception, MobileNets, etc.). Ensuite, nous essayons, nous voyons si nous obtenons de
bons résultats, et si c'est le cas, nous pouvons nous arrêter là. Pour notre DNN, nous avons simplement
opté pour une architecture classique avec 2 couches de 64 et 32 neurones entièrement connectés qui se sont
révélées très ecaces pour notre étude de cas. Ensuite, nous évitons le surapprentissage dans le cours en
appliquant deux techniques diérentes. Celles-ci nous permettront d'améliorer le modèle, et donc d'améliorer
le résultat. Ces deux techniques sont :
1. Early Stopping (Arrêt anticipé)
2. Dropout
D'autres questions et leurs réponses seront ajoutées dès que des questions pertinentes seront posées dans le
cours.
Page 101 of 103

6.3 Q&Rs sur la Partie 3 - Optimiser les revenus

Pourriez-vous nous expliquer plus en détail ce qu'est une distribution ? Qu'y a-t-il sur l'axe
des abscisses et sur l'axe des ordonnées ?
Supposons que nous avons une expérience pour sélectionner 100 fois la stratégie à déployer sur le client
(c.-à-d. avec 100 clients distincts les uns après les autres), et nous calculons la fréquence de sélection de
la stratégie. Puis, on la répète encore 100 fois et encore 100 fois de plus. On obtient ainsi de nombreuses
fréquences. Si nous répétons de tels calculs de fréquence plusieurs fois, par exemple 500 fois, nous pouvons
tracer un histogramme de ces fréquences. Par le théorème de la limite centrale, il sera en forme de cloche, et
sa moyenne sera la moyenne de toutes les fréquences obtenues au cours de l'expérience. Par conséquent, sur
l'axe des abscisses, nous avons les diérentes valeurs possibles de ces fréquences, et sur l'axe des ordonnées,
nous avons le nombre de fois où nous avons obtenu chaque fréquence dans le cadre de l'expérience.
Dans la première conférence sur l'intuition, pourriez-vous expliquer pourquoi D5 (en orange)
est la meilleure distribution ? Pourquoi ce n'est pas D3 (en rose) ?
Dans cette situation, 0 est la perte, et 1 est le gain (win). La D5 est la meilleure parce qu'elle est asymétrique,
de sorte que nous aurons des résultats moyens proches de 1, ce qui signie que nous avons plus de gains. En
fait, toutes les machines de casino d'aujourd'hui sont soigneusement programmées pour avoir une distribution
comme D1 ou D3. C'est un bon exemple concret.
Sur le graphique ci-dessous, pourquoi la marque jaune est-elle le meilleur choix, et non la
marque verte ?
La marque jaune est la meilleure, car elle est la plus éloignée de l'origine sur l'axe des abscisses, ce qui signie
donc qu'elle a le rendement estimé le plus élevé.
Page 102 of 103

Je ne comprends pas comment et pourquoi l'Échantillonnage Thompson peut accepter un

feedback diérée. Veuillez expliquer.
Lors de l'Échantillonnage Thompson, nous pouvons toujours eectuer des mises à jour de notre algorithme
(comme faire de nouvelles suppositions pour les distributions avec les données existantes, faire un échantil-
lonnage avec la distribution supposée, etc.) en attendant les résultats d'une expérience dans le monde réel.
Cela n'empêcherait pas notre algorithme de bien fonctionner. C'est pourquoi il peut accepter les feedbacks
diérés.
Quels sont d'autres exemples d'applications de l'Échantillonnage Thompson ?

L'exemple le plus classique est l'optimisation du taux de conversion. Vous avez plusieurs annonces pour un
même produit et vous voulez savoir laquelle a le CTR le plus élevé. Vous allez donc faire la même chose que
nous avons fait avec les stratégies, sauf que cette fois-ci, les bras seront les publicités.
Une autre application potentielle du Multi-armed bandits (MAB) peut être le test des algorithmes en ligne.
Supposons par exemple que vous exploitez un site e-commerce et que vous avez à votre disposition plusieurs
algorithmes de Machine Learning pour fournir des recommandations aux utilisateurs (sur ce que le site vend),
mais vous ne savez pas quel algorithme mène aux meilleures recommandations.
Vous pouvez considérer votre problème comme un problème MAB et dénir chaque algorithme de Machine
Learning comme un "bras" : à chaque phase où un utilisateur demande une recommandation, un bras (c'est-à-
dire un des algorithmes) sera sélectionné pour faire les recommandations, et vous recevrez une récompense.
Dans ce cas, vous pouvez dénir votre récompense de diérentes manières, un exemple simple est "1" si
l'utilisateur clique / achète un article et "0" sinon. Éventuellement, votre algorithme bandit convergera et
nira toujours par choisir l'algorithme qui est le plus ecace pour fournir des recommandations. C'est un
bon moyen de trouver le modèle le plus adapté à un problème en ligne.
Un autre exemple qui me vient à l'esprit est trouver le meilleur traitement clinique pour les patients : chaque
traitement possible pourrait être considéré comme un "bras", et un moyen simple de dénir la récompense
serait un nombre entre 0 (le traitement n'a aucun eet) et 1 (le patient est guéri parfaitement).
Dans ce cas, l'objectif est de trouver le plus rapidement possible le meilleur traitement tout en minimisant
les regrets cumulatifs (ce qui revient à dire que l'on veut éviter au maximum de choisir des traitements
"négatifs" voire relatifs pendant le processus).
Où puis-je trouver d'excellentes ressources sur la distribution Beta ?

La meilleure est la suivante : Distribution Beta
Je souhaiterais savoir comment on appliquerait l'Échantillonnage Thompson de façon proactive

dans le cadre de cette campagne de stratégie théorique. Pourriez-vous répéter le programme
à chaque phase ?
Tout d'abord, un ingénieur informatique crée un pipeline pour lire les données du site Web et y réagir en
temps réel. Ensuite, une visite sur le Web déclenche une réponse pour recalculer les paramètres et choisir
une stratégie pour la prochaine fois.
D'autres questions et leurs réponses seront ajoutées dès que des questions pertinentes seront posées dans le
cours.
Page 103 of 103

L Intelligence Artificielle Dans Le Monde Du Business

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

L Intelligence Artificielle Dans Le Monde Du Business

Transféré par

Droits d'auteur :

Formats disponibles

L'intelligence articielle dans le monde

par Hadelin de Ponteves, Kirill Eremenko, et Charles Bordet

Table des matières

2 Partie 2 - Minimiser les coûts 24

3 Partie 3 - Optimiser les revenus 49

4 Annexe 1 : Réseaux de neurones articiels 63

4.8 Descente de gradient stochastique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84

5 Annexe 2 : Trois modèles supplémentaires d'IA 90

6 Annexe 3 : Questions et réponses 100

Partie Étude de cas Solutions d'IA

Nous suivrons dans chacune de ces parties le même processus en 3 étapes :

3. Implémentation. Nous implémenterons la solution d'IA en Python, nous entrerons en production et

1 Partie 1 - Optimisation des processus

1.1 Étude de cas : Optimisation des ux dans un entrepôt e-commerce

Figure 1: Robot d'entrepôt autonome

Niveau de priorité Emplacement

1.1.2 Environnement à dénir

• Dénir les états

• Dénir les actions

• Dénir les récompenses

Dénissons ces trois éléments.

Dénir les états.

Dénir les actions.

Dénir les récompenses.

Passons maintenant à l'emplacement B. Lorsque le robot se trouve à l'emplacement B, il ne peut se rendre

1.2 Solutions d'IA

1.2.1 Processus décisionnels de Markov

S = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}

A = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}

• T s'appelle la règle de transition :

T : (st ∈ S, st+1 ∈ S, at ∈ A) 7→ P(st+1 |st , at )

• R est la fonction de récompense :

P(st+1 |s0 , a0 , s1 , a1 , ..., st , at ) = P(st+1 |st , at )

En d'autres termes, un processus décisionnel de Markov n'a pas de mémoire.

1. L'IA observe l'état actuel st .

2. L'IA exécute l'action at .

3. L'IA reçoit la récompense rt = R(st , at ).

4. L'IA passe à l'état suivant st+1 .

Donc maintenant la question est :

Comment l'IA sait-elle quelle action exécuter à chaque temps t ?

Par conséquent, la question est la suivante :

Comment trouver cette stratégie optimale π∗ ?

• et Q(st , at ), soit la Q-Value de l'action at exécutée dans l'état st ,

T Dt (st , at ) = R(st , at ) + γmax(Q(st+1 , a)) − Q(st , at )

• Si T Dt (st , at ) est élevée, l'IA obtient une "bonne surprise".

• Si T Dt (st , at ) est petite, l'IA obtient une "frustration".

Qt (st , at ) = Qt−1 (st , at ) + αT Dt (st , at )

Cette équation ci-dessus est l'équation de Bellman. C'est le pilier du Q-Learning.

Cette solution est la méthode Argmax.

La méthode Softmax consiste à considérer pour chaque état s la distribution suivante :

1.2.3 L'algorithme Q-Learning complet

st = random(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)

at = random(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11) s.t. R(st , at ) > 0

3. Nous atteignons l'état suivant st+1 et nous obtenons la récompense R(st , at )

4. Nous évaluons la diérence temporelle T Dt (st , at ):

T Dt (st , at ) = R(st , at ) + γmax(Q(st+1 , a)) − Q(st , at )

5. Nous mettons à jour la Q-value en appliquant l'équation de Bellman :

Qt (st , at ) = Qt−1 (st , at ) + αT Dt (st , at )

# Importing the libraries

# Setting the parameters gamma and alpha for the Q-Learning

# PART 1 - DEFINING THE ENVIRONMENT

# Defining the states

# Defining the actions

L'intelligence articielle dans le monde

4 Annexe 1 : Réseaux de neurones articiels 63

1.1 Étude de cas : Optimisation des ux dans un entrepôt e-commerce

1.1.2 Environnement à dénir

• Dénir les états

• Dénir les actions

• Dénir les récompenses

Dénissons ces trois éléments.

Dénir les états.

Dénir les actions.

Dénir les récompenses.

4. Nous évaluons la diérence temporelle T Dt (st , at ):

2.1.2 Environnement à dénir

• Dénir les états

• Dénir les actions

• Dénir les récompenses

Dénir les états.

Dénir les actions.

Dénir les récompenses.

Exemple de simulation nale.

• l'erreur de perte entre la prédiction et la cible est le carré de la diérence temporelle :