WEBVTT

00:00.560 --> 00:02.560
Bonjour et bienvenue dans ce tutoriel.

00:02.750 --> 00:04.610
Nous avons maintenant le cerveau de demain.

00:04.610 --> 00:06.350
Nous avons également l'optimiseur.

00:06.350 --> 00:09.980
Nous sommes donc prêts à former nos différents agents.

00:10.010 --> 00:11.620
Ce sont nos différents cerveaux.

00:11.720 --> 00:18.650
C’est donc à partir de maintenant que cette grande fonction de train contiendra tout l’algorithme A3 et que ce que nous sommes

00:18.650 --> 00:24.920
sur le point de mettre en œuvre dans ce train que j’ai trouvé est tout simplement cette énorme fonction de

00:25.230 --> 00:31.200
train qui ne sera que cette grosse fonction de train. classe, mais qui utilisera cette fonction de train.

00:31.250 --> 00:33.880
Et la dernière étape de ce module avec le code principal.

00:34.100 --> 00:35.010
Alors on y va.

00:35.060 --> 00:37.340
Mais avant de commencer, vous pouvez le remarquer.

00:37.490 --> 00:42.020
Eh bien d’abord, nous importons certaines bibliothèques, ce qui correspond aux bibliothèques classiques avec le module torche.

00:42.020 --> 00:49.040
Je veux dire que votre bibliothèque de flambeau se termine alors pour créer l'environnement qui va éclater.

00:49.220 --> 00:54.470
Ensuite, nous allons bien sûr importer les classes de notre modèle.

00:54.620 --> 00:55.980
Fichier celui-ci.

00:56.420 --> 01:00.070
Et enfin, nous utiliserons une variable de TORCIDA.

01:00.150 --> 01:04.000
Je regrette de participer à des compétitions très performantes sur le gradient.

01:04.100 --> 01:05.750
Merci aux graphiques dynamiques.

01:05.990 --> 01:11.960
Et puis nous avons ceci afin d’assurer la fonction partagée des diplômés que je ne voulais pas consacrer trop

01:11.960 --> 01:16.930
de temps à cela, car c’est d’abord une fonction qui garantit que tout fonctionne correctement.

01:17.030 --> 01:20.400
Si le modèle utilisé par l'agent n'a pas de dégradé de partage.

01:20.480 --> 01:25.640
C'est pourquoi on appelle cela les diplômés partagés courts et l'autre raison est que je ne pense pas que cette

01:25.640 --> 01:26.530
fonction soit nécessaire.

01:26.630 --> 01:32.700
Mais nous ne savons jamais et au moins avec cela nous serons sûrs à 100% que le code s'exécutera correctement mais

01:33.080 --> 01:34.790
ce n'est pas vraiment important.

01:34.880 --> 01:40.640
Ce sur quoi nous devons nous concentrer est cette fonction de tendance que nous commençons tous à créer en ce moment.

01:41.000 --> 01:41.600
Alors on y va.

01:41.610 --> 01:48.860
Def and train deviendra bientôt un train et cette transformation nécessitera plusieurs arguments.

01:49.010 --> 01:50.400
Le premier est le rang.

01:50.420 --> 01:56.460
Je vais expliquer ce que c'est et le second le second est harams afin que tous les

01:56.460 --> 01:57.840
paramètres soient l'environnement.

01:57.920 --> 02:02.860
Ensuite, le troisième paramètre va être la morale partagée.

02:03.170 --> 02:09.260
Donc, vous savez que le modèle partagé est ce que l'agent va pouvoir exécuter

02:09.260 --> 02:17.050
sur un certain nombre d'étapes de sa petite exploration, puis le dernier argument sera l'optimiseur que nous avons défini précédemment.

02:17.770 --> 02:20.040
Donc, parfait pour les arguments.

02:20.090 --> 02:24.010
Et maintenant, nous sommes prêts à commencer à mettre en œuvre la même fonction.

02:24.170 --> 02:30.890
La première chose à faire est donc que vous sachiez que vous vous souvenez de ce qu’A-380 représente, c’est-à-dire des

02:31.010 --> 02:32.480
agents Crilley actifs synchrones.

02:32.540 --> 02:34.980
Donc, en 8: 3, il y a un synchrone.

02:34.980 --> 02:40.940
Donc, comme vous l'avez compris, nous devons priver chacun de ses agents d'entraînement de leurs droits et leurs

02:40.940 --> 02:49.010
économies, puis nous allons utiliser le rang pour déplacer chaque camp avec ce rang. Ce paramètre de rang est simplement ici pour décaler la

02:49.220 --> 02:52.230
graine afin que chaque agent d'entraînement soit synchronisé.

02:52.580 --> 02:59.390
Ainsi, par exemple, s’il ya des agents d’entraînement, les rangs vont de 1 à 10 et il y aura

02:59.390 --> 03:02.600
un entier par agent de 1 à 10.

03:02.630 --> 03:08.840
Ainsi, lorsque nous décalons la graine d'un fil, tous les nombres pseudo aléatoires créés par ce

03:08.840 --> 03:11.340
fil seront totalement indépendants des autres.

03:11.480 --> 03:14.250
Cependant la graine ou des nombres fixes.

03:14.510 --> 03:19.640
Ainsi, lorsque nous reproduirons l'expérience, nous retrouverons exactement les mêmes événements.

03:19.880 --> 03:23.450
Et c'est parce que c'est déterministe en ce qui concerne le siège.

03:23.690 --> 03:30.470
Il est donc important de comprendre cela et c’est pourquoi nous devons faire est de synchroniser chaque agent stagiaire en utilisant

03:30.800 --> 03:34.260
le bon ici pour déplacer la graine avec le rang.

03:34.350 --> 03:36.110
Alors faisons ceci pour le faire.

03:36.140 --> 03:39.170
Nous allons prendre notre bibliothèque de torche.

03:39.170 --> 03:45.350
Ensuite, nous allons obtenir la graine avec le soulignement manuel souligne la parenthèse de la graine.

03:45.350 --> 03:51.040
C'est une fonction et maintenant nous allons prendre les graines de tous les agents auxquels nous pouvons accéder

03:51.220 --> 03:55.620
à partir de cette graine et les déplacer par rang pour se synchroniser.

03:55.660 --> 04:05.420
Chacun de ces agents ajoutera simplement ici plus rec et cela changera la graine avec le rang afin de priver de ses droits chaque agent

04:05.510 --> 04:09.970
stagiaire car il existe une graine pour chaque agence de formation.

04:09.980 --> 04:15.390
Tout d’abord bien, la prochaine étape consiste à récupérer l’environnement.

04:15.530 --> 04:21.470
Nous allons donc créer une nouvelle variable que nous allons appeler et que nous allons maintenant utiliser pour

04:21.590 --> 04:26.120
créer Atari et fonctionner à partir du dernier module pour créer l’environnement d’évasion.

04:26.150 --> 04:28.130
C'est pour obtenir l'environnement de rupture.

04:28.250 --> 04:38.070
Nous prenons donc cette fonction pour créer Terry et nous devons maintenant entrer un seul argument, qui sont les paramètres

04:38.070 --> 04:39.060
de l'environnement.

04:39.270 --> 04:42.730
Et nous les avons parce que c'est l'une des entrées de la fonction cérébrale.

04:42.750 --> 04:48.270
C’est ce paramètre ici qui sera les paramètres de l’environnement d’évasion

04:48.330 --> 04:58.320
et donc pour obtenir les environnements d’évasion, nous prenons l’argument de ces programmes puis nous obtenons un nom qui, à

04:58.320 --> 05:03.240
l’avenir, se trouve dans le code suivant exécutera tout

05:03.240 --> 05:06.010
le code sera brisé vizir.

05:06.010 --> 05:09.450
Très bien, cela nous procure un environnement parfait.

05:09.610 --> 05:16.080
Et maintenant, la prochaine étape consiste à aligner le siège de l'environnement sur celui des agents.

05:16.180 --> 05:17.650
Et pourquoi faisons-nous cela.

05:17.650 --> 05:24.220
C’est parce que rappelez-vous que chaque agent de l’A-3 Silmaril a

05:24.220 --> 05:31.000
sa propre vision de l’environnement, tout comme sa propre copie de l’environnement.

05:31.000 --> 05:36.520
utiliser le siège car chaque siège détermine un environnement

05:36.520 --> 05:37.320
spécifique.

05:37.450 --> 05:43.390
Donc, en associant une graine différente à chaque agent, nous obtiendrons exactement ce que nous voulons, à

05:43.390 --> 05:46.340
savoir que chaque agent aura son propre environnement.

05:46.500 --> 05:54.730
Et alors, comment pouvons-nous faire pour que nous puissions prendre notre environnement? Utilisez ensuite la fonction de graine pour choisir

05:54.770 --> 05:57.340
ceux qu’il aura pour l’environnement.

05:57.520 --> 06:01.370
Et maintenant, aligner le siège de l'environnement sur la graine de l'agent.

06:01.600 --> 06:08.460
Eh bien, nous devons simplement obtenir ceci, car cela correspond au siège de l'agent qui a été déplacé pour prendre des rangs

06:08.530 --> 06:14.170
afin d'obtenir des agents de formation organisés et décents, car ils sont tous sur un plateau différent.

06:14.200 --> 06:20.020
Nous devons donc simplement payer cela ici et cela alignera le siège de l'environnement sur celui

06:21.210 --> 06:24.660
de l'agent Bon, nous allons maintenant avoir notre modèle.

06:24.670 --> 06:27.060
C'est notre A-3 voir les cerveaux.

06:27.180 --> 06:32.320
Et c'est donc maintenant que nous allons utiliser la classe active de notre fichier de modèle.

06:32.350 --> 06:38.500
Nous allons donc créer un nouvel objet de cette classe d’activité et appeler ce modèle d’objet

06:38.500 --> 06:40.960
ou cerveau si vous le souhaitez.

06:41.200 --> 06:47.650
Mais fondamentalement, cet objet contiendra toutes les convolutions du CM La connexion linéaire et la fonction Ford

06:47.650 --> 06:49.500
pour propager le signal.

06:49.600 --> 06:55.630
Donc, il contiendra essentiellement le cerveau de l'acteur dans la critique avec la capacité de propager le signal

06:55.630 --> 06:59.120
dans tout le cerveau pour obtenir le résultat final.

06:59.170 --> 07:06.850
Faisons cela, créons notre modèle de manière à appeler ce modèle d’objet.

07:07.150 --> 07:15.040
Et donc nous créons un objet de la classe create Act et nous prenons donc un critique d'acteur de classe et nous nous souvenons maintenant

07:15.040 --> 07:17.250
des arguments lorsque les deux entrées.

07:17.350 --> 07:20.420
C'est en fait les arguments de la fonction.

07:20.640 --> 07:26.230
Donc nous devons l’entrer vous savez que c’est ce que nous devons faire pour utiliser l’objet dans la méthode.

07:26.530 --> 07:33.010
Mais alors, les arguments que nous devons mettre en avant sont des noms nominaux en mauvais état qui sont

07:33.010 --> 07:38.680
enchaînés dans des chaînes d’images imprimées et l’espace réel dans lequel se trouve l'ensemble des actions.

07:38.680 --> 07:42.550
Mettons donc ces arguments dans la fonction train.

07:42.760 --> 07:51.580
Donc, le premier que nous pouvons obtenir avec notre environnement et cela, puis nous utilisons un espace d'observation qui

07:51.580 --> 07:59.020
correspond à l'espace d'observations, puis nous obtenons le nombre d'entrées pour lesquelles nous obtenons zéro.

07:59.190 --> 07:59.550
D'accord.

07:59.550 --> 08:01.120
C'est pour les entrées.

08:01.290 --> 08:04.690
Et maintenant pour l'espace d'action.

08:04.860 --> 08:10.480
Eh bien, c’est à peu près la même chose que nous devons tirer de notre environnement pour qu’il soit plus important que cela.

08:10.500 --> 08:12.920
Et puis l'espace d'action.

08:12.920 --> 08:13.260
D'accord.

08:13.260 --> 08:17.860
Et cela nous donne les arguments que nous devons entrer lors de la création d'un objet.

08:17.860 --> 08:20.130
Le modèle de la classe execrate.

08:20.400 --> 08:25.150
OK, nous avons maintenant notre modèle et la prochaine étape consiste à préparer nos états d'entrée.

08:25.170 --> 08:31.230
Alors rappelez-vous que nous continuons à approfondir notre apprentissage informel et que l'entrée saisit nos images d'entrée; par conséquent, cette tâche sera

08:31.560 --> 08:37.080
effectuée à l'origine par Ray, qui contiendra un canal, car nous allons travailler avec des images en noir et blanc,

08:37.080 --> 08:40.670
ce qui donnera du temps dans les océans de 42 par 42

08:40.980 --> 08:46.680
Mais il est important de comprendre et de garder à l'esprit que les états d'entrée sont des images d'entrée.

08:46.680 --> 08:51.940
Donc, ce que nous devons faire, c'est obtenir le non-pouvoir, puis nous le convertirons en réponse à la torture.

08:52.050 --> 08:57.770
Mais la première étape comme celle que nous avons faite précédemment consiste à obtenir un arbitre et à l’obtenir.

08:57.840 --> 08:58.970
C'est en fait assez simple.

08:58.980 --> 09:06.080
Bien, nous devons d’abord créer une variable pour l’état d’entrée qui passera d’un état à l’autre pour obtenir un

09:06.080 --> 09:07.130
tableau d’arbitres.

09:07.230 --> 09:13.000
Nous devons simplement prendre notre environnement, puis nous adapter et utiliser ensuite la fonction de réinitialisation.

09:13.200 --> 09:19.940
Et cela initialisera les États comme un empire de dimensions 42 par 42.

09:20.190 --> 09:27.170
On signifie 1 canal de sorte que l'image en noir et blanc et 42 par 42 est bien sûr les dominations de l'image.

09:27.210 --> 09:30.860
Le nombre de pixels et la largeur et le nombre de pixels et la hauteur.

09:30.870 --> 09:32.630
Donc, fondamentalement, ce n’est que l’instance temporelle.

09:32.670 --> 09:34.660
Et ce sont ceux avec lesquels nous travaillons.

09:34.820 --> 09:40.830
Et maintenant que nous sommes en train d'arbitrer parce que cela nous donnera ces images d'une

09:40.830 --> 09:42.670
telle assurance-temps dans Empire.

09:42.870 --> 09:48.510
Maintenant, nous pouvons les convertir en danseurs de flambeau et pour bien le faire, nous passons à nouveau à l'état de données car nous

09:48.510 --> 09:50.890
n'avons pas besoin de conserver les tableaux de nombres.

09:51.180 --> 09:55.030
Et c’est là que nous utilisons le module torche.

09:55.260 --> 10:02.790
Et rappelez-vous que nous avons déjà fait cela avec la fonction de soulignement de parenthèses non thaïes.

10:02.880 --> 10:08.350
Et à l'intérieur de cette fonction, nous devons entrer le taux de numérotation que nous voulons convertir en capteur de torche.

10:08.610 --> 10:14.880
Et c’est l’état où la version précédente du tableau d’État non payant deviendra un pipeline à partir de la fonction de

10:14.880 --> 10:20.510
conduite de la torche, de sorte que l’intensificateur ne soit créé que par un état plus intense.

10:20.550 --> 10:24.870
Et maintenant, il ne reste plus qu’à initialiser le viable.

10:24.870 --> 10:30.650
Rappelez-vous que la variable est généralement la variable qui dit si un épisode est terminé ou si le jeu est terminé.

10:30.870 --> 10:37.110
Bien, ici, nous voulons juste présenter très bien ce que nous avons fait et initialiser true pour spécifier que ce

10:37.160 --> 10:41.230
ne sera pas le voivode sera vrai lorsque le jeu sera terminé.

10:41.260 --> 10:46.790
Cela sera utile pour plus tard afin que l'IA ne joue pas indéfiniment pour éclater.

10:46.820 --> 10:47.350
D'accord.

10:47.390 --> 10:54.320
Donc, c’était fondamentalement le début de cette fonction de tendance avec une initialisation et des tâches

10:54.320 --> 10:55.370
à faire.

10:55.370 --> 11:00.560
La partie la plus importante ici est que nous devons priver chacun des agents stagiaires de leurs droits.

11:00.560 --> 11:04.890
C'est un premier principe de l'A3 similaire que nous devons appliquer.

11:05.160 --> 11:09.780
Et maintenant, dans le prochain tutoriel, nous allons procéder à la synchronisation avec le modèle partagé.

11:09.830 --> 11:14.810
N'oublions pas qu'il existe un modèle différent, mais également le modèle de partage, qui est un modèle partagé

11:14.810 --> 11:16.180
par tous les agents.

11:16.190 --> 11:22.430
Nous devons donc nous synchroniser avec le modèle d'exposition afin que chaque agent puisse obtenir que ce modèle

11:22.520 --> 11:25.990
partagé procède à une petite exploration d'un certain nombre d'étapes.

11:26.000 --> 11:28.080
C'est ce que nous ferons dans le prochain Statoil.

11:28.130 --> 11:29.710
Et jusque-là, profitez de l'IA.
