WEBVTT

00:00.240 --> 00:02.790
Hallo und willkommen zu diesem Python-Tutorial.

00:02.790 --> 00:07.230
In Ordnung, wir haben eine letzte Funktion, die wir in unserer Replay-Speicherklasse implementieren können.

00:07.230 --> 00:12.060
Das ist die einfache Funktion und natürlich einige Stichproben aus unserem Gedächtnis.

00:12.210 --> 00:16.080
Deshalb liefert diese Funktion diese Stichproben.

00:16.080 --> 00:17.850
Also gut, lass es uns tun.

00:17.870 --> 00:20.630
Wir werden es einfach nennen.

00:20.640 --> 00:21.330
Auf geht's.

00:21.420 --> 00:25.030
Und diese Funktion benötigt zwei Argumente als Eingabe.

00:25.260 --> 00:32.490
Der erste ist wie üblich unser zukünftiges Objekt, um die Speicherklasse abzuspielen, und das zweite Argument ist, dass Sie versuchen können,

00:32.490 --> 00:33.430
zu erraten.

00:33.510 --> 00:40.290
Wir nehmen einige Proben fester Größe und müssen daher eine Größe für die Proben auswählen. Genauer gesagt,

00:40.290 --> 00:42.610
nennen wir sie eine Losgröße.

00:42.820 --> 00:47.910
Das ist der Name, den wir unserer zweiten Argumentgröße geben.

00:48.180 --> 00:49.530
Und da gehen wir hin.

00:49.560 --> 00:54.490
Wir haben unsere zwei Argumente und jetzt können wir die einfache Funktion implementieren.

00:54.500 --> 01:00.780
Nun möchte ich Sie nur warnen, dass dies ein wenig technisch wird, aber ich versuche mein Bestes, um es zu erklären.

01:01.250 --> 01:05.140
Wir beginnen also mit der Erstellung der Beispielvariablen.

01:05.150 --> 01:09.620
Dies ist nur die Variable, die die Samples des Speichers enthält.

01:09.620 --> 01:11.340
In Ordnung, so einfach ist gleich.

01:11.360 --> 01:14.090
Und wie wollen wir diese Proben bekommen?

01:14.450 --> 01:20.960
Zunächst einmal müssen wir unser Gedächtnis mitnehmen, weil wir die Samples aus unserem Gedächtnis bekommen.

01:20.960 --> 01:26.870
Dann werden wir wahrscheinlich die Chargengröße benötigen, da die Proben die Eloses-Chargengröße

01:26.930 --> 01:27.720
erhalten.

01:27.830 --> 01:33.920
Wir brauchen also Speicher, wir brauchen Batch-Größe und dann brauchen wir ein paar Tricks, um ein gutes Format

01:34.040 --> 01:35.600
dieser Samples zu erhalten.

01:35.600 --> 01:40.790
Also, was ich tun werde, werde ich die Codezeile schreiben und dann dieses Element Element

01:40.790 --> 01:41.900
für Element erklären.

01:41.990 --> 01:42.860
Also machen wir's.

01:42.860 --> 01:48.580
Ich beginne mit einer Zip-Funktion. Ich werde sehr bald erklären, was es macht.

01:48.620 --> 01:51.980
Und innerhalb dieser Funktion füge ich einen Stern hinzu.

01:52.100 --> 01:53.800
Ich werde das auch erweitern.

01:53.900 --> 02:02.600
Der Stern und der Zufallsgedanke Central, so zufällig, wie Sie vielleicht gedacht haben, ist die zufällige Bibliothek, die wir hier importiert

02:02.600 --> 02:03.360
haben.

02:03.410 --> 02:08.900
Das ist der Hauptgrund, warum wir diese Zufallsbibliotheken importieren mussten, weil wir einige Stichproben

02:08.900 --> 02:09.730
nehmen.

02:10.040 --> 02:15.570
Von dieser zufälligen Bibliothek verwenden wir also die einfache Funktion.

02:15.600 --> 02:20.060
Das sind also unsere Variablen und dies ist eine Funktion, also werde ich ein paar Klammern hinzufügen.

02:20.210 --> 02:26.110
Wie Sie sehen, ist sample eine Funktion, und wir müssen einige Argumente einfügen, damit Sie das erste

02:26.110 --> 02:27.850
Argument selbst sehen können.

02:27.850 --> 02:34.660
Und wenn wir von Selbst sprechen, entspricht dies der Erinnerung an sich selbst, der Erinnerung an unser zukünftiges

02:34.870 --> 02:36.970
Instanzobjekt unserer Wiederholungserinnerung für uns.

02:37.180 --> 02:44.290
Ich füge hier also selbst diese Erinnerung hinzu und dann ist das zweite Argument, dass Sie die Größe der

02:44.530 --> 02:51.360
Bechuana-Aufnahme zufällig aus unserem Gedächtnis erraten haben und dass wir ihr einen Namen gegeben haben, der Batch-Größe ist.

02:51.550 --> 02:55.690
Das zweite Argument wird also sein, dass Bachche saugt.

02:55.870 --> 02:56.410
Gut.

02:56.470 --> 03:01.080
Die Codezeile ist also geschrieben und ich werde erklären, was sie macht.

03:01.510 --> 03:08.260
Mit dieser einfachen Zufallspunktfunktion nehmen wir zunächst einige Stichproben aus dem Speicher, die eine

03:08.800 --> 03:11.820
feste Größe dieser Größe haben.

03:12.550 --> 03:13.940
Das ist verständlich.

03:14.150 --> 03:18.230
Aber was macht diese Zipp-Stern-Funktion?

03:18.530 --> 03:20.500
Nun, es gibt kein Geheimnis.

03:20.540 --> 03:22.870
Es ist wie eine Umformfunktion.

03:22.880 --> 03:28.460
Zum Beispiel möchte ich hier ein wenig hinzufügen, um zu erklären, dass ich es entfernen werde.

03:28.460 --> 03:34.680
Nehmen wir an, wir haben zum Beispiel eine Liste der folgenden Elemente.

03:34.820 --> 03:37.900
Erst eins zwei drei.

03:38.180 --> 03:39.680
Und dann das zweite Element.

03:39.680 --> 03:43.180
Vier fünf sechs.

03:43.190 --> 03:48.020
Wir haben also eine Liste von zwei Doppeln aus drei Elementen, eins zwei drei vier fünf sechs.

03:48.380 --> 03:52.690
Na dann, wenn ich die zip-Funktion mit dem Stern drauf anwende.

03:52.880 --> 04:02.840
Nun, was so eine Zip-Star-Liste werden würde, wird einer neuen Liste gleich sein, aber mit einer anderen Form

04:03.380 --> 04:12.440
und einer anderen Form wird eins für dann zwei drei und dann fünf sechs sein.

04:12.460 --> 04:12.770
Gut.

04:12.800 --> 04:13.950
Das ist genau das, was es tut.

04:13.970 --> 04:16.640
Es formt gerade Ihre Liste um.

04:16.990 --> 04:21.610
OK, jetzt verstehst du, was diese Zipp-Starliste macht.

04:21.680 --> 04:24.560
Nun, lass uns erklären, warum wir es tun mussten.

04:24.590 --> 04:30.360
So wie Sie verstanden haben, werden wir die Ereignisse zur Erinnerung hinzufügen und die Ereignisse haben die Form.

04:30.440 --> 04:34.530
Erst der Staat, dann die Aktion und dann die Belohnung.

04:34.820 --> 04:40.330
Für unseren Algorithmus möchten wir jedoch nicht, dass dieses Format das folgende Format haben soll.

04:40.330 --> 04:47.540
Ein Format besteht aus drei Mustern, einem Muster für die Zustände, einem Muster für die Aktionen und einem Muster für

04:47.540 --> 04:48.660
die Belohnung.

04:48.800 --> 04:53.690
Nehmen wir zum Beispiel an, dass dieser eine bis drei Zustand eine Aktion eins ist.

04:53.800 --> 05:01.100
Wir möchten eins und dann erklären, dass wir zwei Aktionen durchführen, und es war uns zu gut, was wir wollen, ist eine Charge für

05:01.100 --> 05:03.630
jede Charge für Zustand eins und Zustand zwei.

05:03.680 --> 05:10.090
Eins ist ein Spiel für Aktion eins in Aktion zwei und ein drittes für uns war eins und wir waren zwei.

05:10.190 --> 05:15.680
Das ist genau das Format, das als nächstes erwartet wird, denn dann werden wir diese Chargen in eine

05:15.770 --> 05:22.610
Torte verwandeln, die einen schrecklichen Einfluss hat, an den wir uns noch erinnern werden, eine Variable, die sowohl einen Tensor als auch einen

05:22.610 --> 05:23.280
Gradienten enthält.

05:23.510 --> 05:29.750
Und das, um in der Lage zu sein, in Bezug auf einen Tensor zu unterscheiden, um in der Lage zu

05:29.750 --> 05:35.480
sein, in Bezug auf Intensivierung innerhalb der Struktur eines schrecklichen enthaltenden Tensors und eines Gradienten zu unterscheiden.

05:35.540 --> 05:37.820
Wieder funktioniert Pi Fackel.

05:37.820 --> 05:44.480
Zusammenfassend stellen wir fest, dass wir für jede der Aktionen und Belohnungen des Staates

05:44.480 --> 05:50.600
einen Stapel erstellen, und dann werden wir jeden dieser Wetches separat in

05:50.840 --> 05:54.360
einige Bytes einfügen jeder von ihnen.

05:54.620 --> 05:57.430
Also gut, das ist der Zweck der Zipp-Funktion.

05:57.480 --> 06:00.350
Also lassen Sie mich diesen Kommentar einfach entfernen.

06:00.530 --> 06:05.980
Jetzt müssen wir nur noch die Muster zurückgeben.

06:06.230 --> 06:12.650
Wie ich gerade erklärt habe, können wir die Samples nicht direkt zurückgeben, aus dem einfachen Grund, dass wir die

06:12.830 --> 06:15.670
Samples in eine durchführbare Fackel bringen wollen.

06:15.680 --> 06:22.580
Um dies für jedes der Samples zu tun, verwenden wir die Map-Funktion. Diese

06:22.580 --> 06:30.180
Map-Funktion führt die Zuordnung von Samples zu Foltervariablen durch, die einen Tensor und einen Gradienten enthalten.

06:30.200 --> 06:33.550
Wie Sie sehen können, benötigt diese Map-Funktion mehrere Argumente.

06:33.620 --> 06:38.600
Das erste Argument ist eine Funktion und diese Funktion wird die Funktion sein, die die

06:38.600 --> 06:40.590
Samples in einige Brennweitenvariablen umwandelt.

06:40.760 --> 06:45.340
Und das zweite Argument ist, worauf wir diese Funktion anwenden wollen.

06:45.590 --> 06:50.580
Das sind also die Argumente dieser Funktion und damit auch, was sie sein wird.

06:50.600 --> 06:52.780
Das sind natürlich die Proben.

06:52.790 --> 06:55.510
Das zweite Argument hier sind also die Symbole.

06:55.870 --> 06:59.440
Aber dann definieren wir die Funktion, auf die wir angewendet werden wollen.

06:59.480 --> 07:00.620
Jedes der Symbole.

07:01.040 --> 07:06.890
Um hier eine Funktion zu definieren, müssen wir zuerst der Funktion einen Namen geben, die Lambda aufrufen wird.

07:07.070 --> 07:14.330
Das ist nur ein Name und geben Lenda dann X, was die Variable dieser Funktion sein wird.

07:14.420 --> 07:18.390
Das ist also nur ein Name und eine Angabe für die Variable und dann.

07:18.500 --> 07:24.140
Und hier geben wir den Ausdruck der Funktion, die wir wollen, dass diese Lambda-Funktion

07:25.400 --> 07:32.010
zurückkehrt, und sehen, was gut sein wird. Es soll etwas sein, das unsere Samples in eine Brennervariable

07:32.250 --> 07:34.800
umwandelt, und dies zu tun.

07:34.800 --> 07:37.370
Wir haben es bereits in einigen früheren Tutorials erwähnt.

07:37.560 --> 07:39.880
Nun, wir haben die Voivode-Funktion für sie.

07:40.110 --> 07:46.680
Die Voice wird funktionieren. Wir werden diese Umwandlung von einem Fackeltänzer in eine Variable vornehmen, die den Sensor

07:46.690 --> 07:48.590
und die größte enthält.

07:48.810 --> 07:55.830
Das erste, was ich hier hinzufügen möchte, ist eine variable Variable, in der ich X konvertieren werde,

07:56.010 --> 08:01.540
da X die einfachsten sein werden, die auf die Samples angewendet werden.

08:02.420 --> 08:09.080
Aber das ist alles, was noch eine technische Sache ist, die wir implementieren müssen, ist die Tatsache, dass

08:09.140 --> 08:15.680
für jede Charge, die in der Stichprobe enthalten ist, beispielsweise die Charge von Aktionen a 1 8

08:15.680 --> 08:23.080
2 3 und die anderen Aktionen, die wir in Bezug darauf verketten müssen zum ersten Mal Motor, der den Staaten entspricht.

08:23.120 --> 08:25.380
Und warum müssen wir diese Verkettung machen.

08:25.550 --> 08:27.610
Es ist nur so, dass alles gut ausgerichtet ist.

08:27.710 --> 08:34.740
Das heißt, dass in jeder Reihe die Aktion angegeben wird und die Belohnung der gleichen Zeit t entspricht.

08:35.180 --> 08:42.240
So erhalten wir schließlich eine Liste von Partien, die alle aufeinander abgestimmt sind, und jede Partie ist eine Torte in Richtung Voivod.

08:42.470 --> 08:44.700
Wie können wir diese Verkettung machen?

08:44.840 --> 08:48.030
Nun, wir müssen die Cat-Funktion aus der Fackel-Bibliothek verwenden.

08:48.170 --> 08:55.400
Wir fügen hier eine Fackel hinzu, zu der wir hinzufügen, die auf X angewendet wird. In dieser Funktion

08:55.400 --> 09:00.820
müssen wir jedoch die Dimension angeben, für die diese Verkettung erstellt werden soll.

09:00.860 --> 09:05.460
Und wie ich gerade erwähnte, ist dies die erste Zeitmaschine, die das Indexzeitalter hat.

09:05.900 --> 09:12.320
Und los geht's, wir haben unsere Funktion bereit. Diese Lunda-Funktion nimmt die Proben in

09:12.320 --> 09:18.110
Bezug auf die erste Engine und verkettet sie schließlich in einige Brennweitenvariablen,

09:18.110 --> 09:24.230
die sowohl einen Tensor als auch einen Gradienten enthalten gelten für castigate in dem

09:24.230 --> 09:28.610
Sinne, dass wir differenzieren können, um Datengewichte zu haben.

09:28.610 --> 09:30.170
Also gut, diese Funktion ist fertig.

09:30.410 --> 09:35.270
Und hier ist das zweite Argument der Kartenfunktion.

09:35.270 --> 09:42.960
Wir müssen angeben, auf was wir diese Funktion anwenden wollen, und das ist auf allen unseren Proben.

09:43.040 --> 09:43.850
Da gehen wir.

09:43.850 --> 09:50.750
Wir werden diese Lambda-Funktion auf alle Samples anwenden, so dass wir schließlich eine Liste von Übereinstimmungen erhalten,

09:50.990 --> 09:53.840
bei denen jede Übereinstimmung ein PI-Brenner ist.

09:53.840 --> 09:58.810
In Ordnung, das war ziemlich technisch, aber jetzt wird alles gut funktionieren.

09:58.850 --> 10:00.060
Wir möchten diese Technik anwenden.

10:00.080 --> 10:05.150
Danach verwenden wir es nur hier. Wenn Sie also nicht die technischen Details genau

10:05.150 --> 10:11.060
verstehen wollen, können Sie diese drei Codezeilen einfach in Ihr Gedächtnis kopieren, wenn Sie mit Fackel eine

10:11.060 --> 10:14.460
künstliche Intelligenz erzeugen möchten es wie du willst

10:14.600 --> 10:21.110
Aber jetzt ist die gute Nachricht, dass wir mit dieser Replay-Wiedergabe der Memory-Klasse fertig sind und jetzt mit

10:21.470 --> 10:26.780
der nächsten und letzten Klasse fortfahren können, was der gesamte Sicherheitsmodus sein wird.

10:26.960 --> 10:34.520
In diesem Modell haben wir natürlich unser Netzwerk, das Wiederholung und dann den Rest des

10:34.640 --> 10:36.600
Sicherheitsalgorithmus erfahren wird.

10:36.620 --> 10:39.150
Es wird also eine viel größere Klasse sein.

10:39.200 --> 10:44.240
Wir werden ungefähr 10 Funktionen erstellen, aber das ist nur, weil wir dies Schritt für Schritt machen, damit

10:44.240 --> 10:46.130
Sie besser verstehen, was los ist.

10:46.520 --> 10:49.260
Ich kann es also kaum erwarten, unser Sicherheitsmodell zu implementieren.

10:49.280 --> 10:50.900
Und bis dahin ich