Explication du théorème du gradient de politique : Une introduction pratique

Pourquoi utiliser les méthodes de gradient de politique ?

L'un des principaux avantages des méthodes de gradient de politique est leur capacité à gérer des espaces d'action complexes, là où les approches traditionnelles basées sur la valeur rencontrent des difficultés.

Traitement des espaces d'action à haute dimension

Les méthodes basées sur la valeur, telles que l'apprentissage Q, fonctionnent en estimant la fonction de valeur pour toutes les actions possibles. Cela devient difficile lorsque l'espace d'action de l'environnement est soit continu, soit discret, mais étendu. 

Les méthodes de gradient de politique paramètrent la politique et estiment le gradient des récompenses cumulées en fonction desparamètres de la politique. Ils utilisent ce gradient pour optimiser directement la politique en mettant à jour ses paramètres. Ils peuvent donc traiter efficacement des espaces d'action à haute dimension ou continus. Les gradients de politique sont également à la base des méthodes d'apprentissage par renforcement utilisant la rétroaction humaine (RLHF).  

En paramétrant la politique et en ajustant ses paramètres sur la base des gradients, les gradients de politique peuvent traiter efficacement des actions continues et à haute dimension. Cette approche directe permet une meilleure généralisation et une exploration plus souple, ce qui la rend bien adaptée à des tâches telles que le contrôle robotique et d'autres environnements complexes.

Apprentissage de politiques stochastiques

Compte tenu d'un ensemble d'observations : 

• Une politique déterministe spécifie l'action à entreprendre par l'agent. 
• Une politique stochastique donne un ensemble d'actions et la probabilité que l'agent choisisse chaque action. 

Dans le cadre d'une politique stochastique, la même observation peut conduire à choisir des actions différentes selon les itérations. Cela favorise l'exploration de l'espace d'action et empêche la politique de rester bloquée dans des optima locaux. C'est pourquoi les politiques stochastiques sont utiles dans les environnements où l'exploration est essentielle pour découvrir le chemin qui mène au rendement maximal. 

Dans les méthodes fondées sur la politique, les résultats de la politique sont convertis en une distribution de probabilités, chaque action possible étant assortie d'une probabilité. L'agent choisit une action en échantillonnant cette distribution, ce qui permet de mettre en œuvre une politique stochastique. Ainsi, les méthodes de gradient de politique combinent l'exploration et l'exploitation, ce qui est utile dans les environnements présentant des structures de récompense complexes. 

Dérivation du théorème du gradient de politique

Avant de plonger dans la dérivation, il est important d'établir la notation mathématique et les concepts clés utilisés tout au long de la preuve.

Notation mathématique et préliminaires

Comme mentionné dans une section précédente, le théorème du gradient de politique stipule que la dérivée du rendement attendu est l'espérance du produit du rendement et de la dérivée du logarithme de la politique. 

Avant de dériver le théorème du gradient de politique, nous introduisons la notation :

• E[X] désigne l'espérance probabiliste d'une variable aléatoire X.
• Mathématiquement, la politique est exprimée sous la forme d'une matrice de probabilité qui donne la probabilité de choisir différentes actions sur la base de différentes observations. Une politique est généralement modélisée comme une fonction paramétrée, dont les paramètres sont représentés par θ.
• _πθ fait référence à une politique paramétrée par θ. Dans la pratique, ces paramètres sont les poids du réseau neuronal qui modélise la politique. 
• La trajectoire, τdésigne une séquence d'états, partant généralement d'un état initial aléatoire jusqu'au pas de temps actuel ou à l'état final.
• ∇_θf désigne le gradient d'une fonction f par rapport au(x) paramètre(s) θ.
• J(π_θ) désigne le rendement attendu par l'agent qui suit la politique _πθ. Il s'agit également de la fonction objective pour la montée en gradient. 
• L'environnement donne une récompense à chaque étape, en fonction de l'action de l'agent. Le rendement fait référence aux récompenses cumulées entre l'état initial et le pas de temps actuel. 
• R(τ) désigne le rendement généré sur la trajectoire τ.

Étapes de dérivation

Nous montrons comment dériver et prouver le théorème du gradient de la politique à partir des premiers principes, en commençant par l'expansion de la fonction objective et en utilisant l'astuce de la dérivée logarithmique. 

La fonction objective (équation 1)

La fonction objective de la méthode du gradient de politique est le rendement 

J accumulée en suivant la trajectoire basée sur la politique π exprimée en termes de paramètres θ. Cette fonction objective est donnée comme suit : 

Dans l'équation ci-dessus : 

• Le côté gauche (LHS) est le rendement attendu en suivant la politique π_θ.
• Le côté droit (RHS) est l'espérance (sur la trajectoire τ générée en suivant la politique π_θ à chaque étape) des rendements R(τ) générés sur la trajectoire τ.

Le différentiel de la fonction objective (équation 2)

Différenciation (par rapport à θ) les deux côtés de l'équation ci-dessus donne :

Le gradient de l'espérance (équation 3)

L'espérance (sur la droite) peut être exprimée comme une intégrale sur le produit de : 

• La probabilité de suivre une trajectoire τ
• Les rendements générés sur la trajectoire τ

Ainsi, la partie droite de l'équation 2 est reformulée comme suit : 

Le gradient d'une intégrale est égal à l'intégrale du gradient. Ainsi, dans l'expression ci-dessus, nous pouvons apporter le gradient ∇_θ sous le signe de l'intégrale. Ainsi, la droite devient : 

L'équation 2 peut donc être réécrite comme suit :

La probabilité de la trajectoire (équation 4)

Nous allons maintenant examiner de plus près P(τ|θ), la probabilité que l'agent suive la trajectoire τ compte tenu des paramètres de politique θ (et donc de la politique _πθ). Une trajectoire est constituée d'un ensemble d'étapes. Ainsi : 

• La probabilité d'obtenir la trajectoire τ est le produit de :
• La probabilité de suivre toutes les étapes individuelles. 

• Au pas de temps tl'agent passe de l'état s à l'état s_t+1 en suivant l'action a_t. La probabilité que cela se produise est donnée par le produit de :
• La probabilité que la politique prédise une action a_t dans l'état s_t
• La probabilité de se retrouver dans l'état s_t+1 compte tenu de l'action a_t et l'état s_t

Ainsi, à partir d'un état initial s₀la probabilité que l'agent suive la trajectoire τ sur la base de la politique π_θ est donnée comme suit :

Pour simplifier les choses, nous voulons exprimer le produit dans la ligne droite ci-dessus sous la forme d'une somme. Nous prenons donc le logarithme des deux côtés de l'équation ci-dessus :

La dérivée de la log-probabilité (équation 5) 

Nous prenons maintenant la dérivée (par rapport à θ) de la probabilité logarithmique dans l'équation ci-dessus.

Sur la droite (RHS) de l'équation ci-dessus : 

• Le premier terme log ρ₀(s₀) est constante par rapport à θ. Sa dérivée est donc égale à 0. 
• Le premier terme à l'intérieur de la somme P(s_t+1|s_t, a_t) est également indépendant de θ et sa dérivée par rapport à θ est également 0.

En supprimant les termes zéro de l'équation, nous obtenons l'équation 5 : 

Rappelons que l'équation 2 indique que : 

L'équation 5 évalue le logarithme de la première partie de la droite de l'équation 2. Nous devons relier la dérivée d'un terme à son logarithme. Pour ce faire, nous utilisons la règle de la chaîne et l'astuce de la dérivée logarithmique. 

L'astuce de la dérivée logarithmique

Nous faisons un détour et utilisons les règles du calcul pour obtenir un résultat qui nous permettra de simplifier l'équation précédente et de la rendre compatible avec les méthodes de calcul. 

En calcul, la dérivée d'un logarithme peut être exprimée comme suit : 

Ainsi, en réarrangeant l'équation ci-dessus, la dérivée de x peut être exprimée en termes de dérivée du logarithme de x :

C'est ce qu'on appelle parfois l'astuce du log-dérivé. 

La règle de la chaîne

Selon la règle de la chaîne, étant donné z(y) en tant que fonction de yoù y est une fonction de θ, y(θ)la dérivée de z par rapport à θ est donnée comme suit :

Dans ce cas, y(θ) représente P(θ) et z(y) représente le log(y). Ainsi, 

Application de la règle de la chaîne

Le calcul nous apprend que d(log(y)) / dy = 1/y. Utilisez ceci dans la première expression de la droite ci-dessus. 

Déplacements y vers la LHS et utilisez la notation et utilisez la notation

y représente P(θ). L'équation ci-dessus est donc équivalente à : 

Application de l'astuce de la dérivée logarithmique

Le résultat ci-dessus donne la première expression de la droite de l'équation 2 (voir ci-dessous).  

En utilisant le résultat dans la partie droite de l'équation 2, nous obtenons : 

Nous réarrangeons les termes sous l'intégrale RHS comme suit :

Calcul du résultat final

Observez que l'expression ci-dessus contient l'expansion intégrale d'une espérance : ∫P(θ)∇logP(θ) = E[∇logP(θ)]

Ainsi, la droite ci-dessus peut être exprimée comme l'espérance : 

Nous remplaçons la dérivée de la probabilité logarithmique par l'expression de la récompense attendue : 

Dans l'équation ci-dessus, remplacez la valeur de ∇logP(θ) de l'équation 5 pour obtenir :

C'est l'expression du gradient de la fonction de récompense selon le théorème du gradient de la politique. 

L'intuition derrière le gradient de politique

Les méthodes de gradient de politique convertissent les résultats de la politique en une distribution de probabilité. L'agent échantillonne cette distribution pour choisir une action. Les méthodes de gradient de politique ajustent les paramètres de la politique. Cela conduit à mettre à jour cette distribution de probabilité à chaque itération. La distribution de probabilités actualisée a une plus grande probabilité de choisir des actions qui conduisent à des récompenses plus élevées. 

L'algorithme du gradient de la politique calcule le gradient du rendement attendu en fonction des paramètres de la politique. En déplaçant les paramètres de la politique dans la direction de ce gradient, l'agent augmente la probabilité de choisir des actions qui se traduisent par des récompenses plus élevées au cours de la formation. 

Essentiellement, les actions qui ont conduit à de meilleurs résultats sont plus susceptibles d'être choisies à l'avenir, ce qui améliore progressivement la politique visant à maximiser les récompenses à long terme.

Mise en œuvre de gradients de politique en Python

Après avoir discuté des principes fondamentaux des gradients de politique, nous montrons comment les mettre en œuvre à l'aide de PyTorch et de Gymnasium. 

Mise en place de l'environnement

Dans un premier temps, nous devons installer gymnasium et quelques bibliothèques de support comme NumPy et PyTorch.

Pour installer gymnasium et ses dépendances sur un serveur ou une machine locale, exécutez :

$ pip install gymnasium 

Pour l'installer en utilisant un Notebook comme Google Colab ou DataLab, utilisez : 

!pip install gymnasium

Vous importez ces paquets dans l'environnement Python :

import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
import torch.distributions as distributions
import numpy as np
import gymnasium as gym  

Codage d'un agent de gradient de politique simple

Créez une instance de l'environnement à l'aide de la méthode .make().

env = gym.make('CartPole-v1')

Comme pour les autres méthodes d'apprentissage automatique, nous utilisons un réseau neuronal pour mettre en œuvre l'agent de gradient de politique. 

CartPole-v1 est un environnement simple, nous concevons donc un réseau simple avec 1 couche cachée de 64 neurones. La dimension de la couche d'entrée est égale aux dimensions de l'espace d'observation. La dimension de la couche de sortie est égale à la taille de l'espace d'action de l'environnement. Ainsi, le réseau politique établit une correspondance entre les états observés et les actions. À partir d'une observation, le réseau produit l'action prévue conformément à la politique. 

Le code ci-dessous met en œuvre le réseau de politiques : 

class PolicyNetwork(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim, dropout):
        super().__init__()

        self.layer1 = nn.Linear(input_dim, hidden_dim)
        self.layer2 = nn.Linear(hidden_dim, output_dim)
        self.dropout = nn.Dropout(dropout)

    def forward(self, x):
        x = self.layer1(x)
        x = self.dropout(x)
        x = F.relu(x)
        x = self.layer2(x)
        return x

Formation de l'agent

L'environnement donne une récompense à chaque étape en fonction de l'état et de l'action de l'agent. L'approche du gradient de politique consiste à effectuer une descente de gradient sur les récompenses cumulées (rendement). L'objectif est de maximiser le rendement total. 

Pour calculer le rendement d'un épisode, vous accumulez (avec un facteur d'actualisation) les récompenses de tous les pas de temps de cet épisode. En outre, la normalisation des rendements est utile pour assurer une formation régulière et stable. Le code ci-dessous montre comment procéder :

def calculate_stepwise_returns(rewards, discount_factor):
    returns = []
    R = 0

    for r in reversed(rewards):
        R = r + R * discount_factor
        returns.insert(0, R)
    returns = torch.tensor(returns)
    normalized_returns = (returns - returns.mean()) / returns.std()
    return normalized_returns

À chaque itération de la passe en avant, nous procédons aux étapes suivantes : 

• Exécutez l'agent en fonction de la politique actuelle à l'aide de la fonction .step(). La politique prédit la probabilité d'entreprendre l'action choisie à chaque étape.
• Recevoir la récompense de l'environnement en fonction de l'action de l'agent.
• Accumulez les récompenses par étapes et les probabilités logarithmiques des actions jusqu'à ce que l'agent atteigne un état final.

Le code ci-dessous met en œuvre la passe en avant :

def forward_pass(env, policy, discount_factor):
    log_prob_actions = []
    rewards = []
    done = False
    episode_return = 0

    policy.train()
    observation, info = env.reset()

    while not done:
        observation = torch.FloatTensor(observation).unsqueeze(0)
        action_pred = policy(observation)
        action_prob = F.softmax(action_pred, dim = -1)
        dist = distributions.Categorical(action_prob)
        action = dist.sample()
        log_prob_action = dist.log_prob(action)

        observation, reward, terminated, truncated, info = env.step(action.item())
        done = terminated or truncated

        log_prob_actions.append(log_prob_action)
        rewards.append(reward)
        episode_return += reward

    log_prob_actions = torch.cat(log_prob_actions)
    stepwise_returns = calculate_stepwise_returns(rewards, discount_factor)

    return episode_return, stepwise_returns, log_prob_actions

Utilisation de la rétropropagation et de l'ascension du gradient pour mettre à jour la politique

Dans l'apprentissage automatique traditionnel :

• La perte correspond à la différence entre la production prévue et la production réelle. 
• Nous minimisons la perte à l'aide de la descente de gradient.

En RL :

• La perte est une approximation de la quantité sur laquelle la descente (ou l'ascension) de gradient doit être appliquée. 
• Nous maximisons le rendement (récompenses cumulées) à l'aide de la méthode de la montée en gradient.
• La valeur de retour attendue est utilisée comme approximation de la perte pour la descente de gradient. La valeur de retour attendue est le produit de :
• Les rendements attendus de chaque étape avec 
• La probabilité de choisir l'action échantillonnée à chaque étape. 
• Pour appliquer l'ascension du gradient à l'aide de la rétropropagation, nous utilisons la valeur négative de la perte. 

Le code ci-dessous calcule la perte :

def calculate_loss(stepwise_returns, log_prob_actions):
    loss = -(stepwise_returns * log_prob_actions).sum()
    return loss

Comme pour les algorithmes d'apprentissage automatique standard, pour mettre à jour la politique, vous exécutez la rétropropagation par rapport à la fonction de perte. La méthode update_policy() ci-dessous invoque la méthode calculate_loss(). Il exécute ensuite la rétropropagation sur cette perte pour mettre à jour les paramètres de la politique, c'est-à-dire les poids du modèle du réseau de la politique. 

def update_policy(stepwise_returns, log_prob_actions, optimizer):
    stepwise_returns = stepwise_returns.detach()
    loss = calculate_loss(stepwise_returns, log_prob_actions)
    
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    return loss.item()

La boucle de formation 

Nous utilisons les fonctions définies précédemment pour former la politique. Avant de commencer la formation, nous avons besoin : 

• Une politique non entraînée initialisée en tant qu'instance aléatoire de la classe PolicyNetwork. 
• Un optimiseur qui utilise l'algorithme d'Adam. 
• Hyperparamètres pour le facteur d'actualisation, le taux d'apprentissage, le taux d'abandon, le seuil de récompense et le nombre maximal d'époques d'apprentissage. 

Nous itérons dans la boucle d'apprentissage jusqu'à ce que le rendement moyen dépasse le seuil de récompense. À chaque itération, nous exécutons les étapes suivantes : 

• Pour chaque épisode, exécutez une fois la passe avant. Recueillez la probabilité logarithmique des actions, les rendements progressifs et le rendement total de cet épisode. Accumulez les retours épisodiques dans un tableau. 
• Calculez la perte en utilisant les logarithmes des probabilités et les rendements progressifs. Exécutez la rétro-propagation sur la perte. Utilisez l'optimiseur pour mettre à jour les paramètres de la politique. 
• Vérifiez si le rendement moyen sur N_TRIALS dépasse le seuil de récompense.

Le code ci-dessous met en œuvre ces étapes :

def main(): 
    MAX_EPOCHS = 500
    DISCOUNT_FACTOR = 0.99
    N_TRIALS = 25
    REWARD_THRESHOLD = 475
    PRINT_INTERVAL = 10
    INPUT_DIM = env.observation_space.shape[0]
    HIDDEN_DIM = 128
    OUTPUT_DIM = env.action_space.n
    DROPOUT = 0.5

    episode_returns = []

    policy = PolicyNetwork(INPUT_DIM, HIDDEN_DIM, OUTPUT_DIM, DROPOUT)

    LEARNING_RATE = 0.01
    optimizer = optim.Adam(policy.parameters(), lr = LEARNING_RATE)

    for episode in range(1, MAX_EPOCHS+1):
        episode_return, stepwise_returns, log_prob_actions = forward_pass(env, policy, DISCOUNT_FACTOR)
        _ = update_policy(stepwise_returns, log_prob_actions, optimizer)

        episode_returns.append(episode_return)
        mean_episode_return = np.mean(episode_returns[-N_TRIALS:])

        if episode % PRINT_INTERVAL == 0:
            print(f'| Episode: {episode:3} | Mean Rewards: {mean_episode_return:5.1f} |')

        if mean_episode_return >= REWARD_THRESHOLD:
            print(f'Reached reward threshold in {episode} episodes')
            break

Exécutez le programme de formation en appelant la fonction main():

main()

Ce cahier d'exercices DataLab contient l'implémentation ci-dessus de l'algorithme du gradient de politique.l'implémentation ci-dessus de l'algorithme du gradient de politique. Vous pouvez l'exécuter directement ou l'utiliser comme point de départ pour modifier l'algorithme.

Avantages et défis des méthodes de gradient de politique

Les méthodes de gradient de politique offrent plusieurs avantages, tels que

• Traitement des espaces d'action continus: Les méthodes basées sur la valeur (comme l'apprentissage Q) sont inefficaces avec les espaces d'action continus car elles doivent estimer les valeurs sur l'ensemble de l'espace d'action. Les méthodes de gradient de politique peuvent directement optimiser la politique en utilisant le gradient des rendements attendus. Cette approche fonctionne bien avec les distributions d'actions continues. Ainsi, les méthodes de gradient de politique sont adaptées à des tâches telles que le contrôle robotique, qui sont basées sur des espaces d'action continus.
• Politiques stochastiques: Les méthodes de gradient de politique peuvent apprendre des politiques stochastiques - qui donnent une probabilité de choisir chaque action possible. Cela permet à l'agent d'essayer une variété d'actions et réduit le risque de rester bloqué dans des optima locaux. Il est utile dans les environnements complexes où l'agent doit explorer l'espace d'action pour trouver la politique optimale. La nature stochastique permet d'équilibrer l'exploration (essayer de nouvelles actions) et l'exploitation (choisir les actions les plus connues), ce qui est crucial pour les environnements incertains ou avec des récompenses éparses.
• Optimisation directe des politiques: Les gradients de politique optimisent directement la politique au lieu d'utiliser des fonctions de valeur. Dans les espaces d'action continus ou à haute dimension, l'approximation des valeurs pour chaque action peut s'avérer coûteuse en termes de calcul. C'est pourquoi les méthodes fondées sur les politiques donnent de bons résultats dans ce type d'environnement. 

Malgré leurs nombreux avantages, les méthodes de gradient de politique présentent des difficultés inhérentes :

• Variance élevée dans les estimations du gradient: Les méthodes de gradient de politique sélectionnent les actions en échantillonnant une distribution de probabilité. En fait, ils échantillonnent la trajectoire pour estimer le rendement attendu. Le processus d'échantillonnage étant intrinsèquement aléatoire, les rendements estimés lors des itérations suivantes peuvent présenter une variance élevée. Il peut alors être difficile pour l'agent d'apprendre efficacement, car les mises à jour de la politique peuvent fluctuer de manière significative entre les itérations. 
• Instabilité pendant l'entraînement:
• Les méthodes de gradient de politique sont sensibles aux hyperparamètres tels que le. Si le taux d'apprentissage est trop élevé, les mises à jour des paramètres de la politique peuvent être trop importantes, ce qui fait que la formation ne tient pas compte des paramètres optimaux. Par ailleurs, si le taux d'apprentissage est trop faible, la convergence peut être lente. 
• Les méthodes de gradient de politique doivent trouver un équilibre entre l'exploration et l'exploitation. Si l'agent n'explore pas suffisamment, il peut ne pas atteindre le voisinage de la politique optimale. Inversement, s'il explore trop, il ne convergera pas vers la politique optimale et oscillera autour de l'espace d'action. 
• Inefficacité de l'échantillon: Les méthodes de gradient de politique estiment le rendement en suivant chaque politique jusqu'à son terme et en accumulant les récompenses de chaque étape. Ils ont donc besoin de nombreuses interactions avec l'environnement pour dessiner un grand nombre d'échantillons de trajectoires. Cette méthode est inefficace et coûteuse pour les environnements comportant de grands espaces d'état ou d'action. 

Solutions pour la stabilité

L'instabilité étant un problème relativement courant dans les méthodes de gradient de politique, les développeurs ont adopté diverses solutions pour stabiliser le processus d'apprentissage. Nous présentons ci-dessous des solutions courantes pour stabiliser la formation à l'aide de gradients de politique : 

Utilisation des fonctions de base

En raison d'un échantillonnage inefficace, les gradients des rendements estimés pendant les itérations d'apprentissage peuvent présenter une variance élevée, ce qui rend l'apprentissage instable et lent. Une approche courante pour réduire la variance consiste à utiliser des fonctions de référence, telles que la méthode A2C (Advantage Actor-Critic). L'idée est d'utiliser une approximation (la fonction d'avantage) au lieu du rendement estimé pour la fonction objective. 

L'avantage est calculé comme la différence entre le rendement réel de la trajectoire échantillonnée et le rendement attendu compte tenu de l'état initial. Cette approche consiste à utiliser la fonction de valeur comme valeur attendue des états et des paires état-action. En représentant la perte comme la différence entre le rendement réel et le rendement attendu plutôt que comme les seuls rendements, l'A2C réduit la variance de la fonction de perte et, par conséquent, des gradients, ce qui rend l'apprentissage plus stable. 

Utilisation de la régularisation de l'entropie

Dans certains environnements, tels que ceux où les récompenses sont rares (très peu d'états donnent une récompense), la politique adopte rapidement une approche déterministe. Il adopte également une approche gourmande et exploite les chemins qu'il a déjà explorés. Cela empêche de poursuivre l'exploration et conduit souvent à une convergence vers des optima locaux et des politiques sous-optimales. 

La solution consiste à encourager l'exploration en pénalisant la politique lorsqu'elle devient trop déterministe. Pour ce faire, un terme basé sur l'entropie est ajouté à la fonction objective. L'entropie mesure le caractère aléatoire de la politique. Plus l'entropie est grande, plus les actions choisies par l'agent sont aléatoires. Ce terme basé sur l'entropie est le produit du coefficient d'entropie et de l'entropie de la politique actuelle. 

L'intégration de l'entropie dans la fonction objective permet de trouver un équilibre entre l'exploitation et l'exploration. 

Extensions du gradient de politique

Parmi les diverses extensions des méthodes de gradient de politique, l'une des plus fondamentales est l'algorithme REINFORCE. Il fournit une mise en œuvre directe du théorème du gradient de politique et constitue la base de techniques plus avancées.

Algorithme REINFORCE

L'algorithme REINFORCE, également connu sous le nom de Monte Carlo Reinforce, est l'une des applications de base du théorème du gradient de la politique. Il utilise des méthodes de Monte Carlo pour estimer les rendements et les gradients des politiques. Lorsqu'il suit l'algorithme REINFORCE, l'agent échantillonne directement toutes les actions (de l'état initial à l'état final) à partir de l'environnement. Cela contraste avec d'autres méthodes, telles que l'apprentissage en profondeur et la programmation dynamique, qui s'appuient sur des estimations de la fonction de valeur pour déterminer les actions à entreprendre. 

Nous présentons ci-dessous les étapes de base de l'algorithme REINFORCE :

• Initialiser la politique avec des paramètres aléatoires
• Répétez plusieurs épisodes de formation. Pour chaque épisode : 
• Générez chaque étape de l'épisode complet comme suit : 
• Transmettre l'état à la fonction de politique. 
• La fonction politique génère des probabilités pour chaque action possible.
• Prélevez au hasard une action dans cette distribution de probabilités.
• Pour chaque état de l'épisode, estimez les rendements (récompenses cumulées actualisées) jusqu'à l'étape.
• Estimez le gradient de la fonction objective (selon le théorème du gradient de la politique), exprimé comme le produit des rendements par étapes et des probabilités d'action pour chaque étape. 
• Mettre à jour les paramètres de la politique en appliquant les gradients

Pour chaque politique, vous pouvez échantillonner une seule trajectoire pour estimer le gradient (comme indiqué ci-dessus) ou faire la moyenne du gradient sur plusieurs trajectoires échantillonnées dans le cadre de la même politique. 

Méthodes de la critique d'acteur

Les méthodes de critique des acteurs combinent des méthodes de gradient de politique (comme REINFORCE) avec des fonctions de valeur.

• Le fonctionnement de l'acteur est similaire à celui des méthodes de gradient de politique. L'acteur met en œuvre la politique, en sélectionnant des actions à chaque étape sur la base de la politique. Il actualise la politique en suivant le gradient du rendement attendu. 
• Le critique met en œuvre la fonction de valeur, qui est utilisée comme base de référence (discutée dans la section précédente). Cela contribue à rendre la formation plus efficace et plus stable. 

Les méthodes de gradient de politique comme REINFORCE estiment les gradients le long de chaque trajectoire en utilisant le retour brut. Étant donné qu'un processus d'échantillonnage dessine ces trajectoires, il peut entraîner de grandes variances dans les rendements et les gradients. L'utilisation d'une fonction d'avantage au lieu des rendements bruts résout ce problème. La fonction d'avantage est la différence entre le rendement réel et le rendement attendu (c'est-à-dire la fonction de valeur). Les méthodes de critique d'acteur sont une classe d'algorithmes. Lorsque le critique est mis en œuvre à l'aide de la fonction d'avantage (l'approche la plus courante), il est également appelé acteur-critique d'avantage (A2C). 

Optimisation de la politique proximale (PPO)

Dans des environnements complexes, les méthodes de critique des acteurs comme l'A2C ne suffisent pas à contrôler la variance des rendements et des gradients. Dans ce cas, il est utile de limiter artificiellement l'ampleur de la modification de la politique à chaque itération. Cela oblige la politique actualisée (après l'ascension du gradient) à se situer dans le voisinage de l'ancienne politique. 

Les méthodes telles que l'optimisation de la politique proximale apportent deux modifications aux gradients de la politique :

• Utilisez une fonction d'avantage. En règle générale, cette fonction d'avantage utilise la fonction de valeur comme base de référence. En cela, elles sont similaires aux méthodes A2C. 
• Limiter l'ampleur de la modification des paramètres de la politique à chaque itération. Pour ce faire, on utilise une fonction objective de substitution écrêtée. L'algorithme spécifie une fourchette dans laquelle le rapport entre la nouvelle et l'ancienne politique doit se situer. Lorsque le rapport (après la mise à jour du gradient) dépasse ces valeurs prédéterminées, il est réduit pour se situer dans la fourchette. 

Ainsi, le PPO améliore considérablement les méthodes de gradient de politique de vanille, ce qui améliore la stabilité dans des environnements complexes. L'écrêtage de la fonction objective permet d'éviter que les variations importantes des rendements et des gradients ne déstabilisent les mises à jour de la politique. Pour parvenir à un équilibre entre l'exploration et l'exploitation, il est également possible de modifier le PPO pour utiliser la régularisation de l'entropie. Pour ce faire, un terme d'entropie (un paramètre d'échelle multiplié par l'entropie de la politique) est ajouté à la fonction objective. 

Avancées récentes

Les gradients de politique font partie des premières méthodes utilisées pour résoudre les problèmes de NR. Après l'avènement des GPU rapides, plusieurs nouvelles approches ont été proposées pour appliquer les techniques modernes de ML aux gradients de politique. 

Apprentissage par renforcement graduel 

Ces dernières années, des progrès ont été réalisés dans l'application de méthodes telles que le renforcement du gradient aux algorithmes RL. L'amplification du gradient combine les prédictions de plusieurs modèles faibles pour générer un seul modèle fort. C'est ce que l'on appelle l'apprentissage par renforcement graduel (Gradient-Boosted Reinforcement Learning, GBRL). GBRL est un package Python similaire à XGBoost qui met en œuvre ces techniques pour les algorithmes RL.

Transfert de l'apprentissage par renforcement 

L'apprentissage par transfert (TL) est une technique dans laquelle les connaissances acquises par un modèle sont appliquées pour améliorer les performances d'un autre modèle. L'apprentissage par transfert est utile car la formation de modèles ML à partir de zéro est coûteuse. Les approches TL ont été utilisées avec des gradients de politique pour améliorer les performances des modèles RL. Cette approche est appelée apprentissage par renforcement du transfert (TRL). 

Conclusion

Les gradients politiques font partie des approches les plus fondamentales pour résoudre les problèmes de NR.

 Dans cet article, nous avons présenté les premiers principes des gradients de politique et montré comment dériver le théorème du gradient de politique. Nous avons également démontré comment mettre en œuvre un algorithme simple basé sur le gradient à l'aide de PyTorch dans un environnement Gymnasium. Enfin, nous avons abordé les défis pratiques et les extensions courantes de l'algorithme de base du gradient de politique.

Si vous souhaitez approfondir votre compréhension de l'apprentissage par renforcement et de l'apprentissage profond avec PyTorch, consultez ces cours :

• Cursus sur l'apprentissage par renforcement - Découvrez les fondements de l'apprentissage par renforcement, des méthodes basées sur la valeur aux techniques d'optimisation des politiques.
• Introduction à l'apprentissage profond avec PyTorch - Obtenez une expérience pratique avec PyTorch et construisez des modèles d'apprentissage profond à partir de zéro.