WEBVTT

00:00.240 --> 00:06.600
Hallo und willkommen zu diesem Python-Tutorial in Statoil. Wir werden den ersten Schritt bei der Implementierung

00:06.630 --> 00:08.270
des tiefen Theoriemodells machen.

00:08.280 --> 00:13.590
Im Grunde sind wir dabei, den gesamten Prozess des Diffusionsalgorithmus zu implementieren.

00:13.830 --> 00:16.580
Und so werden wir das nutzen, was wir zuvor geschaffen haben.

00:16.590 --> 00:22.460
Dies ist die Architektur des neuronalen Netzwerks, um den Speicher nachzuspielen, um ihn in den gesamten Lernprozess

00:22.530 --> 00:24.180
der Dequeue zu integrieren.

00:24.180 --> 00:28.320
Und dieser ganze Lernalgorithmus wird in eine Klasse passen.

00:28.380 --> 00:32.340
Das ist das letzte, was wir machen, um künstliche Intelligenz zu implementieren.

00:32.340 --> 00:35.650
Und diese Klasse wird nur verschiedene Funktionen enthalten.

00:35.700 --> 00:41.790
Wir haben also die Funktionen in ihm, die alle Variablen erstellen und initialisieren, die

00:41.790 --> 00:48.450
mit unseren zukünftigen Umleitungsobjekten verknüpft sind, die das Modell selbst darstellen und einige andere Funktionen haben.

00:48.510 --> 00:52.830
Eine davon ist natürlich, jedes Mal die richtige Aktion auszuwählen.

00:52.950 --> 00:59.250
Wir werden auch eine Update-Funktionskernfunktion haben, um diesen Kern zu erhalten und eine Vorstellung davon zu haben, wie das Lernen

00:59.250 --> 01:01.030
läuft, wenn es gut läuft.

01:01.090 --> 01:07.080
Wenn die Erkundung gut verläuft und sie zur Ausbeutung übergehen kann, dann

01:07.080 --> 01:12.430
haben wir eine sichere Funktion, um morgen zu retten.

01:12.480 --> 01:14.590
Wir müssen also ein paar Funktionen erstellen.

01:14.640 --> 01:17.440
Wir werden eine Funktion für jeden erstellen, die sich darum bemüht.

01:17.490 --> 01:22.820
Und heute beginnen wir wie üblich mit der Endfunktion, wenn wir eine Klasse machen.

01:23.010 --> 01:30.040
Aber vergessen wir nicht zuerst die Klasse einzuführen, also nennen wir sie D.

01:30.200 --> 01:35.970
F Und für Ihr Netzwerk rufen Sie dann einige Klammern an.

01:36.030 --> 01:39.440
Und dann gehen wir mit unserer ersten Funktion.

01:39.500 --> 01:47.910
Also machen wir diese Def, dann doppelte Unterstreichung, dann nochmal doppelte Unterstreichung und Klammern.

01:48.170 --> 01:53.530
So wie Sie in dieser Funktion verstanden haben, werden wir die an unser Objekt angehängten Variablen einführen.

01:53.570 --> 01:59.240
Wir haben also ein paar Zeilen, die alle von selbst beginnen, und wir erstellen und initialisieren

01:59.300 --> 02:03.530
im Wesentlichen alle Variablen, die zur Implementierung des D2-Netzwerks erforderlich sind.

02:03.530 --> 02:09.740
Wir werden zum Beispiel ein Objekt oder ein Netzwerk erstellen, da wir natürlich unser tiefes neuronales Netzwerk brauchen,

02:10.310 --> 02:12.190
um unser Gedächtnis zu brauchen.

02:12.300 --> 02:14.630
Wir erstellen eine weitere Variable für den Speicher.

02:14.740 --> 02:20.430
Wir haben also noch eine andere Variable für sich selbst, aber das ist nicht alles, was wir auch schaffen müssen.

02:20.480 --> 02:22.390
Einige Variablen für das letzte Datum.

02:22.490 --> 02:24.820
Die letzte Aktion und das letzte Wort.

02:24.920 --> 02:30.520
Sie kennen natürlich die Variablen, die Sie im Diffusionsalgorithmus sehen.

02:30.920 --> 02:31.830
Und dann noch was.

02:31.940 --> 02:38.150
Nun, wir benötigen auch ein Optimierungsprogramm, das Sie kennen, um ein stochastisches Raster im Sinne von Datengewichtungen

02:38.510 --> 02:42.170
durchzuführen, je nachdem, wie viel sie zum Fehler beitragen.

02:42.320 --> 02:48.650
Wenn die KI einen Fehler macht, denke ich, dass dies im Wesentlichen die Variablen sind, die wir jetzt

02:48.650 --> 02:50.230
erstellen und initialisieren müssen.

02:50.510 --> 02:58.460
Aber in dieser init-Funktion werden wir ein paar Argumente zuerst als normales Selbst angeben. Dies sind die Argumente, die sich

02:58.460 --> 03:00.190
auf unser Objekt beziehen.

03:00.200 --> 03:05.210
Dann, da Sie wissen, werden wir ein Objekt der Netzwerkklasse erstellen.

03:05.390 --> 03:12.740
Nun, da die Netzwerkklasse als Argument für die Eingabe-Größe der init-Funktion und die Aktion verwendet

03:12.740 --> 03:13.740
wird.

03:13.850 --> 03:19.110
Wenn Sie ein Objekt der Netzwerkklasse erstellen, müssen Sie ein Eingabegrößenargument und das tatsächliche

03:19.160 --> 03:20.180
Argument auswählen.

03:20.180 --> 03:22.140
Deshalb können wir sie einfach hier

03:25.660 --> 03:27.520
kopieren und los geht's.

03:27.710 --> 03:30.450
So werden diese Argumente jetzt werden.

03:30.560 --> 03:33.160
Auch einige Argumente waren nicht von Dauer.

03:33.170 --> 03:39.680
Wann immer wir einige zukünftige Objekte der verschiedenen Klasse erstellen, die einige zukünftige Vorbilder darstellen. Nun müssen wir die

03:39.680 --> 03:45.010
Eingabegröße angeben, an die ich mich erinnere, die Anzahl der Dimensionen in den Vektoren, die

03:45.010 --> 03:46.330
Ihre Zustände enthalten.

03:46.370 --> 03:52.940
Ihre Eingabestatus und eine Reihe von Aktionen, dh die Anzahl der möglichen Aktionen, die das Auto ausführen kann.

03:53.150 --> 03:54.000
Also erinnere ich dich.

03:54.110 --> 03:57.830
Gehen Sie entweder geradeaus oder rechts.

03:58.190 --> 03:59.270
Okay, perfekt.

03:59.270 --> 04:04.640
Dann wissen Sie, dass Sie ein neues Objekt der Wiedergabespeicherklasse erstellen werden, um das Speicherobjekt

04:04.640 --> 04:10.680
zu erstellen, um unsere Erinnerung an die Übergänge und die Informationen zu erhalten, die das Kapazitätsargument enthalten.

04:10.850 --> 04:16.640
Da wir es jedoch nur einmal verwenden werden, wenn wir Speicher erstellen, und nicht

04:16.640 --> 04:20.000
danach, müssen wir das Kapazitätsargument nicht angeben.

04:20.030 --> 04:25.330
Wir könnten dies tun, werden aber direkt die Anzahl der Übergänge eingeben, die unser Gedächtnis haben soll.

04:26.150 --> 04:32.390
Dann brauchen wir noch ein letztes Argument, um den Parameter im Lehrermodell abzurufen.

04:32.480 --> 04:35.470
Denken Sie daran, dass dieser Gamma-Parameter die Verzögerung ist.

04:35.750 --> 04:41.300
Und das ist ein Parameter der Gleichung und deshalb werden wir es hier angeben, da wir ihn

04:41.510 --> 04:42.920
später mehrmals verwenden werden.

04:43.160 --> 04:44.990
Also lass es uns hier stellen.

04:45.070 --> 04:47.140
Wir nennen es Gamma.

04:47.150 --> 04:52.610
Dafür ist es nur der Name des Arguments und dann gehen wir davon aus, dass alle Argumente, die Sie dafür benötigen, in

04:52.610 --> 04:53.740
seiner Funktion benötigt werden.

04:53.750 --> 05:00.320
Das bedeutet also, dass jedes Mal, wenn wir unser Wörterbuchmodell erstellen, jedes Mal, wenn wir ein Objekt des Lehrers

05:00.320 --> 05:01.390
im Unterricht erstellen.

05:01.520 --> 05:08.060
Nun müssen wir als Eingangsgröße die Anzahl der Aktionen und den Parameter angeben.

05:08.360 --> 05:10.590
Und wir enden mit den wahren Werten für sie.

05:11.210 --> 05:13.870
Nun gut, gehen wir jetzt in die Funktion.

05:14.100 --> 05:14.400
OK.

05:14.410 --> 05:16.480
Also im Grunde wird dies einfach sein.

05:16.510 --> 05:21.090
Wir sind gerade dabei, alle benötigten Variablen zu erstellen und zu initialisieren.

05:21.110 --> 05:22.770
Und so fangen wir mit dem ersten an.

05:22.910 --> 05:24.460
Beginnen wir mit Gamma.

05:24.530 --> 05:26.090
Eigentlich der Verzögerungskoeffizient.

05:26.330 --> 05:31.850
Da dies ein Voivode ist, der an sein Objekt angehängt werden soll, beginnen wir mit Selbst.

05:31.880 --> 05:39.500
Gamma ist also eine Variable unseres Lehrers und des Modells selbst. Gamma entspricht den Argumenten, die eingegeben werden,

05:39.530 --> 05:42.930
wenn ein Objekt der Detune-Klasse erstellt wird.

05:42.950 --> 05:46.900
Also Janna und da gehen wir mit dem zweiten Argument.

05:47.040 --> 05:50.560
Das zweite Argument wird das Belohnungsfenster sein.

05:50.840 --> 05:52.340
Was ist das für ein Fenster?

05:52.520 --> 05:57.950
Nun, das wird das gleitende Fenster des Mittelwerts der letzten 100 Wörter sein, mit dem Sie nur

05:58.010 --> 06:04.280
die Entwicklung der Leistung beurteilen werden, von der Sie wissen, dass sie die Bedeutung des Wortes in diesem Krieg Windu hat,

06:04.280 --> 06:06.320
das im Laufe der Zeit abrutscht.

06:06.440 --> 06:11.680
Was wir beobachten wollen, ist die Bedeutung der letzten 100 Wörter, die mit der Zeit zunehmen.

06:11.930 --> 06:18.610
Also lasst es uns mit diesem Belohnungsunterstrich-Fenster initialisieren.

06:18.710 --> 06:24.690
Und da dies ein Schiebefenster des sich entwickelnden Mittelwerts der letzten 100 Wörter sein wird.

06:24.860 --> 06:31.710
Nun, wir werden es als leere Liste initialisieren und dann erweitern, um Überstunden zu machen.

06:32.860 --> 06:35.320
Alles klar, dann aufregender.

06:35.420 --> 06:37.430
Lassen Sie uns unser neuronales Netzwerk schaffen.

06:37.580 --> 06:43.780
Wir werden es Mario als Autodidakt bezeichnen, da dies im Grunde das Herz der Modelle ist.

06:43.790 --> 06:51.890
Ich nenne es Modell und dieses Modell wird nichts anderes als ein Subjekt in dieser Klasse sein und ein

06:51.890 --> 06:53.270
solches Objekt erstellen.

06:53.300 --> 07:02.630
Wir nehmen unser Klassennetzwerk in Klammern und setzen hier nur die Argumente der Klasse, aber wir fügen diese Argumente in die

07:02.750 --> 07:08.930
Argumente der init-Funktion ein. Deshalb müssen wir sie einfach hier kopieren und

07:08.930 --> 07:15.290
sie einfach in die Netzwerkklasse einfügen und dann wir Gehen Sie mit dieser Codezeile.

07:15.350 --> 07:22.690
Wir schaffen ein neuronales Netzwerk für ein perfektes Lernmodell, dann erstellen wir ein Gedächtnis.

07:22.880 --> 07:29.930
Wir werden also wieder einen neuen Vargo erstellen, den wir selbstlernendes Gedächtnis nennen.

07:29.930 --> 07:34.190
Und wieder wird dies ein Objekt der Wiedergabespeicherklasse sein.

07:34.220 --> 07:42.320
Nehmen wir also einfach den Namen oder die Klasse, lasst uns kopieren, aber stellen wir uns der Tatsache, dass wir in einigen Klammern die

07:42.320 --> 07:48.680
Kapazität einsetzen müssen, weil die Kapazität ein Argument der Funktion ist und dies das einzige Argument ist, das

07:48.680 --> 07:49.880
wir hier benötigen.

07:50.240 --> 07:55.100
Welche Kapazität werden wir wählen? Denken Sie daran, dass die Anzahl der Übergänge der Anzahl

07:55.100 --> 07:59.800
der Ereignisse entspricht, die Sie als letzte Aktion und als letztes Wort angegeben haben.

07:59.830 --> 08:07.550
Und so, wie in einer der Priester-Mühen erwähnt, werden wir einhunderttausend einhunderttausend Übergänge in das Gedächtnis aufnehmen,

08:07.550 --> 08:14.390
und dann werden wir dieses Gedächtnis abtasten, um eine kleine Anzahl von zufälligen Übergängen zu

08:14.390 --> 08:18.670
erhalten, und das, auf dem das Modell OK ist.

08:18.720 --> 08:21.210
Jetzt haben wir unser Gedächtnis perfekt.

08:21.210 --> 08:23.180
Nun lasst uns unseren Optimierer holen.

08:23.430 --> 08:31.800
Also selbst erstellen wir eine neue Variable, die wir Optimizer nennen. Optimizer ist also eine weitere Variable

08:31.800 --> 08:35.320
unseres zukünftigen Dequeue eines Objekts als Optimierer.

08:35.520 --> 08:44.130
Und jetzt, wenn wir zurückgehen, können Sie sehen, dass wir Upton Folter importiert haben, eine modulare Taschenlampe, die alle Werkzeuge enthält, um

08:44.160 --> 08:47.080
das Gitter in die Mitte zu bekommen.

08:47.130 --> 08:54.260
Natürlich enthält es einige Optimierer, und wir haben ihm die Abkürzung Upton gegeben. Daher wollen wir hier

08:54.270 --> 09:00.900
das Modell zu ihm bringen, das ist das, was er will, und aus diesem Modul werden

09:00.900 --> 09:03.060
wir eines der Optimierer.

09:03.180 --> 09:05.670
Wie Sie sehen, sind sie hier alle aufgeführt.

09:05.880 --> 09:10.630
Viele von ihnen sind ausgezeichnet, zum Beispiel ist Ropps Propp ein hervorragender Optimierer.

09:10.640 --> 09:16.170
Es wird beispielsweise dringend empfohlen, neuronale Netzwerke oder unbeaufsichtigtes Deep Learning aufzunehmen.

09:16.230 --> 09:22.140
Aber der andere, der ausgezeichnet ist und den er wählen wird, ist der Atom-Optimierer.

09:22.500 --> 09:26.400
Das ist das, was Sie sehen werden, mit dem man ein gutes selbstfahrendes Auto bekommt.

09:26.580 --> 09:32.000
Sie sind aber auch herzlich eingeladen, andere zu probieren, aber Sie können sich für Armlehne entscheiden, aber für Metal wählen

09:32.000 --> 09:32.810
wir Adam.

09:32.850 --> 09:34.290
Also drücke ich die Eingabetaste.

09:34.560 --> 09:37.240
Und tatsächlich werden Sie feststellen, dass sich hier das Kapitol befindet.

09:37.260 --> 09:40.430
Das liegt daran, dass wir ein Objekt der Atom-Klasse erstellen.

09:40.430 --> 09:44.990
Dies ist eine Klasse, aber das Objekt ist selbst ein Atom-Optimierer.

09:45.060 --> 09:50.970
Da dies jedoch eine Klasse ist, müssen wir einige Argumente angeben. Die Argumente der Atom-Klasse und

09:51.060 --> 09:55.270
die Argumente sind alle Parameter, die Ihr Optimizer anpassen können.

09:55.380 --> 10:00.330
Das ist zum Beispiel normalerweise die Lernrate des Verfalls oder einiger anderer Parameter.

10:00.510 --> 10:05.690
Neben den Parametern von Ormeau legen wir eine Lernrate fest.

10:05.970 --> 10:08.650
Es ist also der Anfang der Parameter unseres Modells.

10:08.670 --> 10:12.830
Wir können sie mit einem Selbstzweifel-Modell erhalten.

10:12.870 --> 10:17.530
Das ist das Modell, das wir hier als Autodidakt aus unserer eigenen Klasse erstellt haben.

10:17.580 --> 10:24.780
Um das Autodidakt-Modell aufzurufen und dann auf die Parameter des Modells zuzugreifen, fügen wir auf einfache Weise einen weiteren Punkt

10:25.500 --> 10:28.170
und dann Parameter mit einigen Klammern hinzu.

10:28.170 --> 10:35.860
Das heißt, um den Addon-Optimierer mit dem neuronalen Netzwerk zu verbinden, das wir hier wieder erstellt haben.

10:35.880 --> 10:42.810
Wie bereits erwähnt, werden wir eine Lernrate hinzufügen, und das Argument dafür ist unser.

10:43.170 --> 10:50.540
Und wir setzen ihn auf einen Wert, so dass das Lernen nicht zu schnell erfolgt, wenn die Lernrate zu groß

10:50.540 --> 10:53.910
wird, dann lernt die KI die KI richtig.

10:53.910 --> 10:58.890
Wir möchten unserer KI etwas Zeit geben, um aus ihren Fehlern zu lernen.

10:58.890 --> 11:04.320
Du weißt, wenn wir es bestrafen, wenn es einige Fehler macht, wie zum Beispiel einen Sinn zu finden oder zu nahe an

11:04.320 --> 11:05.510
eine Wand zu kommen.

11:05.770 --> 11:08.780
Nun, wir möchten etwas Zeit zum Lernen geben.

11:08.880 --> 11:12.030
Wir wollen einen Weg zum neuronalen Netz, um korrekt zu datieren.

11:12.180 --> 11:21.010
Ein guter Wert für die Lernrate, nach der ich mehrere ausprobiert habe, ist 0. 2 oder eins.

11:21.210 --> 11:24.540
Alles klar und das ist alles, was wir brauchen, um einen Optimierer zu erstellen.

11:24.720 --> 11:28.320
Im Grunde erstellen Sie also ein Objekt der Atom-Klasse.

11:28.530 --> 11:29.050
Großartig.

11:29.070 --> 11:35.980
Und die letzten drei Variablen, die wir brauchen, sind die Variablen, aus denen sich unsere Übergangsereignisse zusammensetzen.

11:36.150 --> 11:40.130
Das ist also das letzte Datum, die letzte Aktion und das letzte Wort.

11:40.170 --> 11:45.280
Das ist im Grunde das, was wir jetzt erstellen, und wir müssen sie nur initialisieren.

11:45.300 --> 11:50.130
Beginnen wir mit dem letzten Datum, dem letzten Datum, das wir als Autodidakt bezeichnen.

11:50.400 --> 11:56.000
Letzter Unterstrichstatus und wie werden Sie ihn initialisieren.

11:56.190 --> 12:03.840
Denken Sie daran, dass das letzte Datum ein Vektor von 5 Herrschaften ist, ein Vektor, der in einem Zustand der Umgebung

12:03.840 --> 12:04.700
codiert ist.

12:04.950 --> 12:10.800
Zur Erinnerung, diese fünf Dimensionen sind die drei Signale der drei Sensoren, die

12:10.800 --> 12:15.180
gerade und rechts bleiben, sowie Orientierung und Minus-Orientierung.

12:15.210 --> 12:18.350
Das ist also ein Vektor und ein intuitiver Sinn.

12:18.420 --> 12:21.060
Aber für die Fackel muss es mehr als ein Vektor sein.

12:21.210 --> 12:23.640
Es muss tatsächlich ein Brennertensor sein.

12:23.820 --> 12:29.970
Aber es muss nicht nur ein Brennersensor sein, sondern es muss eine weitere Dimension haben, die ich

12:29.970 --> 12:33.510
als falsche Dimension bezeichnen möchte, die der Charge entspricht.

12:33.630 --> 12:39.810
Und das ist, weil die letzten acht die Eingabe des neuronalen Netzwerks sein werden, aber wenn ich mit mir

12:39.810 --> 12:46.220
arbeite, wenn das im Allgemeinen funktioniert, ob es bei dichterem Fluss einen Brenner trägt, während die Eingangsvektoren nicht ein einfacher

12:46.290 --> 12:48.040
Vektor für sich sein können.

12:48.210 --> 12:49.760
Es muss in einer Reihe sein.

12:49.830 --> 12:57.660
Das Netzwerk kann nur Stapel von Eingabebeobachtungen akzeptieren. Daher wird nicht nur ein Tensor

12:57.870 --> 13:05.140
für die Eingabezustandsvektoren erstellt, sondern auch diese dem Stapel entsprechende falsche Dimension.

13:05.190 --> 13:11.490
Also machen wir das und beginnen mit dem Initialisieren eines Brennersensors, damit es nicht einfacher

13:11.490 --> 13:12.340
ist.

13:12.510 --> 13:21.810
Wir nehmen unsere Brennerbibliothek, dann Punkt, und dann werden wir die Tensor-Klasse verwenden, da, wie Sie vielleicht schon vermutet

13:21.810 --> 13:27.950
haben, ein Objekt der Tensor-Klasse erstellt wird, das ein Tensor-Objekt ist.

13:28.120 --> 13:34.660
In diesem Tensor müssen wir ein Argument angeben, das die Größe des Tensors angibt.

13:34.660 --> 13:38.720
Sie können sich vorstellen, dass Sie wie ein Array mit einem einzigen Typ sind.

13:38.890 --> 13:45.430
Aber im Grunde wird dies nun natürlich dargestellt. Dieser Eingabezustand, den Sie sehen können, hat einen Vektor und damit

13:46.180 --> 13:49.380
die Anzahl der Elemente, die der Abstand haben muss.

13:49.570 --> 13:55.180
Nun, wir müssen natürlich die Eingabegröße verwenden, da die Eingabegröße genau die Anzahl der

13:55.510 --> 13:57.520
Dimensionen unserer Eingabezustandsvektoren ist.

13:57.520 --> 13:59.050
Jetzt sollte ich Tensoren sagen.

13:59.170 --> 14:05.650
Was wir also einfach in unsere Tensorklasse eingeben müssen, um ein Tensorobjekt zu erstellen.

14:06.010 --> 14:07.260
Nun, das ist ungenau.

14:07.540 --> 14:10.230
Und später wird die Eingangsgröße quantifiziert.

14:11.350 --> 14:12.430
In Ordnung, das ist gut.

14:12.430 --> 14:13.670
Das ist das Erste, was gemacht wurde.

14:13.720 --> 14:17.390
Wir haben den Tensor gerade so initialisiert, wie er sein sollte.

14:17.530 --> 14:23.080
Denken Sie jedoch daran, dass wir noch etwas tun müssen, um diese falsche Dimension zu erstellen, denn

14:23.080 --> 14:30.070
dies ist es, was das Netzwerk für seine Eingaben erwartet, und diese zur Überprüfung zu erstellen, die übrigens der erste Motor sein

14:30.070 --> 14:35.840
muss, an dem Sie den Schaden kennen Ich werde das zum ersten Mal erwähnen, wenn ich dies erwähne,

14:35.940 --> 14:37.800
sagen wir es sehr gut.

14:38.230 --> 14:46.050
Nun, um das zu tun, müssen wir das einfach hinzufügen und dann in ein paar Klammern drücken.

14:46.050 --> 14:49.580
Wir müssen den Index dieser großen Dimension setzen.

14:49.620 --> 14:55.790
Und wie ich gerade gesagt habe, diese gefälschte Dimension muss die erste Animation des letzten Datums sein,

14:55.790 --> 15:02.460
und da Indizes und Bytes sowie Null gestartet sind, müssen wir Null eingeben, damit diese neue Paradigma-Engine zur ersten

15:02.460 --> 15:03.570
Line-Engine wird.

15:03.570 --> 15:09.360
Wir haben also eine erste Engine, die der Charge entspricht, und dann sollte der Diamant

15:09.360 --> 15:15.960
auf diesen Sensor reagieren, der die fünf Elemente Ihrer Eingangszustände, die drei Signale, die Orientierung und die negative

15:15.990 --> 15:16.910
Orientierung enthält.

15:17.370 --> 15:21.960
Dann haben wir unsere Eingabestatus richtig initialisiert.

15:21.960 --> 15:22.850
Perfekt.

15:23.310 --> 15:30.840
Und dann noch zwei Variablen, und das wird viel einfacher, weil die nächste Variable die letzte Aktion

15:31.110 --> 15:31.850
ist.

15:32.190 --> 15:36.340
Das ist ein neuer Roybal, den wir für Object letzte Aktion erstellen.

15:36.510 --> 15:43.440
Denken Sie daran, im ersten Tutorial des Abschnitts, den ich Ihnen erzählt habe, dass die

15:43.440 --> 15:52.470
Aktionen entweder 0 1 oder 2 sein werden, und dann mithilfe des Aktionsrotationsvektors diese Indexe dieser Aktionen in die Drehwinkel

15:52.470 --> 15:58.010
umwandeln, an die ich unsere 0 erinnere 20 oder minus 20.

15:58.050 --> 16:00.980
Wir können damit tatsächlich unser Gedächtnis auffrischen.

16:01.200 --> 16:03.170
Nun ist es genau hier.

16:03.170 --> 16:06.260
Aktion zur Drehung, wenn die Aktion Null ist.

16:06.390 --> 16:11.650
Nun, dies entspricht dem ersten Index von Null, wenn die Aktion 1 ist.

16:11.700 --> 16:17.310
Dies wird dem Index eines dieser Vektoren von 20 Grad entsprechen, und wenn die Aktion

16:17.310 --> 16:23.490
zu minus 20 Grad wird, wird dies der Drehwinkel unseres Autos sein, wenn wir die Aktion spielen.

16:23.510 --> 16:24.200
Gut.

16:24.380 --> 16:31.040
Und da die Aktion entweder 0 1 oder 2 sein wird, ist die Aktion für eine einfache Nummer

16:31.040 --> 16:31.740
vorhanden.

16:31.850 --> 16:35.440
Und so können wir es ganz einfach auf Null initialisieren.

16:35.660 --> 16:38.330
Wir müssen keine Zehner schaffen oder sonst noch etwas hören.

16:38.360 --> 16:40.880
Wir müssen es nur mit Null initialisieren.

16:41.420 --> 16:42.850
Und schlussendlich.

16:43.010 --> 16:44.460
Nun, das ist das letzte Wort.

16:44.550 --> 16:48.840
Es ist das letzte Wort.

16:48.860 --> 16:49.940
Da gehen wir.

16:49.940 --> 16:56.510
Und wieder ist das Wort eine Float-Nummer, an die ich mich erinnere, zwischen minus 1 und plus 1.

16:56.510 --> 16:57.790
Das ist also wieder die Nummer.

16:57.860 --> 16:59.400
Und was die Action angeht.

16:59.510 --> 17:02.900
Wir werden es auf Null initialisieren und dann gehen wir.

17:02.900 --> 17:06.330
Glückwunsch sind in seiner Funktion bereit.

17:06.350 --> 17:08.930
Nun können wir uns auf das aufregende Material konzentrieren.

17:08.930 --> 17:16.040
Und eigentlich ist das Wichtigste für die KI, dass sie

17:16.080 --> 17:23.240
entscheidet, welche Aktion zu jeder Zeit und zu jeder Zeit gespielt wird.

17:23.510 --> 17:27.310
Also lass uns das neben Mühe tun und bis dahin ich.
