WEBVTT

00:00.530 --> 00:02.950
Bonjour et bienvenue dans ce tutoriel sur Python.

00:02.990 --> 00:08.520
La prochaine étape consiste donc à faire en sorte que les compteurs fonctionnent, ce qui nous donnera ce que nous voulons.

00:08.540 --> 00:14.130
C'est ce nombre de neurones dans cet énorme vecteur après l'application des convolutions.

00:14.300 --> 00:19.640
C'est la seule information manquante dont nous avons besoin pour le moment et nous allons l'obtenir avec la fonction.

00:19.700 --> 00:23.930
Faisons donc cette fonction que nous allons appeler elle compte.

00:24.280 --> 00:27.570
Et ces neurones de base très simplement.

00:27.830 --> 00:32.220
Et quelle est cette fonction compte neurones va prendre comme arguments.

00:32.510 --> 00:39.450
Eh bien, il va prendre l'objet lui-même, mais ensuite, il faudra autre chose, car le nombre de neurones

00:39.450 --> 00:44.540
de sortie dans la couche aplatie ne dépend en réalité que d'une chose.

00:44.660 --> 00:50.840
Cela dépend des dominations de l'image d'entrée d'origine, celle qui se situe au tout début du réseau

00:50.840 --> 00:51.930
de neurones.

00:52.160 --> 00:58.370
Ainsi, le seul argument dont nous avons besoin pour le moment est en réalité que le moment mentionne la synchronisation des images d'entrée.

00:58.370 --> 01:03.410
Donnons donc un nom à cet argument représentant le losange et l'image d'entrée.

01:03.520 --> 01:06.790
Et nous allons appeler cela une image.

01:07.220 --> 01:07.690
D'accord.

01:07.850 --> 01:14.720
Et je peux vous dire maintenant que les dimensions réelles des images d’entrée provenant de Dume vont

01:14.720 --> 01:16.850
être 80 x 80.

01:16.850 --> 01:23.330
Nous allons réduire la taille des images d'origine à 80 sur 80, ce qui constituera le

01:23.390 --> 01:26.270
format des images destinées au réseau neuronal.

01:26.270 --> 01:32.300
Donc, leur image va en réalité être un 80 80 et celui correspond au fait que nous travaillons avec des images

01:32.300 --> 01:33.750
en noir et blanc.

01:33.830 --> 01:41.040
C’est avec un seul canal, donc les images vont être corrélées au total 80 et 80.

01:41.280 --> 01:41.560
D'accord.

01:41.560 --> 01:43.590
C'est donc le seul argument dont nous avons besoin.

01:43.660 --> 01:45.670
Et maintenant, scrutons les neurones.

01:45.850 --> 01:47.280
Alors, comment vas-tu faire ça?

01:47.500 --> 01:51.110
Tout d’abord, nous n’avons actuellement aucune image en entrée.

01:51.250 --> 01:54.070
Nous n'avons aucune image catastrophique que nous puissions importer.

01:54.070 --> 01:55.330
Nous allons le faire plus tard.

01:55.540 --> 02:01.240
La première chose à faire est donc de créer une fausse image, mais cela a permis de créer des introns de 80 à 80.

02:01.240 --> 02:06.160
Nous allons créer cette fausse image avec de faux pixels et nous donnerons toujours le

02:06.160 --> 02:12.280
nombre que nous voulons, car ce nombre ne dépend que des dimensions et non des pixels contenus dans

02:12.280 --> 02:13.320
les images.

02:13.330 --> 02:15.640
Donc, cela crée simplement une fausse image pour commencer.

02:15.730 --> 02:18.520
Et ensuite, nous allons calculer le nombre de neurones que nous voulons.

02:18.520 --> 02:23.860
Donc, le truc pour créer une fausse image est bien, nous allons l'appeler x.

02:23.890 --> 02:30.700
Tout d'abord, nous allions utiliser la torche avec Rand parce que vous savez que nous allons insérer des pixels

02:30.700 --> 02:37.200
aléatoires dans ces images. Nous utilisons ces fonctions aléatoires à partir de torche, qui est la fonction rand.

02:37.250 --> 02:42.740
Ensuite, à l'intérieur, nous allons entrer car vous pouvez voir les damnations des images.

02:42.850 --> 02:44.400
C'est un 80 80.

02:44.560 --> 02:50.500
Mais puisque nous allons placer cette image dans le réseau de neurones et que vous vous en souvenez, le réseau de

02:50.500 --> 02:55.170
neurones ne peut accepter que des lots d’états d’entrée qui sont ici des lots d’images d’entrée.

02:55.370 --> 03:00.600
Nous allons créer ces faux diamants dans lesquels nous pouvons directement exécuter cette fonction d'exécution.

03:00.670 --> 03:05.720
En fait, nous commençons tout juste avec celui qui correspond au lot, puis

03:05.730 --> 03:11.070
nous pouvons simplement le placer tous les 188 correspondant aux dominations de l'image d'entrée.

03:11.110 --> 03:16.980
Et comme vous l'avez compris, ces désignations sont contenues dans cette image, l'argument qui représente

03:16.980 --> 03:19.330
ce tableau 1 80 80.

03:19.420 --> 03:23.290
Il suffit donc d’ajouter des images.

03:23.620 --> 03:29.410
Mais pour pouvoir passer les éléments de la table parce que vous savez maintenant, Image les est un double

03:29.410 --> 03:31.940
en tant que liste d'arguments d'une fonction.

03:32.020 --> 03:39.460
Nous devons ajouter ici avant l'image qu'il y a avant que Apple Store, le magasin lui permette de transmettre à Apple les

03:39.550 --> 03:44.100
éléments de l'image avec lui en tant que liste d'arguments pour la fonction.

03:44.170 --> 03:49.600
Et comme vous pouvez le voir, c’est exactement ce qui est spécifié ici avec le magasin et le diamant.

03:49.930 --> 03:56.640
Très bien, cela créera une image de faux pixels qui n'aura rien à voir avec les images.

03:56.800 --> 04:01.720
Mais encore une fois, nous serons toujours en mesure d’obtenir le nombre final de

04:01.720 --> 04:11.080
neurones et la dernière chose dont nous devons nous souvenir est de convertir ce vecteur d’entrée en une variable de la flamme, car cela ira dans

04:11.380 --> 04:13.060
le réseau de neurones.

04:13.060 --> 04:13.380
D'accord.

04:13.390 --> 04:20.650
Donc, cela représente maintenant une image d'entrée de pixels aléatoires qui vient d'être convertie en une image viable et qui ira maintenant

04:20.650 --> 04:22.440
dans le réseau de neurones.

04:22.570 --> 04:28.330
Et plus spécifiquement les couches convolutives du réseau de neurones car, puisque nous n’avons besoin

04:28.330 --> 04:34.100
que du nombre de neurones après l’application des convolutions, nous ne ferons que remonter aux convolutions 3.

04:34.210 --> 04:36.440
Donc, jusqu’à la troisième couche convolutive.

04:36.580 --> 04:39.630
Et nous n'entrerons pas dans les deux connexions complètes ici.

04:39.850 --> 04:45.490
Et c’est parce que le nombre de neurones que nous voulons est compris entre la convolution 3 et f. c 1.

04:45.520 --> 04:52.120
Bon, maintenant que nous avons une image d'entrée avec les bonnes mentions Eh bien, il est temps de propager cette image

04:52.180 --> 04:58.330
dans le réseau de neurones pour atteindre la couche aplatie, puis nous allons obtenir les neurones dans la couche aplatie

04:58.330 --> 05:03.850
et nous allons simplement obtenir le L'information que nous voulons, c'est le nombre de neurones dans cette

05:03.850 --> 05:04.750
couche aplatie.

05:04.990 --> 05:08.950
Alors maintenant, nous devons faire exactement ce que nous faisons dans une fonction avancée.

05:08.950 --> 05:14.560
Nous devons propager les signaux dans le réseau neuronal, mais uniquement dans les couches de convolution, jusqu'à

05:14.560 --> 05:16.120
atteindre la couche d'inondation.

05:16.330 --> 05:17.360
Alors faisons ceci.

05:17.360 --> 05:25.660
Nous allons mettre à jour x maintenant x est l'image d'entrée et avec le deuxième X ici, X deviendra bien la

05:25.660 --> 05:27.050
première couche convolutive.

05:27.310 --> 05:32.930
Et maintenant, nous devons suivre la première étape du processus en trois étapes, à savoir l’application de la déconvolution aux

05:32.950 --> 05:33.790
images d’entrée.

05:33.850 --> 05:40.960
Ensuite, lors de la deuxième étape, nous appliquons l’élagage mixte aux images compliquées et aux inserts que nous

05:40.960 --> 05:48.160
activons les neurones dans ces images compliquées puled. Le x deviendra cette première convolution, il est composé de

05:48.160 --> 05:50.590
tous ces pools complétés d’Energis.

05:51.010 --> 05:56.840
Faisons donc cette première étape pour appliquer la première convolution à la convolution aux images d’entrée.

05:57.040 --> 06:07.540
Donc ce que nous faisons est de prendre notre propre convolution qui convoite celle de Lucian que nous allons appliquer à nos images

06:07.550 --> 06:11.360
d’entrée qui sont représentées jusqu’à présent par x.

06:11.500 --> 06:14.290
C'est donc la première fois que la première est faite maintenant.

06:14.320 --> 06:22.630
Dans un deuxième temps, nous allons appliquer le spooling à nos images alambiquées retournées par convolution lorsque X et deux arrachements atteignent

06:22.640 --> 06:26.880
leur point culminant. Nous allons prendre une fonction du module fonctionnel.

06:26.920 --> 06:34.610
Donc, nous prenons le raccourci que cela et ensuite nous allons utiliser la fonction Max pool à D.

06:34.810 --> 06:42.340
C’est celui que nous avons mis en auto-convolution un X dans la parenthèse du tirant maximal au tirant d’avance parce que nous

06:42.360 --> 06:45.220
jouons au tirage suivant dans les images alambiquées.

06:45.750 --> 06:53.140
Mais cette fonction suivante prend des arguments supplémentaires qui sont d'abord la taille du noyau.

06:53.190 --> 06:59.190
Encore une fois, c’est la taille de la fenêtre qui glisse dans vos images et qui prend le maximum de

06:59.190 --> 07:00.710
pixels dans chaque diapositive.

07:00.830 --> 07:06.750
Cela détectera donc toujours les caractéristiques car celles-ci sont associées à une valeur élevée du pixel dans

07:06.840 --> 07:07.750
les tableaux.

07:07.890 --> 07:09.580
Comme vous dites intuition des conférences.

07:09.780 --> 07:14.020
Donc, ce premier besoin humain documenté est la taille du noyau.

07:14.100 --> 07:15.560
Et nous allons en prendre trois.

07:15.660 --> 07:17.650
C'est un choix commun pour la taille du noyau.

07:17.940 --> 07:25.200
Et ensuite, nous devons définir les progrès que vous connaissez en termes de nombre de pixels que les images vont glisser.

07:25.200 --> 07:27.560
Et nous allons faire un pas de deux.

07:27.610 --> 07:29.400
Encore une fois, c'est un choix commun.

07:29.820 --> 07:30.670
Alors on y va.

07:30.690 --> 07:32.530
Maintenant, la deuxième étape est terminée.

07:32.620 --> 07:38.910
Et maintenant, passons à la troisième étape qui consiste à activer tous les neurones de ce pool et les

07:38.910 --> 07:39.580
images alambiquées.

07:39.610 --> 07:46.090
Et cette première couche de convolution et pour refaire cela, nous allons appliquer une fonction à tout cela.

07:46.170 --> 07:51.960
Et donc ici et reprenons parce que nous allons prendre une autre fonction qui, comme vous l'avez

07:52.050 --> 07:55.170
peut-être deviné, sera une fonction d'activation mais laquelle.

07:55.230 --> 08:01.410
Comme d’habitude, la fonction d’activation sera corrigée et vous vous souviendrez peut-être du nom de cette

08:01.620 --> 08:02.330
fonction.

08:02.790 --> 08:03.410
Nous y voilà.

08:03.450 --> 08:04.290
C'est celui-là.

08:04.290 --> 08:12.540
Nous appliquons donc vraiment à nos images compliquées mises en commun, c’est tout cela.

08:12.540 --> 08:12.940
D'accord.

08:12.990 --> 08:14.270
Et c'est tout.

08:14.370 --> 08:15.320
Trois étapes effectuées.

08:15.330 --> 08:16.370
C'était très rapide.

08:16.500 --> 08:23.460
Alors rappelez-vous que la façon dont nous devons regarder ceci est d’abord d’appliquer la convolution à nos images d’entrée,

08:23.460 --> 08:28.830
puis nous appliquons le tirage Max à nos images alambiquées obtenues avec une convolution.

08:28.950 --> 08:35.730
Ensuite, nous activons les neurones de toute cette couche convolutive de pool avec la fonction d’activation

08:35.730 --> 08:43.960
du redresseur. Nous obtenons ainsi notre première couche convolutive sur laquelle était tiré un point culminant et dans laquelle les

08:44.050 --> 08:46.200
neurones sont maintenant activés.

08:46.260 --> 08:51.640
Et donc, en gros, il propage les signaux de la première couche convolutive à

08:51.640 --> 08:52.500
la suivante.

08:52.630 --> 08:56.580
Et en parlant de la prochaine, c'est exactement ce dont nous allons nous occuper maintenant.

08:56.570 --> 09:01.660
Nous allons faire la même chose que nous venons de faire lors de la première convolution vers la

09:01.660 --> 09:08.170
deuxième couche de convolution pour propager à nouveau les signaux plus loin dans le réseau de neurones en activant les neurones de la

09:08.170 --> 09:09.660
deuxième couche de convolution.

09:09.850 --> 09:12.910
Mais avant cela, nous devons obtenir cette couche convolutionnelle.

09:13.120 --> 09:18.330
Nous allons donc appliquer la convolution à X qui est maintenant la première couche de convolution.

09:18.460 --> 09:24.070
Bien, nous allons appliquer la convolution à 2 x pour obtenir la deuxième couche convolutive, après quoi

09:24.070 --> 09:25.120
Max le tirera.

09:25.240 --> 09:27.860
Et puis finalement activer Sirat.

09:27.970 --> 09:29.070
Alors faisons ceci.

09:29.170 --> 09:35.350
En fait, il est très facile de copier cela et de le coller ci-dessous.

09:35.350 --> 09:39.240
Bien entendu, nous devons également remplacer la convolution une par convolution.

09:39.520 --> 09:40.460
Et c'est parti.

09:40.480 --> 09:43.650
C'est en fait prêt à voir très facile.

09:43.900 --> 09:50.200
Et maintenant, avec cette ligne, nous propagons les signaux de la deuxième convolution vers la suivante,

09:50.260 --> 09:52.580
qui sera la troisième convolution.

09:52.720 --> 09:57.220
Et pour obtenir cette troisième convolution, vous devrez l'appliquer à nouveau.

09:57.220 --> 10:04.630
Je copie donc le collage ci-dessous et remplace la convolution par la convolution 3, ce qui est fait, n'est-ce

10:04.870 --> 10:06.340
pas si pratique?

10:06.340 --> 10:11.490
Nous propagons les signaux dans les trois lettres de convolution dans une lampe de poche.

10:11.500 --> 10:13.100
Merci à cette structure géniale.

10:14.020 --> 10:15.340
Très bien si parfait.

10:15.340 --> 10:21.250
Nous avons maintenant nos signaux propagés jusqu’à la troisième couche de convolution et après.

10:21.360 --> 10:24.780
Et parler de cela nous amène à ce que nous recherchons.

10:24.820 --> 10:28.510
Ce qui nous intéresse, c’est l’aplatissement.

10:28.510 --> 10:33.620
Très bien, maintenant que nous avons notre troisième convolution là-bas, c'est le dernier X ici.

10:33.790 --> 10:36.120
Il est temps de nous aplatir.

10:36.490 --> 10:37.990
Et c'est exactement ce que nous allons faire.

10:37.990 --> 10:44.200
Nous allons maintenant aplatir tous les pixels de cette troisième couche de convolution, c'est-à-dire que nous allons prendre tous

10:44.290 --> 10:48.430
les pixels de tous les canaux de la troisième couche de convolution.

10:48.640 --> 10:51.920
Nous allons les mettre l'un après l'autre dans un énorme vecteur.

10:52.150 --> 10:56.920
Et bien sûr, cet énorme vecteur ne sera rien d’autre que la couche d’aplatissement et

10:56.920 --> 11:02.000
nous utiliserons en même temps une astuce pour obtenir le nombre de neurones dans cet aplatissement.

11:02.070 --> 11:03.790
C'est ce que nous recherchons.

11:03.790 --> 11:09.370
C'est le nombre de neurones qui nous manque et, par conséquent, retournons directement ce que nous voulons et,

11:09.370 --> 11:15.130
dans ce retour, nous allons aplatir la troisième couche de convolution et obtenir le même nombre de neurones dans

11:15.130 --> 11:16.330
cette couche d'aplatissement.

11:16.630 --> 11:20.150
Nous allons donc prendre X. qui est notre troisième convolution ici.

11:20.320 --> 11:25.150
Nous allons prendre ici tous les canaux de la troisième convolution et utiliser une

11:25.150 --> 11:32.160
fonction qui est la fonction de taille pour aplatir tous les pixels de tous ces canaux dans un même vecteur énorme.

11:32.230 --> 11:35.930
Et si le truc que vous pouvez trouver dans la pitié regarder le labeur.

11:36.130 --> 11:42.400
Bien, prenons d’abord les données de X parce que X est une structure spéciale, vous savez que c’est un voivode de torche. Il

11:42.400 --> 11:44.250
a donc une structure assez complexe.

11:44.320 --> 11:51.920
Mais nous devons d’abord y accéder avec des données, puis voir ce qu’il contient.

11:52.090 --> 11:57.700
Nous utilisons donc cette fonction de vue et nous devons maintenant accéder à ce que

11:57.700 --> 12:01.980
nous recherchons, à savoir avec les arguments 1 et moins 1.

12:02.230 --> 12:04.390
Vous devez comprendre ce qu'il y a à l'intérieur de la structure.

12:04.510 --> 12:10.060
Mais vous pouvez simplement comprendre que c'est comme cela que nous allons obtenir ce nombre de neurones et

12:10.150 --> 12:15.560
que pour finir, nous devons ajouter de la taille entre parenthèses et à l'intérieur des entrées 1.

12:15.880 --> 12:21.610
En gros, ce que nous faisons ici, c'est que nous prenons tous les pixels de tous les canaux et que

12:21.610 --> 12:27.180
nous les plaçons les uns après les autres dans cet énorme vecteur qui sera l'entrée du réseau entièrement connecté.

12:27.190 --> 12:29.250
C'est essentiellement ce que fait la taille.

12:29.410 --> 12:34.060
Et avec cela, nous pouvons obtenir le nombre de nouveaux que nous recherchons.

12:34.060 --> 12:36.460
D'accord, maintenant nous obtenons ce que nous voulons.

12:36.490 --> 12:44.350
Nous pouvons donc enfin remplacer ici les neurones numériques par ce que cette fonction renvoie si elle

12:44.530 --> 12:47.400
est appliquée au format des images.

12:47.440 --> 12:50.140
C'est un par 80 par 80.

12:50.170 --> 13:00.040
Nous devons donc maintenant remplacer les neurones numériques en prenant la fonction de neurones de comptage

13:00.250 --> 13:09.040
que nous appliquons au format des images, soit 80 et 80 au total.

13:09.460 --> 13:10.400
Et c'est parti.

13:10.510 --> 13:17.140
Et bien sûr, nous ne nous oublions pas nous-mêmes, car Count neuron est en fait une méthode du test CNN.

13:17.170 --> 13:18.490
Nous devons donc ajouter le.

13:18.700 --> 13:21.190
Et maintenant, l'avertissement devrait disparaître.

13:21.190 --> 13:22.540
Et c'est parti.

13:22.540 --> 13:23.890
Maintenant tout va bien.

13:23.980 --> 13:29.930
Nous obtenons l'architecture du réseau de neurones sans rien manquer et nous avons cette fonction de combinaison si vous

13:30.140 --> 13:35.290
savez que vous voulez essayer d'autres architectures et que vous ne voulez pas compter le nombre de

13:35.290 --> 13:36.210
neurones manuellement.

13:36.340 --> 13:39.940
Si vous utilisez simplement cette fonction, vous la lisez au format de vos images.

13:40.180 --> 13:42.130
Et cela vous donnera directement ce que vous voulez.

13:42.130 --> 13:45.810
C'est le nombre de neurones dans la couche d'inondation sans rien faire.

13:45.820 --> 13:49.450
Et partout où l’architecture est cruciale.

13:49.480 --> 13:57.040
Et maintenant, nous en avons terminé avec la première grande étape importante de ce cerveau que nous faisons et nous avons une dernière

13:57.040 --> 13:57.720
étape.

13:57.790 --> 14:02.500
C’est une dernière fonction à créer, qui sera la principale fonction de transmission.

14:02.590 --> 14:07.730
Nous allons donc propager les signaux du début du cerveau qui vont des yeux

14:07.730 --> 14:12.160
à la couche de sortie qui se trouve après la deuxième connexion.

14:12.460 --> 14:15.850
Nous le ferons donc dans les deux prochaines pages et d’ici là notre IA.
