WEBVTT

00:00.420 --> 00:04.730
Hallo und herzlich willkommen zum allerletzten Schritt dieses ersten Teils.

00:04.860 --> 00:10.500
Jetzt müssen wir nur noch die Ford-Funktion machen, die das Signal von Anfang an ausbreitet,

00:10.500 --> 00:16.650
wenn das Gehirn das Bild bis zum Ende bringt, wenn ich die Aktion platziere, damit wir dies

00:16.650 --> 00:22.260
tun können ganze Funktion und das wird unser letzter Schritt sein, bevor wir uns

00:22.260 --> 00:26.710
dem Training widmen, um unsere KI mit tiefem Faltungskulang zu trainieren.

00:26.890 --> 00:28.080
Also lass uns das tun.

00:28.080 --> 00:34.470
Wir werden den Funktionsaufruf annehmen, der eigentlich der init-Funktion ähnelt. Es handelt sich dabei um eine vorhandene Funktion,

00:34.470 --> 00:38.760
aber dieses Mal verwenden wir ihn, um einige andere Funktionen aufzurufen.

00:38.790 --> 00:43.170
Die, die wir zuvor gemacht haben, weil Sie wissen, dass wir die Vorwärtsfunktion vom Gehirn

00:43.290 --> 00:45.490
und die Portfunktion vom Körper verwenden werden.

00:45.630 --> 00:50.270
Daher verwenden wir diese Funktion jetzt, um diese Funktionen grundsätzlich aufzurufen.

00:50.550 --> 00:53.160
Der Aufruf wird also zwei Argumente annehmen.

00:53.160 --> 00:54.330
Der erste ist Selbst.

00:54.330 --> 01:00.220
Natürlich das Objekt und das zweite Argument, das nach Ihren Wünschen sein wird.

01:00.360 --> 01:02.910
Nun, wir machen diesmal die ganze Verbreitung.

01:02.910 --> 01:08.460
Was wir als Eingabe nehmen wollen, ist natürlich die Eingabebilder, denn dies ist natürlich der Ausgangspunkt,

01:08.460 --> 01:10.860
wenn die KI das Spiel spielt.

01:10.860 --> 01:16.080
Es visualisiert zuerst die Bilder des Spiels, verbreitet dann die Signale im Gehirn und spielt

01:16.080 --> 01:17.180
dann die Aktion.

01:17.190 --> 01:20.130
Das zweite Argument wird daher Eingaben sein.

01:20.610 --> 01:24.740
Und jetzt sind wir bereit, diese ganze Verbreitung zu machen.

01:24.810 --> 01:26.220
Also machen wir das nochmal.

01:26.220 --> 01:31.900
Der erste Schritt, in dem es der erste Schritt ist, ist das Erhalten der Eingabebilder vom Spiel.

01:32.190 --> 01:38.010
Und da diese Bilder in das neuronale Netzwerk eingehen, können Sie sich vorstellen, dass wir sie

01:38.010 --> 01:42.840
in einer speziellen Struktur formatieren müssen und die Struktur ist natürlich eine Fackelstruktur.

01:42.840 --> 01:48.420
Das erste, was passieren wird, ist, dass wir diese Bilder in ein Umpire-Array

01:48.420 --> 01:55.320
umwandeln, dann in einen Brennerspanner und dann den Brennerspanner in eine Brennervariable, die sowohl den Tensor

01:55.500 --> 01:58.260
als auch einen Gradienten enthält.

01:58.350 --> 02:03.780
Das ist für unsere dynamischen Graphen sehr effizient, um die später schnelleren Kattie Gradienten in dem Sinne sehr effizient

02:03.780 --> 02:04.460
zu berechnen.

02:04.620 --> 02:06.200
Das ist also unser erster Schritt.

02:06.270 --> 02:12.130
Und wenn wir erst einmal das richtige Format unserer Bilder erhalten haben, können sie in das neuronale Netzwerk

02:12.360 --> 02:16.320
eindringen, und dann werden wir die gesamte Ausbreitung der Signale durchführen.

02:16.380 --> 02:20.340
Machen wir dies zuerst, indem wir das Bild in das richtige Format konvertieren.

02:20.430 --> 02:23.050
Unsere Bilder sind also für Eingaben.

02:23.220 --> 02:26.780
Jetzt erstellen wir eine neue Variable, die ich als Eingabe bezeichne.

02:26.820 --> 02:30.470
Das ist also die eigentliche Eingabe des neuronalen Netzwerks und dieser Eingabe.

02:30.510 --> 02:31.760
Wo soll es sein?

02:31.920 --> 02:34.490
Nun, zuerst müssen wir unsere Eingaben nehmen.

02:34.530 --> 02:36.650
Das sind unsere Originalbilder.

02:36.870 --> 02:42.190
Dann wollen wir, wie gesagt, diese Bilder in Nampa-Arrays konvertieren.

02:42.330 --> 02:49.260
Um dies zu tun, können wir einfach keine nehmen, von der eine Verknüpfung und dann das Funktionsarray hat.

02:49.500 --> 02:52.850
Also setzen wir die Klammern des Funktionsarrays ein.

02:52.890 --> 02:53.340
Da gehen wir.

02:53.340 --> 02:55.940
Jetzt wird es in etwas und in Arrays umgewandelt.

02:56.190 --> 03:02.790
Da jedoch die Zellen der Numpad-Arrays die Pixel enthalten, ist es tatsächlich sicherer, den

03:02.790 --> 03:04.230
Typ Float anzugeben.

03:04.310 --> 03:11.040
Es ist besser, sicherzustellen, dass wir jetzt einige Schwimmer haben, um sicherzustellen, dass wir diesen Schwimmer verwenden können.

03:11.090 --> 03:12.690
Tut mir leid das zu hören.

03:12.720 --> 03:15.390
Okay, jetzt haben wir noch einen Schiedsrichter.

03:15.540 --> 03:17.330
Aber mit dem Tablet.

03:17.720 --> 03:24.150
In Ordnung, und das ist auch ein weiterer Grund, dass Tensoren per Definition Arrays eines einzigen Typs sind.

03:24.270 --> 03:28.060
Daher wählen wir den einzelnen Typ als Float-Float 32 aus.

03:28.060 --> 03:28.350
Gut.

03:28.350 --> 03:34.440
Nun, da wir unsere Nicht-Bio-Erhöhung haben, besteht der nächste Schritt darin, diesen in einen Schildkröten-Sensor

03:34.440 --> 03:37.990
umzuwandeln. Dazu können wir beispielsweise eine Fackel verwenden.

03:38.070 --> 03:45.380
Und dann von der Nicht-Pilot-Funktion, die diese in einen Brennersensor umwandelt.

03:45.420 --> 03:46.200
Da gehen wir.

03:46.210 --> 03:52.320
Der letzte Schritt besteht darin, diese Brennersensoren in eine Brennervariable zu setzen, die sowohl den Tensor als auch die

03:52.320 --> 03:53.230
Übereinstimmung enthält.

03:53.400 --> 04:02.010
Und Sie wissen, wie Sie das machen. Natürlich nehmen wir unsere Variablenklasse, denn eigentlich ist alles, was sich in

04:02.010 --> 04:05.530
dieser Variablen befindet, die Eingabe der Variablenklasse.

04:05.760 --> 04:11.400
Aber ich wollte Ihnen das auf diese Weise zeigen, denn Sie wissen, wir beginnen mit unseren Eingabebildern,

04:11.400 --> 04:15.890
konvertieren sie dann in nummerierte Arrays, dann in Fühlerspanner und dann morgen.

04:16.170 --> 04:17.220
Und jetzt geht es uns gut.

04:17.220 --> 04:23.370
Sie dürfen in das neuronale Netzwerk eindringen, das zuerst die Augen des Auges ist, und dann die vollständig verbundenen

04:23.370 --> 04:25.770
Schichten, um zu den Vorhersagen zu führen.

04:26.220 --> 04:30.340
Wenn wir von den Augen der Augen sprechen, werden wir jetzt genau das tun.

04:30.480 --> 04:37.280
Wir werden diese erlaubten Bilder jetzt in die Augen der Augen verbreiten, die durch die

04:37.290 --> 04:38.720
drei Faltungsschichten gehen.

04:38.850 --> 04:41.620
Und um das zu tun, werden Sie jetzt sehen, wie einfach es ist.

04:41.640 --> 04:46.290
Das liegt daran, dass wir unser Gehirn bereits durch die Init-Funktion in unserem Körper haben.

04:46.320 --> 04:56.190
Wir müssen einfach unser Gehirn als das Gehirn nehmen und dieses Gehirn auf die Eingabebilder anwenden, und das wird die

04:56.190 --> 04:59.830
Dinge vom Gehirn zur Nahrungsfunktion hier ausbreiten.

05:00.430 --> 05:06.190
Das wird die Signale im Gehirn ausbreiten und da die

05:06.520 --> 05:13.600
Vorwärtsfunktion des Gehirns die Ausgangssignale zurückgibt, die die Neuronen der Ausgangsschicht mit Q-Werten

05:13.610 --> 05:19.030
enthalten Ob es sich hierbei um eine Variable handelt,

05:19.090 --> 05:26.690
und wir nennen es ganz einfach, dass dieser Ausgang das Ausgangssignal des Gehirns ist.

05:26.930 --> 05:31.970
Und jetzt, da wir das Ausgangssignal des Gehirns haben Nun, wir müssen dieses Ausgangssignal

05:31.970 --> 05:37.990
an den Körper weiterleiten und dazu müssen wir die zweite Vorwärtsfunktion des Körpers verwenden und dies tun.

05:38.030 --> 05:46.370
Wir müssen einfach unseren Körper nehmen und ihn natürlich auf die Ausgabe anwenden, da die Ford-Funktion des

05:46.370 --> 05:50.600
Körpers die Ausgangssignale des Gehirns als Eingabe übernimmt.

05:50.660 --> 05:55.880
Genau das ist also jetzt die Ausgabe und gibt die Aktionen zurück.

05:56.000 --> 05:58.080
Und deshalb gibt es die Aktionen zurück.

05:58.380 --> 06:03.530
Nun, hier werden wir Aktionen hinzufügen, um die Ausgabe selbst zu bewirken.

06:03.920 --> 06:09.380
In Ordnung, so können Sie jetzt sehen, dass wir ganz einfach die Signale im Gehirn und dann vom

06:09.380 --> 06:15.410
Gehirn bis zum allerersten verbreitet haben, indem wir die Formfunktion aus dem Gehirn verwenden, die uns bringt und die

06:15.410 --> 06:19.830
Eingabebilder bringt und sie dann ins Gehirn propagiert bewahren Sie die Schlüsselwerte auf.

06:20.240 --> 06:25.400
Und dann verbreiten wir dieses Ausgangssignal in den Körper, wo die Vorwärtsfunktion unseres Körpers die

06:25.520 --> 06:26.900
Aktion zum Spielen bringt.

06:26.900 --> 06:32.300
Das einzige, was wir jetzt noch tun müssen, und das ist die letzte Codezeile dieses ersten

06:32.300 --> 06:34.510
Teils, in der das erstellt wird.

06:34.760 --> 06:39.370
Wir müssen die Aktion zurückspielen, und das sind Aktionen.

06:39.530 --> 06:45.020
Im Moment müssen die Aktionen jedoch formatiert werden, und wir müssen sie mit Recht wieder

06:45.260 --> 06:51.660
in sie konvertieren. Dazu werden wir die Datenstruktur dieser Aktionen verwenden und dann die Nicht-Pilot-Funktion hinzufügen und

06:51.890 --> 06:53.840
dann gehen wir weiter.

06:53.840 --> 06:56.780
Jetzt haben wir die Aktionen im richtigen Format.

06:56.780 --> 06:58.040
Also herzlichen Glückwunsch.

06:58.040 --> 07:00.660
Mit diesem ersten Teil 1 sind wir nun fertig.

07:00.770 --> 07:03.410
Wir bauen die KI in drei Schritten auf.

07:03.410 --> 07:06.860
Zuerst haben wir das Gehirn gemacht, dann haben wir den Körper gemacht.

07:06.860 --> 07:13.430
Drittens bauen wir das Gehirn im Körper zusammen und verbreiten das gesamte Signal von den Augen bis zu dem Moment, in

07:13.430 --> 07:15.130
dem wir die Aktion ausführen.

07:15.560 --> 07:17.100
Das ist also ein erster Schritt.

07:17.120 --> 07:22.200
Das war ein großer Schritt, aber jetzt, da Sie verstanden haben, haben wir eine KI gebaut, aber es ist immer noch dumm.

07:22.220 --> 07:24.110
Wir müssen es trainieren, um intelligent zu sein.

07:24.170 --> 07:29.030
Also müssen wir es trainieren, um das zu tun, was wir wollten, und um

07:29.030 --> 07:34.100
dies zu tun, verwenden wir das Wort muss, um Umgebungen zu tun, die Sie

07:34.100 --> 07:34.690
kennen.

07:34.760 --> 07:40.610
Und wenn man bestraft oder geschwächt wird, wenn es ein schlechtes Wort bekommt, kommt das Queue-Lernen

07:40.610 --> 07:41.670
ins Spiel.

07:41.690 --> 07:47.510
Das ist genau das, was wir in diesem Teil tun, um mit tiefem Faltungs-Q-Lernen im Auge zu trainieren.

07:47.510 --> 07:50.270
Ich kann es kaum erwarten, bis ich anfangen kann.
