WEBVTT

00:00.390 --> 00:02.710
Bonjour et bienvenue à l'épice Intertoto.

00:03.000 --> 00:07.800
Très bien, dans cette nouvelle section de code, nous allons mettre en œuvre l'expérience de jeu.

00:07.920 --> 00:13.850
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

00:13.850 --> 00:16.700
comme vous l’avez vu dans les conférences sur l’intuition.

00:16.890 --> 00:21.540
Mais tout d’abord, rappelons brièvement ce qu’est la relecture d’expérience.

00:21.540 --> 00:27.750
Vous savez donc que toute cette intelligence artificielle est basée sur les processus de décision de Markov et que

00:27.750 --> 00:31.840
les processus de décision de Markov consistent à examiner une série d'événements.

00:32.010 --> 00:38.770
Vous savez donc que les événements vont par exemple d’un état à l’autre et d’un tipis à l’autre.

00:39.060 --> 00:44.410
Mais si les événements se sont bien déroulés depuis le lendemain, ils sont très corrélés à l’état actuel.

00:44.550 --> 00:46.820
Eh bien, le réseau ne se porterait pas très bien.

00:46.980 --> 00:52.710
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

00:52.710 --> 00:54.860
chronologique avec un seul pas de temps.

00:55.020 --> 01:00.300
Ce n'était rien apprendre, car un pas de temps n'était pas suffisant pour qu'un modèle

01:00.300 --> 01:03.070
puisse comprendre les corrélations à long terme.

01:03.090 --> 01:07.060
Donc, c'est la même chose ici et c'est pourquoi nous devons mettre en œuvre la relecture d'expérience.

01:07.230 --> 01:08.230
Alors, comment ça marche.

01:08.340 --> 01:13.960
Eh bien, c'est très simple, au lieu de ne considérer que l'état actuel qui n'est qu'un état à

01:13.960 --> 01:14.640
l'instant t.

01:14.680 --> 01:16.830
Nous allons considérer plus dans le passé.

01:16.830 --> 01:22.560
Donc, exactement comme pour les lithium et donc notre série d’événements ne sera pas comme.

01:22.560 --> 01:27.450
Et je suppose qu’il s’agira par exemple des cent États du passé.

01:27.450 --> 01:33.770
Donc, comme T-moins cent quatre-vingts moins 99 jusqu'à moins 1, puis S-T.

01:34.020 --> 01:40.830
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

01:40.830 --> 01:47.040
une mémoire à long terme, par opposition à une mémoire à court terme ou même devrais-je dire une

01:47.040 --> 01:49.950
mémoire instantanée, ce qui améliore considérablement le processus.

01:50.310 --> 01:57.690
Et ensuite, une fois que nous aurons créé cette mémoire des 100 derniers événements, nous comprendrons simplement qu'il faudra quelques

01:57.690 --> 02:02.300
lots aléatoires de ces transitions pour effectuer notre prochaine mise à jour.

02:02.310 --> 02:09.270
C'est notre prochaine étape en sélectionnant la section suivante et donc dans cette classe de mémoire de relecture que

02:09.270 --> 02:13.450
nous implémentons pour la relecture d'expérience, nous allons créer trois fonctions.

02:13.530 --> 02:17.490
Tout d’abord, la fonction habituelle est celle de toute classe.

02:17.520 --> 02:23.400
Ainsi, dans cette fonction, nous définirons les variables qui seront attachées aux futures instances de la classe,

02:23.400 --> 02:27.210
à savoir les futurs objets créés à partir de cette classe.

02:27.540 --> 02:32.790
Et très simplement, ces variables constitueront la mémoire des 100 transitions en 100 événements.

02:32.970 --> 02:38.790
Et la capacité qui correspond au nombre 100, vous serez le bienvenu pour essayer une mémoire plus longue en augmentant

02:38.790 --> 02:39.550
la capacité.

02:39.780 --> 02:46.170
Il s’agit donc de la première fonction de cette fonction. Nous allons ensuite créer deux autres fonctions, une fonction Push,

02:46.500 --> 02:51.050
afin de s’assurer que la mémoire ne contient jamais plus de 100 transitions.

02:51.180 --> 02:57.150
Et pour cela, nous allons utiliser la capacité simplement en remplissant une condition simple, puis

02:57.360 --> 03:03.300
nous créerons la fonction simple qui consistera naturellement à échantillonner quelques transitions dans cette mémoire

03:03.390 --> 03:05.060
des 100 dernières transitions.

03:05.520 --> 03:08.440
Très bien, commençons par présenter le cours.

03:08.520 --> 03:17.460
Donc, comme vous le savez, nous commençons par la classe, puis nous les donnons à la classe que nous appelons la

03:17.460 --> 03:25.500
mémoire de rejeu; puis, entre parenthèses, nous entrons objet, puis Cullin, puis nous commençons avec la première fonction.

03:25.560 --> 03:26.860
La fin est la fonction.

03:27.150 --> 03:30.730
Donc, c'est exactement la même chose qu'avant de commencer avec la mort.

03:30.870 --> 03:36.750
Ensuite, deux traits de soulignement, deux soulignements puis les variables.

03:36.750 --> 03:42.750
Donc, il y a bien sûr self qui est la variable attachée aux instances futures de

03:42.750 --> 03:48.810
la classe d'objets futurs, puis nous aurons une autre variable à votre disposition pour vous permettre

03:48.810 --> 03:52.950
d'essayer une autre expérience avec certains souvenirs. être la capacité.

03:52.950 --> 03:58.020
Cette capacité sera donc simplement le numéro cent, car nous allons faire en sorte que nous

03:58.020 --> 04:00.960
puissions jouer avec les cent transitions de moins.

04:00.960 --> 04:03.910
D'accord, puis Collon Et c'est parti.

04:03.930 --> 04:10.430
Entrons dans la fonction et définissons les variables de notre objet de mémoire de répétition.

04:10.440 --> 04:19.400
Ainsi, le premier sera la capacité autodidacte et, comme vous l'avez probablement compris, ce sera la capacité qui correspond au nombre

04:19.670 --> 04:24.690
maximum de transitions que nous souhaitons avoir dans notre mémoire d'événements.

04:24.830 --> 04:30.980
Et ce sera égal aux arguments qui entreront lors de la création d'un objet de la classe de

04:31.000 --> 04:34.530
mémoire de relecture et par conséquent, c'est la capacité.

04:34.550 --> 04:36.480
C'est l'argument de la fonction init.

04:36.660 --> 04:38.180
Donc, capacité.

04:38.180 --> 04:44.960
Donc, encore une fois, il ne faut pas confondre que capacité est le nom de la variable qui est attachée

04:45.470 --> 04:52.670
à 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.

04:52.810 --> 04:53.620
D'accord.

04:53.830 --> 04:55.880
Et puis nous avons un deuxième voïvode.

04:56.170 --> 04:57.890
C'est bien sûr la mémoire.

04:58.000 --> 05:01.620
Alors autodidacte Nemec.

05:01.760 --> 05:02.650
D'accord.

05:02.800 --> 05:05.730
Et quelle sera donc cette mémoire du voivode?

05:05.990 --> 05:13.950
Eh bien, cette mémoire est supposée contenir les 100 derniers événements. Il s’agit donc d’un test simple.

05:14.100 --> 05:20.300
Vous connaissez une liste qui contiendra les 100 derniers événements, les 100 dernières transitions et initialisera la

05:20.300 --> 05:20.850
liste.

05:20.870 --> 05:24.620
Il n’ya rien de plus simple, nous ajoutons simplement des crochets de ce type.

05:24.740 --> 05:26.040
Et c'est reparti.

05:26.060 --> 05:31.490
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

05:31.490 --> 05:36.430
de l'exploration, la mémoire sera une liste vide et ensuite nous mettrons les transitions.

05:36.500 --> 05:38.350
Chaque fois que nous atteignons un état futur.

05:38.600 --> 05:43.370
Et en parlant de cela, c'est exactement ce que nous ferons avec la prochaine fonction que nous

05:43.520 --> 05:44.720
appellerons la fonction push.

05:44.790 --> 05:51.380
Nous allons créer cette fonction push pour insérer les événements dans cette liste de mémoire, puis nous utiliserons cette

05:51.620 --> 05:57.170
capacité pour nous assurer que cette liste de mémoire contient toujours 100 événements et jamais plus.

05:57.500 --> 05:59.660
Très bien alors faisons ceci dans la prochaine aussi.

05:59.690 --> 06:01.250
Et jusque là je