WEBVTT

00:00.300 --> 00:02.000
Bonjour et bienvenue dans ce tutoriel.

00:02.160 --> 00:05.090
Félicitations encore pour avoir fini avec ça.

00:05.150 --> 00:08.200
Voir nous avons fait nous avons fait les cerveaux et nous les avons formés.

00:08.400 --> 00:15.600
Mais maintenant, nous devons encore créer un agent de test qui ne sera pas du tout une date pour demain, mais il

00:15.780 --> 00:19.430
utilisera simplement le modèle de partage pour effectuer ses propres explorations.

00:19.530 --> 00:26.080
Et bien sûr, dans ce code, nous enregistrerons quelques vidéos et ce seront les agents de test de vidéos

00:26.090 --> 00:28.750
qui se démarqueront avec un certain score.

00:28.810 --> 00:30.840
Alors passons en revue ce code.

00:30.850 --> 00:35.860
Le plus important est fait, donc je vous ai dit que nous n'allons pas le coder ligne par ligne, mais je pense

00:35.860 --> 00:38.580
qu'il est important que vous compreniez ce qui se passe ici.

00:38.800 --> 00:42.680
Nous y allons donc avec ce code dans la première section, comme vous l'avez remarqué.

00:42.790 --> 00:49.480
Nous avons importé les bibliothèques, puis nous avons trouvé cette fonction de test qui permettra à cet agent de test de faire

00:49.480 --> 00:52.390
sa propre exploration et de jouer au jeu épineux.

00:52.600 --> 00:58.610
Nous obtenons donc que la fonction de test prend trois arguments. Le premier est le classement qui doit encore synchroniser l'agent

00:58.850 --> 01:02.060
de test comme nous l'avons fait pour les agents de formation.

01:02.230 --> 01:05.380
Ensuite, nous avons bien sûr nos paramètres, car vous en avez besoin.

01:05.380 --> 01:12.220
Et bien sûr, nous avons le modèle partagé car cet agent de test utilisera un modèle partagé pour effectuer

01:12.220 --> 01:13.360
sa propre exploration.

01:13.360 --> 01:18.790
Très bien, nous entrons dans la fonction et cette ligne de code est synchronisée avec l’agent de test.

01:18.820 --> 01:23.120
Exactement comme nous le faisions auparavant, nous importons l'environnement.

01:23.170 --> 01:27.070
Je rappelle donc cela dans le code principal qui sera dans le prochain tutoriel.

01:27.250 --> 01:33.970
Et le nom ici sera remplacé par une pause de zéro afin que nous puissions entrer dans l’environnement de la pause

01:34.060 --> 01:40.180
zéro et jouer au jeu ainsi qu’aux Trumans de la Croix-Rouge qui recevront les vidéos de notre soirée.

01:40.180 --> 01:46.680
Donc, fondamentalement, cette ligne de code au total signifie que nous exécutons un seul environnement avec la vidéo.

01:47.080 --> 01:54.520
Ensuite, à la ligne de code suivante, nous synchronisons cet environnement avec le même principe que la fonction Trend.

01:54.700 --> 02:02.170
Ensuite, nous obtenons notre modèle et pour ce faire, nous créons un objet de la classe d'activité et nous plaçons la

02:02.170 --> 02:08.920
forme en entrée dans notre espace d'observation de l'environnement et les zéros de forme sont exactement comme la fonction

02:09.190 --> 02:13.690
train et nos sorties qui sont les actions avec un espace d'action.

02:13.900 --> 02:19.770
Donc, exactement comme avant, il y a quelque chose de nouveau ici puisque nous en avons terminé avec la formation.

02:19.870 --> 02:25.450
Nous ne voulons pas mettre le modèle en mode train parce que simplement nous ne voulons pas qu'il soit entraîné, nous

02:25.450 --> 02:26.880
voulons le mettre en développement.

02:27.160 --> 02:29.740
Et c'est ce que nous faisons ici avec un modèle qui a évolué.

02:29.890 --> 02:36.940
Il ne s’agit donc tout simplement que de mettre l’agent de test dans un mode qui permettra de tester

02:37.030 --> 02:38.350
les performances évaluées.

02:38.720 --> 02:45.680
Ensuite, nous avons ici nos états d’entrée qui sont les images d’entrée du jeu qui sont à ce stade

02:45.680 --> 02:46.790
une course entière.

02:46.840 --> 02:49.360
Ensuite, nous les convertissons en danseurs de flambeau.

02:49.480 --> 02:52.810
Ici, nous initialisons certains mots.

02:52.840 --> 02:54.980
Nous initialisons à vrai.

02:55.200 --> 03:03.430
Donc, toujours comme la dernière fois puis quelque chose de nouveau, nous introduisons ce troisième viable avec une fonction de temps pour

03:03.850 --> 03:05.990
mesurer le temps des calculs.

03:06.190 --> 03:08.680
Et c'est parce que vous voulez avoir le point de départ.

03:08.890 --> 03:15.160
Ensuite, ici, les actions que nous utilisons utilisent un type de repère très pratique qui permet d’ajouter un élément au repère à partir de la

03:15.160 --> 03:16.550
droite ou de la gauche.

03:16.600 --> 03:21.960
C'est donc très pratique et je vais vous donner la référence, je pense, en version décrémentée du code.

03:22.180 --> 03:27.320
Donc, vous allez voir ce qu'est cette file d'attente et c'est ce qui permet de le faire.

03:27.490 --> 03:33.370
Ensuite, nous initialisons la longueur d’un épisode avec zéro bien sûr, puis nous incrémentons la taille dans cette

03:33.400 --> 03:34.690
boucle de puits.

03:34.870 --> 03:36.480
Nous utilisons donc le même truc ici.

03:36.680 --> 03:42.290
Bien que vrai et dans la boucle, nous incrémentons la longueur de l'épisode de un.

03:42.490 --> 03:49.700
Lorsque le jeu est terminé lorsque le jeu est terminé, nous rechargeons le dernier ensemble du modèle partagé, le modèle de partage

03:49.730 --> 03:51.460
daté par les autres modèles.

03:51.460 --> 03:55.610
Rappelez-vous qu'ici, le modèle partagé n'est plus daté.

03:55.660 --> 04:04.030
Toujours si le jeu est terminé si le jeu est terminé, Reinette ré-initialise les états de cellules voir

04:04.190 --> 04:13.840
X puis les états H x et si le jeu n’est pas terminé, nous conservons les mêmes états et états de cellule.

04:13.840 --> 04:18.030
Mais pour s’assurer qu’ils sont enseignés de manière variable afin qu’ils puissent être attachés à un dégradé.

04:18.170 --> 04:25.240
OK, c’est donc quelque chose que nous avons déjà éliminé dans la fonction de tendance, puis dans la boucle while et après que nous

04:25.240 --> 04:30.870
ayons des données qui sont dans les états masqués de la bonne façon, selon les deux cas présentés ici.

04:31.060 --> 04:34.360
Eh bien, que faisons-nous? Nous obtenons les prévisions de demain.

04:34.450 --> 04:37.380
C'est exactement ce que nous faisons ici avec cette ligne de code.

04:37.750 --> 04:43.360
On obtient donc la valeur qui est la sortie du critique la valeur réelle qui est la sortie de l'acteur.

04:43.600 --> 04:49.750
Et ensuite, tous les états cachés H x et la cellule États X en haut sont générés, puis nous générons

04:49.750 --> 04:54.130
une distribution des probabilités des actions correspondant à la valeur d’action Q Valeurs ici.

04:54.270 --> 04:56.380
Et nous faisons cela avec la fonction suivante.

04:56.470 --> 05:01.230
Et bien sûr, nous n’avons pas besoin de connaître les probabilités de chance ici, car il s’agit uniquement de la

05:01.480 --> 05:02.650
formation de l’agent d’essai.

05:02.650 --> 05:09.130
Il ne fera que jouer les actions que nous allons utiliser, vous le savez comme une mauvaise activité, mais nous

05:09.190 --> 05:10.920
ne faisons aucune formation ici.

05:10.960 --> 05:19.040
Donc, nous avons juste un accessoire et à partir de là, nous jouons l'action en prenant directement pour RMX ces probabilités c'est-à-dire

05:19.040 --> 05:22.720
qu'il prend l'action qui présente la probabilité la plus élevée.

05:22.810 --> 05:26.860
Et la raison en est que l'agent de test ne fait aucune exploration.

05:26.860 --> 05:32.830
Rappelez-vous que nous voulons avoir une chance de choisir certaines actions peu probables lorsque vous souhaitez

05:32.830 --> 05:38.170
explorer certaines de ces autres actions et que vous savez que vous ne prenez

05:38.170 --> 05:44.260
pas à chaque fois l'action la plus probable mais que l'agent de test c'est pourquoi nous prenons

05:44.260 --> 05:50.800
directement l'action qui a la probabilité maximale, puis une fois que nous jouons l'action, nous atteignons l'état suivant

05:50.800 --> 05:53.340
et nous obtenons le mot suivant.

05:53.470 --> 05:56.920
Et c'est un jour daté si le jeu est terminé ou non.

05:57.160 --> 06:03.700
Nous obtenons donc tout cela avec cette ligne de code en jouant l'action après l'avoir sélectionnée avec notre

06:03.790 --> 06:04.630
Max ici.

06:04.840 --> 06:13.000
Donc, nous jouons l'action ici et nous obtenons l'état où nous obtenons la récompense et nous le faisons à nouveau et ensuite, puisque nous venons de recevoir

06:13.090 --> 06:18.950
une nouvelle récompense, nous allons mettre à jour une partie de la récompense en ajoutant simplement ce nouveau mot.

06:19.180 --> 06:21.480
Et enfin chaque fois que le jeu est terminé.

06:21.490 --> 06:28.510
Donc, si cela signifie que lorsque le jeu est terminé lorsque je finis de jouer au jeu, nous allons

06:28.510 --> 06:31.210
imprimer les résultats avec le temps opposé.

06:31.230 --> 06:36.100
Nous voulions la longueur de l'épisode, c'est combien de temps il a duré.

06:36.100 --> 06:42.890
Jouer à fond et c’est comme ça que nous imprimons toutes ces variables en utilisant ces petites astuces.

06:42.910 --> 06:46.280
C'est pour le moment, alors nous en voulons, c'est juste une variable.

06:46.340 --> 06:51.960
Certains des mots et des idées en détail est la longueur du présent OK.

06:52.160 --> 06:57.860
Et puis, une fois que nous avons bien imprimé tous les résultats puisque le jeu est terminé et que nous voulons commencer un

06:58.220 --> 06:59.930
nouveau jeu, nous allons tout réinitialiser.

06:59.930 --> 07:04.170
C'est la somme de deux mots zéro la longueur d'un épisode à zéro.

07:04.230 --> 07:10.100
Nous allons rejouer toutes les actions en utilisant cette fonction de clé réinitialise les images d'entrée

07:10.100 --> 07:13.360
que vous connaissez en répétant toutes les pauses.

07:13.610 --> 07:21.980
Et finalement, nous utilisons ce temps qui dort 60 secondes pour faire une pause d’une minute afin de laisser les autres

07:21.980 --> 07:22.840
agents s’exercer.

07:22.850 --> 07:24.810
Et que si le jeu est terminé.

07:25.210 --> 07:25.840
D'ACCORD.

07:25.940 --> 07:32.210
Et enfin, nous avons cette dernière ligne de code qui nous donnera le nouvel état et nous pourrons ensuite avancer.

07:32.240 --> 07:34.550
Nous pouvons continuer dans ce nouveau jeu.

07:34.550 --> 07:35.840
Alors on y va.

07:35.870 --> 07:37.430
C'est la fonction de test.

07:37.430 --> 07:40.550
Les choses pour lesquelles vous verrez les vidéos dans un ou deux tutoriels.

07:40.550 --> 07:45.310
J'espère que vous serez comme la dernière fois à regarder les résultats avec vous.

07:45.350 --> 07:47.360
Curial et moi ça va être amusant.

07:47.480 --> 07:48.400
Et je te le dis.

07:48.440 --> 07:50.330
Attendez-vous à voir de bons résultats.

07:50.360 --> 07:55.130
Mais gardez à l'esprit que ce jeu d'évasion était super stimulant.

07:55.130 --> 07:58.430
Nous pensions que c'était un jeu simple, mais pas du tout.

07:58.430 --> 08:01.480
En fait, cela s'est avéré être beaucoup plus difficile que le destin.

08:01.670 --> 08:03.890
Et c'est pourquoi nous l'avons mis dans le dernier module.

08:04.190 --> 08:09.510
Mais de toute façon, faisons cette fonction principale dans le prochain tutoriel.

08:09.590 --> 08:11.770
Même ce n'est pas le plus important ici.

08:11.780 --> 08:18.860
Maintenant que l’A-380 est dément, nous ne le coderons pas ligne par ligne, il développera le code et très rapidement

08:18.980 --> 08:20.570
nous obtiendrons les résultats.

08:20.570 --> 08:22.130
Jusque-là, profitez de l'IA.
