WEBVTT

00:00.240 --> 00:06.600
Bonjour et bienvenue dans ce tutoriel Python de Statoil, nous allons faire le premier pas vers la mise en œuvre

00:06.630 --> 00:08.270
du modèle de théorie approfondie.

00:08.280 --> 00:13.590
Nous sommes donc sur le point de mettre en œuvre l’ensemble du processus de l’algorithme de diffusion.

00:13.830 --> 00:16.580
Et nous allons utiliser ce que nous avons créé auparavant.

00:16.590 --> 00:22.460
C’est l’architecture du réseau de neurones qui permet de rejouer la mémoire pour l’intégrer dans l’ensemble du processus

00:22.530 --> 00:24.180
d’apprentissage en file d'attente.

00:24.180 --> 00:28.320
Et tout cet algorithme d'apprentissage va s'inscrire dans une classe.

00:28.380 --> 00:32.340
C'est la dernière que nous faisons pour mettre en œuvre l'intelligence artificielle.

00:32.340 --> 00:35.650
Et cette classe ne contiendra que des fonctions différentes.

00:35.700 --> 00:41.790
Nous aurons donc les fonctions internes qui créeront et initialiseront toutes les variables attachées

00:41.790 --> 00:48.450
à nos futurs objets de détournement qui représenteront le modèle lui-même et qui auront d’autres fonctions.

00:48.510 --> 00:52.830
L’un d’eux sera bien sûr de choisir la bonne action à chaque fois.

00:52.950 --> 00:59.250
Nous aurons également une fonction de base de la fonction de mise à jour pour obtenir ce noyau et avoir une idée de la progression

00:59.250 --> 01:01.030
de l’apprentissage s’il se déroule bien.

01:01.090 --> 01:07.080
Si l’exploration se déroule bien et si elle peut passer à l’exploitation, nous aurons une fonction sûre

01:07.080 --> 01:12.430
pour sauver demain, c’est sauver le cerveau de la voiture et ensuite, charger la fonction.

01:12.480 --> 01:14.590
Nous avons donc deux fonctions à remplir.

01:14.640 --> 01:17.440
Nous allons faire une fonction pour chacun de peiner.

01:17.490 --> 01:22.820
Et aujourd'hui, nous allons commencer avec la fonction de fin comme d'habitude lorsque nous faisons un cours.

01:23.010 --> 01:30.040
Mais d'abord, n'oublions pas de présenter le cours afin que nous l'appelions D.

01:30.200 --> 01:35.970
Q Et pour votre réseau, des parenthèses s’appellent.

01:36.030 --> 01:39.440
Et puis nous allons avec notre première fonction.

01:39.500 --> 01:47.910
Faisons donc cette définition puis double soulignement puis son double soulignement et sa parenthèse.

01:48.170 --> 01:53.530
Donc, comme vous l'avez compris dans cette fonction, nous allons introduire les variables attachées à notre objet.

01:53.570 --> 01:59.240
Nous allons donc avoir quelques lignes commençant tout seul et nous allons créer et initialiser toutes

01:59.300 --> 02:03.530
les variables nécessaires à la mise en œuvre du réseau D2.

02:03.530 --> 02:09.740
Ainsi, nous allons par exemple créer un objet ou un réseau car nous avons bien sûr besoin de notre réseau de

02:10.310 --> 02:12.190
neurones profonds, puis de notre mémoire.

02:12.300 --> 02:14.630
Nous allons créer une autre variable pour la mémoire.

02:14.740 --> 02:20.430
Nous aurons donc une autre mémoire variable, mais ce n’est pas tout ce que nous devrons créer également.

02:20.480 --> 02:22.390
Quelques variables pour la dernière date.

02:22.490 --> 02:24.820
La dernière action et le dernier mot.

02:24.920 --> 02:30.520
Bien sûr, vous connaissez les variables que vous voyez dans l'algorithme de diffusion.

02:30.920 --> 02:31.830
Et puis quoi d'autre.

02:31.940 --> 02:38.150
Nous aurons également besoin d’un optimiseur que vous connaissez pour réaliser une grille stochastique en termes de

02:38.510 --> 02:42.170
pondération des données en fonction de leur contribution à l’erreur.

02:42.320 --> 02:48.650
Lorsque l’intelligence artificielle commet une erreur, je pense que c’est donc essentiellement les variables que nous devons

02:48.650 --> 02:50.230
maintenant créer et initialiser.

02:50.510 --> 02:58.460
Mais dans cette fonction init, nous allons mettre deux arguments en premier, comme d'habitude, les arguments faisant référence

02:58.460 --> 03:00.190
à notre objet.

03:00.200 --> 03:05.210
Ensuite, puisque vous savez que nous allons créer un objet de la classe network.

03:05.390 --> 03:12.740
Eh bien, puisque la classe réseau prend comme argument la taille d'entrée de la fonction init et l'action, c'est la même

03:12.740 --> 03:13.740
chose ici.

03:13.850 --> 03:19.110
Lors de la création d'un objet de la classe network, nous devrons choisir un argument de taille d'entrée

03:19.160 --> 03:20.180
et l'argument réel.

03:20.180 --> 03:22.140
Nous pouvons donc simplement les

03:25.660 --> 03:27.520
copier ici et ici.

03:27.710 --> 03:30.450
Donc, ces arguments vont maintenant devenir.

03:30.560 --> 03:33.160
De plus, certains arguments n'ont pas duré.

03:33.170 --> 03:39.680
Chaque fois que nous créons des objets futurs de la classe différente que des modèles de rôle futurs, nous devrons

03:39.680 --> 03:45.010
spécifier la taille de la saisie. Je rappelle le nombre de dimensions dans les vecteurs qui

03:45.010 --> 03:46.330
incluent vos états.

03:46.370 --> 03:52.940
Vos états d'entrée et un certain nombre d'actions, qui correspond au nombre d'actions possibles que la voiture peut effectuer.

03:53.150 --> 03:54.000
Alors je te le rappelle.

03:54.110 --> 03:57.830
Ce sont soit aller à gauche aller tout droit ou aller à droite.

03:58.190 --> 03:59.270
Ok parfait.

03:59.270 --> 04:04.640
Ensuite, vous savez que vous allez créer un nouvel objet de la classe de mémoire de

04:04.640 --> 04:10.680
relecture afin de créer l’objet de mémoire afin d’obtenir la mémoire des transitions et, dans les informations, l’argument de capacité.

04:10.850 --> 04:16.640
Mais comme nous ne l'utilisons qu'une fois, en fait, lorsque nous créons de la mémoire et non plus

04:16.640 --> 04:20.000
après, nous n'aurons pas besoin de spécifier l'argument de capacité.

04:20.030 --> 04:25.330
Nous pourrions le faire, mais nous entrerons directement le nombre de transitions que nous voulons que notre mémoire ait.

04:26.150 --> 04:32.390
Mais nous avons besoin d’un dernier argument, à savoir obtenir le paramètre dans le modèle de l’enseignant.

04:32.480 --> 04:35.470
Rappelez-vous que ce paramètre gamma est le délai.

04:35.750 --> 04:41.300
Et c’est un paramètre de l’équation et nous allons donc le mettre ici car nous l’utiliserons

04:41.510 --> 04:42.920
ensuite plusieurs fois.

04:43.160 --> 04:44.990
Alors mettons-le ici.

04:45.070 --> 04:47.140
Nous allons l'appeler Gamma.

04:47.150 --> 04:52.610
Donc, pour cela, il ne s'agit que du nom de l'argument, puis nous allons inclure tous les arguments dont vous aurez besoin pour

04:52.610 --> 04:53.740
cela dans sa fonction.

04:53.750 --> 05:00.320
Cela signifie donc que chaque fois que nous créons notre modèle de dictionnaire, c’est chaque fois que nous créons un objet de

05:00.320 --> 05:01.390
l’enseignant en classe.

05:01.520 --> 05:08.060
Eh bien, nous devrons spécifier comme arguments la taille de l’entrée, le nombre d’actions et le paramètre.

05:08.360 --> 05:10.590
Et nous finirons avec les vraies valeurs pour eux.

05:11.210 --> 05:13.870
D'accord, allons maintenant dans la fonction.

05:14.100 --> 05:14.400
D'ACCORD.

05:14.410 --> 05:16.480
Donc, au fond, cela va être facile.

05:16.510 --> 05:21.090
Nous sommes sur le point de créer et d’initialiser toutes les variables dont nous avons besoin.

05:21.110 --> 05:22.770
Et alors commençons par le premier.

05:22.910 --> 05:24.460
Commençons par le gamma.

05:24.530 --> 05:26.090
En fait, le coefficient de retard.

05:26.330 --> 05:31.850
Donc, puisqu'il s'agit d'un voïvode qui veut être attaché à son objet, nous commençons par soi-même.

05:31.880 --> 05:39.500
Ainsi, le gamma va être une variable de notre professeur et un modèle lui-même qui équivaut aux arguments qui seront entrés lors de

05:39.530 --> 05:42.930
la création d'un objet de la classe de désaccord.

05:42.950 --> 05:46.900
Alors Janna et là nous allons avec le deuxième argument.

05:47.040 --> 05:50.560
Le deuxième argument va être la fenêtre de récompense.

05:50.840 --> 05:52.340
Alors, quelle est cette fenêtre.

05:52.520 --> 05:57.950
Eh bien, ce sera la fenêtre glissante de la moyenne des 100 derniers mots que vous utiliserez

05:58.010 --> 06:04.280
simplement pour évaluer l’évolution de la performance qui, comme vous le savez, aura la signification du mot dans cette guerre

06:04.280 --> 06:06.320
Windu qui glissera avec le temps.

06:06.440 --> 06:11.680
Et ce que nous voulons observer, c’est la signification des 100 derniers mots qui augmente avec le temps.

06:11.930 --> 06:18.610
Donc initialisons-le avec la fenêtre de soulignement de la récompense auto.

06:18.710 --> 06:24.690
Et puis, puisque cela va être une fenêtre glissante de l'évolution de la moyenne des 100 derniers mots.

06:24.860 --> 06:31.710
Eh bien, nous allons l’initialiser sous forme de liste vide, puis nous élargirons pour indiquer que nous travaillons des heures supplémentaires.

06:32.860 --> 06:35.320
Très bien alors plus excitant.

06:35.420 --> 06:37.430
Créons notre réseau de neurones.

06:37.580 --> 06:43.780
Nous allons donc appeler cela un Mario autodidacte, car au fond, c'est le cœur des modèles.

06:43.790 --> 06:51.890
Je l'appelle modèle et ce modèle ne sera rien d'autre qu'un sujet de cette classe et permettra de créer

06:51.890 --> 06:53.270
un tel objet.

06:53.300 --> 07:02.630
Nous prenons notre réseau de classes entre parenthèses et ici nous venons de mettre les arguments de la classe mais nous plaçons ces arguments dans

07:02.750 --> 07:08.930
les arguments de la fonction init et par conséquent nous avons juste besoin de les copier

07:08.930 --> 07:15.290
ici et de les coller dans la classe réseau puis nous aller avec cette ligne de code.

07:15.350 --> 07:22.690
Nous créons un réseau de neurones pour un modèle d’apprentissage parfait, puis créons une mémoire.

07:22.880 --> 07:29.930
Encore une fois, nous allons créer un nouveau Vargo que nous appelons mémoire autodidacte.

07:29.930 --> 07:34.190
Et encore une fois, cela va être un objet de la classe de mémoire de rejeu.

07:34.220 --> 07:42.320
Alors prenons simplement le nom ou la classe, copions encore, mais faisons face ici et entre parenthèses, nous devons définir la capacité,

07:42.320 --> 07:48.680
car la capacité est un argument de la fonction et c'est le seul argument dont nous

07:48.680 --> 07:49.880
avons besoin ici.

07:50.240 --> 07:55.100
Alors, quelle capacité allons-nous choisir? Rappelez-vous que cela correspond au nombre de transitions

07:55.100 --> 07:59.800
au nombre d'événements passés, indiquez la dernière action et le dernier mot.

07:59.830 --> 08:07.550
Et ainsi, comme mentionné dans l’un des travaux du Priester, nous allons prendre cent mille cent mille transitions en

08:07.550 --> 08:14.390
mémoire, puis nous allons échantillonner à partir de cette mémoire pour obtenir un petit nombre de

08:14.390 --> 08:18.670
transitions aléatoires et celle sur laquelle le modèle ira.

08:18.720 --> 08:21.210
Alors maintenant, nous avons notre mémoire parfaite.

08:21.210 --> 08:23.180
Maintenant, obtenons notre optimiseur.

08:23.430 --> 08:31.800
Encore une fois, nous créons une nouvelle variable que nous appelons optimiseur. Ainsi, l’optimiseur est une autre variable de notre future

08:31.800 --> 08:35.320
retrait de la file d’objets que cet optimiseur.

08:35.520 --> 08:44.130
Et maintenant, si nous remontons en arrière, vous pouvez voir que nous avons importé Upton torturé, une torche modulaire contenant tous les outils à

08:44.160 --> 08:47.080
utiliser pour placer la grille au centre.

08:47.130 --> 08:54.260
Donc, bien sûr, il contient des optimiseurs et nous lui avons donné le raccourci Upton. Nous allons donc

08:54.270 --> 09:00.900
lui présenter le modèle, qui est la torche qui lui revient et à partir de ce module,

09:00.900 --> 09:03.060
nous allons prendre un optimiseurs.

09:03.180 --> 09:05.670
Comme vous pouvez le voir, ils sont tous énumérés ici.

09:05.880 --> 09:10.630
Bon nombre d'entre eux sont excellents, par exemple Armor's Propp est un excellent optimiseur.

09:10.640 --> 09:16.170
Il est par exemple fortement recommandé d’enregistrer les réseaux de neurones ou l’apprentissage en profondeur non supervisé.

09:16.230 --> 09:22.140
Mais l’autre excellent et qu’il choisira est l’optimiseur d’atomes.

09:22.500 --> 09:26.400
C'est celle que vous verrez avec celle-ci qui vous donnera une bonne voiture autonome.

09:26.580 --> 09:32.000
Mais encore une fois, vous êtes totalement le bienvenu pour essayer d’autres, vous pouvez essayer l’appui-bras mais pour le métal, nous

09:32.000 --> 09:32.810
choisirons Adam.

09:32.850 --> 09:34.290
Alors j'appuie sur entrer.

09:34.560 --> 09:37.240
Et en fait, vous remarquerez qu'il y a la capitale ici.

09:37.260 --> 09:40.430
C'est parce que nous créons un objet de la classe Atom.

09:40.430 --> 09:44.990
C'est une classe mais l'objet sera un optimiseur d'atomes lui-même.

09:45.060 --> 09:50.970
Mais comme il s’agit d’une classe, nous devons définir quelques arguments. Les arguments de la classe Atom et

09:51.060 --> 09:55.270
ceux-ci sont tous les paramètres permettant de personnaliser votre et votre optimiseur.

09:55.380 --> 10:00.330
Ainsi, par exemple, il s’agit généralement du taux d’apprentissage de la décroissance ou de certains autres paramètres.

10:00.510 --> 10:05.690
Et en plus de prendre tous les paramètres d’Ormeau, nous spécifierons un taux d’apprentissage.

10:05.970 --> 10:08.650
C'est donc le début des paramètres de notre modèle.

10:08.670 --> 10:12.830
Nous pouvons les obtenir avec le modèle de doute de soi.

10:12.870 --> 10:17.530
Voilà donc le modèle que nous avons créé ici, modèle autodidacte de notre propre classe.

10:17.580 --> 10:24.780
Donc modèle autodidacte, puis pour accéder aux paramètres du modèle, nous ajoutons un autre point, puis des

10:25.500 --> 10:28.170
paramètres avec des parenthèses très simplement.

10:28.170 --> 10:35.860
Il s’agit donc simplement de connecter l’optimiseur d’addon à notre réseau de neurones, celui que nous avons créé ici à nouveau. Comme

10:35.880 --> 10:42.810
nous venons de le dire, nous allons ajouter un taux d’apprentissage et l’argument de ce principe est le nôtre.

10:43.170 --> 10:50.540
Et nous allons lui attribuer une valeur telle que l'apprentissage ne se produise pas trop rapidement si nous obtenons

10:50.540 --> 10:53.910
un taux d'apprentissage trop élevé, l'IA apprendra correctement.

10:53.910 --> 10:58.890
Nous voulons donner à l'IA un peu de temps pour explorer les leçons de ses erreurs.

10:58.890 --> 11:04.320
Vous savez quand nous punissons cela quand il commet des erreurs comme aller sur un sens ou s'approcher trop

11:04.320 --> 11:05.510
près d'un mur.

11:05.770 --> 11:08.780
Eh bien, nous voulons donner du temps pour apprendre.

11:08.880 --> 11:12.030
Nous voulons que le réseau de neurones soit correctement daté.

11:12.180 --> 11:21.010
Et donc, un bon rapport qualité-prix pour le taux d'apprentissage auquel j'ai abouti après avoir essayé plusieurs d'entre eux est 0. 2 ou un.

11:21.210 --> 11:24.540
Très bien et c'est tout ce dont nous avons besoin pour créer un optimiseur.

11:24.720 --> 11:28.320
Donc, fondamentalement, vous créez un objet de la classe Atom.

11:28.530 --> 11:29.050
Génial.

11:29.070 --> 11:35.980
Et puis les trois dernières variables dont nous avons besoin sont les variables composant nos événements de transition.

11:36.150 --> 11:40.130
Donc, c'est la dernière date la dernière action et le dernier mot.

11:40.170 --> 11:45.280
Et donc, c’est essentiellement ce que nous allons créer maintenant et nous aurons juste besoin de les initialiser.

11:45.300 --> 11:50.130
Commençons donc par la dernière date, la dernière date que nous appellerons autodidacte.

11:50.400 --> 11:56.000
Dernier état de soulignement et comment allez-vous l’initialiser?

11:56.190 --> 12:03.840
Souvenez-vous bien que la dernière date est un vecteur de 5 dominations, un vecteur codé dans un état

12:03.840 --> 12:04.700
de l'environnement.

12:04.950 --> 12:10.800
Et pour rappel, ces cinq dimensions sont les trois signaux des trois capteurs laissés

12:10.800 --> 12:15.180
droits et à droite ainsi que l’orientation et l’orientation moins.

12:15.210 --> 12:18.350
Donc, ceci est un vecteur et un sens intuitif.

12:18.420 --> 12:21.060
Mais pour le flambeau, il doit être plus qu'un vecteur.

12:21.210 --> 12:23.640
En réalité, il doit s'agir d'un tenseur de torche.

12:23.820 --> 12:29.970
Mais non seulement il doit s'agir d'un capteur de torche, mais il doit également comporter une autre dimension

12:29.970 --> 12:33.510
que j'aime appeler une fausse dimension correspondant au lot.

12:33.630 --> 12:39.810
Et c’est parce que les huit derniers seront l’entrée du réseau de neurones mais lorsqu’on travaille avec moi quand cela fonctionne en

12:39.810 --> 12:46.220
général, que ce soit avec un flux plus dense, on porte une torche alors que les vecteurs d’entrée ne peuvent pas être

12:46.290 --> 12:48.040
un simple vecteur en soi.

12:48.210 --> 12:49.760
Il doit être dans un lot.

12:49.830 --> 12:57.660
Le réseau ne peut accepter qu'un lot d'observations d'entrée et crée donc non seulement un tenseur pour

12:57.870 --> 13:05.140
les vecteurs d'état d'entrée, mais nous allons également créer cette fausse dimension correspondant au lot.

13:05.190 --> 13:11.490
Faisons ceci et commençons par initialiser un tenseur de torche pour faire cela, rien de

13:11.490 --> 13:12.340
plus simple.

13:12.510 --> 13:21.810
Nous prenons notre bibliothèque de torches puis point, puis nous allons utiliser la classe tenseur car, comme vous l’auriez peut-être deviné,

13:21.810 --> 13:27.950
cela créera un objet de la classe tenseur qui est un objet tenseur.

13:28.120 --> 13:34.660
Et dans ce tenseur, nous devons mettre un argument qui spécifiera la taille du tenseur.

13:34.660 --> 13:38.720
Vous pouvez imaginer que cela vous prend comme un tableau ayant un seul type.

13:38.890 --> 13:45.430
Mais fondamentalement, ce que cela va représenter maintenant est bien sûr cet état d'entrée que vous pouvez voir avec un vecteur et donc

13:46.180 --> 13:49.380
pour spécifier le nombre d'éléments que la distance doit avoir.

13:49.570 --> 13:55.180
Nous devons bien sûr utiliser la taille d’entrée car celle-ci correspond exactement au nombre de dimensions

13:55.510 --> 13:57.520
de nos vecteurs d’état d’entrée.

13:57.520 --> 13:59.050
Maintenant je devrais dire des tenseurs.

13:59.170 --> 14:05.650
Et c’est ce que nous devons simplement entrer dans notre classe de tenseurs pour créer un objet tensor.

14:06.010 --> 14:07.260
Eh bien c'est imprécis.

14:07.540 --> 14:10.230
Et plus tard, la taille de l'entrée sera quantifiée.

14:11.350 --> 14:12.430
D'accord c'est bon.

14:12.430 --> 14:13.670
C'est la première chose faite.

14:13.720 --> 14:17.390
Nous venons d'initialiser le tenseur comme il se doit.

14:17.530 --> 14:23.080
Mais rappelez-vous que nous devons faire autre chose: créer cette fausse dimension, car c’est ce

14:23.080 --> 14:30.070
à quoi le réseau s’attend pour ses entrées et créer celle-ci pour examen qui, en passant, doit être le premier moteur

14:30.070 --> 14:35.840
à connaître les dommages que vous subissez. mis dans le lot sera la première fois que je

14:35.940 --> 14:37.800
mentionne cela disons très bien.

14:38.230 --> 14:46.050
Eh bien, pour ce faire, nous devons simplement ajouter cela, puis presser, puis entre parenthèses.

14:46.050 --> 14:49.580
Nous devons mettre l’indice de cette grande dimension.

14:49.620 --> 14:55.790
Et comme je viens de le dire, cette fausse dimension doit être la première animation de la dernière date et, depuis

14:55.790 --> 15:02.460
les index et les octets et le zéro commencé, nous devons saisir zéro pour que ce nouveau moteur de paradigme devienne le premier

15:02.460 --> 15:03.570
moteur de ligne.

15:03.570 --> 15:09.360
Nous avons donc un premier moteur temporel correspondant au lot, puis le losange devrait répondre

15:09.360 --> 15:15.960
à ce capteur qui contiendra les cinq éléments de vos états d'entrée, l'orientation des trois signaux et

15:15.990 --> 15:16.910
l'orientation moins.

15:17.370 --> 15:21.960
Et ensuite nous allons initialiser correctement nos états d’entrée.

15:21.960 --> 15:22.850
Parfait.

15:23.310 --> 15:30.840
Et puis deux variables à parcourir et cela sera beaucoup plus facile car la variable suivante est la dernière

15:31.110 --> 15:31.850
action.

15:32.190 --> 15:36.340
C’est un nouveau Roybal que nous créons pour la dernière action de Object.

15:36.510 --> 15:43.440
Et rappelez-vous que dans le premier tutoriel de la section, je vous ai dit que les actions vont

15:43.440 --> 15:52.470
être soit 0 1 ou 2, puis en utilisant le vecteur de rotation des actions, nous allons convertir ces index de ces actions en

15:52.470 --> 15:58.010
angles de rotation que je rappelle à notre 0 20 ou moins 20.

15:58.050 --> 16:00.980
Nous pouvons réellement rafraîchir notre mémoire avec cela.

16:01.200 --> 16:03.170
Eh bien c'est exactement ici.

16:03.170 --> 16:06.260
Action en rotation si l'action est zéro.

16:06.390 --> 16:11.650
Cela correspondra au premier indice de zéro si l’action est 1.

16:11.700 --> 16:17.310
Cela correspond à l'index un de ces vecteurs de 20 degrés et si l'action est

16:17.310 --> 16:23.490
à nous aurons moins 20 degrés, ce sera l'angle de rotation de notre voiture lorsque nous jouerons l'action.

16:23.510 --> 16:24.200
D'accord.

16:24.380 --> 16:31.040
Et donc puisque l'action va être soit 0 1 ou 2 bien l'action est là pour un nombre

16:31.040 --> 16:31.740
simple.

16:31.850 --> 16:35.440
Et très simplement, nous pouvons l’initialiser à zéro.

16:35.660 --> 16:38.330
Nous n'avons pas besoin de créer des dizaines ou d'entendre autre chose.

16:38.360 --> 16:40.880
Nous avons juste besoin de l'initialiser avec zéro.

16:41.420 --> 16:42.850
Et enfin.

16:43.010 --> 16:44.460
Eh bien c'est le dernier mot.

16:44.550 --> 16:48.840
C'est le soi qui est le dernier mot.

16:48.860 --> 16:49.940
Nous y voilà.

16:49.940 --> 16:56.510
Et encore une fois, le mot est un nombre flottant que je rappelle entre moins 1 et plus 1.

16:56.510 --> 16:57.790
Donc, c'est encore le numéro.

16:57.860 --> 16:59.400
Et comme pour l'action.

16:59.510 --> 17:02.900
Nous allons l'initialiser à zéro et ensuite nous irons.

17:02.900 --> 17:06.330
Félicitations sont dans sa fonction est prête.

17:06.350 --> 17:08.930
Alors maintenant, nous sommes prêts à passer aux choses excitantes.

17:08.930 --> 17:16.040
Et en réalité, la chose la plus importante pour l'IA est de décider quelle action jouer à chaque fois et à

17:16.080 --> 17:23.240
chaque jeu. Et c'est exactement ce que nous allons faire dans le prochain tutoriel en créant la méthode de sélection de l'action.

17:23.510 --> 17:27.310
Alors faisons ceci dans le prochain travail et jusque-là I.
