WEBVTT

00:00.420 --> 00:06.440
Bonjour et bienvenue à la dernière étape de notre processus pour rendre le cerveau, nous avons une fonction à faire à gauche.

00:06.450 --> 00:12.180
Il s’agit de la fonction directe qui propagera les signaux dans toutes les couches du réseau neuronal, y

00:12.510 --> 00:16.180
compris les trois couches de convolution et la couche entièrement connectée.

00:16.380 --> 00:21.660
Et donc cette fonction est la fonction directe exactement comme pour la voiture autonome, sauf

00:21.780 --> 00:27.440
que cette fois nous devons propager les signaux dans les couches convolutives avant la couche entièrement connectée.

00:27.660 --> 00:32.610
Et la bonne nouvelle est que nous l’avions déjà fait à l’étape précédente avec la fonction de comptage Newnes.

00:32.640 --> 00:37.160
Nous avons donc déjà le code pour propager le signal dans le pays.

00:37.340 --> 00:38.940
Et donc ce sera très rapide.

00:38.950 --> 00:43.950
Nous allons simplement combiner ce que nous avons fait ici et ce que nous avons fait pour la voiture sous-marine et nous

00:43.950 --> 00:45.720
aurons notre fonction avancée pour notre cerveau.

00:45.780 --> 00:46.860
Alors faisons ceci.

00:46.860 --> 00:54.660
Nous introduisons ici une nouvelle fonction, la dernière pour le cerveau et cette fonction est la fonction avant

00:55.170 --> 00:56.940
qui prend un argument.

00:57.160 --> 01:05.400
Eh bien, exactement comme avant, faites référence aux objets et à X, qui seront d’abord les images d’entrée, puis vous saurez que X sera

01:05.400 --> 01:10.280
mis à jour à mesure que le signal se propage dans le nouveau réseau.

01:10.650 --> 01:11.460
D'accord.

01:11.460 --> 01:14.350
Alors Cullen et ensuite allons dans la fonction.

01:14.370 --> 01:20.500
Donc, comme je viens de le dire, nous avons déjà créé le code pour propager les signaux dans les trois couches de convolution.

01:20.580 --> 01:23.440
C'est exactement ces trois lignes de code.

01:23.640 --> 01:29.040
Je les copie donc et les colle ici et là.

01:29.040 --> 01:34.430
Nous avons déjà notre propagation du signal dans les trois couches de convolution.

01:34.520 --> 01:40.830
Et maintenant, nous devons juste propager le signal des couches convolutives vers la

01:40.830 --> 01:46.680
couche cachée, puis finalement vers la couche de sortie qui se trouve

01:46.680 --> 01:53.520
à la toute fin du réseau neuronal. obtenu ici, rappelez-vous que X est au début

01:53.520 --> 01:54.610
l'image d'entrée.

01:54.720 --> 02:00.780
Alors ici, X devient la première couche convolutive, alors X devient la deuxième convolutive.

02:00.930 --> 02:03.840
Et puis ici X devient la troisième convolution ici.

02:03.960 --> 02:07.730
Donc, à ce stade, X est la troisième couche convolutive.

02:07.860 --> 02:15.000
Et maintenant, pour prendre l’aplatissement, nous devons aplatir cette troisième couche convolutive X et, pour ce faire, nous allons faire quelque chose de très

02:15.070 --> 02:20.220
similaire à ce que nous avons fait ici, mais cette fois, nous n’avons pas besoin du nombre

02:20.220 --> 02:25.090
de neurones dont nous avons simplement besoin pour aplatir canaux dans la troisième convolution ici.

02:25.140 --> 02:28.130
Ce sera donc plus simple mais très similaire.

02:28.410 --> 02:35.570
Et pour bien le faire, nous allons reprendre X car X va devenir la couche d'aplatissement.

02:35.890 --> 02:43.990
Nous ne faisons que mettre à jour X pour que x soit égal, puis nous reprenons X mais ce X est l'ancien X qui est la troisième couche

02:43.990 --> 02:44.480
convolutive.

02:44.550 --> 02:51.510
Donc nous prenons la troisième convolution alors, mais ensuite nous prenons la fonction de vue à laquelle nous appliquons

02:51.510 --> 02:52.460
les arguments

02:52.530 --> 02:55.730
Le premier est X cette taille zéro.

02:56.100 --> 03:01.800
Alors encore une fois nous prenons la fonction de taille pour prendre tous les pixels de tous les canaux et de

03:01.800 --> 03:07.320
la troisième couche convolutive et nous les plaçons les uns après les autres dans cet énorme vecteur qui va devenir

03:07.320 --> 03:11.280
ce X ici et ce X deviendra alors l'entrée de le réseau entièrement connecté.

03:11.460 --> 03:12.860
Mais ce n'est pas tout ce dont nous avons besoin.

03:13.080 --> 03:14.530
Et voici venir.

03:14.650 --> 03:15.990
Et moins un.

03:16.200 --> 03:19.170
Donc, cette astuce que vous pouvez trouver dans les tutoriels montre de poche.

03:19.350 --> 03:25.130
C'est ainsi que vous pouvez aplatir une convolution, ils sont composés de plusieurs canaux en utilisant la fonction de taille.

03:25.200 --> 03:29.890
Et bien sûr, si vous voulez plus de détails sur la façon dont cela fonctionne, vous pouvez aller aux tutoriels sur les montres de poche.

03:30.030 --> 03:31.410
Je vais fournir le lien.

03:31.800 --> 03:38.250
Nous savons maintenant que cet aplatissement va devenir l’entrée d’un réseau classique

03:38.580 --> 03:43.800
entièrement connecté avec une simple transmission linéaire du signal.

03:43.830 --> 03:49.440
Et donc maintenant nous n'allons pas utiliser une fonction de convolution pour transmettre le signal, nous

03:49.440 --> 03:54.720
allons utiliser une transmission linéaire avec une classe linéaire, puis casser la linéarité car lorsque

03:54.780 --> 03:57.670
nous travaillons avec des images relations linéaires.

03:57.900 --> 04:03.360
Nous allons utiliser une fonction rectifiable pour apprendre ces relations non linéaires.

04:03.510 --> 04:04.560
Alors faisons ceci.

04:04.560 --> 04:06.160
C'est en fait la prochaine étape.

04:06.210 --> 04:09.320
Et maintenant, c'est exactement ce que nous avons fait pour la voiture autonome.

04:09.360 --> 04:15.030
Nous prenons X parce que nous voulons le mettre à jour à nouveau, nous voulons obtenir la couche cachée maintenant.

04:15.100 --> 04:20.970
Et donc tout d’abord, ce que nous faisons est que nous prenions notre connexion complète SE1 parce que la connexion complète.

04:20.970 --> 04:27.030
Le FC 1 est celui qui relie la couche d’aplatissement au caché là-bas et nous devons donc prendre

04:27.300 --> 04:32.850
SE1 et l’appliquer au X que nous avons en ce moment, qui est la crue.

04:33.000 --> 04:38.780
Et nous n'oublions pas le moi bien sûr car tout le monde est une variable de notre fonction init.

04:38.890 --> 04:45.510
Donc, autodidacte, SE1 X et qui transmet linéairement le signal du plus flatteur au caché.

04:45.690 --> 04:49.990
Mais maintenant, nous devons activer ces neurones tout en enfreignant la loi par erreur.

04:50.130 --> 04:53.480
Et c'est exactement ce que nous faisons avec la fonction d'activation du redresseur.

04:53.490 --> 05:00.990
Nous devons donc maintenant prendre notre module fonctionnel et, de ce module fonctionnel, nous prenons bien sûr une

05:01.140 --> 05:03.870
fonction rectifiable qui vous correspond réellement.

05:04.230 --> 05:08.130
Et nous avons mis SE1 autodidacte entre parenthèses.

05:08.220 --> 05:14.280
Très bien, dans cette ligne de code, nous transmettons d’abord les signaux de la couche d’aplatissement à

05:14.280 --> 05:17.210
la couche cachée du réseau entièrement connecté.

05:17.580 --> 05:23.970
Et puis nous activons les neurones de cette couche cachée en brisant l'air avec cette

05:23.970 --> 05:29.100
fonction d'activation du redresseur et nous y retrouvons notre tête parfaite.

05:29.130 --> 05:35.370
Et maintenant, nous avons une dernière étape à faire. Il est bien sûr de propager le signal de la couche

05:35.670 --> 05:39.680
cachée vers la couche de sortie avec les neurones de sortie finaux.

05:39.720 --> 05:41.160
Eh bien c'est très simple.

05:41.160 --> 05:43.680
C'est exactement ce que nous avons fait avec la voiture.

05:43.680 --> 05:51.720
Nous prenons notre deuxième collection complète de C2 et nous l'appliquons bien sûr aux neurones de la couche cachée

05:51.990 --> 05:53.700
qui est actuellement x.

05:53.740 --> 05:55.900
Voici donc les neurones ici et là.

05:56.040 --> 06:02.840
Tout cela x et x devient bien entendu les neurones de sortie de la couche de sortie contenant les valeurs de cube.

06:03.210 --> 06:10.070
Et finalement, nous renvoyons simplement les neurones de sortie qui sont x avec les valeurs de cube.

06:10.320 --> 06:11.240
Tellement parfait.

06:11.250 --> 06:16.950
Félicitations, nous venons de créer un cerveau Nous venons de fabriquer le cerveau de notre IA Les yeux et le reste

06:16.950 --> 06:17.740
des cellules.

06:17.790 --> 06:19.130
Alors félicitations.

06:19.140 --> 06:23.550
Il est maintenant temps de créer le corps qui définit comment nous allons jouer l'action.

06:23.550 --> 06:26.480
Après tous les signaux sont traités dans le cerveau.

06:26.690 --> 06:28.370
C'est donc notre deuxième grand pas.

06:28.380 --> 06:30.280
Faisons-le dans les prochains tutoriels.

06:30.300 --> 06:31.780
Et jusque-là AI.
