WEBVTT

00:00.450 --> 00:02.670
Hallo und willkommen zu diesem Muster ist es Horror.

00:02.850 --> 00:06.890
Also gut, also haben wir den Speicher gerade aktualisiert, nachdem wir den neuen Zustand erreicht haben.

00:06.900 --> 00:09.010
Und jetzt kümmern wir uns um den nächsten Tag.

00:09.330 --> 00:12.810
Wie Sie jetzt wissen, ist das nächste Update.

00:12.810 --> 00:20.040
Nun, im Grunde sind wir mit einem Übergang fertig, den wir mit dem letzten Element des Übergangs, dem neuen Zustand,

00:20.040 --> 00:20.960
datiert haben.

00:21.150 --> 00:23.340
Jetzt fangen wir also wieder von vorne an.

00:23.520 --> 00:25.530
Und als wir wieder von vorne anfingen.

00:25.650 --> 00:31.320
Es ist, als ob Sie wissen, dass wir uns in diesem neuen Zustand der Umgebung befinden, und was müssen wir jetzt natürlich tun?

00:31.500 --> 00:37.170
Natürlich ist es eine Aktion zu spielen, weil wir bereits die Beobachtung der Nachrichtenzustände erhalten haben.

00:37.410 --> 00:43.290
Jetzt müssen wir eine Aktion spielen. Daher müssen wir natürlich die Aktion zum

00:43.290 --> 00:46.960
Auswählen der Aktion verwenden, um die Aktion abzuspielen.

00:47.010 --> 00:54.320
Also lass es uns tun, lass uns eine neue Voivode-Aktion erstellen und lass uns die Aktion mit der Select-Aktion spielen, also nehme

00:54.320 --> 00:55.240
ich mit.

00:55.380 --> 01:03.150
Zunächst einmal muss angegeben werden, dass die select-Aktionsfunktion eine Methode des Objekts der zu erstellenden

01:03.150 --> 01:04.300
Klasse ist.

01:04.470 --> 01:08.610
Also ein Selbst, das Action auswählt.

01:08.640 --> 01:09.520
Auf geht's.

01:09.560 --> 01:11.090
Das ist also die nächste Aktion.

01:11.310 --> 01:17.560
Und da natürlich die Select-Action-Funktion den Status als Eingabe annimmt, wird die Select-Action-Funktion natürlich

01:17.560 --> 01:24.270
die Ausgabe des neuronalen Netzwerks zurückgeben, wenn der aktuelle Eingabezustand in das neuronale Netzwerk

01:24.270 --> 01:25.220
eingeht.

01:25.500 --> 01:31.650
Wir müssen also die Eingabestufe hier eingeben, und da dies die Zustände sind, die wir gerade jetzt in der

01:31.650 --> 01:37.350
Umgebung erreicht haben, wo der Eingabestatus natürlich Sie angeben, weil dieser Zustand, den wir gerade zu dem

01:37.350 --> 01:40.070
Zeitpunkt erreichten, den wir gerade erreichen, Newstead ist.

01:40.290 --> 01:45.140
In dieser Select-Action-Funktion meine ich also, neue Stöcke zu setzen.

01:45.150 --> 01:51.710
Also gut, mit dieser Codezeile spielen wir einfach die neue Aktion, nachdem wir den neuen Zustand erreicht haben.

01:52.140 --> 01:58.780
OK und jetzt, da wir eine Aktion gespielt haben Nun, wir bekommen die Belohnung und deshalb bekommen wir Feedback mit der Belohnung.

01:59.010 --> 02:04.550
Und wenn wir also mehr als 100 Elemente im Speicher haben, wäre es Zeit zu lernen.

02:04.860 --> 02:10.830
Deshalb müssen wir jetzt das tun, was logisch ist, wenn Sie eine Aktion auswählen, die natürlich dazu

02:10.830 --> 02:13.830
dient, die KI zu senken, um zu lernen.

02:13.950 --> 02:15.620
Wenn es die Dinge richtig macht.

02:15.870 --> 02:22.530
Und jetzt, da die Aktion gerade gut gespielt wurde, werden wir die KI dazu bringen, aus den Aktionen der letzten

02:22.530 --> 02:23.940
100 Ereignisse zu lernen.

02:24.130 --> 02:31.320
Aber bevor wir diese gelernte Funktion anwenden, müssen wir diese Bedingung festlegen, um sicherzustellen, dass wir bereits mehr als

02:31.320 --> 02:37.380
100 Ereignisse erreicht haben, weil Sie wissen, dass wir aus den Zufallsstichproben des Speichers lernen.

02:37.530 --> 02:41.110
Sie wissen, dass wir über einen riesigen Speicher von 10000 Elementen verfügen.

02:41.190 --> 02:48.930
Wir nehmen einige Stichproben des Speichers von 100 Elementen und die KI lernt aus den

02:48.990 --> 02:52.850
Informationen in dieser Stichprobe von 100 Zufallsübergängen.

02:52.860 --> 03:00.690
Nehmen wir also diese Bedingung vor, um sicherzustellen, dass die Anzahl der Elemente des Speichers dieses

03:00.810 --> 03:06.390
Speichers groß ist, und seien Sie vorsichtig. Nur ein kleiner

03:06.390 --> 03:12.380
Trick. Selbstlernender Speicher ist das Objekt Ihrer Wiedergabespeicherklasse Attribut, das Speicher ist.

03:12.510 --> 03:21.780
In der Tat müssen wir etwas von dem Speicher nehmen, in dem der erste Speicher das Objekt der

03:21.780 --> 03:28.170
Wiedergabespeicherklasse ist und der zweite Speicher hier das Attribut dieses Speichers ist.

03:28.200 --> 03:37.350
Wenn also die Anzahl der Elemente im Speicher gut ist, möchten wir, dass es größer als 100 ist, dann Cullin. Und was

03:37.860 --> 03:38.800
passiert dann?

03:38.970 --> 03:46.320
Wir können lernen, aber um zu lernen, müssen wir diese Zufallsstichprobe von 100 Übergängen erhalten, die wir mit

03:46.320 --> 03:48.840
der einfachen Funktion erhalten können.

03:48.840 --> 03:55.140
Und da die einfache Funktion die verschiedenen Chargen zum Zeitpunkt t in die Zustände zurückstellt, sind diese Daten 20 und die Aktionen

03:55.290 --> 03:57.950
des Zeitpunkts t und wir waren bei 20.

03:58.200 --> 04:03.360
Nun, was wir jetzt tun müssen, ist die Erstellung neuer Revivals, die zum

04:03.360 --> 04:08.580
Zeitpunkt der nächsten Datumsstapel, der Stapel der Wörter und der Stapel der Aktionen sein

04:08.580 --> 04:16.030
werden. Dabei können wir einfach die gleichen Namen vergeben wie wir für die Argumente hier gaben und sie sind hier.

04:16.200 --> 04:24.720
Diese Variablen sind mit den Ergebnissen der einfachen Funktion identisch, da sie genau diese Stapel zurückgeben und der nächste

04:24.720 --> 04:28.320
Zustand des Staates Wörter und Aktionen erfordert.

04:28.320 --> 04:35.570
Was wir jetzt einfach tun müssen, ist, zuerst unser Speicherobjekt zu erhalten, und dann werden wir von diesem

04:35.620 --> 04:40.300
Speicherobjekt die einfache Methode verwenden, die als Eingaben verwendet wird.

04:40.500 --> 04:46.370
Nun, die Anzahl der Übergänge, von denen unsere KI lernen soll, beträgt 100.

04:46.620 --> 04:50.540
Deshalb haben wir dafür gesorgt, dass wir mehr als hundert Übergänge hatten.

04:50.610 --> 04:54.780
Es wird also aus 100 Übergängen der Erinnerung lernen.

04:54.840 --> 04:56.500
Das Lernen wird also viel besser sein.

04:56.610 --> 04:59.560
Und jetzt machen wir das wirklich.

04:59.700 --> 05:04.560
Nun, da die Lernmethode eine Methode unserer Klasse ist.

05:04.830 --> 05:11.180
Nun, wir müssen auf diese Learn-Methode von den zukünftigen Objekten zugreifen, die aus einer anderen Klasse erstellt

05:11.190 --> 05:14.300
werden, und daher müssen wir selbst übernehmen.

05:14.430 --> 05:21.960
Das Selbst bezieht sich auf dieses Ziel, das während des Unterrichts zu tun ist, und lernte dann, wie diese erlernte Methode

05:22.470 --> 05:29.340
eine Methode erlernte, zu der diese Jungs hier natürlich den schlechten Zustand des belgischen Staates, die natürliche Welt und

05:29.340 --> 05:30.530
die Bachche-Aktion stellen.

05:30.630 --> 05:38.730
Dies sind unsere aus unserem Gedächtnis gesammelten Stapel. Wir erhalten 100 von ihnen,

05:39.330 --> 05:47.750
weil wir 100 Übergänge von diesen 100 Übergängen haben. Wir nehmen 100 Zustände.

05:47.780 --> 05:51.530
100 nächste Zustände. 100 Belohnungen.

05:51.850 --> 05:54.490
Es wird aus all diesen zufälligen Chargen geschehen.

05:54.520 --> 05:55.850
Perfekt.

05:55.960 --> 06:03.310
Jetzt müssen wir die letzten Updates durchführen, nachdem Sie wissen, dass Sie einen neuen Status erreicht haben und in

06:03.310 --> 06:04.140
Aktion sind.

06:04.330 --> 06:08.890
Nun, wir haben dich eigentlich zum Spielen gebracht, aber diese Reaktion hatten wir immer noch nicht.

06:08.920 --> 06:11.590
Das ist unser Selbst, die letzte Aktion, die den Voivode betrifft.

06:11.770 --> 06:13.730
Stellen wir also sicher, dass wir das nicht vergessen.

06:13.780 --> 06:15.160
Lass es uns gleich tun.

06:15.190 --> 06:24.610
Wir werden die letzte Aktion selbst aktualisieren, die der letzten Aktion entspricht, und natürlich die Aktion, die wir mit

06:24.610 --> 06:27.020
dieser Auswahlaktion hier bleiben.

06:27.020 --> 06:30.520
In Ordnung, der letzte Abschnitt wird dann aktualisiert.

06:30.520 --> 06:31.890
Gleiches für den neuen Staat.

06:31.930 --> 06:39.190
Wir haben den neuen Status erreicht, aber das letzte Datum wurde noch nicht aktualisiert, da das letzte Datum natürlich vor dem Status zum

06:39.280 --> 06:40.590
Zeitpunkt t lag.

06:40.750 --> 06:44.870
Aber seitdem haben wir den neuen Staatsüberschuss erreicht, wenn es Zeit ist, einen zu überschreiten.

06:45.070 --> 06:48.180
Nun, das letzte, was Sie hier gesagt haben.

06:48.190 --> 06:50.290
Deshalb müssen wir auch aktualisiert werden.

06:50.290 --> 06:57.070
Selbst, dass der letzte Zustand unserem neuen Zustand gleicht.

06:57.280 --> 06:58.020
Da gehen wir.

06:58.210 --> 06:59.620
Und was brauchen wir jetzt noch?

06:59.830 --> 07:01.640
Nun, es bleibt nur noch eins übrig.

07:01.660 --> 07:08.070
Das ist natürlich das Wort und das Wort ist genau das Wort, das wir in der Realität bekommen.

07:08.290 --> 07:15.910
Das ist also das Argument dieser Funktion, die, wenn wir die Verbindung zu unserer Karte herstellen, das letzte Wort

07:15.910 --> 07:17.160
sein wird.

07:17.200 --> 07:23.250
Das ist das Wort, das wir direkt nach dem Spielen der Aktion in diesen neuen Zuständen erhalten.

07:23.470 --> 07:30.260
Wenn wir also zu einem Ton weitermachen, wird dieses letzte Wort dasjenige sein, das minus eins ist, wenn wir weiter weg von dem Schritt kommen,

07:30.290 --> 07:35.580
werden wir ein etwas schlechtes Wort minus 0 erhalten. 2, wenn wir dem Ziel näher kommen.

07:35.660 --> 07:38.680
Wir erhalten eine etwas gute Belohnung 0. 1.

07:38.830 --> 07:43.370
Und wenn wir zu nahe an einen Rand der Karte kommen, geht es um Strafe.

07:43.510 --> 07:45.330
Wir bekommen für jeden minus eins.

07:45.440 --> 07:47.110
Das ist das letzte Wort, das wir bekommen.

07:47.110 --> 07:50.700
In der Realität passiert das tatsächlich auf der Karte.

07:50.830 --> 07:53.550
Und das wird das Argument der Funktion sein.

07:53.600 --> 07:54.690
Das letzte Wort hier.

07:54.700 --> 07:56.200
Das ist genau das hier.

07:56.250 --> 08:01.840
Da dies also das Argument der Aktualisierungsfunktion ist, das diesem entspricht,

08:02.170 --> 08:11.590
waren wir nicht hier, und daher ist unser Selbst, dass die am Anfang in dieser Funktion initialisierte letzte Wortvariable das

08:12.070 --> 08:20.570
neue Wort ist, das wir in Wirklichkeit bekommen, das Wort ist oder das ist das gleiche letzte Wort

08:20.730 --> 08:21.360
Gut.

08:21.410 --> 08:23.680
Jetzt haben wir unser letztes Wort aktualisiert.

08:23.990 --> 08:27.240
Und jetzt, da wir gerade unser letztes Wort bekommen haben.

08:27.500 --> 08:29.470
Nun können wir uns jetzt mit der Welt verabreden.

08:29.850 --> 08:37.140
Sie erinnern sich an den Krieg, als sie hier als eine der Variablen des Objekts unserer Klasse initialisiert wurden.

08:37.190 --> 08:42.500
Das ist das Fenster, das den Verlauf dieses Zuges verfolgen wird, indem er den Durchschnitt

08:42.500 --> 08:44.270
der letzten 100 Belohnungen nimmt.

08:44.300 --> 08:50.180
Sie wissen also, es wird wie ein Schiebefenster sein, das uns zeigt, wie sich der Mittelwert der Welt entwickelt.

08:50.180 --> 08:52.730
Und da haben wir gerade unser letztes Wort bekommen.

08:52.910 --> 08:56.910
Nun, wir können das Fenster, in dem wir waren, auf den neuesten Stand bringen.

08:57.080 --> 09:03.680
Nun, wir müssen einfach dieses letzte Wort an das Fenster anhängen und deshalb werde

09:03.980 --> 09:12.350
ich mir mein Kriegsfenster selbst nehmen, wenn wir das sagen, wenn sie das hören und ich werde die Append-Funktion verwenden.

09:12.530 --> 09:18.830
Und innerhalb der Open-Funktion müssen wir das Element eingeben, das wir an das anfügen möchten, als wir

09:18.830 --> 09:21.480
das getan haben. Natürlich möchten wir.

09:21.500 --> 09:22.610
Alles klar perfekt.

09:22.610 --> 09:29.480
Und da dieses Kriegsfenster eine feste Größe haben wird, wissen Sie, dass es kein wachsendes Fenster sein wird. Daher wird es ein

09:29.480 --> 09:35.300
Fenster mit fester Größe sein, das mit der Zeit verschoben wird, um die Entwicklung der Welt zu zeigen.

09:35.500 --> 09:38.590
Und so müssen wir uns jetzt für eine Größe dieses Winters entscheiden.

09:38.750 --> 09:43.600
Und es ist einfach die Anzahl der Mittel der Belohnung, die wir in diesem Fenster haben werden.

09:43.900 --> 09:49.330
So lassen Sie uns zum Beispiel die letzten 1000 Mittel der letzten 100 Wörter kennen.

09:49.340 --> 09:58.730
Um dies sicherzustellen, werden wir hinzufügen, wenn dann geplant, dann nehmen wir unser Arbeitsfenster und fügen hier einfach

09:58.740 --> 10:05.810
hinzu, wenn die Anzahl der Elemente im Fenster größer als 1000 ist.

10:05.990 --> 10:14.780
Nun, wir wollen das erste Element davon löschen, das unser Fenster hat, und das erste

10:14.780 --> 10:19.070
Element dieses Fensters muss Null indizieren.

10:19.150 --> 10:19.550
Gut.

10:19.550 --> 10:24.620
Jetzt stellen wir sicher, dass dieses Kriegsfenster niemals mehr als 1000 Elemente enthält.

10:24.620 --> 10:31.130
Es gibt eintausend Mittel der letzten 100 Wörter, die perfekt sind. Dies wird ein Fenster mit fester Größe sein, sodass

10:31.310 --> 10:34.360
wir sehen können, ob der Mittelwert des Wortes zunimmt.

10:34.460 --> 10:39.560
Und deshalb, wenn das Training gut läuft und dementsprechend das Gericht macht, was wir wollen.

10:39.800 --> 10:40.760
Perfekt.

10:41.000 --> 10:46.010
Und jetzt bleibt nur noch ein winziges kleines Ding übrig, was es sein wird.

10:46.190 --> 10:52.130
Denken Sie daran, dass diese Aktualisierungsfunktion nicht nur die verschiedenen Elemente des Übergangs im Kriegsfenster

10:52.140 --> 10:57.960
aktualisiert, sondern auch die Aktion zurückgibt, die beim Erreichen dieses neuen Status ausgeführt wurde.

10:58.190 --> 11:05.270
Das ist der Grund, warum wir das haben und dann ist das Datum gleich, dass wir weniger Signal haben und

11:05.360 --> 11:10.760
deshalb sollte es etwas zurückgeben und das, was zurückkehren soll, ist natürlich das Handeln.

11:10.820 --> 11:18.950
Das Letzte, was wir hier noch tun müssen, ist einfach die Aktion zu wiederholen, die gerade gespielt wurde, als die neue

11:18.950 --> 11:20.180
Stufe erreicht wurde.

11:20.600 --> 11:23.670
Und das ist unsere Update-Funktion.

11:23.840 --> 11:29.110
Es werden alle erforderlichen Aktualisierungen durchgeführt und die Aktion wird geändert, wenn die neue Stufe erreicht wird.

11:29.480 --> 11:30.650
Das ist perfekt.

11:30.650 --> 11:35.230
Dies war die letzte schwierige Maßnahme, um all dies zu einem Prozess zu machen.

11:35.240 --> 11:37.120
Jetzt wird der Rest gut sein.

11:37.220 --> 11:42.170
Wir werden nur eine Kernfunktion erstellen, um die gewünschten Mittel im Fenster zurückzugeben.

11:42.200 --> 11:47.450
Dann machen wir eine sichere Funktion, um das Gehirn des Autos zu retten, wann immer Sie die Anwendung beenden und

11:47.600 --> 11:48.840
zu ihr zurückkehren möchten.

11:48.890 --> 11:53.720
Und natürlich, da Sie das Gehirn Ihres Autos laden möchten, wenn Sie zurückkommen, kehren Sie

11:53.720 --> 11:54.730
zur Anwendung zurück.

11:55.040 --> 12:01.370
Am Ende erstellen wir eine Ladefunktion, die Ihr Modell lädt, nachdem Sie Ihr Modell mit derselben

12:01.370 --> 12:02.800
Funktion gespeichert haben.

12:02.840 --> 12:06.470
Also drei Funktionen dazu, aber es wird einfach sein.

12:06.500 --> 12:12.760
Und dann haben wir den aufregendsten Abschnitt dieses ersten Moduls, nämlich die Demo, die wir sehen werden, wenn

12:12.770 --> 12:13.840
die Luft funktioniert.

12:13.850 --> 12:19.430
Wir werden sehen, ob das Auto die Ziele erreicht, und wir werden sehen, wie wir es verbessern können,

12:19.430 --> 12:21.980
und schließlich müssen Sie Ihre erste KI aufbauen.

12:22.160 --> 12:24.010
Ich kann es kaum erwarten, die Demo zu starten.

12:24.140 --> 12:27.580
Lassen Sie uns diese drei Funktionen zuerst und bis dahin ich machen.