WEBVTT

00:00.630 --> 00:03.170
Bonjour et bienvenue dans ce tutoriel sur Python.

00:03.170 --> 00:03.500
D'accord.

00:03.510 --> 00:09.120
Maintenant, dans la prochaine fonction que nous allons implémenter, nous allons former le réseau de

00:09.120 --> 00:11.470
neurones profonds de notre intelligence artificielle.

00:11.490 --> 00:16.980
Donc, fondamentalement, nous allons faire tout le processus de propagation, puis de retour.

00:16.980 --> 00:19.140
Donc, nous allons obtenir notre production.

00:19.200 --> 00:20.850
Nous allons obtenir la cible.

00:20.890 --> 00:26.020
Nous allons comparer la sortie de la cible pour calculer la dernière erreur, puis nous allons propager cette

00:26.130 --> 00:28.410
dernière en arrière dans le nouveau réseau.

00:28.680 --> 00:33.960
Et en utilisant la descente de gradient suggérée, qui devra attendre en fonction de son apport à la

00:33.960 --> 00:34.780
dernière erreur.

00:35.190 --> 00:39.030
Faisons donc tout cela pour ceux d'entre vous qui viennent des profondeurs du Marine Corps.

00:39.030 --> 00:43.850
Ce sera une bonne chose, mais pour les autres, ne vous inquiétez pas, je vais l'élargir à nouveau.

00:44.160 --> 00:51.630
Nous allons donc appeler cette nouvelle fonction learn et learn va prendre plusieurs arguments.

00:51.630 --> 00:57.350
Premier moi bien sûr qui fera référence à l'objet du diplôme en classe.

00:57.510 --> 01:08.770
Ensuite, nous allons prendre notre état de lot pour l’état actuel, puis notre prochain état de

01:08.860 --> 01:15.570
lot, puis notre action Cette récompense et enfin Arbat.

01:15.590 --> 01:16.960
Alors, pourquoi prenons-nous cela.

01:16.970 --> 01:19.770
Vous avez probablement reconnu quelle est cette série.

01:19.880 --> 01:26.350
Eh bien, c’est bien sûr une transition, une transition du processus de décision du marché qui est à la base.

01:26.360 --> 01:27.440
Avez-vous appris.

01:27.500 --> 01:30.420
Et pourquoi les prenons-nous tous en lots?

01:30.560 --> 01:36.200
Eh bien, c’est parce que vous savez que nous ne considérons pas les transitions en fonction d’une série d’activités de l’état

01:36.200 --> 01:39.630
actuel ou supérieur de la récompense actuelle et de l’action en cours.

01:39.650 --> 01:44.050
Nous avons créé ici des lots simples grâce à la fonction simple.

01:44.210 --> 01:48.430
Et maintenant, nos transitions sont sous la forme d'un premier lot pour cet état.

01:48.500 --> 01:53.520
Un deuxième lot pour la prochaine date, un lot pour la récompense et un lot pour l'action.

01:53.510 --> 01:59.090
C'est la forme de notre transition maintenant et ils sont tous bien alignés dans le temps grâce

01:59.090 --> 02:04.150
à cette concaténation que nous avons faite ici par rapport à la première dimension.

02:04.160 --> 02:10.460
Donc, le point est maintenant que nous avons ces lots de transition, un lot pour chacun des états les jours suivants, nous le

02:10.450 --> 02:15.400
regardons en action et nous faisons tout cela parce que nous utilisons cette astuce de rejeu d'expérience.

02:15.530 --> 02:18.580
Ainsi, notre réseau neuronal profond peut apprendre quelque chose.

02:18.590 --> 02:24.190
N'oubliez pas que si vous aviez uniquement une transition, il s'agirait d'un apprentissage instantané.

02:24.260 --> 02:28.930
Ou si vous voulez apprendre très peu de mémoire et que la taupe n’apprendra rien.

02:29.180 --> 02:35.690
Nous devons donc prendre ces lots de la mémoire qui deviennent nos transitions, puis nous obtiendrons éventuellement les différentes sorties

02:35.690 --> 02:40.940
pour chacun des états des états d'entrée et nous le ferons pour les États et pour

02:41.160 --> 02:45.620
les prochains États, car nous aurons besoin des deux. pour calculer la perte.

02:45.680 --> 02:51.860
Je rappellerai bientôt l'équation de la balance qui est au cœur de l'algorithme d'apprentissage.

02:51.860 --> 02:57.120
Alors maintenant, passons à la fonction et obtenons d’abord les sorties de l’état de la boîte.

02:57.170 --> 03:04.740
Je vais donc appeler cela les premiers résultats viables, puis nous dirons bien sûr que notre auto-dialogue

03:04.740 --> 03:07.670
n’est pas tout à fait naturel.

03:07.740 --> 03:14.160
Non, car nous voulons obtenir les sorties de notre modèle des états d'entrée de l'état.

03:14.510 --> 03:19.110
Et puisque notre modèle attend en réalité un lot d’états d’entrée.

03:19.310 --> 03:25.330
Eh bien, nous pouvons totalement entrer cet état maintenant pour l’entrée de tous.

03:25.340 --> 03:31.550
C'est exactement comme cela que nous avons initialisé les états qui entrent dans le réseau avec la torture

03:31.550 --> 03:35.080
répondons avec cette dimension vague pour le lot parfait.

03:35.180 --> 03:37.720
Nous obtenons maintenant les résultats de tous.

03:37.880 --> 03:45.680
Mais il existe un autre truc technique si nous ne vendons que cet état de modèle, nous obtiendrons les résultats de toutes les actions possibles

03:45.860 --> 03:50.980
que vous connaissez 0 1 et 2, mais ce n'est pas ce que nous souhaitons.

03:50.990 --> 03:54.580
Nous ne nous intéressons qu'aux actions choisies.

03:54.740 --> 04:01.190
Les actions qui ont été décidées par le

04:01.190 --> 04:09.320
réseau à jouer à chaque fois et pour les intéresser sont

04:09.320 --> 04:16.840
les actions bien jouées. nous ajoutons cette action à celle-ci.

04:16.880 --> 04:23.600
Et dans cette section, nous allons rassembler chaque fois la meilleure action à jouer pour chacun des états d'entrée

04:23.600 --> 04:24.560
de l'état.

04:24.830 --> 04:30.690
Nous ne voulons pas que l'action qui a été jouée soit l'action choisie, et nous obtenons cette information

04:30.840 --> 04:31.770
avec celle-ci.

04:32.130 --> 04:33.390
Mais alors faites attention.

04:33.450 --> 04:40.190
L’état d’ici a ces faux diamants et cette graisse dans le lot et cette section ne les a pas.

04:40.190 --> 04:46.190
Backstay l'a parce que nous avions l'habitude d'utiliser Unsworth ici, mais nous n'avons pas utilisé de compression des

04:46.430 --> 04:52.880
bras pour les actions. Nous devons donc l'ajouter ici pour que l'action Bache ait exactement la même dimension que l'état.

04:53.150 --> 05:02.710
Donc, nous allons ajouter un point et presser votre droite ici et en réalité ce n'est pas zéro mais un parce que zéro

05:03.200 --> 05:09.120
réponse à Faith n'est pas l'état et un correspondra à l'examen des actions.

05:09.370 --> 05:16.540
Et enfin, la dernière chose que nous devons faire ici est de tuer ce faux lot avec un squeeze.

05:16.600 --> 05:18.010
Pourquoi avons-nous besoin de faire cela?

05:18.130 --> 05:20.130
Parce que maintenant nous sommes hors du réseau de neurones.

05:20.200 --> 05:22.820
Nous avons nos résultats mais nous ne voulons pas qu'ils reviennent.

05:22.900 --> 05:24.080
Nous les voulons.

05:24.190 --> 05:26.260
Et la réponse simple est simple vecteur.

05:26.260 --> 05:31.540
Un vecteur de sortie des lots juste au moment où nous travaillons dans le réseau de neurones, car le

05:31.540 --> 05:34.880
réseau de neurones attend le format de capteurs dans un lot.

05:34.990 --> 05:40.510
Mais maintenant, nous avons nos résultats et, dans la prochaine équation de baluns de l'apprentissage en profondeur, nous n'en aurons pas besoin

05:40.510 --> 05:41.530
dans un lot.

05:41.530 --> 05:48.130
Donc, je tue cela ici et tue la dimension de la foi pour retrouver la forme simple de nos sorties.

05:48.160 --> 05:54.530
Donc, j'ajoute simplement ici Point, puis Squeeze, puis, depuis que je veux tuer le faux stratifié correspondant

05:54.540 --> 05:56.120
au dos de l'action.

05:56.250 --> 06:01.430
Eh bien, puisque le moteur d'espace-temps a l'index un, j'en ajoute un ici.

06:01.560 --> 06:02.050
D'accord.

06:02.100 --> 06:05.480
Et maintenant on y va on a nos sorties.

06:05.490 --> 06:05.910
D'ACCORD.

06:06.000 --> 06:11.100
Nous avons un petit avertissement sur le fait que la sortie de la variable locale est affectée mais n’est jamais utilisée.

06:11.190 --> 06:11.860
C'est bon.

06:11.880 --> 06:13.510
Nous allons l'utiliser très rapidement.

06:13.920 --> 06:15.540
Voilà donc nos résultats.

06:15.600 --> 06:23.660
Et maintenant, nous voulons avoir nos prochaines sorties. Alors maintenant, vous vous demandez peut-être pourquoi nous avons besoin des prochains résultats.

06:23.840 --> 06:29.160
Pour bien comprendre cela, nous devons revenir à l’algorithme d’apprentissage en profondeur qui se trouve ici et

06:29.180 --> 06:31.670
qui fait partie du manuel de Letak.

06:31.850 --> 06:33.820
Voilà donc tout le processus de diffusion.

06:33.860 --> 06:39.180
Au début, nous initialisions toutes les valeurs de clé, puis à chaque instant t.

06:39.440 --> 06:44.770
Et bien voilà, nous sélectionnons l'action avec Max soughed, c'est ce que nous avons fait avec la fonction select action

06:44.870 --> 06:51.050
Ensuite, nous avons ouvert la transition et, comme vous pouvez le constater, nous obtenons la prédiction, nous obtenons la cible et nous pouvons

06:51.050 --> 06:52.120
être les derniers.

06:52.190 --> 06:54.330
Alors, pourquoi avons-nous également besoin de la prochaine sortie?

06:54.350 --> 07:01.640
En raison de la cible, la cible est égale au Ghana multipliée par le résultat suivant et le résultat souhaité.

07:01.640 --> 07:06.060
Nous calculons ensuite les objectifs, car nous avons besoin du résultat suivant.

07:06.200 --> 07:07.790
Calculons ceci en premier.

07:07.820 --> 07:14.060
Donc, encore une fois, pour que la prochaine mise à jour soit très simple, la prochaine sortie sera le résultat

07:14.060 --> 07:19.180
de notre réseau de neurones lorsque l’état suivant mis en lots l’entrera en tant qu’entrée.

07:19.190 --> 07:27.110
Nous prenons donc très simplement notre modèle, notre réseau de neurones, puis cette fois-ci, l’entrée du réseau de neurones

07:27.110 --> 07:33.020
sera l’état en lots suivant qui sera mis en lots par la suite.

07:33.200 --> 07:41.290
Mais rappelez-vous maintenant si nous revenons à l'algorithme précédent. Vous pouvez voir que la sortie suivante est le maximum des valeurs

07:41.290 --> 07:45.530
q pour l'état suivant par rapport à toutes les actions.

07:45.730 --> 07:51.790
Donc maintenant, pour obtenir le prochain résultat, nous devons obtenir le maximum de cette valeur q et par conséquent, je vais

07:51.790 --> 07:52.720
le faire ici.

07:52.840 --> 08:00.550
Détachez-vous pour détacher toutes les sorties du modèle car nous avons plusieurs états dans ce lot next états qui est le

08:00.550 --> 08:06.730
lot de tous les états suivants dans toutes les transitions prises à partir de l'échantillon aléatoire de

08:06.730 --> 08:07.620
notre mémoire.

08:07.840 --> 08:14.530
Je les détache donc tous à l'aide de la fonction de détachement, puis je prends le maximum de toutes ces

08:14.530 --> 08:15.250
deux valeurs.

08:15.340 --> 08:20.920
Et puisque nous prenons le maximum de ces deux valeurs en ce qui concerne l'action, nous devons préciser que

08:20.920 --> 08:23.080
c'est en ce qui concerne l'action.

08:23.080 --> 08:26.310
Et puisque l'action est représentée par l'index.

08:26.530 --> 08:32.770
Encore une fois, nous devons placer ici la suivante, puis spécifier que nous

08:33.290 --> 08:41.140
prenons les valeurs de repère comme étant T plus 1, ce qui correspond à la prochaine

08:41.380 --> 08:47.370
étape. par conséquent, nous devons ici ajouter des parenthèses d'indice 0.

08:47.770 --> 08:54.400
De cette façon, nous obtenons le maximum des valeurs de clé des états suivants représentés par

08:54.400 --> 09:01.490
le zéro suivant en fonction de toutes les actions représentées par l'index. Nous obtenons maintenant les résultats suivants.

09:01.570 --> 09:02.860
Ce sont un nouvel ensemble.

09:02.870 --> 09:04.320
C'est quand nous avons eu l'avertissement.

09:04.320 --> 09:05.050
Mais c'est bon.

09:05.080 --> 09:07.950
Nous allons l'utiliser maintenant pour calculer la cible.

09:08.470 --> 09:12.510
Et en parlant de la cible qui est la prochaine étape de cette fonction connue.

09:12.520 --> 09:13.210
Alors on y va.

09:13.220 --> 09:15.460
La cible est égale.

09:15.670 --> 09:18.220
Revenons maintenant à notre manuel sur l'IA.

09:18.400 --> 09:24.800
La cible est égale au mot plus les temps gamma, la sortie suivante correspond au maximum des valeurs de cube du

09:24.800 --> 09:25.710
jour suivant.

09:25.930 --> 09:29.290
Selon les actions que nous pouvons calculer cela.

09:29.340 --> 09:35.590
C'est donc égal à moi que gamma et moi que Gamma a été initialisé.

09:35.590 --> 09:45.100
Voici un exemple qui est une variable Virgin Q Un objet est automatiquement transmis à Times les prochaines sorties, comme nous venons

09:45.100 --> 09:49.910
de le dire, et voulons-nous que ce soit le meilleur.

09:49.940 --> 09:57.400
Nous travaillons avec des lots ici, donc nous voulons un lot et c’est la cible.

09:57.520 --> 10:03.820
Dans un échantillon du gamma mémoire multiplié par les sorties suivantes Plus la récompense.

10:03.900 --> 10:04.480
D'accord.

10:04.480 --> 10:05.080
Parfait.

10:05.110 --> 10:07.100
Nous avons donc maintenant nos résultats.

10:07.180 --> 10:13.270
Nous avons également nos objectifs et nous pouvons donc calculer la perte qui représente l’erreur de

10:13.270 --> 10:14.260
la prévision.

10:14.500 --> 10:21.000
Alors appelons cela les dernières deux est bien sûr pour la différence temporelle.

10:21.040 --> 10:28.720
C’est encore une fois au cœur de l’apprentissage Q et ce tiddy va être égal à la version qui améliore

10:28.720 --> 10:30.330
beaucoup le Cunanan.

10:30.520 --> 10:34.730
C'est la dernière fonction que nous choisirons pour notre intelligence artificielle.

10:34.800 --> 10:38.640
Pour ceux d'entre vous qui viennent du parcours vert profond, c'est vraiment le dernier que je recommande.

10:38.680 --> 10:43.280
Si vous voulez implémenter la Coonerty et comment allez-vous l'obtenir.

10:43.510 --> 10:50.380
Encore une fois, nous allons prendre une fonction du module fonctionnel représenté par F

10:50.380 --> 10:57.970
et donc ici, je vais utiliser notre module fonctionnel f canards et le Hubble nous peut être

10:57.970 --> 11:02.420
obtenu grâce à la fonction Smoots L-1 aime celui-là.

11:02.420 --> 11:03.850
Donc en appuyant sur entrer.

11:03.850 --> 11:07.910
Et c'est vraiment la meilleure fonction perdue que je recommande pour un apprentissage en profondeur.

11:07.930 --> 11:09.680
Cela améliore vraiment la Culin.

11:09.820 --> 11:12.670
Mais c'est une fonction donc j'ajoute des parenthèses.

11:12.850 --> 11:14.740
Et maintenant, rien de plus simple.

11:14.830 --> 11:19.340
Les arguments que nous devons entrer sont les prédictions et les cibles.

11:19.420 --> 11:24.010
Donc, bien sûr, les prédictions sont des sorties parce que c'est la sortie du réseau de neurones.

11:24.190 --> 11:27.600
Non, la sortie du réseau de neurones correspond à ce que prédit le réseau de neurones.

11:27.730 --> 11:29.030
Donc, c'est la prédiction.

11:29.260 --> 11:35.900
Le premier argument ici est donc les sorties et le second argument est bien entendu la cible.

11:36.100 --> 11:40.110
La chose que nous essayons d'obtenir et qui est déjà calculée est parfaite.

11:40.150 --> 11:43.150
Nous pouvons directement entrer la cible.

11:43.150 --> 11:43.630
Parfait.

11:43.650 --> 11:48.200
Nous venons de nous dire que nous avons juste un petit thé

11:48.220 --> 11:48.760
Nous y voilà.

11:48.760 --> 11:50.470
Maintenant, l'avertissement devrait disparaître.

11:50.890 --> 11:51.420
Oui.

11:51.430 --> 11:52.110
Parfait.

11:52.180 --> 11:58.090
Et maintenant que nous avons la dernière erreur, nous pouvons remonter l’erreur des propagateurs dans le réseau pour mettre à jour les

11:58.090 --> 12:03.230
poids avec une descente de gradient stochastique et c’est exactement ce que nous allons faire à l’étape suivante.

12:03.490 --> 12:12.040
Donc, bien sûr, ce que nous devons faire maintenant, comme vous pouvez le deviner, est d’optimiser notre optimiseur que

12:12.190 --> 12:14.850
nous vous présentons à nouveau.

12:15.030 --> 12:21.430
Et c’est un optimiseur d’atomes qui est en fait un objet de la classe Atom et il est déjà

12:21.580 --> 12:23.720
équipé des paramètres de notre modèle.

12:23.810 --> 12:31.480
Et nous avons déjà choisi un taux d’apprentissage de 0. 1 pour cent de perfectionner notre optimiseur est prêt, mais nous devons

12:31.480 --> 12:37.150
maintenant jouer sur la dernière erreur pour effectuer une grille stochastique dans le sens et les poids de données.

12:37.180 --> 12:43.540
Ainsi, lorsque vous travaillez avec des combattants, la première chose à faire est de le réinitialiser à chaque itération de la

12:43.540 --> 12:44.150
boucle.

12:44.200 --> 12:50.620
Nous devons réinitialiser l'optimiseur d'une interaction à l'autre dans la boucle pour obtenir le réseau

12:50.660 --> 12:53.310
dans l'ensemble et le réinitialiser.

12:53.350 --> 12:54.820
Et chaque itération de la boucle.

12:55.200 --> 12:59.410
Eh bien, nous allons utiliser la méthode suivante qui est zéro.

12:59.940 --> 13:00.400
Et c'est parti.

13:00.410 --> 13:05.180
Zéro grad réinitialisera l'optimiseur à chaque itération de la boucle.

13:05.230 --> 13:07.300
Alors n'oublions pas la parenthèse.

13:07.390 --> 13:08.180
Parfait.

13:08.200 --> 13:14.850
Et maintenant qu'il est réinitialisé, nous pouvons effectuer une propagation en arrière avec notre optimiseur.

13:15.190 --> 13:16.380
Et comment faisons-nous cela.

13:16.540 --> 13:22.660
Eh bien, nous nous en tenons aux lois et nous allons le propager dans le réseau et le

13:22.660 --> 13:24.330
propager dans le réseau.

13:24.460 --> 13:33.190
Nous devons utiliser la fonction backward et à l'intérieur de cette fonction backward, il est recommandé d'entrer des variables de soulignement

13:33.220 --> 13:37.180
de maintien et de la définir comme étant vraie

13:37.240 --> 13:40.990
Je recommande de le faire car cela améliorera la propagation en arrière.

13:41.200 --> 13:46.420
L'utilisation de variables écrites est égale à true, c'est libérer de la mémoire et nous devons libérer

13:46.420 --> 13:52.730
de la mémoire car nous allons passer plusieurs fois sur la dernière, ce qui va certainement améliorer les performances de l'entraînement.

13:52.900 --> 13:58.980
Enfin, la dernière étape de cette fonction est d’avoir des poids de données en fonction de la propagation en arrière.

13:58.980 --> 14:02.570
C'est en fonction de combien les poids ont contribué à l'erreur.

14:02.800 --> 14:11.680
Et pour ce faire, nous reprenons notre optimiseur qui a été initialisé en réinitialisation et nous utilisons la fonction step et

14:12.250 --> 14:17.560
simplement avec cette ligne de code en utilisant la fonction step.

14:17.560 --> 14:19.450
Cela mettra à jour les poids.

14:19.480 --> 14:21.860
C'est cette ligne de code qui met à jour les poids.

14:21.910 --> 14:28.750
Cette ligne de code qui propage l'erreur dans le réseau de neurones et cette ligne de code utilise l'optimiseur pour mettre

14:28.930 --> 14:31.510
à jour les pondérations et c'est parti.

14:31.510 --> 14:36.800
Nous avons un réseau de neurones d'apprentissage, alors félicitations.

14:36.840 --> 14:42.320
C’était probablement la partie la plus technique et la plus difficile de toute cette dispute ou de ce lendemain.

14:42.450 --> 14:47.880
Je sais que mon flambeau peut être difficile parfois avec facilité, mais à la fin,

14:47.880 --> 14:54.900
je vous promets que vous obtiendrez un réseau de neurones très fonctionnel et, partant, un modèle particulier et, éventuellement,

14:54.960 --> 14:56.580
une grande intelligence artificielle.

14:56.580 --> 15:03.150
Passons maintenant à l’étape suivante ou enseignant et modèle, qui sera la fonction de mise à jour qui sera

15:03.210 --> 15:07.170
évidemment mise à jour lorsque l’intelligence artificielle découvrira le nouvel état.

15:07.170 --> 15:11.420
Donc, vous savez qu'il va découvrir le nouvel état et ensuite il recevra la récompense.

15:11.520 --> 15:16.860
En fonction de l'action affichée, ce nouvel état s'en chargera avec la fonction de mise à jour

15:16.860 --> 15:19.510
et le fera dans le prochain tutoriel.

15:19.710 --> 15:21.000
Jusque-là profiter.

15:21.020 --> 15:21.300
JE.
