WEBVTT

00:00.420 --> 00:04.730
Bonjour et bienvenue à la toute dernière étape de cette première partie.

00:04.860 --> 00:10.500
Maintenant, la seule chose qui nous reste à faire est de faire de cette fonction la fonction Ford

00:10.500 --> 00:16.650
qui propagera le signal dès le début, lorsque le cerveau produira l’image à la toute fin lorsque je placerai l’action

00:16.650 --> 00:22.260
afin que nous puissions le faire. toute notre fonction et ce sera notre dernière étape avant que

00:22.260 --> 00:26.710
nous passions à la formation de notre IA avec un kulang convolutionnel profond.

00:26.890 --> 00:28.080
Alors faisons ceci.

00:28.080 --> 00:34.470
Nous allons prendre l'appel de fonction qui est en fait similaire à la fonction init, c'est-à-dire qu'il s'agit

00:34.470 --> 00:38.760
d'une fonction existante, mais cette fois-ci, nous l'utilisons pour appeler d'autres fonctions.

00:38.790 --> 00:43.170
Celles que nous avons faites auparavant parce que vous savez que nous allons utiliser la fonction avant

00:43.290 --> 00:45.490
du cerveau et la fonction port du corps.

00:45.630 --> 00:50.270
Et donc nous utilisons cette fonction maintenant pour appeler essentiellement ces fonctions.

00:50.550 --> 00:53.160
Donc, appel va prendre deux arguments.

00:53.160 --> 00:54.330
Le premier est soi.

00:54.330 --> 01:00.220
Bien sûr, l'objet et le deuxième argument qui, selon vous, vont être.

01:00.360 --> 01:02.910
Eh bien, nous faisons toute la propagation cette fois-ci.

01:02.910 --> 01:08.460
Donc, ce que nous voulons prendre comme entrée, ce sont bien sûr les images d’entrée, car c’est bien sûr

01:08.460 --> 01:10.860
le point de départ lorsque l’intelligence artificielle joue.

01:10.860 --> 01:16.080
Il s'agit d'abord de visualiser les images du jeu, puis de propager les signaux dans le cerveau, puis

01:16.080 --> 01:17.180
de jouer l'action.

01:17.190 --> 01:20.130
Par conséquent, le deuxième argument va être des entrées.

01:20.610 --> 01:24.740
Et maintenant nous sommes prêts à faire toute cette propagation.

01:24.810 --> 01:26.220
Alors faisons cela à nouveau.

01:26.220 --> 01:31.900
La première étape consiste donc à recevoir les images d'entrée du jeu.

01:32.190 --> 01:38.010
Et puisque ces images vont entrer dans le réseau de neurones, vous pouvez imaginer que nous devons les formater

01:38.010 --> 01:42.840
dans une structure spéciale et que la structure est bien sûr une structure de torche.

01:42.840 --> 01:48.420
La première chose à faire est donc de convertir ces images en un tableau d’arbitres, puis de

01:48.420 --> 01:55.320
les convertir en un tenseur de torche, puis de placer le tenseur de la torche dans une variable de torche contenant

01:55.500 --> 01:58.260
à la fois le tenseur et le gradient.

01:58.350 --> 02:03.780
C’est pour que nos graphiques dynamiques calculent très efficacement les gradients plus tard plus vite Kattie très bien dans

02:03.780 --> 02:04.460
le sens.

02:04.620 --> 02:06.200
C'est donc notre premier pas.

02:06.270 --> 02:12.130
Et puis, une fois que nous aurons le bon format de nos images, ils pourront entrer dans le réseau de

02:12.360 --> 02:16.320
neurones et c’est alors que nous ferons toute la propagation des signaux.

02:16.380 --> 02:20.340
Commençons donc par convertir l'image au bon format.

02:20.430 --> 02:23.050
Donc, nos images sont tellement pour les entrées.

02:23.220 --> 02:26.780
Maintenant, nous allons créer une nouvelle variable que j'appelle entrée.

02:26.820 --> 02:30.470
Voilà donc la véritable entrée du réseau de neurones et cette entrée.

02:30.510 --> 02:31.760
Où ça va être.

02:31.920 --> 02:34.490
Eh bien, nous devons d’abord prendre nos intrants.

02:34.530 --> 02:36.650
Ce sont nos images originales.

02:36.870 --> 02:42.190
Ensuite, comme nous l’avons dit, nous voulons convertir ces images en matrices Nampa.

02:42.330 --> 02:49.260
Donc, pour ce faire, nous pouvons simplement en prendre aucun, qui comporte un raccourci, puis le tableau de fonctions.

02:49.500 --> 02:52.850
Nous avons donc mis entre parenthèses le tableau de fonctions.

02:52.890 --> 02:53.340
Nous y voilà.

02:53.340 --> 02:55.940
Maintenant, il est converti en quelque chose et par des tableaux.

02:56.190 --> 03:02.790
Mais comme les cellules des tableaux du pavé numérique contiennent les pixels, il est en fait plus sûr de

03:02.790 --> 03:04.230
spécifier le type float.

03:04.310 --> 03:11.040
Il vaut mieux s’assurer que nous avons des flotteurs maintenant pour pouvoir utiliser ce flotteur.

03:11.090 --> 03:12.690
Désolé d'entendre.

03:12.720 --> 03:15.390
D'accord, nous avons toujours un arbitre.

03:15.540 --> 03:17.330
Mais avec la tablette.

03:17.720 --> 03:24.150
Très bien, et c’est aussi une autre raison pour laquelle les tenseurs sont par définition des tableaux d’un seul type.

03:24.270 --> 03:28.060
Nous avons donc choisi le type simple comme étant un flotteur 32.

03:28.060 --> 03:28.350
D'accord.

03:28.350 --> 03:34.440
Maintenant que nous avons notre relance non bio, l'étape suivante consiste à convertir cela en capteur de tortue.

03:34.440 --> 03:37.990
Pour ce faire, nous pouvons utiliser par exemple une torche.

03:38.070 --> 03:45.380
Et puis de souligner la fonction non-pilote qui va convertir cela en un capteur de torche.

03:45.420 --> 03:46.200
Nous y voilà.

03:46.210 --> 03:52.320
Et maintenant, la dernière étape consiste à placer ces capteurs dans une variable contenant à la fois le tenseur

03:52.320 --> 03:53.230
et l'accord.

03:53.400 --> 04:02.010
Et vous savez comment le faire, bien sûr, nous prenons notre classe de variables car en réalité tout ce qui est à l’intérieur de cette

04:02.010 --> 04:05.530
variable est en fait l’entrée de la classe de variables.

04:05.760 --> 04:11.400
Mais je voulais vous le montrer de cette façon parce que vous savez que nous commençons par nos images

04:11.400 --> 04:15.890
d'entrée, puis que nous les convertissons en tableaux numérotés, puis en torpeurs et ensuite demain.

04:16.170 --> 04:17.220
Et maintenant on va bien.

04:17.220 --> 04:23.370
Ils sont autorisés à entrer dans le réseau neuronal qui est d'abord les yeux de l'œil, puis les

04:23.370 --> 04:25.770
couches entièrement connectées pour mener aux prédictions.

04:26.220 --> 04:30.340
Donc, en parlant des yeux, c’est exactement ce que nous allons faire maintenant.

04:30.480 --> 04:37.280
Nous allons maintenant propager ces images autorisées dans les yeux à travers les trois couches

04:37.290 --> 04:38.720
de convolution.

04:38.850 --> 04:41.620
Et pour faire cela, vous allez voir maintenant à quel point c'est si simple.

04:41.640 --> 04:46.290
C'est parce que nous avons déjà notre cerveau dans notre corps à partir de la fonction init.

04:46.320 --> 04:56.190
Nous avons simplement besoin de prendre notre cerveau en charge et d'appliquer ce cerveau aux images d'entrée, ce qui propagera les choses

04:56.190 --> 04:59.830
à la fonction alimentaire à partir du cerveau.

05:00.430 --> 05:06.190
Cela va propager les signaux à l'intérieur du cerveau et puisque la fonction avant du cerveau

05:06.520 --> 05:13.600
renvoie les signaux de sortie que les neurones de la couche de sortie contenant les valeurs Q Eh bien, cette

05:13.610 --> 05:19.030
entrée du cerveau ici retournera ce signal de sortie et nous allons donc mettre

05:19.090 --> 05:26.120
Ici, qu’il soit converti en variable et que nous l’appelions très simplement, cette sortie est le signal de sortie du

05:26.120 --> 05:26.690
cerveau.

05:26.930 --> 05:31.970
Et maintenant que nous avons le signal de sortie du cerveau, nous devons propager ce signal

05:31.970 --> 05:37.990
de sortie au corps. Pour ce faire, nous allons utiliser la deuxième fonction de transfert du corps et le faire.

05:38.030 --> 05:46.370
Nous devons simplement prendre notre corps et l’appliquer bien sûr à la sortie car la fonction Ford du corps

05:46.370 --> 05:50.600
prend en entrée les signaux de sortie du cerveau.

05:50.660 --> 05:55.880
Donc, c'est exactement ce que la sortie est en ce moment et retourne les actions.

05:56.000 --> 05:58.080
Et donc depuis il retourne les actions.

05:58.380 --> 06:03.530
Eh bien, ici, nous allons ajouter des actions pour générer ce même résultat.

06:03.920 --> 06:09.380
Bon, maintenant vous pouvez voir que très simplement, nous avons propagé les signaux à l'intérieur du cerveau,

06:09.380 --> 06:15.410
puis du cerveau au tout-premier en utilisant la fonction de forme du cerveau qui nous prend et met les

06:15.410 --> 06:19.830
images d'entrée puis les propage dans le cerveau pour conserver les valeurs clés.

06:20.240 --> 06:25.400
Et ensuite, nous propagons ce signal de sortie dans le corps où la fonction avant de notre corps

06:25.520 --> 06:26.900
obtient l'action à jouer.

06:26.900 --> 06:32.300
Et maintenant, il ne nous reste plus qu’à faire, c’est la toute dernière ligne de code de

06:32.300 --> 06:34.510
cette première partie qui construit le.

06:34.760 --> 06:39.370
Nous devons retourner l'action à jouer et ce sont des actions.

06:39.530 --> 06:45.020
Cependant, pour le moment, les actions doivent coder en format et nous devons les reconvertir de plein

06:45.260 --> 06:51.660
droit. Pour ce faire, nous allons prendre la structure de données de ces actions, puis ajouter ici la fonction

06:51.890 --> 06:53.840
non pilote, puis nous poursuivons.

06:53.840 --> 06:56.780
Maintenant, nous avons les actions que nous avons tournées dans le bon format.

06:56.780 --> 06:58.040
Alors félicitations.

06:58.040 --> 07:00.660
Nous avons maintenant terminé avec cette première partie 1.

07:00.770 --> 07:03.410
Nous construisons l'IA en trois étapes.

07:03.410 --> 07:06.860
Nous avons d'abord créé le cerveau, puis le corps.

07:06.860 --> 07:13.430
Et troisièmement, nous assemblons le cerveau dans le corps et nous avons propagé l’ensemble du signal des yeux au moment

07:13.430 --> 07:15.130
où nous jouons l’action.

07:15.560 --> 07:17.100
C'est donc un premier pas fait.

07:17.120 --> 07:22.200
C’était un grand pas en avant, mais comme vous l'avez compris, nous avons construit une AI, mais c'est toujours stupide.

07:22.220 --> 07:24.110
Nous devons le former pour être intelligent.

07:24.170 --> 07:29.030
Nous devons donc le former pour faire ce que nous voulions faire. Pour ce faire, nous allons

07:29.030 --> 07:34.100
utiliser le terme «environnement contraint», car il faut apprendre du monde en le renforçant lorsqu'il obtient une bonne

07:34.100 --> 07:34.690
récompense.

07:34.760 --> 07:40.610
Et en étant puni ou affaibli quand il reçoit un mauvais mot, c’est là que l’apprentissage de la mémoire va

07:40.610 --> 07:41.670
entrer en jeu.

07:41.690 --> 07:47.510
Et c’est donc exactement ce que nous ferons dans cette partie pour s’entraîner dans les yeux avec un apprentissage Q convolutionnel profond.

07:47.510 --> 07:50.270
J'ai hâte de commencer et jusque-là.
