WEBVTT

00:00.300 --> 00:06.000
Hallo en welkom bij de allerlaatste stap van dit deel één gebouw, het enige dat we nu nog

00:06.000 --> 00:12.000
hoeven te doen, is deze grote voorwaartse functie te maken die het signaal vanaf het allereerste begin zal verspreiden

00:12.210 --> 00:17.010
wanneer de hersenen het beeld naar de het einde, wanneer het oog de actie speelt.

00:17.260 --> 00:22.440
Dus we gaan deze hele functie maken en dat zal onze laatste stap zijn voordat we verder

00:22.440 --> 00:26.190
gaan met deel twee, training of oog met diep, convolutief leren.

00:26.790 --> 00:27.710
Dus laten we dit doen.

00:27.900 --> 00:33.630
We gaan de functie-aanroep aannemen, die eigenlijk vergelijkbaar is met de init-functie.

00:33.630 --> 00:35.460
Dat wil zeggen, het is een bestaande functie.

00:35.640 --> 00:40.800
Maar deze keer gebruiken we het om wat andere functies aan te roepen, degene die we eerder maakten, want, weet je,

00:40.800 --> 00:45.170
we gaan de voorwaartse functie van de hersenen en de voorwaartse functie van het lichaam gebruiken.

00:45.450 --> 00:49.860
En dus gebruiken we deze schoolfunctie nu om deze functies in feite aan te roepen.

00:50.400 --> 00:52.860
Zogenaamd zal twee argumenten aannemen.

00:53.010 --> 00:59.130
De eerste is natuurlijk het zelf, het object en een tweede argument, wat volgens jou zal

00:59.130 --> 00:59.910
het zijn?

01:00.180 --> 01:02.580
Nou, we doen deze keer de hele verspreiding.

01:02.730 --> 01:07.980
Dus wat we als invoer willen nemen, zijn natuurlijk de invoerafbeeldingen, want dat is natuurlijk

01:07.980 --> 01:08.820
het startpunt.

01:08.910 --> 01:14.010
Wanneer de A. L. het spel speelt, is het eerst de beelden van

01:14.010 --> 01:16.500
het spel visualiseren, dan de signalen in de hersenen verspreiden en dan de actie plaatsen.

01:17.020 --> 01:19.590
Daarom zal het tweede argument inputs zijn.

01:20.430 --> 01:24.110
En nu zijn we klaar om deze hele verspreiding te maken.

01:24.660 --> 01:25.650
Dus laten we dit doen.

01:25.830 --> 01:27.630
OK, dus de eerste stap, wat is het?

01:27.750 --> 01:31.530
De eerste stap is het ontvangen van de invoerbeelden van het spel.

01:31.980 --> 01:37.230
En aangezien deze afbeeldingen het neurale netwerk binnenkomen, kun je je voorstellen dat we ze in

01:37.350 --> 01:39.420
een speciale structuur moeten formatteren.

01:39.570 --> 01:42.260
En deze structuur is natuurlijk een fakkelstructuur.

01:42.690 --> 01:48.480
Dus het eerste dat zal gebeuren, is dat we deze afbeeldingen omzetten in een array, en

01:48.480 --> 01:51.030
vervolgens een getal omzetten in een toortssensor.

01:51.270 --> 01:57.180
En tot slot zullen we de toortssensor in een levensvatbare toorts plaatsen die zowel het spanraam als een gradiënt

01:57.180 --> 01:57.960
zal bevatten.

01:58.170 --> 02:03.720
Dat is voor onze dynamische grafieken om de gradiënten later zeer efficiënt te berekenen voor stochastische

02:03.720 --> 02:04.160
gradiëntafdaling.

02:04.470 --> 02:06.080
Dus dat is onze eerste stap.

02:06.090 --> 02:12.180
En als we eenmaal het juiste formaat van onze afbeeldingen hebben, kunnen ze het neurale netwerk binnendringen en

02:12.180 --> 02:15.370
daar doen we de hele verspreiding van de signalen.

02:16.230 --> 02:20.010
Dus laten we deze eerste stap doen, de afbeelding converteren naar het juiste formaat.

02:20.280 --> 02:22.740
Dus onze beelden zijn tot nu toe input.

02:23.070 --> 02:26.400
Dus nu gaan we een nieuwe variabele maken, die ik input noem.

02:26.640 --> 02:29.130
Dus dat is de echte input van het neurale netwerk.

02:29.340 --> 02:31.470
En deze input, wat gaat het worden?

02:31.770 --> 02:34.050
Wel, eerst moeten we onze inbreng nemen.

02:34.380 --> 02:36.300
Dat zijn onze originele beelden.

02:36.720 --> 02:42.000
Vervolgens, zoals we al zeiden, willen we deze afbeeldingen converteren naar geen arrays.

02:42.180 --> 02:48.880
Dus om dit te doen, kunnen we gewoon non-pay nemen, dat een snelkoppeling heeft, en dan de functiearray.

02:49.380 --> 02:53.490
Dus we plaatsen invoer tussen haakjes van de functiereeks die we nu gaan gebruiken.

02:53.490 --> 02:55.710
Het wordt door arrays in iets omgezet.

02:56.040 --> 03:02.820
Maar aangezien de verkoop van de arrays de pixels zal bevatten, is het eigenlijk veiliger om het type

03:02.820 --> 03:04.040
float te specificeren.

03:04.350 --> 03:10.710
Het is beter om ervoor te zorgen dat we nu wat floats hebben en ervoor te zorgen dat we NPE kunnen gebruiken die

03:11.130 --> 03:11.970
hier doorheen drijven.

03:12.540 --> 03:13.070
Oke.

03:13.260 --> 03:16.850
Dus nu hebben we nog een aantal, maar dan met het type float.

03:17.570 --> 03:18.050
Oke.

03:18.060 --> 03:19.500
En dat is ook nog om een andere reden.

03:19.500 --> 03:23.900
Het is dat sensoren per definitie arrays van een enkel type zijn.

03:24.090 --> 03:27.150
En dus kiezen we het enkele type als float, float 32.

03:27.900 --> 03:28.240
Oke.

03:28.240 --> 03:33.570
Dus nu we onze cijfers hebben, is de volgende stap om die om te zetten in een toortssensor.

03:33.810 --> 03:42.090
En om dit te doen, kunnen we daar bijvoorbeeld naar toe gebruiken en dan de van onderstreping niet-bevooroordeelde functie die dat

03:42.600 --> 03:46.010
zal omzetten in een toortssensor die we gebruiken.

03:46.020 --> 03:52.260
En nu is de laatste stap om deze toortssensoren in een toortsvariabele te plaatsen die zowel de tensor als de

03:52.260 --> 03:52.980
gradiënt bevat.

03:53.220 --> 03:54.780
En je weet hoe je het moet doen.

03:54.810 --> 04:03.330
Natuurlijk nemen we onze variabele klasse omdat eigenlijk alles wat zich binnen deze variabele bevindt, eigenlijk de invoer is

04:03.330 --> 04:05.190
van de variabele klasse.

04:05.580 --> 04:10.860
Maar ik wilde je dat op deze manier laten zien, want, weet je, we beginnen met onze

04:10.860 --> 04:15.630
invoerbeelden, dan converteren we ze naar geen arrays, dan naar toortssensoren en dan naar volume.

04:15.990 --> 04:16.830
En nu zitten we goed.

04:17.070 --> 04:23.340
Ze mogen het neurale netwerk betreden dat eerst de ogen van de A is. L. en vervolgens de volledig verbonden lagen om

04:23.340 --> 04:25.230
tot de voorspellingen te leiden.

04:26.070 --> 04:29.910
Dus over de ogen van de ogen gesproken, dat is precies wat we nu gaan doen.

04:30.360 --> 04:35.720
We gaan deze toegestane beelden nu verspreiden in de ogen van de ogen.

04:35.730 --> 04:38.400
Dat is door de drie convolutionele lagen.

04:38.670 --> 04:43.770
En om dit te doen, ga je nu zien hoe het zo eenvoudig

04:43.770 --> 04:52.260
is dat, omdat we ons brein en ons lichaam al hebben vanuit de init-functie, we gewoon ons brein zo zelf dat brein moeten

04:52.260 --> 04:59.760
nemen en dit brein toepassen op de invoerbeelden en dat zal zich voortplanten dankzij de voorwaartse functie hier vanuit de hersenen.

05:00.290 --> 05:02.910
Dat zal de signalen in de hersenen verspreiden.

05:03.290 --> 05:09.110
En aangezien de voorwaartse functie van de hersenen terugkeert, signaleert de output dat de neuronen van

05:09.110 --> 05:11.000
de outputlaag de kernwaarden bevatten.

05:11.270 --> 05:16.030
Welnu, deze cel van de herseninvoer hier zal dit uitgangssignaal terugsturen.

05:16.280 --> 05:21.680
En daarom gaan we hier plaatsen wanneer het terugkeert naar een variabele en we gaan het

05:21.680 --> 05:23.030
heel eenvoudig output noemen.

05:24.020 --> 05:26.370
En deze output is het outputsignaal van de hersenen.

05:26.720 --> 05:31.910
En nu we het uitgangssignaal van de hersenen hebben, moeten we dit uitgangssignaal naar het lichaam

05:31.910 --> 05:32.510
verspreiden.

05:32.780 --> 05:36.650
En om dit te doen, gaan we de tweede voorwaartse functie van het lichaam gebruiken.

05:36.860 --> 05:45.230
En om dit te doen, hoeven we alleen maar ons lichaam te nemen en het natuurlijk toe te passen op de output, omdat

05:45.260 --> 05:50.360
de voorwaartse functie van het lichaam als input outputsignalen van de hersenen gebruikt.

05:50.510 --> 05:55.640
Dus dat is precies wat de output nu is en de acties retourneert.

05:55.790 --> 06:03.050
En daarom, omdat het de acties retourneert, gaan we hier acties toevoegen die gelijk zijn aan Southbury-uitvoer.

06:03.740 --> 06:04.100
Oke.

06:04.100 --> 06:09.650
Dus nu kun je zien dat we heel eenvoudig de signalen in de hersenen hebben gepropageerd en vervolgens van

06:09.650 --> 06:16.010
de hersenen naar het lichaam, eerst door de voorwaartse functie van de hersenen te gebruiken, waardoor we de invoerbeelden invoeren en ze

06:16.010 --> 06:19.460
vervolgens in de hersenen verspreiden om terug te keren de kernwaarden.

06:20.030 --> 06:25.400
En dan verspreiden we dit uitgangssignaal in het lichaam met de voorwaartse functie van ons lichaam om de actie

06:25.400 --> 06:26.270
te laten spelen.

06:26.720 --> 06:32.240
En dus nu is het enige dat we nog moeten doen, en dat is de allerlaatste regel code

06:32.240 --> 06:38.810
van dit deel één om het gebied te bouwen, nou, we moeten de actie teruggeven om te spelen, en dat zijn acties.

06:39.380 --> 06:45.070
Op dit moment hebben de acties echter het torch-formaat en moeten we ze terug converteren naar niet-direct.

06:45.080 --> 06:51.500
En om dit te doen, nemen we de gegevensstructuur van deze acties en voegen hier de niet-planfunctie

06:51.650 --> 06:52.430
toe.

06:52.700 --> 06:53.670
En daar gaan we.

06:53.690 --> 06:56.240
Nu hebben we de acties in het juiste formaat geretourneerd.

06:56.630 --> 06:57.950
Gefeliciteerd dus.

06:57.950 --> 07:00.410
We zijn nu klaar met dit eerste deel.

07:00.590 --> 07:03.070
We hebben de AI in drie stappen gebouwd.

07:03.230 --> 07:04.780
Eerst maakten we de hersenen.

07:04.940 --> 07:06.650
Ten tweede hebben we het lichaam gemaakt.

07:06.680 --> 07:13.160
En ten derde verzamelden we de hersenen en het lichaam en verspreidden we het hele signaal van de ogen naar het moment dat

07:13.190 --> 07:14.650
we de actie spelen.

07:15.440 --> 07:16.970
Dus dat is een eerste stap gezet.

07:17.000 --> 07:18.260
Dat was een enorme stap.

07:18.260 --> 07:21.950
Maar nu, zoals je begreep, hebben we een AI gebouwd, maar het is nog steeds stom.

07:22.070 --> 07:26.270
We moeten hem trainen om intelligent te zijn, dus we moeten hem trainen om te doen wat we willen dat hij doet.

07:26.480 --> 07:31.190
En om dit te doen, gaan we de beloning gebruiken om de omgeving te doen, weet je, omdat

07:31.190 --> 07:37.160
het leert van de beloningen door versterkt te worden wanneer het een goede beloning krijgt en door gestraft of verzwakt te worden wanneer het

07:37.160 --> 07:38.270
een slechte beloning krijgt.

07:38.540 --> 07:41.150
Dus dat is waar het leren van de cue in het spel komt.

07:41.510 --> 07:47.060
En dat is precies wat we in dit deel zullen doen om de lucht te trainen met diep, convolutief leren.

07:47.300 --> 07:48.590
Ik kan niet wachten om te beginnen.

07:48.590 --> 07:50.340
En tot die tijd, geniet van I.
