Q Learning en Python : qu'est-ce que c'est, définitions [Exemples de codage]

L'apprentissage par renforcement se produit lorsqu'un agent apprenant apprend à se comporter de manière optimale en fonction de son environnement grâce à des interactions constantes. L'agent passe par diverses situations, également appelées états. Comme vous l'auriez deviné, l'apprentissage par renforcement a de nombreuses applications dans notre monde. En savoir plus si vous souhaitez en savoir plus sur les algorithmes de science des données.

En outre, il possède de nombreux algorithmes, parmi les plus populaires est l'apprentissage Q . Dans cet article, nous discuterons de ce qu'est cet algorithme et de son fonctionnement.

Alors, sans plus tarder, commençons.

Qu'est-ce que Q Learning ?

L'apprentissage Q est un algorithme d'apprentissage par renforcement, et il se concentre sur la recherche du meilleur plan d'action pour une situation particulière. C'est hors politique parce que les actions dont la fonction d'apprentissage Q apprend sont en dehors de la politique existante, donc elle n'en a pas besoin. Il se concentre sur l'apprentissage d'une politique qui augmente sa récompense totale. C'est une forme simple d'apprentissage par renforcement qui utilise des valeurs d'action (ou valeurs Q) pour améliorer le comportement de l'agent d'apprentissage.

L'apprentissage Q est l'un des algorithmes les plus populaires dans l'apprentissage par renforcement, car il est facile à comprendre et à mettre en œuvre. Le « Q » dans l'apprentissage Q représente la qualité. Comme nous l'avons mentionné précédemment, l'apprentissage Q se concentre sur la recherche de la meilleure action pour une situation particulière. Et la qualité montre à quel point une action spécifique est utile et quelle récompense elle peut vous aider à atteindre.

Définitions importantes

Avant de commencer à discuter de son fonctionnement, nous devrions d'abord jeter un coup d'œil à certains concepts essentiels de l'apprentissage q. Commençons.

Valeurs Q

Les valeurs Q sont également appelées valeurs d'action. Ils sont représentés par Q(S, A), et ils vous donnent une estimation de la qualité de l'action A à prendre à l'état S. Le modèle calculera cette estimation de manière itérative en utilisant la règle de mise à jour de la différence temporelle dont nous avons discuté plus tard. dans cette section.

Épisodes et récompenses

Un agent part d'un état de départ, passe par plusieurs transitions, puis passe de son état actuel au suivant en fonction de ses actions et de son environnement. Chaque fois que l'agent agit, il obtient une récompense. Et quand il n'y a pas de transitions possibles, c'est la fin de l'épisode.

Mise à jour TD (différence temporelle)

Voici la règle TD-Update ou Temporal Difference :

Q(S,A) Q(S,A) + (R + Q(S',A')-Q(S,A))

Ici, S représente l'état actuel de l'agent, tandis que S' représente l'état suivant. A représente l'action actuelle, A' représente la meilleure action suivante selon l'estimation de la valeur Q, R indique la récompense actuelle selon l'action actuelle, représente le facteur d'actualisation et indique la longueur du pas.

Lisez aussi : Prérequis pour la science des données. Comment évolue-t-il dans le temps ?

Exemple de Q Learning Python

La meilleure façon de comprendre Q apprendre Python est de voir un exemple. Dans cet exemple, nous utilisons l'environnement de gym d'OpenAI et entraînons notre modèle avec. Tout d'abord, vous devrez installer l'environnement. Vous pouvez le faire avec la commande suivante :

pip installer une salle de sport

Maintenant, nous allons importer les bibliothèques dont nous aurons besoin pour cet exemple :

salle de gym d'importation

importer des itertools

importer matplotlib

importer matplotlib.style

importer numpy en tant que np

importer des pandas en tant que pd

importer système

à partir des collections importer defaultdict

de windy_gridworld importer WindyGridworldEnv

importer le traçage

matplotlib.style.use('ggplot')

Sans les bibliothèques nécessaires, vous ne pourriez pas effectuer ces opérations avec succès. Après avoir importé les bibliothèques, nous allons créer l'environnement :

env = WindyGridworldEnv()

Nous allons maintenant créer la politique -greedy :

def createEpsilonGreedyPolicy(Q, epsilon, num_actions):

"""

Crée une politique gourmande en epsilon basée sur

sur une fonction Q et epsilon donnée.

Renvoie une fonction qui prend l'état

en entrée et renvoie les probabilités

pour chaque action sous la forme d'un tableau numpy

de la longueur de l'espace d'action (ensemble de réponses possibles).

"""

def policyFunction (état):

Action_probabilities = np.ones(num_actions,

dtype = float) * epsilon / num_actions

best_action = np.argmax(Q[état])

Probabilités_action[meilleure_action] += (1.0 – epsilon)

retourner Action_probabilités

politique de retourFonction

Voici le code pour construire un modèle q-learning :

def qLearning(env, num_episodes, discount_factor = 1.0,

alpha = 0,6, epsilon = 0,1) :

"""

Algorithme Q-Learning : contrôle TD hors politique.

Trouve la politique gourmande optimale tout en améliorant

suivant une politique epsilon-gourmande » » »

# Fonction de valeur d'action

# Un dictionnaire imbriqué qui mappe

# état -> (action -> action-valeur).

Q = defaultdict(lambda : np.zeros(env.action_space.n))

# Garde une trace des statistiques utiles

stats = plotting.EpisodeStats(

episode_lengths = np.zeros(num_episodes),

episode_rewards = np.zeros(num_episodes))

# Créer une fonction de politique gourmande epsilon

# de manière appropriée pour l'espace d'action de l'environnement

politique = createEpsilonGreedyPolicy(Q, epsilon, env.action_space.n)

# Pour chaque épisode

pour ith_episode dans range(num_episodes):

# Réinitialisez l'environnement et choisissez la première action

état = env. reset()

pour t dans itertools.count() :

# obtenir les probabilités de toutes les actions à partir de l'état actuel

action_probabilities = politique (état)

# choisir l'action en fonction de

# la distribution de probabilité

action = np.random.choice(np.arange(

len(action_probabilités)),

p = probabilités_actions)

# prendre des mesures et obtenir une récompense, passer à l'état suivant

next_state, récompense, fait, _ = env.step(action)

# Mettre à jour les statistiques

stats.episode_rewards[i_episode] += récompense

stats.episode_lengths[i_episode] = t

# Mise à jour TD

best_next_action = np.argmax(Q[next_state])

td_target = récompense + discount_factor * Q[next_state][best_next_action]

td_delta = td_target – Q[état][action]

Q[état][action] += alpha * td_delta

# done est vrai si l'épisode s'est terminé

si c'est fait :

Pause

état = état_suivant

retour Q, statistiques

Entraînons le modèle maintenant :

Q, stats = qApprentissage(env, 1000)

Après avoir créé et formé le modèle, nous pouvons tracer les statistiques essentielles de celui-ci :

plotting.plot_episode_stats(stats)

Utilisez ce code pour exécuter le modèle et tracer le graphique. Quel genre de résultats voyez-vous? Partagez vos résultats avec nous, et si vous rencontrez des confusions ou des doutes, faites-le nous savoir.

Lisez aussi : Algorithmes d'apprentissage automatique pour la science des données

Apprenez des cours de science des données dans les meilleures universités du monde. Gagnez des programmes Executive PG, des programmes de certificat avancés ou des programmes de maîtrise pour accélérer votre carrière.

Dernières pensées

Lorsque vous tracez le graphique, vous verrez que la récompense par épisode augmente progressivement au fil du temps. Et après certains épisodes, l'intrigue reflète également le fait qu'elle nivelle la limite de récompense élevée par épisode. Qu'est-ce que cela indique ?

Cela signifie que votre modèle a appris à augmenter la récompense totale qu'il peut gagner dans un épisode en s'assurant qu'il se comporte de manière optimale. Vous devez également avoir vu pourquoi q apprendre Python voit des applications dans tant d'industries et de domaines.