Octobre 2018
Volume 33, numéro 10
Cet article a fait l'objet d'une traduction automatique.
Artificially Intelligent - présentation d’apprentissage par renforcement
Par Frank La La | Octobre 2018
.png "Frank La Vigne")
Dans les articles précédents, j’ai mentionné un apprentissage supervisé et algorithmes d’apprentissage non supervisé. Au-delà de ces deux méthodes de machine learning établit un autre type : Apprentissage par renforcement (RL). Formellement défini, RL est une approche orientée sur l’objectif d’apprentissage via l’interaction avec l’environnement dans des conditions idéales learning calcul.
Comme les autres aspects de l’intelligence artificielle, la plupart des algorithmes et des approches activement utilisées aujourd'hui trace leurs origines vers les années 1980 (bit.ly/2NZP177). Avec l’arrivée d’un stockage économique et la puissance de calcul de la demande, les techniques d’apprentissage par renforcement ont émergé nouveau.
Sans doute l’utilisation la plus célèbre de RL jusqu'à ce jour est le programme AlphaGo zéro à partir de DeepMind Technologies Ltd. Contrairement à AlphaGo, ce qui vous avez appris à partir des enregistrements des acteurs humains amateurs et professionnelles, AlphaGo zéro n’avait aucun accès aux jeux de données de formation humaines. Au lieu de cela, le système tirées entièrement jouer à des jeux par rapport à lui-même. Après plusieurs semaines, AlphaGo zéro atteint l’état de niveau master et, après 40 jours, est devenu le joueur Go meilleures dans le monde. N’oubliez pas qu’il l’a fait tout cela sans intervention humaine. Plus d’informations sur le projet est à bit.ly/2K9NpW8. RL a également été utilisé pour former des algorithmes pour jouer à des jeux d’arcade classique et atteindre les scores les plus élevés possibles avec peu ou aucune participation humaine.
Dans cet article, j’aborder les principes fondamentaux de RL et s’appuient sur les articles dans des futures.
Principaux composants d’un modèle RL
RL se concentre sur un modèle à l’aide d’un système de récompense de manière très similaire à la façon dont animaux et humains Découvrez basée sur l’expérience de formation — par essais et erreurs. RL imite systèmes comportementales cognitifs humains, étant donné un certain nombre de chevauchement avec psychologie cognitive. Les algorithmes RL également déploiement une certaine quantité de mathématiques de la théorie des jeux et des stratégies, également.
Les deux premiers éléments dans n’importe quel modèle RL sont l’environnement et l’agent. À l’aide de l’exemple d’échecs, de l’environnement est le plateau de jeu et de l’agent est l’acteur. L’état de l’environnement est le positionnement des éléments sur l’échiquier. L’agent observe l’état de l’environnement et applique une action à l’environnement de recevoir une récompense (consultez Figure 1). Dans le jeu des échecs, cette action peut être avancer un pion ou capture l’adverse. Tout déplacement dans un jeu de chess modifie automatiquement l’état de l’environnement. L’agent peut prendre une des déplacements se valide disponible le joueur dans un jeu de chess.
.png "Composants essentiels à un renforcement de système d’apprentissage")
Figure 1 les composants essentiels à un renforcement de système d’apprentissage
L’agent reçoit une récompense de l’environnement basé sur les actions exécutée. La récompense est une valeur numérique analogue au score dans un jeu vidéo. Agents de choisir parmi les options disponibles en fonction de la récompense anticipée. Les agents sont programmées pour optimiser leur récompense. Par exemple, déplacer un élément vers l’avant peut-être donner lieu à une récompense de 1, tandis que la capture d’une pièce adverse peut-être donner lieu à une récompense de 5. Étant donné ces choix, l’algorithme choisira capture une pièce adverse sur simplement plus tard, chaque fois. Une telle structure reward génèrera un agent agressif, car il choisira toujours capture un adverse, même au détriment de perdre le jeu. Clairement, ce n’est pas le résultat optimal. Par conséquent, la précision de l’environnement et la structure de récompense sont essentiels pour la réussite d’un modèle formé par le biais de RL.
Un problème d’espace plus petits
Création d’un modèle qui capture la complexité des échecs pour l’apprentissage d’un agent se situe bien en dehors de l’étendue de cette colonne. Par souci de simplicité, j’ai permet de réduire l’environnement à une 4x4 grille. L’agent de contrôle le déplacement d’un caractère dans cette grille. Certaines cellules de la grille sont opérationnel, tandis que d’autres conduire à l’agent de tomber dans l’eau et, par conséquent, tuer le caractère et la réinitialisation de la simulation. L’agent a une cellule de l’objectif à atteindre et vous serez récompensé par un score de 1 pour rechercher un chemin d’accès sécurisé à ce dernier. Déplaçant dans le tableau retourne une valeur de récompense de 0. Pour cet exemple, j’utiliserai l’environnement figés Lake à partir de la salle de sport OpenAI (bit.ly/2v1csWA).
Pour commencer, ouvrez un bloc-notes Python 3 Jupyter sur votre plateforme préférée. J’ai expliqué comment bien démarrer avec les blocs-notes Jupyter dans un article précédent (msdn.com/magazine/mt829269). Créer une cellule vide et entrez et exécutez le code suivant pour importer les bibliothèques appropriées et de configurer l’environnement pour l’agent dans lequel effectuer l’apprentissage :
import gym
import numpy as np
env = gym.make('FrozenLake-v0')
Maintenant, créez une nouvelle cellule, entrez le code suivant, puis exécutez :
print("observation_space")
print(env.observation_space)
print("action_space")
print(env.action_space)
Le résultat doit indiquer qu’il existe 16 valeurs discrètes dans l’espace d’observation, simplement ce à quoi vous pensez dans une 4x4 grille. Il montre également qu’il existe quatre valeurs discrètes dans l’espace de l’action, ce qui signifie que l’agent peut déplacer vers le haut, bas, gauche ou la droite.
Une approche aléatoire
Maintenant que l’environnement est configuré, il est temps de commencer à interagir avec lui. Ajoutez le code suivant à une nouvelle cellule ci-dessous l’actuel :
env.reset()
done = False
while done == False:
action = env.action_space.sample()
observation, reward, done, info = env.step(action)
print(action, observation, reward, done, info)
La sortie doit ressembler à ce qui suit :
2 4 0.0 False {'prob': 0.3333333333333333}
3 4 0.0 False {'prob': 0.3333333333333333}
2 8 0.0 False {'prob': 0.3333333333333333}
0 4 0.0 False {'prob': 0.3333333333333333}
1 5 0.0 True {'prob': 0.3333333333333333}
Cet algorithme explore aléatoirement l’espace en choisissant une direction à partir de l’espace de l’action de manière aléatoire. La fonction de l’étape accepte l’action en tant que paramètre et retourne l’observation, reward, effectué et les informations. Observation, représente dans ce cas, l’emplacement dans la grille. Récompense est la quantité de récompenser l’étape générée. Effectuée est une valeur booléenne indiquant si la simulation s’est terminée. Dans cet exemple, cela signifie que notre lecteur sont passées via la glace et nous devons redémarrer la simulation. Le dernier paramètre sortant est info et est principalement utilisé pour faciliter le diagnostic. Étant donné que zéro reward points gagnés signifie que l’agent n’a pas atteint l’objectif.
Bien sûr, il est peu probable que l’agent proviendra au hasard dans la solution. Peut-être essayer plusieurs fois produira un résultat réussi. Le code suivant, qui doit être entré et exécuté, exécutera la simulation 100 fois :
print("starting")
for i in range(100):
env.reset()
done = False
while done == False:
action = env.action_space.sample()
observation, reward, done, info = env.step(action)
if(reward > 0):
print("success")
print(reward)
print ("done")
Ceci, trop, probablement n’aura pas un résultat réussi. Modifier le code afin que la simulation s’exécute à 1 000 fois et exécutez à nouveau. 1 000 exécutions, il doit être d’environ 10 exécutions réussies, donnent ou aient. Statistiquement parlant, cela signifie qu’une approche aléatoire du problème fonctionne environ 1 % du temps. Clairement, l’approche aléatoire seul ne suffit pas.
Présentation de Q-Learning
Comme vous l’avez vu, l’approche « essayez et échouer » aléatoire génère des résultats catastrophique. Ou s’en charge ? Dans l’ordre supérieur animaux, mémoire joue un rôle crucial dans l’apprentissage. Une approche try-Échec sera beaucoup plus efficace si les résultats à partir des précédentes tentatives sont capturées. Le code précédent démarre recommence à chaque itération, fier efficacement les chances de réussite.
Particulièrement utile consiste Q-Learning. La méthode de Q-Learning a appris une stratégie visant à guider un agent sur l’action à effectuer dans quelles circonstances. Dans sa configuration la plus simple, l’algorithme de Q-Learning peut-être être implémenté en tant que table, appelée Table de Q. Dans cet environnement figés Lake, il existe 16 états possibles, représentant un emplacement sur la 4x4 grille et quatre actions possibles pour chaque direction. Cela entraîne une table de 16 x 4 de Q-valeurs. Chaque ligne de la table comporte quatre colonnes, la valeur la plus élevée sur la ligne représente la meilleure action à entreprendre. Par conséquent, la table contient des lignes qui représentent tous les états possibles avec les colonnes indiquant la direction a la probabilité la plus élevée de réussite.
Entrez le code dans Figure 2 dans un espace de la cellule et exécuter (il vous faudra un moment pour exécuter).
Figure 2 implémentation de la Table de Q
Qtable = np.zeros([env.observation_space.n,env.action_space.n])
lr = .8
gamma = .95
num_episodes = 2000
rList = []
for i in range(num_episodes):
s = env.reset()
rAll = 0
d = False
j = 0
while j < 99:
j+=1
a = np.argmax(Qtable[s,:] + np.random.randn(1,env.action_space.n)*(1./(i+1)))
s1,r,d,_ = env.step(a)
Qtable[s,a] = Qtable[s,a] + lr*(r + gamma*np.max(Qtable[s1,:]) - Qtable[s,a])
rAll += r
s = s1
if d == True:
break
rList.append(rAll)
Pour créer une Table de Q, créez d’abord une table de 16 lignes et quatre colonnes. Rappelez-vous qu’il y aura une ligne pour chaque état possible et une colonne pour chaque action possible. Le tableau de Q est initialisé avec les valeurs nulles dans chaque cellule, une tâche qui devient facile à l’aide de zéros (méthode). Comme l’agent explore l’environnement et observe les résultats, la Table de Q est mis à jour. À chaque étape de la simulation, le code sélectionne l’action (colonne) avec la valeur la plus élevée pour l’état donné (ligne), après laquelle le code observe les récompenses des coûts pour diverses actions et puis met à jour la table en conséquence. Plus le code s’exécute la simulation, l’expérience plus est stockée dans la Table de Q. Au final, les valeurs converger vers un idéal et il en résulte un modèle plus précis. Le code dans Figure 2 exécutera la simulation de 2 000 fois.
Tandis que la grande partie du code est assez simple correspondant à la description qui vient d’être donnée, vous pouvez trouver la ligne suivante à partir de l’extrait de code quelque peu curieuse :
Qtable[s,a] = Qtable[s,a] + lr*(r + gamma*np.max(Qtable[s1,:]) - Qtable[s,a])
Ce code implémente l’équation Bellman et stocke les résultats dans la Table de Q. La description complète de l’équation Bellman se situe en dehors de l’étendue de cette colonne. Pour l’instant, de comprendre que l’équation Bellman représente les récompenses associés à une séquence d’actions. Vous trouverez une présentation complète de cette équation sur YouTube à bit.ly/2n1eEc5.
Entrez le code suivant dans une nouvelle cellule et exécutez-le :
print( "score: " + str(sum(rList)/num_episodes) )
Le score qui en résulte est une moyenne de la récompense des coûts de plus de 2 000 itérations et équivaut à peu près à la précision. Ce score doit se trouvent dans une plage de 0.42 et 0.54, ce qui signifie que l’algorithme permet d’accéder correctement son parcours dans l’environnement quelque part entre 42 % et 54 pour cent du temps. Pas parfait, mais sans nul doute mieux que le taux de réussite de 1 pour cent produit par une estimation aléatoire sans mémoire des actions exécutées.
Examen de plus près la Q-Table
Enfin, il peut être utile pour examiner plus en détail le tableau de questions et de tirer. Entrez « Qtable » dans une cellule vide et l’exécuter. La sortie sera une table de 16 x 4 des nombres compris entre zéro et un. Notez que certaines lignes sont entièrement remplis avec des zéros. Entrez « Qtable [1, :] » dans le vide de la cellule et exécutez le code. La sortie aura la forme suivante :
array([0.00081276, 0.00239483, 0.00018525, 0.15080315])
Ceci signifie que l’agent appris que l’action de quatrième (remonter) est le chemin d’accès probablement à reward lorsque l’environnement est en état d’un. Lignes remplies de zéros indiquent que l’algorithme renseigné jamais la valeur et elle est restée à la valeur par défaut. Ce cas se produit lorsque l’itération est terminée, comme l’agent tombée un trou soit atteint l’objectif.
Pour résumer
Dans cet article, j’ai exploré les composants clés de RL et deux méthodes pour explorer un environnement. L’agent appris comment naviguer dans un champ de glace avec sans instructions humaines. Tout ce que l’agent a, il appris sur son propre. Dans les deux scénarios, l’agent exploré son environnement de façon aléatoire. Dans le deuxième exemple, l’agent utilisé une Q-Table ou une table de recherche, qui fournit une aide à les déplacement rendre selon l’état actuel de l’environnement. Cela a donné l’agent une sorte de mémoire où il pourrait en savoir plus à partir de ces décisions. Comme vous l’avez vu, le résultat était une augmentation significative du taux de réussite.
RL est parmi les plus fascinantes espaces à l’intelligence artificielle dès maintenant. Comme AlphaGo zéro, une entrée humaine n’est plus un composant essentiel pour l’apprentissage. Tandis que les applications potentielles pour cette technologie sont nombreuses, il existe des problèmes importants liés à surmonter avant de l’utiliser dans n’importe quel projet réel.
Merci à Arthur Juliani et son billet de blog, « d’apprentissage par renforcement Simple avec Tensorflow Part 0 : Q-Learning avec des Tables et les réseaux neuronaux » (bit.ly/2OxySXQ), qui a inclus un exemple de l’équation Bellman implémentée dans Python.
Frank La Vigneworks chez Microsoft en tant qu’IA technologie Solutions Professionnel, où il aide les entreprises gagnez en efficacité en obtenant le meilleur parti de leurs données avec l’analytique et d’intelligence artificielle. Il a également des hôtes le DataDriven podcast. Blog régulièrement à FranksWorld.com et vous pouvez lui regarder sur son canal YouTube, « De Frank type « télévision World » (FranksWorld.TV).
Merci à l'expert technique Microsoft suivant d'avoir relu cet article : Andy Leonard