Bonjour et bienvenue à l'épice Intertoto.
Très bien, dans cette nouvelle section de code, nous allons mettre en œuvre l'expérience de jeu.
Nous allons donc créer un nouveau cours que nous appellerons mémoire de répétition et qui implémentera l’expérience nécessaire pour jouer exactement
comme vous l’avez vu dans les conférences sur l’intuition.
Mais tout d’abord, rappelons brièvement ce qu’est la relecture d’expérience.
Vous savez donc que toute cette intelligence artificielle est basée sur les processus de décision de Markov et que
les processus de décision de Markov consistent à examiner une série d'événements.
Vous savez donc que les événements vont par exemple d’un état à l’autre et d’un tipis à l’autre.
Mais si les événements se sont bien déroulés depuis le lendemain, ils sont très corrélés à l’état actuel.
Eh bien, le réseau ne se porterait pas très bien.
Donc, pour ceux qui viennent du cours d’apprentissage approfondi, c’est exactement la même chose que celle où nous avons appris notre série
chronologique avec un seul pas de temps.
Ce n'était rien apprendre, car un pas de temps n'était pas suffisant pour qu'un modèle
puisse comprendre les corrélations à long terme.
Donc, c'est la même chose ici et c'est pourquoi nous devons mettre en œuvre la relecture d'expérience.
Alors, comment ça marche.
Eh bien, c'est très simple, au lieu de ne considérer que l'état actuel qui n'est qu'un état à
l'instant t.
Nous allons considérer plus dans le passé.
Donc, exactement comme pour les lithium et donc notre série d’événements ne sera pas comme.
Et je suppose qu’il s’agira par exemple des cent États du passé.
Donc, comme T-moins cent quatre-vingts moins 99 jusqu'à moins 1, puis S-T.
En d'autres termes, nous mettons 100 mémoires en moins dans ce que nous appelons la mémoire et c'est pourquoi nous avons
une mémoire à long terme, par opposition à une mémoire à court terme ou même devrais-je dire une
mémoire instantanée, ce qui améliore considérablement le processus.
Et ensuite, une fois que nous aurons créé cette mémoire des 100 derniers événements, nous comprendrons simplement qu'il faudra quelques
lots aléatoires de ces transitions pour effectuer notre prochaine mise à jour.
C'est notre prochaine étape en sélectionnant la section suivante et donc dans cette classe de mémoire de relecture que
nous implémentons pour la relecture d'expérience, nous allons créer trois fonctions.
Tout d’abord, la fonction habituelle est celle de toute classe.
Ainsi, dans cette fonction, nous définirons les variables qui seront attachées aux futures instances de la classe,
à savoir les futurs objets créés à partir de cette classe.
Et très simplement, ces variables constitueront la mémoire des 100 transitions en 100 événements.
Et la capacité qui correspond au nombre 100, vous serez le bienvenu pour essayer une mémoire plus longue en augmentant
la capacité.
Il s’agit donc de la première fonction de cette fonction. Nous allons ensuite créer deux autres fonctions, une fonction Push,
afin de s’assurer que la mémoire ne contient jamais plus de 100 transitions.
Et pour cela, nous allons utiliser la capacité simplement en remplissant une condition simple, puis
nous créerons la fonction simple qui consistera naturellement à échantillonner quelques transitions dans cette mémoire
des 100 dernières transitions.
Très bien, commençons par présenter le cours.
Donc, comme vous le savez, nous commençons par la classe, puis nous les donnons à la classe que nous appelons la
mémoire de rejeu; puis, entre parenthèses, nous entrons objet, puis Cullin, puis nous commençons avec la première fonction.
La fin est la fonction.
Donc, c'est exactement la même chose qu'avant de commencer avec la mort.
Ensuite, deux traits de soulignement, deux soulignements puis les variables.
Donc, il y a bien sûr self qui est la variable attachée aux instances futures de
la classe d'objets futurs, puis nous aurons une autre variable à votre disposition pour vous permettre
d'essayer une autre expérience avec certains souvenirs. être la capacité.
Cette capacité sera donc simplement le numéro cent, car nous allons faire en sorte que nous
puissions jouer avec les cent transitions de moins.
D'accord, puis Collon Et c'est parti.
Entrons dans la fonction et définissons les variables de notre objet de mémoire de répétition.
Ainsi, le premier sera la capacité autodidacte et, comme vous l'avez probablement compris, ce sera la capacité qui correspond au nombre
maximum de transitions que nous souhaitons avoir dans notre mémoire d'événements.
Et ce sera égal aux arguments qui entreront lors de la création d'un objet de la classe de
mémoire de relecture et par conséquent, c'est la capacité.
C'est l'argument de la fonction init.
Donc, capacité.
Donc, encore une fois, il ne faut pas confondre que capacité est le nom de la variable qui est attachée
à l'objet et que capacité est ici l'argument qui entrera lors de la création d'un objet de la classe de mémoire de relecture.
D'accord.
Et puis nous avons un deuxième voïvode.
C'est bien sûr la mémoire.
Alors autodidacte Nemec.
D'accord.
Et quelle sera donc cette mémoire du voivode?
Eh bien, cette mémoire est supposée contenir les 100 derniers événements. Il s’agit donc d’un test simple.
Vous connaissez une liste qui contiendra les 100 derniers événements, les 100 dernières transitions et initialisera la
liste.
Il n’ya rien de plus simple, nous ajoutons simplement des crochets de ce type.
Et c'est reparti.
Notre mémoire est initialisée, donc bien sûr au début de l'expérience ou plus précisément au début
de l'exploration, la mémoire sera une liste vide et ensuite nous mettrons les transitions.
Chaque fois que nous atteignons un état futur.
Et en parlant de cela, c'est exactement ce que nous ferons avec la prochaine fonction que nous
appellerons la fonction push.
Nous allons créer cette fonction push pour insérer les événements dans cette liste de mémoire, puis nous utiliserons cette
capacité pour nous assurer que cette liste de mémoire contient toujours 100 événements et jamais plus.
Très bien alors faisons ceci dans la prochaine aussi.
Et jusque là je