Q Learning: Tout ce que vous devez savoir sur l'apprentissage par renforcement

Cet article fournit une connaissance détaillée et complète de Q-Learning grâce à une belle analogie de l'apprentissage par renforcement via le code Python.

et sont quelques domaines qui sont parmi les meilleurs mots à la mode dans l'industrie et pour une bonne raison. L'IA va créer 2,3 millions d'emplois d'ici 2020, étant donné que son objectif principal est de permettre aux machines d'imiter le comportement humain. C'est bizarre n'est-ce pas? Donc, aujourd'hui, nous allons discuter de Q Learning, la pierre angulaire de l'apprentissage par renforcement dans l'ordre suivant:

Qu'est-ce que l'apprentissage par renforcement?

Jetons un coup d'œil à notre vie quotidienne. Nous effectuons de nombreuses tâches dans l'environnement et certaines de ces tâches nous rapportent des récompenses, d'autres non. Nous continuons à chercher des chemins différents et essayons de découvrir quel chemin mènera à des récompenses et sur la base de notre action, nous améliorons nos stratégies pour atteindre les objectifs. Ce mes amis sont l'une des analogies les plus simples de l'apprentissage par renforcement.





Domaines d'intérêt clés:

  • Environnement
  • action
  • Récompense
  • Etat

apprentissage par renforcement - apprentissage q



L'apprentissage par renforcement est la branche de l'apprentissage automatique qui permet aux systèmes d'apprendre des résultats de leurs propres décisions. Il résout un type particulier de problème où la prise de décision est séquentielle et l'objectif est à long terme.

Processus Q-Learning

Voyons ce que Q apprend avec notre énoncé de problème ici. Cela nous aidera à définir les principaux composants d'une solution d'apprentissage par renforcement, à savoir les agents, l'environnement, les actions, les récompenses et les états.

Analogie d'usine automobile:



Nous sommes dans une usine automobile remplie de robots. Ces robots aident les travailleurs de l'usine en transportant les pièces nécessaires à l'assemblage d'une voiture. Ces différentes pièces sont situées à différents endroits de l'usine dans 9 stations. Les pièces comprennent le châssis, les roues, le tableau de bord, le moteur, etc. Factory Master a donné la priorité à l'emplacement où le châssis est installé comme priorité la plus élevée. Jetons un œil à la configuration ici:

États:

L'emplacement auquel un robot est présent à une instance particulière est appelé son état. Puisqu'il est facile de le coder plutôt que de s'en souvenir par ses noms. Mappons l'emplacement avec des nombres.

tableau tutoriel étape par étape

Actions:

Les actions ne sont rien d'autre que les déplacements effectués par les robots vers n'importe quel endroit. Considérez qu'un robot se trouve à l'emplacement L2 et les emplacements directs vers lesquels il peut se déplacer sont L5, L1 et L3. Comprenons mieux cela si nous visualisons ceci:

Récompenses:

Une récompense sera donnée au robot pour passer directement d'un état à un autre. Par exemple, vous pouvez atteindre L5 directement depuis L2 et vice versa. Ainsi, une récompense de 1 sera fournie dans les deux cas. Jetons un coup d'œil au tableau des récompenses:

Rappelez-vous quand le maître d'usine a priorisé l'emplacement du châssis. C'était L7, nous allons donc intégrer ce fait dans notre tableau de récompenses. Nous attribuerons donc un très grand nombre (999 dans notre cas) à l'emplacement (L7, L7).

Équation de Bellman

Supposons maintenant qu'un robot ait besoin d'aller du point A au point B. Il choisira le chemin qui donnera une récompense positive. Pour cela, supposons que nous fournissions une récompense en termes d'empreinte pour qu'elle suive.

Mais que se passe-t-il si le robot part de quelque part entre les deux, où il peut voir deux ou plusieurs chemins. Le robot ne peut donc pas prendre de décision et cela se produit principalement parce qu’il ne possède pas de Mémoire . C'est là que l'équation de Bellman entre en jeu.

V (s) = max (R (s, a) + & # 120632V (s '))

Où:

  • s = un état particulier
  • a = action
  • s '= état vers lequel le robot passe de s
  • & # 120632 = facteur de remise
  • R (s, a) = une fonction de récompense qui prend un état (s) et une action (a) et produit une valeur de récompense
  • V (s) = valeur d'être dans un état particulier

Maintenant, le bloc sous la destination aura une récompense de 1, qui est la récompense la plus élevée, mais qu'en est-il de l'autre bloc? Eh bien, c'est là que le facteur de remise entre en jeu. Supposons un facteur de remise de 0,9 et remplissons tous les blocs un par un.

Processus décisionnel de Markov

Imaginez qu'un robot se trouve sur le bloc orange et doit atteindre la destination. Mais même s'il y a un léger dysfonctionnement, le robot ne sait pas quel chemin prendre plutôt que de monter.

Il faut donc modifier le processus décisionnel. Il doit Partiellement aléatoire et En partie sous le contrôle du robot . En partie aléatoire parce que nous ne savons pas quand le robot fonctionnera mal et en partie sous contrôle car c'est toujours la décision du robot. Et cela constitue la base du processus décisionnel de Markov.

Un processus de décision de Markov (MDP) est un processus de contrôle stochastique à temps discret. Il fournit un cadre mathématique pour modéliser la prise de décision dans des situations où les résultats sont en partie aléatoires et en partie sous le contrôle d'un décideur.

Nous allons donc utiliser notre équation de Bellman originale et y apporter des modifications. Ce que nous ne savons pas, c'est le prochain état, c'est-à-dire. s ». Ce que nous savons, ce sont toutes les possibilités d’un virage et changeons l’équation.

V (s) = max (R (s, a) + & # 120632 V (s '))

V (s) = max (R (s, a) + & # 120632 & Sigmas »P (s, a, s ') Contre'))

qu'est-ce qu'une sous-chaîne en java

P (s, a, s '): Probabilité de quitter l'état s à s » avec action à

& Sigmas »P (s, a, s ') Contre '): Attentes aléatoires du robot

V (s) = max (R (s, a) + & # 120632 ((0.8V (piècehaut)) + (0,1 V (piècevers le bas) +….))

Maintenant, passons à Q Learning. Q-Learning pose l'idée d'évaluer la qualité d'une action entreprise pour passer à un état plutôt que de déterminer la valeur possible de l'état vers lequel elle est déplacée.

C'est ce que l'on obtient si l'on incorpore l'idée d'évaluer la qualité des actions pour passer à un certain état. De l'équation de Bellman mise à jour si nous les supprimons max composant, nous supposons une seule empreinte pour une action possible qui n'est rien d'autre que le Qualité de l'action.

Q (s, a) = (R (s, a) + & # 120632 & Sigmas »P (s, a, s ') Contre'))

Dans cette équation qui quantifie la qualité de l'action, nous pouvons supposer que V (s) est le maximum de toutes les valeurs possibles de Q (s, a). Remplaçons donc v (s) par une fonction de Q ().

Q (s, a) = (R (s, a) + & # 120632 & Sigmas »P (s, a, s ') max Q (s ’, a’))

Nous ne sommes qu'un pas près de notre équation finale de Q Learning. Nous allons introduire un Différence temporelle pour calculer les valeurs Q par rapport aux changements de l'environnement au fil du temps. Mais comment observer le changement de Q?

TD (s, a) = (R (s, a) + & # 120632 & Sigmas »P (s, a, s ') max Q (s ', a')) - Q (s, a)

Nous recalculons le nouveau Q (s, a) avec la même formule et en soustrayons le Q (s, a) précédemment connu. Ainsi, l'équation ci-dessus devient:

Qt(s, a) = Qt-1(s, a) + α TDt(s, a)

Qt(s, a) = Valeur Q actuelle

Qt-1(s, a) = Valeur Q précédente

hashmap et hashtable en java

Qt(s, a) = Qt-1(s, a) + α (R (s, a) + & # 120632 max Q (s ’, a’)-Qt-1(s, a))

Démonstration Q Learning: NumPy

Je vais utiliser NumPy pour montrer comment fonctionne Q Learning.

Étape 1: importations, paramètres, états, actions et récompenses

import numpy as np gamma = 0.75 # Discount factor alpha = 0.9 # Learning rate location_to_state = {'L1': 0, 'L2': 1, 'L3': 2, 'L4': 3, 'L5': 4, ' L6 ': 5,' L7 ': 6,' L8 ': 7,' L9 ': 8} actions = [0,1,2,3,4,5,6,7,8] rewards = np.array ( [[0,1,0,0,0,0,0,0,0], [1,0,1,0,0,0,0,0,0], [0,1,0,0, 0,1,0,0,0], [0,0,0,0,0,0,1,0,0], [0,1,0,0,0,0,0,1,0] , [0,0,1,0,0,0,0,0,0], [0,0,0,1,0,0,0,1,0], [0,0,0,0, 1,0,1,0,1], [0,0,0,0,0,0,0,1,0]])

Étape 2: mapper les indices aux emplacements

state_to_location = dict ((state, location) for location, state in location_to_state.items ())

Étape 3: Obtenez un itinéraire optimal à l'aide du processus d'apprentissage Q

def get_optimal_route (emplacement_début, emplacement_fin): rewards_new = np.copy (récompenses) état_fin = emplacement_à_état [emplacement_fin] rewards_new [état_fin, état_fin] = 999 Q = np.array (np.zeros ([9,9])) # Q- Processus d'apprentissage pour i dans la plage (1000): # Ramasser un état aléatoire current_state = np.random.randint (0,9) # Python exclut la limite supérieure playable_actions = [] # Itérer dans la nouvelle matrice de récompenses pour j dans la plage ( 9): if rewards_new [état_actuel, j]> 0: playable_actions.append (j) # Choisissez une action aléatoire qui nous mènera à l'état suivant next_state = np.random.choice (playable_actions) # Calcul de la différence temporelle TD = rewards_new [état_actuel , next_state] + gamma * Q [next_state, np.argmax (Q [next_state,])] - Q [current_state, next_state] # Mise à jour de la Q-Value en utilisant l'équation de Bellman Q [current_state, next_state] + = alpha * TD # Initialisez l'itinéraire optimal avec l'emplacement de départ route = [start_location] #Initialize next_location avec l'emplacement de départ next_location = star # Récupère la valeur Q la plus élevée relative à l'état de départ next_state = np.argmax (Q [starting_state,]) # Nous avons obtenu l'index de l'état suivant. Mais nous avons besoin de la lettre correspondante. next_location = state_to_location [next_state] route.append (next_location) # Mettre à jour l'emplacement de départ pour la prochaine itération start_location = next_location retour route

Étape 4: Imprimez l'itinéraire

print (get_optimal_route ('L1', 'L9'))

Production:

Avec cela, nous arrivons à la fin de Q-Learning. J'espère que vous avez appris à connaître le fonctionnement de Q Learning ainsi que les différentes dépendances, telles que la différence temporelle, l'équation de Bellman et plus encore.

Edureka vous permet de maîtriser des techniques telles que l'apprentissage supervisé, l'apprentissage non supervisé et le traitement du langage naturel. Il comprend une formation sur les dernières avancées et approches techniques en intelligence artificielle et apprentissage automatique telles que l'apprentissage en profondeur, les modèles graphiques et l'apprentissage par renforcement.