WEBVTT

00:00.330 --> 00:02.070
Hallo en welkom bij deze tutorial.

00:02.370 --> 00:07.500
Oké, dus we beginnen met het eerste bestand van onze moraal en het belangrijkste bestand, dat

00:07.500 --> 00:08.730
model, die taart.

00:08.980 --> 00:13.920
En dit is in dit bestand dat we het brein van het hele model zullen

00:13.920 --> 00:19.410
implementeren, weet je, het brein in het hart van het ATC-model dat in dit bestand staat, dat we

00:19.410 --> 00:23.970
het neurale netwerk zullen maken, dat natuurlijk wat convolutionele neurale netwerken, omdat we natuurlijk

00:23.970 --> 00:25.370
nog steeds diepgaand leren.

00:25.530 --> 00:27.390
Dus ik zal nog steeds ogen hebben.

00:27.690 --> 00:32.870
En binnen dit neurale netwerk zullen we alles integreren wat te maken heeft met het actieve criticusmodel.

00:33.210 --> 00:37.890
En er is een bonus, zoals ik je al zei, we implementeren een van de krachtigste H3C-modellen.

00:38.040 --> 00:44.010
En wat het zo krachtig maakt, is dat het een vernieuwingsnetwerk zal bevatten, en meer bepaald in Elysium, het kortetermijngeheugen voor

00:44.010 --> 00:49.010
de lange termijn, zodat we de temporele eigenschappen kunnen leren van wat er in het spel gebeurt.

00:49.170 --> 00:54.060
Dat zijn eigenlijk de temporele eigenschappen van de input zodat de voorspellingen nog beter kunnen.

00:55.110 --> 00:55.950
Dus daar gaan we.

00:55.950 --> 01:01.320
We implementeren een zeer krachtig model dat in principe alle neurale netwerken combineert die we in

01:01.320 --> 01:02.370
de verdiepingscursus zagen.

01:02.520 --> 01:07.800
Dat is een kunstmatig nieuw netwerk, een convolutioneel neuraal netwerk en een terugkerend neuraal netwerk.

01:08.040 --> 01:13.170
En in het hart van al deze netwerken is er natuurlijk het ABC-model dat zeer krachtig zal

01:13.170 --> 01:13.690
zijn.

01:14.280 --> 01:15.120
Dus laten we dit doen.

01:15.120 --> 01:18.050
Laten we dit model aanvallen en implementeren.

01:18.330 --> 01:24.030
Dus we beginnen met het maken van twee functies die slechts enkele functies zijn die ervoor zorgen dat we de

01:24.030 --> 01:28.050
gewichten kunnen initialiseren, want, weet je, we zullen een aantal nieuwe netwerken

01:28.050 --> 01:33.060
hebben en daarom zullen we gewichten hebben en we willen deze twee functies eerst maken, zodat we

01:33.060 --> 01:37.800
al een tool hebben om heel gemakkelijk te integreren in het hele model, het neurale netwerk.

01:38.160 --> 01:41.520
Dus deze twee functies worden genormaliseerde kolommen.

01:41.530 --> 01:49.140
En dat is eigenlijk een functie die niet alleen sommige gewichten kan initialiseren, maar ook een specifieke variantie van een zwaartepunt

01:49.140 --> 01:50.220
kan instellen.

01:50.250 --> 01:52.520
Dat is dus precies wat we nu gaan implementeren.

01:52.830 --> 01:57.510
En dan zullen we de tweede functie implementeren, die de gewichten in zijn functie zal zijn, en die

01:57.510 --> 02:00.990
in principe de gewichten op een optimale manier voor het leren zal initialiseren.

02:01.680 --> 02:02.210
Oke.

02:02.220 --> 02:07.770
En als we klaar zijn met deze twee functies, beginnen we met het implementeren van het neurale netwerk.

02:08.280 --> 02:08.900
Dus laten we het doen.

02:08.910 --> 02:11.940
Laten we snel deze twee functies maken.

02:11.950 --> 02:14.070
Dus ik begin hier met een def.

02:14.250 --> 02:18.120
Dan ga ik de naam van deze functie geven die is genormaliseerd.

02:18.690 --> 02:20.460
Onderstreep kolommen.

02:21.240 --> 02:23.420
Underscore initialiseren zijn.

02:24.550 --> 02:31.000
Daar gaan we, en deze functie heeft slechts twee invoer nodig, eerst worden de gewichten die

02:31.420 --> 02:37.960
we willen initialiseren en de standaarddeviatie, omdat, zoals ik net zei, we een specifieke variantie willen instellen

02:37.960 --> 02:40.080
voor onze voorlopige gewichten.

02:40.090 --> 02:44.770
En als je wilt begrijpen waarom we dit moeten doen, is dat omdat, weet je, wanneer we

02:44.770 --> 02:48.940
het neurale netwerk maken, er de acteur en de criticus zullen zijn, volgens het H3C-model.

02:49.150 --> 02:53.410
En we gaan twee aparte, volledig verbonden lagen maken, één voor de acteur en één voor de criticus.

02:53.680 --> 02:59.920
En deze twee volledig verbonden lagen zullen gewichten hebben en we zullen een standaarddeviatie instellen voor elk van

02:59.920 --> 03:01.480
deze twee groepen gewichten.

03:01.660 --> 03:05.410
Dus wat we zullen doen is een kleine standaarddeviatie instellen voor de acteur.

03:05.530 --> 03:12.310
Het zal rond de 0 zijn. 01 en een grote standaarddeviatie voor de criticus, die rond de één zal liggen, denk ik.

03:12.610 --> 03:18.610
Daarom maken we deze functie zodat we heel gemakkelijk de standaarddeviatie kunnen instellen voor de gewichten die we later

03:18.610 --> 03:21.220
zullen initialiseren voor de acteur in de.

03:21.790 --> 03:22.840
Daarom doen we dit.

03:23.440 --> 03:26.230
Dus nu gaan we gewoon een standaardwaarde instellen.

03:26.230 --> 03:31.610
Maar dit zal later veranderen wanneer we de gewichten initialiseren zodat Shuzo één punt nul is.

03:32.080 --> 03:32.620
Oke.

03:32.800 --> 03:36.700
En nu zijn we klaar om te definiëren wat er in deze functie zit.

03:37.270 --> 03:41.680
Dus wat we eerst voorbereiden, is de uitvoer die we gaan oproepen.

03:41.860 --> 03:45.680
Dus deze out-variabele is wat door deze functie wordt geretourneerd.

03:46.210 --> 03:49.830
En dus eerst, wat we gaan doen is het initialiseren.

03:50.200 --> 03:56.530
Dus zoals je hebt begrepen, zal deze output een gevoel van gewicht zijn met een specifieke standaarddeviatie.

03:56.680 --> 04:01.120
Maar voordat we zorgen voor het instellen van de standaarddeviatie, willen we deze gewoon initialiseren.

04:01.240 --> 04:05.800
En dan zullen we hier de standaarddeviatie instellen, wat het argument is, dat de invoer is van deze

04:05.800 --> 04:06.220
functie.

04:06.730 --> 04:10.590
Dus om intensieve gewichten te initialiseren, weet je misschien hoe je het moet doen.

04:10.600 --> 04:11.490
We hebben het al gedaan.

04:12.040 --> 04:20.170
We gaan onze Tahj-bibliotheek gebruiken en van de Stotch-bibliotheek nemen we de RAND en functie, die

04:21.040 --> 04:26.940
de toortssensor initialiseren met willekeurige gewichten die een normale verdeling volgen.

04:27.400 --> 04:30.620
Dus daarom wordt het front-end genoemd en is het voor normaal.

04:31.060 --> 04:36.070
Dus wat we nu gewoon moeten invoeren, is het aantal elementen dat de sensor zal bevatten.

04:36.310 --> 04:41.420
En dit aantal elementen is natuurlijk het aantal gewichten, omdat we hier eigenlijk de sensor

04:41.420 --> 04:42.790
voor deze gewichten initialiseren.

04:43.180 --> 04:47.260
Om dit aantal elementen te krijgen, kunnen we gewoon onze gewichten nemen.

04:48.490 --> 04:57.310
En bij DOT, om de grootte tussen haakjes te krijgen, en dit geeft het aantal elementen in gewicht zodat het een fakkel zal

04:57.310 --> 05:03.430
creëren, Tenzer met hetzelfde aantal elementen van ons gewicht en het zal worden geïnitialiseerd met willekeurige

05:03.430 --> 05:05.920
gewichten volgens een normale verdeling .

05:06.730 --> 05:07.230
Oke.

05:07.240 --> 05:10.580
En nu is het tijd om de standaarddeviatie in te stellen.

05:10.600 --> 05:13.240
We willen dat dat hier de standaarddeviatie is.

05:13.390 --> 05:16.500
Dus wat we nu gaan doen is een simpele normalisatie.

05:16.810 --> 05:21.030
We hebben een fakkelgevoel voor gewichten en nu willen we het normaliseren.

05:21.460 --> 05:25.450
Om het te normaliseren, zullen we gewoon de expliciete berekening schrijven.

05:25.660 --> 05:35.360
Dus wat we hier gewoon moeten doen, is onze output nemen en deze bijwerken door deze te vermenigvuldigen met de standaarddeviatie.

05:35.380 --> 05:40.730
We willen gedeeld hebben door dit wat ik net heb genoemd.

05:40.960 --> 05:44.810
En om de som te krijgen, gaan we de vierkantswortelfunctie met fakkel gebruiken.

05:44.830 --> 05:50.170
En daarom neem ik hier naartoe als QR t, dat is de vierkantswortelfunctie.

05:50.650 --> 05:55.640
En binnen gaan we het kwadraat invoeren van enkele van de gewichten van onze vector.

05:55.990 --> 06:03.430
En dus nemen we onze output, dan gebruiken we de machtsfunctie waaraan we twee toevoegen omdat we het kwadraat

06:03.430 --> 06:08.350
van de som willen nemen en dan nemen we daarom de som.

06:08.860 --> 06:15.910
En binnenin gaan we de index specificeren van de kolom die het gewicht één tot sommigen bevat.

06:16.730 --> 06:25.020
En om deze gewichten dan apart te krijgen, omdat we ze goed willen verzenden, gebruiken we het

06:25.070 --> 06:29.060
onderstrepingsteken uitbreiden als een functie van onze uitvoer.

06:29.360 --> 06:29.720
Oke.

06:29.730 --> 06:36.550
Dus dit zal het gewicht eruit halen, wat tot nu toe was geïnitialiseerd als een toortsoverdracht van gewichten.

06:36.550 --> 06:38.030
Dus dat krijgt al deze gewichten.

06:38.180 --> 06:43.490
We nemen de som van het kwadraat en dan nemen we de vierkantswortel om de normalisatie toe te passen.

06:43.850 --> 06:50.570
En het feit dat we deze standaarddeviatie bij de teller hebben, zorgt ervoor dat we het hier kunnen lezen.

06:51.780 --> 07:00.810
Varianten van alts zullen gelijk zijn aan het kwadraat van de standaarddeviatie, deze formule zorgt er hier voor dat de betekenis van

07:00.810 --> 07:06.900
gewichten die werden geïnitialiseerd een variantie zal hebben die gelijk zal zijn aan het kwadraat

07:06.900 --> 07:10.340
van de standaarddeviatie die we als argumenten invoeren.

07:10.980 --> 07:17.880
En zo kunnen we een specifieke standaarddeviatie instellen voor de toekomstige acteur en criticus die we binnenkort gaan

07:17.880 --> 07:18.360
maken.

07:18.660 --> 07:24.180
En we kiezen een kleine standaarddeviatie voor de acteur en een grote voor de criticus.

07:24.180 --> 07:25.770
En we zullen dit heel gemakkelijk doen.

07:25.770 --> 07:26.870
Bedankt deze functie.

07:27.600 --> 07:28.070
Oke.

07:28.080 --> 07:30.780
En dus hebben we nu nog maar één ding te doen.

07:31.050 --> 07:37.920
Het is natuurlijk om de uitvoer terug te geven die nu is genormaliseerd met deze specifieke standaarddeviatie.

07:38.760 --> 07:39.240
Oke.

07:39.240 --> 07:40.250
Zo perfect.

07:40.260 --> 07:42.390
Dat is de eerste functie die we moesten maken.

07:42.720 --> 07:47.060
Dat is de eerste tool die we heel graag zullen gebruiken om een 3C-brein te maken.

07:47.190 --> 07:49.020
We moeten nu nog een functie maken.

07:49.200 --> 07:50.910
Het zullen de gewichten zijn in zijn functie.

07:51.150 --> 07:56.760
En dat is slechts een functie die, herinner ik, de gewichten initialiseert om het leren optimaal te maken.

07:57.420 --> 07:59.370
Dus laten we dit de komende tijd doen.

07:59.370 --> 08:01.010
En tot die tijd, geniet ervan.