WEBVTT

00:00.330 --> 00:02.520
Hallo en welkom bij deze Python-tutorial.

00:03.000 --> 00:07.920
Oké, in deze tutorial gaan we de functie maken die op elk moment de juiste actie

00:07.920 --> 00:08.400
selecteert.

00:08.670 --> 00:14.310
Dus eigenlijk gaan we de onderdelen implementeren die ervoor zorgen dat de kaarten de juiste beweging maken op elk moment

00:14.460 --> 00:19.260
dat naar links, recht of rechts gaat om het doel te bereiken en de obstakels te vermijden.

00:19.260 --> 00:19.950
Dat is de.

00:20.880 --> 00:22.180
Dus laten we dit nu doen.

00:22.230 --> 00:27.780
We beginnen, zoals gewoonlijk, met een dove om een functie te definiëren, en dan geven we een naam aan

00:27.780 --> 00:30.120
onze functie, die we select gaan noemen.

00:31.090 --> 00:37.990
Actie, dan enkele haakjes en deze functie selecteren voor actie hebben twee argumenten nodig, de eerste is zoals gewoonlijk

00:37.990 --> 00:40.900
zelf, om naar het object te verwijzen.

00:41.260 --> 00:45.770
En het tweede argument, dat volgens jou, welk argument zal zijn?

00:46.240 --> 00:47.290
Nou, wat zou het kunnen zijn?

00:47.690 --> 00:53.650
Als je erover nadenkt, komt de actie die we selecteren uit de outputs van het neurale netwerk omdat

00:53.650 --> 00:59.200
de outputs van het neurale netwerk de kernwaarden zijn voor elk van de drie mogelijke acties en

00:59.320 --> 01:04.810
dus de actie die we spelen, de actie die de output van het neurale netwerk hangt

01:04.810 --> 01:11.120
af van de input-status en de input-status is precies het tweede argument dat we nodig hebben voor de select action-functie.

01:11.680 --> 01:16.090
Het is omdat we letterlijk de output van het neurale netwerk gaan nemen.

01:16.330 --> 01:21.940
En natuurlijk is de output van het neurale netwerk direct afhankelijk van de input van het neurale netwerk.

01:22.210 --> 01:23.740
Dus dat wordt een argument.

01:24.100 --> 01:26.290
En nu kunnen we het elke naam geven.

01:26.500 --> 01:33.730
We zullen het eigenlijk toestand noemen omdat de invoer van de neurale netwerken de invoerstatussen zijn die worden

01:33.850 --> 01:39.570
gecodeerd door de vector van vijf dimensies, de drie signalen oriëntatie en minus oriëntatie.

01:39.940 --> 01:41.830
En dus wordt het nu gemakkelijk.

01:42.010 --> 01:47.800
We gaan de invoerstatussen invoeren in het neurale netwerk, degene die we hierboven hebben gebouwd, hier

01:47.800 --> 01:49.080
met de netwerkklasse.

01:49.450 --> 01:55.240
En dan krijgen we de outputs, de belangrijkste waarden voor elk van de drie mogelijke

01:55.240 --> 01:55.780
acties.

01:55.990 --> 02:01.120
En dan met behulp van de softmax-methode, die ik in deze tutorial ga uitleggen, gaan we

02:01.120 --> 02:02.430
de laatste actie spelen.

02:03.130 --> 02:04.150
Dus laten we dit doen.

02:04.330 --> 02:07.520
Laten we naar de functie gaan en dit allemaal implementeren.

02:08.320 --> 02:13.420
Dus het eerste waar we mee moeten beginnen, is wat ik zojuist heb genoemd, softmax.

02:14.110 --> 02:20.170
Het idee van de softmax is dat we gaan proberen om op elk moment de beste actie te spelen.

02:20.620 --> 02:24.250
Maar tegelijkertijd verkennen we de verschillende acties.

02:24.790 --> 02:25.890
En hoe kunnen we dat doen?

02:25.900 --> 02:30.770
Hoe kunnen we de beste actie krijgen om te spelen terwijl we de andere acties nog steeds verkennen?

02:31.120 --> 02:38.830
Welnu, we gebruiken dit idee van softmax, dat bestaat uit het genereren van een kansverdeling voor elk

02:38.830 --> 02:41.620
van de kernwaarden van actie.

02:42.260 --> 02:44.790
We hebben één sleutelwaarde voor elke actie.

02:45.010 --> 02:46.360
Ga naar links, ga rechtdoor of ga naar rechts.

02:46.690 --> 02:49.300
Maar deze waarde is ook afhankelijk van de invoerstatus.

02:49.570 --> 02:51.970
Dat is precies de CU-functie op intuïtie.

02:51.970 --> 02:55.720
Deze functie van de docent is een functie van de staat en de actie.

02:56.170 --> 03:02.170
Dus omdat we hier één invoerstatus hebben, wat de status hier is en drie mogelijke acties, hebben

03:02.170 --> 03:04.150
we drie sleutelwaarden voor actie.

03:04.150 --> 03:07.000
Eén, cue state actie twee en twee toestanden, actie drie.

03:07.330 --> 03:13.480
En we gaan een kansverdeling genereren met betrekking tot deze drie sleutelwaarden.

03:13.760 --> 03:19.000
Dat wil zeggen, we hebben één kans voor de eerste sleutelwaarde, één kans voor de tweede

03:19.000 --> 03:22.380
sleutelwaarde en een derde kans voor het derde kwartaal.

03:22.690 --> 03:25.030
En al deze drie kansen zullen optellen tot één.

03:25.510 --> 03:32.350
En dus gaan we dit allemaal doen met softmax en softmax zal een grote waarschijnlijkheid toekennen aan de

03:32.350 --> 03:33.200
hoogste waarde.

03:33.670 --> 03:40.270
Daarom is een alternatief voor Softmax een simpele amax, je weet wel, die direct het maximum van de Q-waarden

03:40.270 --> 03:40.990
neemt.

03:41.410 --> 03:44.410
Maar in dat geval onderzoeken we de andere acties niet.

03:44.800 --> 03:50.440
Dankzij deze kansen kunnen we ergens anders verkennen met een temperatuurparameter die we heel snel

03:50.440 --> 03:51.490
gaan zien.

03:52.060 --> 03:55.480
We kunnen ze nog steeds verkennen door deze temperatuurparameter te configureren.

03:55.870 --> 04:02.860
Daarom raad ik in het algemeen voor ontharingsmiddelen ten zeerste aan om een softmax te gebruiken in plaats van een eenvoudige amax.

04:03.310 --> 04:05.110
Oké, dus laten we Softmax implementeren.

04:05.110 --> 04:11.410
En daarom, zoals je hebt begrepen, aangezien Softmax de kansen van elk van de drie Q-waarden voor

04:11.410 --> 04:17.650
de drie mogelijke acties retourneert, nou ja, de eerste variabele die we gaan creëren is probs,

04:17.650 --> 04:19.900
uiteraard verwijzend naar deze kansen.

04:20.350 --> 04:21.880
Dus rekwisieten zijn gelijk aan.

04:22.150 --> 04:24.430
En nu gaan we onze softmax-functie nemen.

04:24.850 --> 04:27.730
En waar halen we het volgens jou vandaan?

04:28.180 --> 04:31.660
Nou, natuurlijk, onthoud dat we het daar naartoe hebben geïmporteerd.

04:31.660 --> 04:38.700
En dan de functionele module, die ik eraan herinner, de module is die de meeste acties bevat om een neuraal netwerk

04:38.710 --> 04:39.490
te implementeren.

04:39.700 --> 04:45.280
We hebben het de sneltoets F gegeven en dat is dus eigenlijk van deze functionele module dat we

04:45.460 --> 04:46.720
onze softmax-functie gaan gebruiken.

04:47.140 --> 04:53.860
Maar omdat we het de sneltoets f hebben gegeven, beginnen we hier met een F die functioneel voorstelt,

04:53.860 --> 04:56.020
waarvan we onze softmax-functie nemen.

04:56.020 --> 04:56.530
Hier is het.

04:56.830 --> 04:59.020
Dat is de eerste tussen haakjes.

04:59.620 --> 05:00.040
Oke.

05:00.040 --> 05:03.600
En wat moeten we nu invoeren in de functie van deze Suffolk?

05:04.000 --> 05:09.690
Nou, dat zijn natuurlijk de entiteiten waarvoor we een kansverdeling willen genereren.

05:10.030 --> 05:11.230
En wat zijn deze entiteiten?

05:11.390 --> 05:13.300
Nou, dat zijn natuurlijk de kernwaarden.

05:13.720 --> 05:16.510
Dus nu is de vraag, hoe kunnen we de belangrijkste waarden krijgen?

05:16.790 --> 05:20.800
De kernwaarden zijn natuurlijk de output van het neurale netwerk.

05:20.980 --> 05:23.140
En om deze uitgangen van het neurale netwerk te krijgen.

05:23.440 --> 05:24.420
Nou, daar gaan we.

05:24.460 --> 05:26.620
We moeten ons neurale netwerk nemen.

05:27.010 --> 05:30.430
Maar in feite hebben we het al, want dat is wat het is.

05:30.910 --> 05:37.360
Geïnitialiseerd in de energiefunctie, weet je, we hebben Selvig gemaakt, dat model, dat niets anders is dan ons

05:37.360 --> 05:41.180
normale netwerk omdat het een object is van de netwerkklasse.

05:41.410 --> 05:42.540
En dat is dus perfect.

05:42.640 --> 05:48.970
We kunnen gewoon ons model hier nemen en softmax dit model toepassen op de invoerstatus, wat hier het argument is,

05:48.970 --> 05:52.780
en dat zal de uitvoer retourneren waarnaar we op zoek zijn.

05:52.930 --> 05:54.020
Dat zijn de kernwaarden.

05:54.370 --> 05:59.260
En dus nu je intuïtie, waarom we het model hier moesten nemen om het in de invoerfunctie te introduceren, zou

05:59.710 --> 06:00.520
beter kunnen worden.

06:00.670 --> 06:05.920
Voor degenen onder u die beginnen met objectgeoriënteerd programmeren, u zult zien dat dit allemaal vanzelfsprekend

06:05.920 --> 06:06.330
wordt.

06:07.060 --> 06:08.700
Dus softmax dan.

06:08.710 --> 06:16.440
Dus we nemen ons model zelf dat model, want dit moet het model zijn van het object dat we hier hebben gemaakt.

06:17.050 --> 06:23.860
Maar dan moeten we de uitvoer van ons neurale netwerkmodel krijgen en daarom gaan we hier

06:23.860 --> 06:30.110
een haakje toevoegen waarin we goed gaan invoeren, de invoerstatus genaamd staat hier.

06:30.460 --> 06:37.450
Dus wat we eerst willen doen, is de staat binnengaan, maar nu moeten we ergens voorzichtig mee zijn.

06:37.780 --> 06:43.930
Staat ziet er op dit moment uit als een simpele staat, maar onthoud dat die staat eigenlijk

06:43.930 --> 06:51.040
een fakkel Tenzer zal zijn, want later gaan we deze zeldzamere staat gebruiken om het als het argument van de deselecteer-actiefunctie

06:51.040 --> 06:51.790
te gebruiken.

06:52.060 --> 06:57.070
Het argument van de staat dat hier staat, zal later in feite deze autodidact worden, die staat.

06:57.520 --> 07:02.380
En aangezien dit een fakkel is TANCER Nou, het model zal het accepteren, dus dat is prima.

07:02.710 --> 07:04.480
Maar nu kunnen we het algoritme verbeteren.

07:05.050 --> 07:12.400
Dus als jij als de staat een fakkel Tenzer is en zoals we eerder zeiden, zijn de meeste antwoorden verpakt in een

07:12.400 --> 07:14.980
variabele die ook een verloop zal bevatten.

07:15.520 --> 07:21.820
Dus wat we nu eerst gaan doen, is deze invoerstatus die intenser is, in een toortsvariabele

07:21.820 --> 07:22.320
wikkelen.

07:22.690 --> 07:27.760
Maar aangezien dit de invoerstatus is, zal er geen differentiatie zijn.

07:28.000 --> 07:33.370
We zullen de gradiënt van deze toestand naar variabel niet gebruiken in de berekeningen.

07:33.760 --> 07:42.460
En daarom, wat we nu gaan doen, is dit naar Tensas State omzetten in een fakkelvariabele.

07:44.640 --> 07:51.180
Zoals zo, maar dan om te specificeren dat we niet de gradiënt in de grafiek willen van alle berekeningen van

07:51.180 --> 07:52.060
de energiemodule.

07:52.410 --> 07:57.480
Welnu, we zullen hier een vluchtig gelijk krijgen.

07:58.020 --> 08:02.900
Zodat we nu onze toestand naar Tenzer hebben, erin, naar variabel.

08:03.300 --> 08:06.910
Maar dankzij deze vluchtige is gelijk aan echte parameter.

08:07.230 --> 08:14.940
Welnu, we zullen de gradiënt die is gekoppeld aan deze invoerstatus niet opnemen in de grafiek van alle berekeningen van

08:14.940 --> 08:16.120
de datummodule.

08:16.740 --> 08:18.270
Dus dat is nog een technische truc.

08:18.420 --> 08:22.680
Dit zal ons wat geheugen besparen en dus de prestaties verbeteren.

08:23.040 --> 08:24.570
Dus ik raad het ten zeerste aan om dit te doen.

08:24.990 --> 08:27.420
En nu gaan we iets leukers toevoegen.

08:27.750 --> 08:30.370
Het gaat over deze temperatuurparameter die ik zojuist heb genoemd.

08:30.720 --> 08:36.120
Deze temperatuurparameter is dus de parameter waarmee we kunnen moduleren hoe het neurale

08:36.120 --> 08:39.750
netwerk zeker weet welke actie het moet uitvoeren.

08:40.050 --> 08:46.830
Dus deze temperatuurparameter zal een positief getal zijn, en hoe dichter het bij nul is, hoe minder zeker het neurale netwerk zal

08:47.040 --> 08:49.290
zijn wanneer het in actie speelt.

08:49.620 --> 08:55.320
En hoe hoger de temperatuurparameter is, des te zekerder is het neurale netwerk bij de actie die het besluit

08:55.320 --> 08:56.210
te spelen.

08:56.700 --> 09:04.410
En om deze parameter toe te voegen, ga ik de output, die de kernwaarden zijn, vermenigvuldigen met deze

09:04.410 --> 09:04.950
temperatuurparameter.

09:05.370 --> 09:07.650
Dus laten we bijvoorbeeld beginnen met zeven.

09:07.980 --> 09:12.990
En ik ga hier specificeren dat de kleine opmerking T gelijk is aan zeven.

09:13.290 --> 09:16.850
Dus dat is de temperatuurparameter die ik op zeven stel.

09:17.100 --> 09:18.300
We gaan wat andere proberen.

09:18.300 --> 09:22.140
Maar ik wil gewoon beginnen met een kleintje, want dat ga je zien bij een kleintje.

09:22.350 --> 09:28.050
Onze auto zal zich nog steeds gedragen als een soort insect, maar door de temperatuurparameter te verhogen, zal onze

09:28.320 --> 09:31.710
auto meer op een auto lijken en besluiten te verkopen.

09:31.710 --> 09:33.740
Het rijden zal veel, veel beter zijn.

09:34.320 --> 09:40.380
En dat is dus logisch, want hoe hoger de temperatuurparameter, hoe groter de kans op de

09:40.380 --> 09:41.490
winnende waarde.

09:42.030 --> 09:49.440
Want als we bijvoorbeeld softmax van de kernwaarden hebben, laten we dan een paar simpele getallen nemen.

09:49.440 --> 09:51.420
Een twee drie.

09:52.020 --> 10:00.240
Als softmax van één tot drie bijvoorbeeld gelijk is aan, of punt van vier, komma elf en vier komma vijfentachtig, dan door

10:00.240 --> 10:06.450
de temperatuur te verhogen, weet je, door nu hoge temperatuur te nemen, is de temperatuur gelijk aan

10:06.450 --> 10:10.350
één door een hoge temperatuur te nemen, zoals, bijvoorbeeld twee.

10:10.350 --> 10:11.760
Dus softmax.

10:13.020 --> 10:21.840
Laten we dit kopiëren en vermenigvuldigen met bijvoorbeeld twee of drie softmax van dezelfde waarden, maar vermenigvuldigd met deze

10:21.930 --> 10:23.710
temperatuurparameter van drie.

10:24.210 --> 10:30.650
Welnu, we krijgen zoiets als nul voor de eerste waarde omdat dit een zeer lage waarschijnlijkheid had.

10:31.020 --> 10:37.320
Dus dat is iets rond nul en dan iets heel kleins voor de tweede kans, want dit was nog

10:37.320 --> 10:38.970
steeds een kleine kans.

10:39.320 --> 10:47.880
Dus laten we zeggen, bijvoorbeeld vier komma twee, maar dan de derde kans omdat het de grootste was en

10:47.880 --> 10:49.560
een behoorlijk hoge.

10:49.980 --> 10:54.900
Welnu, door de temperatuur te verhogen, wordt deze kans nog groter, omdat we er nog zekerder

10:54.900 --> 11:00.410
van zullen zijn dat dit de juiste waarde is die overeenkomt met de actie die we moeten spelen.

11:00.720 --> 11:07.560
En daarom wordt dit nu ongeveer vier komma achtennegentig door deze temperatuurparameter te

11:07.560 --> 11:08.100
verhogen.

11:08.370 --> 11:14.160
Welnu, we zijn er nu nog zekerder van dat de derde actie hier de actie moet zijn die moet worden gespeeld,

11:14.160 --> 11:19.290
omdat de kans op de waarde van deze actie niet alleen de grootste is, maar ook erg hoog.

11:19.680 --> 11:22.260
Dat is dus waar deze temperatuurparameter over gaat.

11:22.500 --> 11:26.670
Het gaat om de zekerheid van welke actie we moeten beslissen om te spelen.

11:27.150 --> 11:27.540
Oke.

11:27.540 --> 11:29.330
Ik ga deze reactie dan ook verwijderen.

11:29.340 --> 11:30.500
Dit was gewoon om het uit te leggen.

11:30.990 --> 11:32.920
En laten we nu onze actie ondernemen.

11:33.360 --> 11:35.070
Dus hoe ga je dat doen?

11:35.400 --> 11:41.310
Welnu, het principe van de softmax-methode is niet alleen het genereren van een kansverdeling voor elk van de

11:41.310 --> 11:45.870
sleutelwaarden, maar ook en dat is de tweede stap van de volgende methode.

11:46.350 --> 11:51.420
We nemen een willekeurige trekking uit deze verdeling om onze laatste actie te krijgen.

11:51.840 --> 11:57.030
En natuurlijk hebben we een grote kans om de actie te krijgen die overeenkomt met de sleutelwaarde

11:57.030 --> 12:00.840
met de grootste kans, want dat is precies hoe een verdeling werkt.

12:01.500 --> 12:02.330
Dus daar gaan we.

12:02.450 --> 12:03.950
Laten we onze actie ondernemen.

12:03.960 --> 12:07.650
Dus we gaan een nieuwe regel invoeren die we actie gaan noemen.

12:08.580 --> 12:16.230
En deze actie wordt een willekeurige trekking van de kansverdeling die we zojuist op dit moment eerder hebben

12:16.230 --> 12:16.970
gemaakt.

12:17.370 --> 12:19.800
En hoe krijgen we zo'n willekeurige trekking?

12:20.040 --> 12:24.120
Welnu, we nemen onze rekwisietenwaarschijnlijkheden van elk van de belangrijkste waarden.

12:24.360 --> 12:32.160
We nemen rekwisieten en dan punt en dan gaan we de multi nominale functie gebruiken en dat geeft

12:32.160 --> 12:35.720
ons een willekeurige trekking uit dit distributieproces.

12:36.000 --> 12:38.150
Dus dat is alles wat ons de actie zal geven.

12:38.310 --> 12:38.940
Perfect.

12:39.330 --> 12:42.270
En nu gaan we natuurlijk de actie teruggeven.

12:42.630 --> 12:44.420
Er is een beetje lastiger.

12:44.670 --> 12:51.110
Nou, het is het feit dat deze rekwisieten dat multinomiale rekwisieten de taart naar variabel terugstuurt met een nep-badge, je weet

12:51.300 --> 12:57.150
wel, deze nep-dimensie die overeenkomt met de badge en daarom om het juiste resultaat te krijgen dat we

12:57.150 --> 12:57.630
willen.

12:58.050 --> 13:00.180
Dat is eigenlijk nul één of twee.

13:00.690 --> 13:08.520
We hoeven alleen maar gegevens toe te voegen en dan enkele haakjes en de actie nul één of twee die

13:08.520 --> 13:12.630
we zoeken in de index is nul en nul.

13:13.410 --> 13:13.940
Oke.

13:13.950 --> 13:14.630
En daar gaan we.

13:14.640 --> 13:20.970
Nu hebben we onze actie dankzij deze select action-functie, de A. L. weet nu welke actie elke keer moet

13:20.970 --> 13:21.990
worden gespeeld.

13:22.680 --> 13:23.320
Geweldig.

13:23.370 --> 13:28.560
Dus nu kunnen we doorgaan naar de volgende functie, de LERN-functie, en daar zullen we het

13:28.740 --> 13:33.690
hele neurale netwerk trainen, weet je, met alle voorwaartse voortplanting en dan de achterwaartse voortplanting

13:33.810 --> 13:35.500
met behulp van stochastische gradiëntafdaling.

13:35.820 --> 13:41.490
Nou, eigenlijk zullen we de hele training van het deep learning-model implementeren dat de kern vormt

13:41.490 --> 13:42.930
van onze kunstmatige intelligentie.

13:43.330 --> 13:44.600
Dus ik kan niet wachten om dat te doen.

13:44.610 --> 13:46.830
Dit wordt een spannende tutorial.

13:47.040 --> 13:49.020
En dus zie ik je in de volgende tutorial.

13:49.350 --> 13:50.890
Tot die tijd, geniet van I.
