WEBVTT

00:00.390 --> 00:02.710
Hallo und herzlich Willkommen im Intertoto Gewürz.

00:03.000 --> 00:07.800
In Ordnung, also werden wir in diesem neuen Codeabschnitt Erfahrung mit Spielen umsetzen.

00:07.920 --> 00:13.850
Wir werden also eine neue Klasse erstellen, die als Wiederholungsspeicher bezeichnet wird und die Erfahrung so implementiert, dass sie genau so

00:13.850 --> 00:16.700
spielt, wie Sie es in den Intuitionsvorlesungen gesehen haben.

00:16.890 --> 00:21.540
Aber zuerst wollen wir uns kurz an die Wiederholung der Erfahrung erinnern.

00:21.540 --> 00:27.750
Sie wissen also, dass diese künstliche Intelligenz auf Markov-Entscheidungsprozessen beruht, und Markov-Entscheidungsprozesse bestehen

00:27.750 --> 00:31.840
aus der Betrachtung einer Reihe von Ereignissen.

00:32.010 --> 00:38.770
Ereignisse sind also Sie wissen zum Beispiel von einem Zustand zum nächsten und Tipis.

00:39.060 --> 00:44.410
Aber wenn die Ereignisse seit dem nächsten Tag so gut waren, hängt das sehr vom aktuellen Zustand ab.

00:44.550 --> 00:46.820
Nun, das Netzwerk würde nicht gut laufen.

00:46.980 --> 00:52.710
Für diejenigen, die aus dem Deep Learning-Kurs kommen, ist dies genau das Gleiche wie bei einem Zeitschritt, in

00:52.710 --> 00:54.860
dem wir unsere Zeitreihe gelernt haben.

00:55.020 --> 01:00.300
Es lernte nichts, weil ein Zeitschritt nicht ausreichte, um ein Modell zu

01:00.300 --> 01:03.070
verstehen, um langfristige Zusammenhänge zu verstehen.

01:03.090 --> 01:07.060
So ist das hier auch und deshalb müssen wir die Erlebniswiedergabe implementieren.

01:07.230 --> 01:08.230
Wie funktioniert das?

01:08.340 --> 01:13.960
Nun, das ist sehr einfach, anstatt nur den aktuellen Zustand zu betrachten, der zum Zeitpunkt t nur ein

01:13.960 --> 01:14.640
Zustand ist.

01:14.680 --> 01:16.830
Wir werden in der Vergangenheit mehr darüber nachdenken.

01:16.830 --> 01:22.560
Also genau wie bei Lithien und deshalb wird unsere Veranstaltungsreihe nicht so sein.

01:22.560 --> 01:27.450
Und ich nehme an, dass dies zum Beispiel die einhundert Staaten in der Vergangenheit sein werden.

01:27.450 --> 01:33.770
Also als T-minus einhundertachtzig minus 99 bis zu minus 1 und dann S-T.

01:34.020 --> 01:40.830
Mit anderen Worten, wir fügen 100 weniger Übergänge in das hinzu, was wir als Erinnerung

01:40.830 --> 01:47.040
bezeichnen, und deshalb haben wir ein Langzeitgedächtnis im Gegensatz zu einem Kurzzeitgedächtnis oder

01:47.040 --> 01:49.950
sogar, sollte ich sagen, ein Sofortgedächtnis.

01:50.310 --> 01:57.690
Und sobald wir diese Erinnerung der letzten 100 Ereignisse erstellt haben, werden wir einfach einige zufällige

01:57.690 --> 02:02.300
Stapel dieser Übergänge benötigen, um unser nächstes Update durchzuführen.

02:02.310 --> 02:09.270
Dies ist unser nächster Schritt, indem wir den nächsten Abschnitt auswählen. Daher werden wir in dieser Replay-Speicherklasse,

02:09.270 --> 02:13.450
die wir für Replay Experience implementieren, drei Funktionen erstellen.

02:13.530 --> 02:17.490
Zunächst einmal ist die Funktion wie gewohnt für jede Klasse der Fall.

02:17.520 --> 02:23.400
In dieser Funktion definieren wir also die Variablen, die an die zukünftigen Instanzen der Klasse angehängt werden, bei der es

02:23.400 --> 02:27.210
sich um die zukünftigen Objekte handelt, die aus dieser Klasse erstellt werden.

02:27.540 --> 02:32.790
Und so werden diese Variablen ganz einfach der Speicher der 100 Übergänge zu 100 Ereignissen sein.

02:32.970 --> 02:38.790
Und die Kapazität, die die Zahl 100 ist, können Sie gerne länger ausprobieren, indem Sie die

02:38.790 --> 02:39.550
Kapazität erhöhen.

02:39.780 --> 02:46.170
Das ist also die erste Funktion in dieser Funktion, und dann werden wir zwei weitere Funktionen erstellen, eine

02:46.500 --> 02:51.050
Push-Funktion, um sicherzustellen, dass der Speicher niemals mehr als 100 Übergänge enthält.

02:51.180 --> 02:57.150
Und dazu nutzen wir die Kapazität, indem wir nur eine einfache Bedingung ausführen, und dann werden wir

02:57.360 --> 03:03.300
schließlich die einfache Funktion erstellen, und das wird natürlich sein, um einige Übergänge in diesem Speicher der

03:03.390 --> 03:05.060
letzten 100 Übergänge abzutasten.

03:05.520 --> 03:08.440
Also gut, beginnen wir mit der Einführung der Klasse.

03:08.520 --> 03:17.460
Wie Sie wissen, fangen wir mit der Klasse an und geben sie an die Klasse weiter, die wir Wiedergabespeicher nennen. Dann

03:17.460 --> 03:25.500
geben wir in Klammern das Objekt und dann Cullin ein. Dann beginnen wir mit der ersten Funktion.

03:25.560 --> 03:26.860
Das Ende ist Funktion.

03:27.150 --> 03:30.730
Das ist also genau so wie vor dem Tod.

03:30.870 --> 03:36.750
Dann zwei Unterstriche, noch einmal zwei Unterstriche und dann die Variablen.

03:36.750 --> 03:42.750
Es gibt also natürlich selbst die Variable, die an die zukünftigen Instanzen der Klasse der zukünftigen

03:42.750 --> 03:48.810
Objekte angehängt ist, und dann haben wir eine andere Variable für Sie, mit der Sie einige

03:48.810 --> 03:52.950
andere Erfahrungen mit den Erinnerungen machen können sei die Kapazität.

03:52.950 --> 03:58.020
Diese Kapazität wird also einfach die Nummer einhundert sein, weil wir mit den

03:58.020 --> 04:00.960
hundert weniger Übergängen Erfahrung sammeln werden.

04:00.960 --> 04:03.910
Alles klar und dann Collon Und jetzt geht es los.

04:03.930 --> 04:10.430
Gehen wir in die Funktion hinein und definieren wir die Variablen unseres Wiedergabespeicherobjekts.

04:10.440 --> 04:19.400
Die erste wird die Fähigkeit zum Selbstunterricht sein, und wie Sie wahrscheinlich verstanden haben, wird dies die Kapazität sein, die die maximale Anzahl

04:19.670 --> 04:24.690
von Übergängen ist, die wir in unserer Erinnerung an Ereignisse haben möchten.

04:24.830 --> 04:30.980
Dies entspricht den Argumenten, die eingegeben werden, wenn ein Objekt der Wiedergabespeicherklasse

04:31.000 --> 04:34.530
erstellt wird und daher Kapazität ist.

04:34.550 --> 04:36.480
Das ist das Argument der init-Funktion.

04:36.660 --> 04:38.180
Also Kapazität.

04:38.180 --> 04:44.960
Um nicht selbst verwirrt zu sein, dass Kapazität der Name der Variablen ist, die an das

04:45.470 --> 04:52.670
Objekt angehängt ist, und Kapazität hier das Argument, das beim Erstellen eines Objekts der Wiedergabespeicherklasse eingegeben wird.

04:52.810 --> 04:53.620
Gut.

04:53.830 --> 04:55.880
Und dann haben wir einen zweiten Woiwode.

04:56.170 --> 04:57.890
Das ist natürlich die Erinnerung.

04:58.000 --> 05:01.620
So lernte Nemec selbst.

05:01.760 --> 05:02.650
Gut.

05:02.800 --> 05:05.730
Und was soll diese Erinnerung an Voivode sein?

05:05.990 --> 05:13.950
Nun, dieser Speicher soll die letzten 100 Ereignisse enthalten und daher sollte dies ein einfacher Test sein.

05:14.100 --> 05:20.300
Sie kennen eine Liste, die die letzten 100 Ereignisse der letzten 100 Übergänge enthält und die Liste

05:20.300 --> 05:20.850
initialisiert.

05:20.870 --> 05:24.620
Es gibt nichts Einfacheres, wir fügen nur solche Klammern hinzu.

05:24.740 --> 05:26.040
Und es geht los.

05:26.060 --> 05:31.490
Unser Gedächtnis wird initialisiert, also zu Beginn des Experiments oder genauer zu Beginn der Erkundung

05:31.490 --> 05:36.430
ist das Gedächtnis eine leere Liste und dann werden wir die Übergänge setzen.

05:36.500 --> 05:38.350
Jedes Mal, wenn wir einen zukünftigen Zustand erreichen.

05:38.600 --> 05:43.370
Und davon reden wir genau mit der nächsten Funktion, die wir

05:43.520 --> 05:44.720
Push-Funktion nennen.

05:44.790 --> 05:51.380
Wir werden diese Push-Funktion einrichten, um die Ereignisse in diese Speicherliste einzufügen, und dann verwenden wir die

05:51.620 --> 05:57.170
Kapazität, um sicherzustellen, dass diese Speicherliste immer 100 Ereignisse enthält und niemals mehr.

05:57.500 --> 05:59.660
Also gut, machen wir das auch im nächsten.

05:59.690 --> 06:01.250
Und bis dahin ich