Notice: This page requires JavaScript to function properly.
Please enable JavaScript in your browser settings or update your browser.
Apprendre Algorithme des Bandits à Gradient | Problème du Bandit Manchot
Introduction à l'Apprentissage par Renforcement
course content

Contenu du cours

Introduction à l'Apprentissage par Renforcement

Introduction à l'Apprentissage par Renforcement

1. Théorie Fondamentale de l'Apprentissage par Renforcement
2. Problème du Bandit Manchot
3. Programmation Dynamique
4. Méthodes de Monte Carlo
5. Apprentissage par Différence Temporelle

book
Algorithme des Bandits à Gradient

Lorsqu'on traite des bandits à plusieurs bras, les méthodes traditionnelles telles que epsilon-greedy et UCB estiment les valeurs d'action pour décider quelle action entreprendre. Cependant, les bandits à gradient adoptent une approche différente — ils apprennent des préférences pour les actions au lieu d'estimer leurs valeurs. Ces préférences sont ajustées au fil du temps à l'aide de l'ascension du gradient stochastique.

Préférences

Au lieu de maintenir des estimations de valeur d'action Q(a)Q(a), les bandits à gradient maintiennent des valeurs de préférence H(a)H(a) pour chaque action aa. Ces préférences sont mises à jour en utilisant une approche d'ascension du gradient stochastique afin de maximiser les récompenses attendues. La probabilité de chaque action est calculée à l'aide d'une fonction softmax :

P(At=a)=eHt(a)b=1neHt(b)=πt(a)P(A_t = a) = \frac{e^{H_t(a)}}{\sum_{b=1}^n e^{H_t(b)}} = \pi_t(a)

où :

  • Ht(a)H_t(a) est la préférence pour l'action aa à l'instant tt ;
  • P(At=a)P(A_t = a) est la probabilité de sélectionner l'action aa à l'instant tt ;
  • Le dénominateur garantit que la somme des probabilités est égale à 1.

La fonction softmax est une fonction essentielle en apprentissage automatique, couramment utilisée pour convertir des listes de nombres réels en listes de probabilités. Cette fonction sert d'approximation lisse à la fonction arg max\argmax, permettant une exploration naturelle en donnant aux actions de moindre préférence une probabilité non nulle d'être sélectionnées.

Règle de mise à jour

Après avoir sélectionné une action AtA_t au temps tt, les valeurs de préférence sont mises à jour selon la règle suivante :

Ht+1(At)Ht(At)+α(RtRˉt)(1π(At))Ht+1(a)Ht(a)α(RtRˉt)π(a)aAt\begin{aligned} &H_{t+1}(A_t) \gets H_t(A_t) + \alpha (R_t - \bar R_t)(1 - \pi(A_t))\\ &H_{t+1}(a) \gets H_t(a) - \alpha (R_t - \bar R_t)\pi(a) \qquad \forall a \ne A_t \end{aligned}

où :

  • α\alpha est le pas d'apprentissage ;
  • RtR_t est la récompense reçue ;
  • Rˉt\bar R_t est la récompense moyenne observée jusqu'à présent.

Intuition

À chaque étape temporelle, toutes les préférences sont légèrement modifiées. Le changement dépend principalement de la récompense reçue et de la récompense moyenne, et peut s'expliquer ainsi :

  • Si la récompense reçue est supérieure à la moyenne, l'action sélectionnée devient plus préférée, tandis que les autres actions deviennent moins préférées ;
  • Si la récompense reçue est inférieure à la moyenne, la préférence pour l'action sélectionnée diminue, tandis que les préférences pour les autres actions augmentent, favorisant ainsi l'exploration.

Exemple de code

def softmax(x):
  """Simple softmax implementation"""
  return np.exp(x) / np.sum(np.exp(x))

class GradientBanditsAgent:
  def __init__(self, n_actions, alpha):
    """Initialize an agent"""
    self.n_actions = n_actions # Number of available actions
    self.alpha = alpha # alpha
    self.H = np.zeros(n_actions) # Preferences
    self.reward_avg = 0 # Average reward
    self.t = 0 # Time step counter

  def select_action(self):
    """Select an action according to the gradient bandits strategy"""
    # Compute probabilities from preferences with softmax
    probs = softmax(self.H)
    # Choose an action according to the probabilities
    return np.random.choice(self.n_actions, p=probs)

  def update(self, action, reward):
    """Update preferences"""
    # Increase the time step counter
    self.t += 1
    # Update the average reward
    self.reward_avg += reward / self.t

    # Compute probabilities from preferences with softmax
    probs = softmax(self.H) # Getting action probabilities from preferences

    # Update preference values using stochastic gradient ascent
    self.H -= self.alpha * (reward - self.reward_avg) * probs
    self.H[action] += self.alpha * (reward - self.reward_avg)

Informations supplémentaires

Les bandits à gradient possèdent plusieurs propriétés intéressantes :

  • Relativité des préférences : les valeurs absolues des préférences d'action n'affectent pas le processus de sélection d'action — seules leurs différences relatives comptent. Déplacer toutes les préférences d'une même constante (par exemple, ajouter 100) aboutit à la même distribution de probabilités ;
  • Effet de la base dans la règle de mise à jour : bien que la formule de mise à jour inclue généralement la récompense moyenne comme base, cette valeur peut être remplacée par n'importe quelle constante indépendante de l'action choisie. La base influence la vitesse de convergence mais ne modifie pas la solution optimale ;
  • Impact du taux d'apprentissage : le taux d'apprentissage doit être ajusté en fonction de la tâche. Une valeur plus faible assure un apprentissage plus stable, tandis qu'une valeur plus élevée accélère le processus d'apprentissage.

Résumé

Les bandits à gradient offrent une alternative puissante aux algorithmes de bandit traditionnels en exploitant l'apprentissage basé sur les préférences. Leur caractéristique la plus intéressante est leur capacité à équilibrer naturellement l'exploration et l'exploitation.

question mark

Quel est le principal avantage de l'utilisation des bandits à gradient par rapport aux algorithmes de bandit traditionnels ?

Select the correct answer

Tout était clair ?

Comment pouvons-nous l'améliorer ?

Merci pour vos commentaires !

Section 2. Chapitre 5

Demandez à l'IA

expand

Demandez à l'IA

ChatGPT

Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion

course content

Contenu du cours

Introduction à l'Apprentissage par Renforcement

Introduction à l'Apprentissage par Renforcement

1. Théorie Fondamentale de l'Apprentissage par Renforcement
2. Problème du Bandit Manchot
3. Programmation Dynamique
4. Méthodes de Monte Carlo
5. Apprentissage par Différence Temporelle

book
Algorithme des Bandits à Gradient

Lorsqu'on traite des bandits à plusieurs bras, les méthodes traditionnelles telles que epsilon-greedy et UCB estiment les valeurs d'action pour décider quelle action entreprendre. Cependant, les bandits à gradient adoptent une approche différente — ils apprennent des préférences pour les actions au lieu d'estimer leurs valeurs. Ces préférences sont ajustées au fil du temps à l'aide de l'ascension du gradient stochastique.

Préférences

Au lieu de maintenir des estimations de valeur d'action Q(a)Q(a), les bandits à gradient maintiennent des valeurs de préférence H(a)H(a) pour chaque action aa. Ces préférences sont mises à jour en utilisant une approche d'ascension du gradient stochastique afin de maximiser les récompenses attendues. La probabilité de chaque action est calculée à l'aide d'une fonction softmax :

P(At=a)=eHt(a)b=1neHt(b)=πt(a)P(A_t = a) = \frac{e^{H_t(a)}}{\sum_{b=1}^n e^{H_t(b)}} = \pi_t(a)

où :

  • Ht(a)H_t(a) est la préférence pour l'action aa à l'instant tt ;
  • P(At=a)P(A_t = a) est la probabilité de sélectionner l'action aa à l'instant tt ;
  • Le dénominateur garantit que la somme des probabilités est égale à 1.

La fonction softmax est une fonction essentielle en apprentissage automatique, couramment utilisée pour convertir des listes de nombres réels en listes de probabilités. Cette fonction sert d'approximation lisse à la fonction arg max\argmax, permettant une exploration naturelle en donnant aux actions de moindre préférence une probabilité non nulle d'être sélectionnées.

Règle de mise à jour

Après avoir sélectionné une action AtA_t au temps tt, les valeurs de préférence sont mises à jour selon la règle suivante :

Ht+1(At)Ht(At)+α(RtRˉt)(1π(At))Ht+1(a)Ht(a)α(RtRˉt)π(a)aAt\begin{aligned} &H_{t+1}(A_t) \gets H_t(A_t) + \alpha (R_t - \bar R_t)(1 - \pi(A_t))\\ &H_{t+1}(a) \gets H_t(a) - \alpha (R_t - \bar R_t)\pi(a) \qquad \forall a \ne A_t \end{aligned}

où :

  • α\alpha est le pas d'apprentissage ;
  • RtR_t est la récompense reçue ;
  • Rˉt\bar R_t est la récompense moyenne observée jusqu'à présent.

Intuition

À chaque étape temporelle, toutes les préférences sont légèrement modifiées. Le changement dépend principalement de la récompense reçue et de la récompense moyenne, et peut s'expliquer ainsi :

  • Si la récompense reçue est supérieure à la moyenne, l'action sélectionnée devient plus préférée, tandis que les autres actions deviennent moins préférées ;
  • Si la récompense reçue est inférieure à la moyenne, la préférence pour l'action sélectionnée diminue, tandis que les préférences pour les autres actions augmentent, favorisant ainsi l'exploration.

Exemple de code

def softmax(x):
  """Simple softmax implementation"""
  return np.exp(x) / np.sum(np.exp(x))

class GradientBanditsAgent:
  def __init__(self, n_actions, alpha):
    """Initialize an agent"""
    self.n_actions = n_actions # Number of available actions
    self.alpha = alpha # alpha
    self.H = np.zeros(n_actions) # Preferences
    self.reward_avg = 0 # Average reward
    self.t = 0 # Time step counter

  def select_action(self):
    """Select an action according to the gradient bandits strategy"""
    # Compute probabilities from preferences with softmax
    probs = softmax(self.H)
    # Choose an action according to the probabilities
    return np.random.choice(self.n_actions, p=probs)

  def update(self, action, reward):
    """Update preferences"""
    # Increase the time step counter
    self.t += 1
    # Update the average reward
    self.reward_avg += reward / self.t

    # Compute probabilities from preferences with softmax
    probs = softmax(self.H) # Getting action probabilities from preferences

    # Update preference values using stochastic gradient ascent
    self.H -= self.alpha * (reward - self.reward_avg) * probs
    self.H[action] += self.alpha * (reward - self.reward_avg)

Informations supplémentaires

Les bandits à gradient possèdent plusieurs propriétés intéressantes :

  • Relativité des préférences : les valeurs absolues des préférences d'action n'affectent pas le processus de sélection d'action — seules leurs différences relatives comptent. Déplacer toutes les préférences d'une même constante (par exemple, ajouter 100) aboutit à la même distribution de probabilités ;
  • Effet de la base dans la règle de mise à jour : bien que la formule de mise à jour inclue généralement la récompense moyenne comme base, cette valeur peut être remplacée par n'importe quelle constante indépendante de l'action choisie. La base influence la vitesse de convergence mais ne modifie pas la solution optimale ;
  • Impact du taux d'apprentissage : le taux d'apprentissage doit être ajusté en fonction de la tâche. Une valeur plus faible assure un apprentissage plus stable, tandis qu'une valeur plus élevée accélère le processus d'apprentissage.

Résumé

Les bandits à gradient offrent une alternative puissante aux algorithmes de bandit traditionnels en exploitant l'apprentissage basé sur les préférences. Leur caractéristique la plus intéressante est leur capacité à équilibrer naturellement l'exploration et l'exploitation.

question mark

Quel est le principal avantage de l'utilisation des bandits à gradient par rapport aux algorithmes de bandit traditionnels ?

Select the correct answer

Tout était clair ?

Comment pouvons-nous l'améliorer ?

Merci pour vos commentaires !

Section 2. Chapitre 5
some-alt