WEBVTT

00:00.450 --> 00:02.520
Bonjour et bienvenue dans ce tutoriel.

00:02.520 --> 00:06.140
Nous avons maintenant notre IA, elle est prête à être entraînée.

00:06.330 --> 00:09.660
Et la première étape de la formation consiste à définir notre rejeu d’expérience.

00:09.900 --> 00:11.330
Donc, nous y arrivons lentement.

00:11.340 --> 00:16.690
La formation et les bonnes nouvelles sont que nous avons une version implémentée de la relecture d’expérience.

00:16.830 --> 00:23.490
En outre, il est adapté à la trace d'éligibilité, ce qui, je le rappelle, est une technique qui au lieu

00:23.490 --> 00:27.160
d'apprendre les q valeurs, chaque transition l'apprend toutes les 10 transitions.

00:27.210 --> 00:29.460
Donc, fondamentalement, c'est exactement comme avant.

00:29.490 --> 00:35.190
Mais au lieu d’avoir une cible unique avec un mot unique pour chaque étape, nous aurons une cible cumulative de

00:35.190 --> 00:40.770
dix étapes et une récompense cumulative de 10 étapes et nous apprendrons à chaque fois les 10 étapes.

00:40.980 --> 00:44.960
Nous apprenons donc sur les transitions en 10 étapes au lieu d'une comme auparavant.

00:45.180 --> 00:50.440
Et avec cela, je vais faire des merveilles et cela fera des merveilles pour le processus de formation.

00:50.440 --> 00:52.570
Vous savez que la formation prendra beaucoup moins de temps.

00:52.620 --> 00:58.850
Merci à cette technique, mais nous devons spécifier une répétition inexpérience que nous apprenons toutes les 10 étapes.

00:58.980 --> 01:04.230
C'est pourquoi cette relecture d'expérience n'est pas une implémentation classique de la relecture d'expérience.

01:04.320 --> 01:06.160
Comme faire un pour la voiture autonome.

01:06.210 --> 01:12.540
Il s’agit d’une mise en œuvre de la relecture d’expérience prenant

01:12.540 --> 01:19.110
en compte cet apprentissage en 10 étapes. Vous trouverez donc dans ce

01:19.110 --> 01:23.460
fichier de relecture d’expérience deux classes.

01:23.460 --> 01:28.430
C'est la première classe et nous avons besoin de cette classe, car nous devons inclure ces 10 étapes dans la

01:28.430 --> 01:33.570
classe de mémoire de replay qui est l'implémentation de la classe pour l'expérience vécue et c'est ainsi que nous nous assurons

01:33.630 --> 01:38.020
que la mémoire prend également en compte le fait que nous sommes. apprendre sur 10 étapes.

01:38.040 --> 01:42.660
C’est pourquoi vous trouverez deux classes dans cette implémentation de la relecture d’expérience, mais c’est

01:42.660 --> 01:49.070
uniquement pour tenir compte du fait que nous apprenons en 10 étapes et que nous devons en tenir compte également en mémoire.

01:49.410 --> 01:51.940
Alors en parlant de notre mémoire, créons-le.

01:51.970 --> 02:00.150
Nous allons appeler notre mémoire mémoire et la mémoire sera un objet de la distribution de la mémoire de relecture et la classe de mémoire

02:00.570 --> 02:04.900
de relecture est une classe de cette répétition d'expérience en ce moment.

02:05.070 --> 02:14.430
Et donc je prends d'abord cette conduite de replay d'expérience ressentie et c'est là que je prends la classe de mémoire de

02:15.180 --> 02:15.880
replay.

02:15.960 --> 02:16.840
Parfait.

02:16.890 --> 02:23.460
Et vous voyez maintenant que nous devons définir deux arguments, le premier et des étapes correspondant exactement au nombre

02:23.640 --> 02:27.540
d’étapes sur lesquelles nous allons apprendre les valeurs de clé.

02:27.540 --> 02:32.090
Donc, vous connaissez le nombre d'étapes sur lesquelles nous accumulons la cible et que nous voulons.

02:32.180 --> 02:37.290
Nous allons avoir un objectif cumulatif et la récompense cumulée, puis le deuxième argument est la capacité

02:37.290 --> 02:39.840
correspondant à la taille de la mémoire.

02:39.840 --> 02:42.650
Donc, par exemple ici, nous pouvons voir des dizaines de milliers.

02:42.810 --> 02:48.270
Donc, si la capacité est égale à 10 000, cela signifie que nous aurons une taille

02:48.270 --> 02:54.210
de 10 000, ce qui signifie que nous aurons une mémoire des 10 000 étapes effectuées par l'œil.

02:54.390 --> 02:57.390
Mais encore une fois, nous n'allons pas apprendre chaque transition.

02:57.390 --> 03:02.690
Nous allons apprendre toutes les dix étapes le long de ces 10000 dernières étapes de la mémoire et c'est

03:02.700 --> 03:06.100
exactement cette nouvelle fonctionnalité que nous introduisons ici par rapport à avant.

03:06.180 --> 03:12.480
Auparavant, nous n'avions que cette astuce de mémoire de répétition et nous avons ici cette astuce de mémoire de répétition plus cette astuce. J'ai

03:12.570 --> 03:16.920
appris toutes les dix étapes et nous allons apprendre toutes les dix étapes. Nous allons le

03:16.920 --> 03:20.000
faire dans la mémoire composée des éléments suivants: 10000 dernières étapes.

03:20.190 --> 03:27.810
Et ceci est une répétition combinée à des traits d'inéligibilité avec 10 étapes qui vont considérablement améliorer les

03:27.810 --> 03:29.240
performances de l'entraînement.

03:29.490 --> 03:31.130
Terminons donc avec ces deux arguments.

03:31.200 --> 03:35.900
Le premier est et étapes et ce sera égal à.

03:36.030 --> 03:43.180
Mais pour le moment, disons, et les étapes spécifieront quelle étape est juste après que ce sera réellement une abjection de

03:43.360 --> 03:49.130
l’autre classe de ce fichier de relecture d’expérience, qui est la classe de progression de fin d’étape

03:49.140 --> 03:52.170
et qui permet de progresser en dix étapes.

03:52.170 --> 03:57.990
Et rappelez-vous qu'au cours des 10 étapes, nous allons résonner les mots sur les 10 étapes pour obtenir les récompenses

03:58.050 --> 03:59.550
cumulatives sur 10 étapes.

03:59.550 --> 04:02.250
Et c'est exactement le test d'éligibilité.

04:02.250 --> 04:09.350
Nous devons donc créer cette étape ici et la créer avec la deuxième classe que nous avons dans

04:09.360 --> 04:13.040
ce fichier de relecture d’expérience qui est une progression.

04:13.160 --> 04:24.430
Alors maintenant, nous allons créer des pas et ceci sera un objet de la classe de pas

04:24.430 --> 04:30.650
à pas que nous reprenons de notre expérience.

04:30.940 --> 04:31.720
Nous y voilà.

04:31.840 --> 04:37.160
Donc, c'est la classe anti-progrès et nous devons maintenant présenter trois arguments, comme vous pouvez le voir,

04:37.180 --> 04:41.010
nous devons définir l'environnement qui est l'environnement ici que nous avons importé.

04:41.230 --> 04:47.680
Ensuite, le deuxième argument est notre IA et il s’agira bien entendu de l’IA que nous

04:47.830 --> 04:55.550
avons construite ici au Royaume-Uni. S. et le dernier argument est une étape dans laquelle nous précisons que nous

04:55.570 --> 04:59.120
voulons que vous sachiez que 10 étapes soient apprises toutes les 10 étapes, c'est-à-dire toutes les 10 transitions.

04:59.200 --> 05:01.140
Alors aidons avec ces arguments.

05:01.180 --> 05:06.920
Le premier est l'environnement et c'est malheureux.

05:06.940 --> 05:11.700
Ensuite, le second est notre IA AI et que nous avons compté par intérim.

05:11.830 --> 05:12.720
C'est celui-là.

05:12.760 --> 05:17.590
Il ne s’agit donc que du nom de l’argument de la classe de progression par étapes et de ce ai ai.

05:17.590 --> 05:19.730
Voici notre ai ai.

05:19.750 --> 05:27.150
Celui que nous avons construit et puis le dernier argument est et pile et qui est égal à 10.

05:27.160 --> 05:27.910
D'accord.

05:27.910 --> 05:33.670
Donc, pour le moment, nous prenons simplement en compte dans la mémoire qu'il existe un apprentissage sur 10 étapes

05:33.670 --> 05:37.210
et que cet apprentissage sur 10 étapes est appelé trace d'éligibilité.

05:37.240 --> 05:39.520
Donc, nous travaillons vraiment sur les choses avancées ici.

05:39.640 --> 05:44.160
Mais souvenez-vous que c'est parce que nous essayons d'être Dume, ce n'est pas comme préparer un morceau de gâteau.

05:44.290 --> 05:47.650
Nous avons donc besoin de ces techniques avancées pour que cela fonctionne.

05:47.660 --> 05:48.880
Alors maintenant, nous sommes presque prêts.

05:48.880 --> 05:55.450
Avant de passer à la prochaine étape qui consistera en réalité à mettre en place des

05:55.450 --> 06:03.730
plateaux LGBT, la seule chose que nous devons inclure est bien sûr la capacité et, disons, 10000 hommes, nous aurons une

06:03.730 --> 06:11.470
taille de 10000, ce qui signifie que la mémoire contiendra le dernier 10000 pas effectués par l'IA et cela

06:11.500 --> 06:13.810
nous permettra d'en générer plusieurs.

06:13.930 --> 06:16.020
Si je me souviens était une fonction simple.

06:16.180 --> 06:22.840
Vous savez que la mémoire contient 10000 transitions, mais pour former l'œil, nous allons échantillonner autant

06:22.840 --> 06:28.360
de lots de dix transitions que jamais auparavant, et nous allons échantillonner ces

06:28.360 --> 06:33.490
mini-lots de 10 transitions en mémoire composés des 10 000 étapes. .

06:33.490 --> 06:38.770
D'accord, je suppose que nous sommes prêts à passer à l'étape suivante, qui concerne la mise en œuvre du suivi

06:38.770 --> 06:39.490
de l'éligibilité.

06:39.520 --> 06:41.680
Donc, nous allons avoir une aventure ici.

06:41.680 --> 06:43.690
Ce ne sera pas une simple implémentation.

06:43.720 --> 06:47.830
Alors faites une bonne pause et quand vous serez prêt, nous pourrons nous attaquer à cela.

06:47.920 --> 06:49.120
Et alors profitez-en.
