• 12 heures
  • Moyenne

Ce cours est visible gratuitement en ligne.

course.header.alt.is_video

course.header.alt.is_certifying

J'ai tout compris !

Mis à jour le 20/01/2020

Connectez un réseau de neurones à l’algorithme d’apprentissage par renforcement

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Dans ce chapitre, nous allons voir comment utiliser un réseau de neurones dans notre algorithme d’apprentissage par renforcement sous Gym. Voyons d'abord la première partie de la méthode :

Disséquons le code afin d'en comprendre les composantes.

Importez les librairies adéquates

Dans cet exemple, nous avons un code de l’algorithme « reinforce » sous forme tabulaire, permettant de simuler un processus d’apprentissage sur une instance nommée « CartPole-v0 ». Nous allons montrer comment remplacer la représentation tabulaire de la politique par une représentation sous forme de réseau de neurones.

D’abord, il faut importer les librairies adéquates issues du package « torch » :

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.distributions import Categorical

Puis, dans la classe qui décrit la politique, nous allons définir l’architecture de réseau de neurones utilisée.

Décrivez l’architecture de réseau de neurones 

Dans le constructeur de la classe « Policy », définissez ensuite le constructeur via la fonction   __init__() .

class Policy(nn.Module):
def __init__():
super(Policy, self).__init__()
self.affine1 = nn.Linear(4, 128)
self.dropout = nn.Dropout(p=0.6)
self.affine2 = nn.Linear(128, 2)
self.saved_log_probs = []
self.rewards = []

Le constructeur procède ainsi : d'abord, il fait appel au constructeur de la super classe via l'instruction ligne 3 ; puis, il rajoute différentes couches afin de construire l'architecture de réseau de neurones souhaitée.

  • En premier, il initialise le réseau avec une couche linéaire (ligne 4) :  self.affine1 = nn.Linear(4,128) .

  • Une opération de dropout (ligne 5) peut-être rajoutée, afin de mettre à zéro des éléments du tenseur de dimension 128 :   self.dropout = nn.Dropout(p=0.6) .

  • Suit une nouvelle couche linéaire (ligne 6) :  self.affine1 = nn.Linear(128, 2) .

  • Enfin, deux listes sont créées afin de recueillir les probabilités par actions (ligne 8) :  self.saved_log_probs = [] ;

  • et les récompenses (ligne 9) :  self.rewards = [] . 

Maintenant que nous avons une description de la politique sous forme de réseau de neurones, regardons comment conduire une “forward pass” ou étape de prédiction en français.

Décrivez l’architecture de réseau de neurones

Vient ensuite la définition de la fonction nommée  def forward(self, x) , celle-ci décrivant le chaînage-avant ou passe forward dans le réseau de neurones.

def forward(self, x):
x = self.affine1(x)
x = self.dropout(x)
x = F.relu(x)
action_scores = self.affine2(x)
return F.softmax(action_scores, dim=1)

On applique successivement les opérations ci-dessus aux données « x », de la politique. D’abord, la première couche linéaire est appliquée,x = self.affine1(x). Puis, au résultant est à nouveau appliqué un dropout,x = self.dropout(x). Et enfin, est appliqué une fonction « relu »,  x =F.relu(x)  . Les scores pour chacune des actions sont donnés par l’application de la seconde fonction linéaire à « x »,action_scores = self.affine2(x). Une fonction « soft-max » est ensuite appliquée sur les scores des actions,return F.softmax(action_scores, dim=1).

Illustrez l’utilisation d’une politique sous la forme d’un réseau de neurones

Pour apprendre les paramètres de cette politique, il faut d'abord créer la politique ; policy ; puis il faut lancer un algorithme d’optimisation stochastique.

policy = Policy()
optimiser = optim.Adam(policy.parameters(), lr=1e-2)

Nous sommes désormais prêts à lancer notre premier test d’un algorithme d’apprentissage par renforcement sur un exemple jouet sous Gym. Et voilà !

 

Vous êtes arrivé à la fin de ce cours ! Vous devez maintenant être capable de :

  • décrire le processus de prise de décision autonome par un drone ;

  • modéliser la prise de décision par un drone ;

  • décrire les principes l'apprentissage par renforcement profond ;

  • mettre en œuvre l'apprentissage par renforcement profond avec un drone.

N'oubliez pas de réaliser les exercices à la fin de chaque partie pour valider ces compétences. C'était un plaisir de vous accompagner tout au long de ce cours.

Je vous souhaite une très bonne continuation dans tous vos projets !

Exemple de certificat de réussite
Exemple de certificat de réussite