WEBVTT

00:00.500 --> 00:02.570
Hallo en welkom bij deze Python-tutorial.

00:03.020 --> 00:03.410
Oke.

00:03.470 --> 00:08.930
Nu, in de volgende functie die we gaan implementeren, zullen we het diepe neurale netwerk trainen dat

00:08.930 --> 00:11.040
zich in onze kunstmatige intelligentie bevindt.

00:11.360 --> 00:16.520
Dus eigenlijk gaan we het hele proces van voorwaartse voortplanting en dan terugvermeerdering doen.

00:16.880 --> 00:18.790
Dat wil zeggen, we gaan onze output krijgen.

00:19.040 --> 00:20.450
We gaan het doelwit halen.

00:20.750 --> 00:24.130
We zullen de uitvoer vergelijken met het doel om de laatste fout te berekenen.

00:24.380 --> 00:28.220
Dan gaan we deze fout terug propageren in het neurale netwerk.

00:28.490 --> 00:33.500
En met behulp van stochastische gradiëntafdaling, zullen we moeten wegen op basis van hoeveel ze hebben bijgedragen aan de

00:33.680 --> 00:34.490
laatste fout.

00:35.030 --> 00:39.980
Dus laten we dit allemaal doen voor degenen onder jullie die van het diepe komen, want dit zal goed spul zijn.

00:40.280 --> 00:43.390
Maar voor de anderen, maak je geen zorgen, ik ga dat nog eens uitbreiden.

00:44.030 --> 00:47.030
Dus we gaan deze nieuwe functie leren noemen.

00:47.510 --> 00:51.110
En voor deze leerfunctie zijn verschillende argumenten nodig.

00:51.530 --> 00:56.990
Eerst zichzelf natuurlijk, die zal verwijzen naar het object van de klasse.

00:57.380 --> 01:08.750
Dan nemen we onze batchstatus voor de huidige status, dan is onze batchstatus die

01:08.750 --> 01:10.310
beloning.

01:11.060 --> 01:13.100
En tot slot, onze partij.

01:14.030 --> 01:14.580
Actie.

01:15.440 --> 01:19.580
Dus waarom nemen we dit, je herkende waarschijnlijk wat de serie is?

01:19.730 --> 01:25.550
Nou, dat is natuurlijk een transitie, een transitie van het marktbeslissingsproces dat aan de basis ligt

01:25.550 --> 01:27.100
van deep learning.

01:27.320 --> 01:30.140
En waarom nemen we ze allemaal in sommige batches?

01:30.380 --> 01:35.590
Wel, dat is omdat, weet je, onthoud, we beschouwen de overgangen niet door een reeks van om de huidige

01:35.750 --> 01:39.180
staat omver te werpen naast de huidige beloning en huidige actie.

01:39.530 --> 01:43.760
We hebben hier enkele eenvoudige batches gemaakt dankzij de eenvoudige functie.

01:44.000 --> 01:49.870
En dus zijn onze overgangen nu in de vorm van een eerste batch voor de staat, een tweede batch voor de volgende, een

01:50.290 --> 01:52.900
batch voor de beloning en een batch voor de actie.

01:53.360 --> 01:55.310
Dat is de vorm van onze overgangen nu.

01:55.490 --> 02:01.640
En ze zijn allemaal goed uitgelijnd met betrekking tot tijd, dankzij deze aaneenschakeling die we hier hebben gemaakt met

02:01.640 --> 02:03.400
betrekking tot de eerste dimensie.

02:04.010 --> 02:10.190
Dus het punt is dat we nu deze overgang van batches hebben, één batch voor elk van de staat, volgende datums,

02:10.190 --> 02:11.300
beloning en actie.

02:11.480 --> 02:15.140
En we doen dit allemaal omdat we deze ervarings-replay-truc gebruiken.

02:15.380 --> 02:18.150
Dus dat is dat ons diepe neurale netwerk iets kan leren.

02:18.470 --> 02:24.350
Onthoud dat als we alleen de overgangen alleen zouden hebben, wat het zou zijn om direct te leren of als

02:24.350 --> 02:28.620
je heel kort geheugen wilt leren en daarom zou de modus niets leren.

02:29.030 --> 02:35.540
We moeten dus deze batches uit het geheugen halen die onze overgangen worden, en uiteindelijk zullen we de verschillende

02:35.540 --> 02:39.170
outputs krijgen voor elk van de statussen van de inputbatchstatus.

02:39.350 --> 02:44.810
En we zullen dit doen voor de betere staat en voor de volgende staat, omdat we beide nodig hebben om het verlies te

02:44.810 --> 02:45.250
berekenen.

02:45.500 --> 02:50.870
Ik zal binnenkort de balansvergelijking herinneren die de kern vormt van het deep learning-algoritme.

02:51.740 --> 02:56.770
Dus laten we nu naar de functie gaan en eerst de outputs van de slechte staat krijgen.

02:57.020 --> 03:04.190
Dus ik ga deze eerste variabele outputs noemen en dan gaan we natuurlijk ons

03:04.200 --> 03:13.910
zelf nemen, dat model, dus zelf dat model, omdat we onze modeloutputs willen krijgen van de input staten van de staat.

03:14.360 --> 03:21.950
En aangezien ons model eigenlijk een batch invoerstatus verwacht, kunnen we die status nu volledig invoeren voor

03:22.430 --> 03:24.910
de invoer van het model.

03:25.190 --> 03:31.460
Dat is precies hoe we de toestanden hebben geïnitialiseerd die het netwerk binnengaan met de toorts-tensor met deze

03:31.460 --> 03:33.140
nep-dimensie voor de batch.

03:33.740 --> 03:34.700
Dus dat is perfect.

03:35.030 --> 03:37.280
We krijgen nu de output van het model.

03:37.730 --> 03:40.310
Maar dan is er nog een technische truc.

03:40.610 --> 03:47.690
Als we alleen dat model in een slechte staat doen, nou, dan krijgen we de resultaten van alle mogelijke acties, je weet wel, nul,

03:47.720 --> 03:48.920
één en twee.

03:49.400 --> 03:50.550
Maar dat is niet wat we willen.

03:50.810 --> 03:56.750
We zijn alleen geïnteresseerd in de acties die zijn gekozen, de acties die door het netwerk zijn besloten om op

03:56.870 --> 03:58.340
elk moment te spelen.

03:58.700 --> 04:03.080
En dus om deze actie te krijgen waar we in geïnteresseerd zijn, zijn de acties die goed worden gespeeld.

04:03.080 --> 04:11.420
We moeten deze verzamelfunctie gebruiken waarin we er een invoeren omdat we alleen de actie willen die is gekozen.

04:12.020 --> 04:17.720
En dan voegen we hier Bache-actie aan toe, de ene en de match-actie.

04:18.080 --> 04:24.190
We zullen elke keer de beste actie verzamelen om te spelen voor elk van de invoerstatussen van de staat.

04:24.680 --> 04:30.110
We willen alleen de actie die wordt gespeeld, de actie die wordt gekozen, en we krijgen dit met

04:30.230 --> 04:31.460
deze andere en batchactie.

04:32.000 --> 04:32.900
Maar wees dan voorzichtig.

04:33.290 --> 04:39.530
De batchstatus hier heeft deze nepdimensie die overeenkomt met de batch en batchactie heeft deze

04:39.530 --> 04:40.400
niet terug.

04:40.400 --> 04:46.130
State heeft het omdat we de untwist hier gebruiken, maar we hebben er geen op squeeze gebruikt voor de acties.

04:46.280 --> 04:52.550
Dus we moeten het hier toevoegen zodat de batchactie exact dezelfde dimensie heeft als de slechte staat.

04:53.030 --> 04:56.840
Dus we gaan een stip toevoegen op scherm nul.

04:57.780 --> 05:04.980
Hier en eigenlijk is dit niet nul, maar één omdat nul overeenkomt met de geloofsdimensie van de staat en

05:04.980 --> 05:08.850
één zal overeenkomen met de geloofsdimensie van de acties.

05:09.210 --> 05:15.770
En tot slot, het laatste dat we hier moeten doen, is dat we deze nep-batch met een kneep moeten doden.

05:16.320 --> 05:17.610
En waarom moeten we dat doen?

05:18.030 --> 05:20.010
Omdat we nu uit het neurale netwerk zijn.

05:20.020 --> 05:22.860
We hebben onze outputs, maar we willen ze niet in een batch.

05:22.860 --> 05:23.760
We willen ze.

05:24.000 --> 05:27.240
En het simpele antwoord is simpele vector een vector van outputs.

05:27.690 --> 05:32.580
De batch is precies wanneer we in het neurale netwerk werken, omdat het neurale netwerk het formaat

05:32.760 --> 05:34.520
van sensoren in een batch verwacht.

05:34.890 --> 05:40.440
Maar nu hebben we onze output en in de volgende balansvergelijking van de Deepu-learning hebben we ze niet in een

05:40.440 --> 05:41.060
batch nodig.

05:41.400 --> 05:47.630
Dus ik vermoord de batch hier en dood de nep-dimensie om de eenvoudige vorm van onze output terug te krijgen.

05:48.030 --> 05:50.490
Dus ik voeg hier gewoon een punt toe en knijp dan.

05:51.360 --> 05:55.830
En dan omdat ik de nep-dimensie die overeenkomt met de batch van de actie wil doden.

05:56.100 --> 06:00.930
Omdat deze nep-dimensie er een heeft geïndexeerd, voeg ik er hier een toe.

06:01.380 --> 06:01.940
Oke.

06:01.950 --> 06:05.750
En nu we gaan, hebben we onze output, oké?

06:05.820 --> 06:06.860
We hebben een kleine waarschuwing.

06:06.870 --> 06:07.370
Wat is het?

06:07.770 --> 06:10.800
Lokale variabele uitgangen worden toegewezen maar nooit gebruikt.

06:11.070 --> 06:11.730
Dat is goed.

06:11.740 --> 06:13.010
We zullen het heel snel gebruiken.

06:13.770 --> 06:15.270
Dus dat is onze output.

06:15.420 --> 06:18.330
En nu willen we onze volgende krijgen.

06:19.310 --> 06:19.890
Uitgangen.

06:20.360 --> 06:23.330
Dus nu denk je misschien, waarom hebben we de volgende output nodig?

06:23.690 --> 06:28.850
Om dit te begrijpen, moeten we teruggaan naar het deep learning-algoritme, dat hier staat.

06:28.850 --> 06:31.370
Dat is onderdeel van het logica-handboek.

06:31.700 --> 06:33.710
Dus dat is het hele decoderingsproces.

06:33.710 --> 06:38.800
In het begin initialiseerden we alle sleutelwaarden en vervolgens op elk moment, T..

06:39.320 --> 06:40.070
Nou, daar gaan we.

06:40.070 --> 06:41.450
We selecteren de actie.

06:41.450 --> 06:44.330
Wij Softmax, dat hebben we gedaan met de select action-functie.

06:44.720 --> 06:46.010
Dan openen we de overgang.

06:46.460 --> 06:51.710
En dan, zoals je kunt zien, krijgen we de voorspelling, krijgen we het doelwit en kunnen we de laatste zijn.

06:52.040 --> 06:53.970
Dus waarom hebben we de volgende uitgangen ook nodig?

06:54.200 --> 06:55.550
Dat komt door het doel.

06:56.030 --> 07:01.000
Het doel is gelijk aan gammatijden, de volgende output plus de beloning.

07:01.310 --> 07:03.410
En we zullen het doel direct daarna berekenen.

07:03.660 --> 07:07.110
Maar aangezien we de volgende uitvoer voor het doel nodig hebben, laten we dit eerst berekenen.

07:07.670 --> 07:13.520
Dus nogmaals, om de volgende uitvoer zo eenvoudig te krijgen, zal de volgende uitvoer het resultaat zijn

07:13.670 --> 07:18.570
van ons neurale netwerk wanneer de batch volgende datum het als invoer invoert.

07:19.040 --> 07:26.840
Dus heel eenvoudig, we nemen ons model dat ons neurale netwerk is, en deze keer zal de invoer van

07:26.840 --> 07:30.440
het neurale netwerk de batch volgende status zijn.

07:31.510 --> 07:37.600
De beste volgende datum, maar onthoud nu, als we teruggaan naar het deep learning-algoritme, wel, je

07:37.600 --> 07:45.200
kunt zien dat de volgende uitvoer het maximum is van de waarden voor de volgende status met betrekking tot alle acties.

07:45.580 --> 07:49.660
Dus op dit moment, om de volgende uitvoer te krijgen, moeten we het maximum van deze waarden krijgen.

07:50.050 --> 07:57.940
En daarom ga ik hier een detach doen, weet je, om alle outputs van het model los te koppelen, omdat we

07:57.940 --> 08:00.490
verschillende toestanden in deze batch hebben.

08:00.490 --> 08:06.670
Volgende toestanden, dat is de batch van alle volgende toestanden in alle overgangen uit de willekeurige steekproef van ons

08:06.670 --> 08:07.290
geheugen.

08:07.720 --> 08:14.440
Dus ik ontkoppel ze allemaal met behulp van de detach-functie, en dan neem ik het maximum van al deze

08:14.440 --> 08:14.920
sleutelwaarden.

08:15.110 --> 08:20.860
En aangezien we het maximum van deze waarden nemen met betrekking tot de actie, moeten we specificeren dat dit is

08:20.860 --> 08:22.630
met betrekking tot de actie.

08:22.900 --> 08:29.170
En aangezien de actie wordt vertegenwoordigd door de index één, nou ja, nogmaals, we moeten de index één hier plaatsen

08:29.650 --> 08:34.540
en dan moeten we specificeren dat we de kernwaarden van ESTIE plus één nemen.

08:34.720 --> 08:41.020
Dat is de volgende datum en de volgende datum wordt weergegeven door de index nul omdat de index nul overeenkomt met

08:41.230 --> 08:42.010
de staat.

08:42.340 --> 08:46.940
En daarom moeten we hier haakjes toevoegen met de index nul.

08:47.650 --> 08:54.340
Op die manier krijgen we het maximum van de waarden die de volgende staat vertegenwoordigd door de index

08:54.340 --> 09:01.340
nul volgens alle acties die worden vertegenwoordigd door de index één en hoe perfect we onze volgende output krijgen.

09:01.420 --> 09:02.770
Dit is een nieuwe stap.

09:02.770 --> 09:03.970
Daarom hadden we de waarschuwing.

09:04.180 --> 09:04.960
Maar dat is prima.

09:04.960 --> 09:07.470
We zullen het nu gebruiken om het doel te berekenen.

09:08.260 --> 09:11.960
En over het doel gesproken, dat is de volgende stap van deze leerfunctie.

09:12.400 --> 09:13.000
Dus daar gaan we.

09:13.060 --> 09:15.140
Doel is gelijk aan.

09:15.520 --> 09:17.920
Laten we nu teruggaan naar ons handboek.

09:18.220 --> 09:20.320
Het doel is gelijk aan de beloning.

09:20.560 --> 09:22.060
Plus gamma-tijden.

09:22.090 --> 09:26.950
De volgende output is het maximum van de waarden in de volgende toestand volgens de acties.

09:27.430 --> 09:28.000
Dus daar gaan we.

09:28.070 --> 09:28.810
Laten we dat doen.

09:29.200 --> 09:31.180
Dus dat is gelijk aan jezelf.

09:31.540 --> 09:35.520
Dat Gamma en Zelda Gamma is geïnitialiseerd.

09:35.530 --> 09:36.770
Hier wordt het geïntroduceerd.

09:36.790 --> 09:42.100
Dat is een variabele van een object-gecentreerde gamma-tijden.

09:42.100 --> 09:47.860
De volgende output, zoals we net zeiden, plus de beloning.

09:48.130 --> 09:49.600
Dat is de beste beloning.

09:49.750 --> 09:51.180
We werken hier met patches.

09:51.520 --> 09:52.930
Dus plus-batch.

09:54.570 --> 10:02.670
Beloning, en dat is het doelwit in één symbool van het geheugen, gemap vermenigvuldigd met de volgende output, plus de

10:02.670 --> 10:03.150
beloning.

10:03.750 --> 10:04.950
Oké, perfect.

10:04.980 --> 10:06.750
Dus nu hebben we onze output's.

10:06.990 --> 10:12.870
We hebben ook ons doel en daarom kunnen we het verlies berekenen, het verlies dat de fout van

10:12.870 --> 10:13.960
de voorspelling vertegenwoordigt.

10:14.340 --> 10:21.570
Dus laten we dit verlies T noemen. G. verlies TDRS, natuurlijk, voor het temporele verschil dat, nogmaals, de kern

10:21.570 --> 10:22.710
vormt van Q Learning.

10:23.100 --> 10:30.120
En dit verlies zal gelijk zijn aan het besef van de WHO dat het leren veel verbetert.

10:30.390 --> 10:34.160
Dat is de verloren functie die we zullen kiezen voor onze kunstmatige intelligentie.

10:34.650 --> 10:39.030
Voor degenen onder u die van de deep learning-cursus komen, is dat echt de laatste die ik aanbeveel als

10:39.030 --> 10:40.460
u deep learning wilt implementeren.

10:40.650 --> 10:43.080
En hoe gaan we dit Hueber-verlies krijgen?

10:43.320 --> 10:50.310
Nou, nogmaals, we gaan een functie nemen van de functionele module vertegenwoordigd door F, en

10:50.310 --> 10:55.140
daarom ga ik hier onze functionele module F gebruiken.

10:55.320 --> 11:03.240
En de Hubble kan worden verkregen dankzij de functie smooth's L1 Luss, die zo presidenta is.

11:03.690 --> 11:07.010
En dat is echt de beste verloren functie die ik aanbeveel voor diep.

11:07.020 --> 11:07.490
V Leren.

11:07.770 --> 11:13.110
Het verbetert echt het Q-leren, maar dit is een functie, dus ik voeg wat haakjes toe en nu

11:13.110 --> 11:14.430
is er niets eenvoudiger.

11:14.700 --> 11:19.010
De argumenten die we moeten invoeren zijn de voorspellingen en de doelen.

11:19.260 --> 11:23.850
Dus de voorspelling is natuurlijk onze output, want dat is de output van het neurale netwerk.

11:24.000 --> 11:27.310
Weet je, de output van het neurale netwerk is wat het neurale netwerk voorspelt.

11:27.570 --> 11:28.690
Dat is dus de voorspelling.

11:29.130 --> 11:31.640
Het eerste argument hier is dus outputs.

11:32.280 --> 11:35.490
En dan is het tweede argument natuurlijk het doelwit.

11:35.970 --> 11:42.000
Het ding dat we proberen te krijgen en het is al perfect berekend, we kunnen direct doelen invoeren.

11:43.020 --> 11:43.530
Perfect.

11:43.530 --> 11:47.300
En nu hebben we de VS gewoon een beetje vergeten hier.

11:48.060 --> 11:48.690
Daar gaan we.

11:48.720 --> 11:50.100
Nu zou de waarschuwing moeten verdwijnen.

11:50.760 --> 11:51.980
Ja perfect.

11:51.990 --> 11:57.930
En nu we de laatste fout hebben, kunnen we deze fout terug in het netwerk propageren om de gewichten

11:57.930 --> 12:00.060
bij te werken met stochastische gradiëntafdaling.

12:00.330 --> 12:02.980
En dat is precies wat we gaan doen in de volgende stap.

12:03.360 --> 12:10.950
Dus wat we nu natuurlijk moeten doen, zoals je zou kunnen raden, is onze optimizer, onze optimizer,

12:10.950 --> 12:13.230
die we hier opnieuw introduceren.

12:13.650 --> 12:14.580
We hebben het geïnitialiseerd.

12:14.850 --> 12:19.650
En dat is een Atom Optimizer, die eigenlijk een object is van de Atom-klasse.

12:20.010 --> 12:23.400
En het is al uitgerust met de parameters van ons model.

12:23.640 --> 12:27.390
En we kozen al voor een leersnelheid van 0. 01 procent.

12:27.690 --> 12:34.830
Zo perfect, onze optimizer is klaar, maar nu moeten we hem toepassen op de laatste fout om een stochastische gradiëntafdaling uit

12:34.830 --> 12:35.610
te voeren.

12:35.790 --> 12:42.450
En als ze dat doen bij het werken met jagers, is het eerste wat we moeten doen, het bij elke iteratie van de

12:42.450 --> 12:43.860
lus opnieuw te initialiseren.

12:44.040 --> 12:50.940
We moeten de optimizer van de ene interation naar de andere in de lus hiervan opnieuw initialiseren om de gradiëntafdaling te krijgen

12:50.940 --> 12:54.570
en deze bij elke iteratie van de lus opnieuw te initialiseren.

12:55.050 --> 12:59.540
Welnu, we gaan de volgende methode gebruiken, die nul gret is.

12:59.790 --> 13:00.300
Daar gaan we.

13:00.300 --> 13:04.830
Zero gravity zal uw optimizer bij elke iteratie van de lus opnieuw initialiseren.

13:05.080 --> 13:06.720
Laten we dan de haakjes niet vergeten.

13:07.380 --> 13:08.010
Perfect.

13:08.010 --> 13:14.520
En nu het opnieuw is geïnitialiseerd, kunnen we achterwaartse voortplanting uitvoeren met onze optimizer.

13:15.000 --> 13:16.110
En hoe doen we dat?

13:16.350 --> 13:23.130
Welnu, we nemen ons verlies en we gaan het terug naar het netwerk verspreiden en het terug naar het

13:23.130 --> 13:24.120
netwerk verspreiden.

13:24.300 --> 13:32.250
We moeten de achterwaartse functie gebruiken en binnen deze achterwaartse functie raad ik aan om variabelen in te voeren, te

13:32.520 --> 13:36.310
behouden, te onderstrepen en gelijk te stellen aan waar.

13:37.050 --> 13:40.710
Ik raad aan om dit te doen omdat dit de terugvermeerdering zal verbeteren.

13:41.070 --> 13:46.380
Het gebruik van retourvariabelen is gelijk aan waar om wat geheugen vrij te maken en we moeten het geheugen vrijmaken

13:46.380 --> 13:48.690
omdat we meerdere keren op het verlies gaan.

13:49.050 --> 13:52.450
Dus dat zal de trainingsprestaties zeker verbeteren.

13:52.710 --> 13:58.890
En tot slot, de laatste stap van deze leerfunctie is het bijwerken van de gewichten volgens de achterwaartse voortplanting.

13:58.890 --> 14:02.400
Dat is in overeenstemming met hoeveel het gewicht heeft bijgedragen aan de fout.

14:02.610 --> 14:10.770
En om dit te doen, nemen we onze optimizer opnieuw, die werd geïnitialiseerd en opnieuw geïnitialiseerd, en we

14:10.920 --> 14:12.780
gebruiken de stapfunctie.

14:13.230 --> 14:18.890
En gewoon met deze regel code, door de stapfunctie te gebruiken, worden de gewichten bijgewerkt.

14:19.350 --> 14:24.990
Dat is deze regel code die wordt bijgewerkt naar gewicht, deze regel code die de fout in het neurale

14:24.990 --> 14:25.680
netwerk verspreidt.

14:26.040 --> 14:29.730
En deze regel code gebruikt de optimizer om de gewichten bij te werken.

14:30.240 --> 14:33.750
En dan gaan we, we hebben een lerend neuraal netwerk.

14:35.010 --> 14:36.500
Oké, dus gefeliciteerd.

14:36.690 --> 14:43.290
Dit was waarschijnlijk het meest technische en moeilijkste deel van dit diepgaande leermodel waarvan ik weet dat het tegenwoordig soms

14:43.290 --> 14:46.400
lastig kan zijn met deze op knijpen en knijpen.

14:46.710 --> 14:51.900
Maar uiteindelijk, beloof ik, krijg je een zeer functioneel neuraal netwerk en dus

14:51.900 --> 14:55.590
een diepgaand leermodel en uiteindelijk een geweldige kunstmatige intelligentie.

14:56.430 --> 15:02.190
Dus laten we nu verder gaan met de volgende stap van ons deep learning-model, de update-functie die uiteraard wordt

15:02.370 --> 15:06.800
bijgewerkt wanneer de A. L. zal de nieuwe staat ontdekken.

15:07.020 --> 15:12.150
Dus, weet je, het zal de nieuwe staat ontdekken en dan zal het de beloning ontvangen, afhankelijk van

15:12.150 --> 15:14.840
de actie die wordt weergegeven en deze nieuwe staat.

15:15.030 --> 15:19.260
We zullen dit dus regelen met de update-functie en dit zullen we doen in de volgende tutorial.

15:19.530 --> 15:21.240
Tot die tijd, geniet van A. L..
