WEBVTT

00:00.520 --> 00:02.690
Hallo und willkommen zu diesem Python-Tutorial.

00:02.860 --> 00:05.680
Also gut, wir haben sehr aufregenden Boden vor uns.

00:05.680 --> 00:10.690
Wir werden damit beginnen, die Architektur des neuronalen Netzwerks zu schaffen, das heißt, wir werden das

00:10.690 --> 00:16.740
neuronale Netzwerk schaffen, das das Herzstück unserer KI sein wird und das die Action im Alter von 90 Jahren zurückbringen wird.

00:16.930 --> 00:18.060
Also lass uns das tun.

00:18.130 --> 00:23.130
Da wir wollen, dass unser neuronales Netzwerk objektiv ist, werden wir es zur Klasse machen.

00:23.200 --> 00:25.100
Und das ist so, weil es viel bequemer ist.

00:25.180 --> 00:28.370
Sie wissen, dass die Klasse das Modell von etwas ist, das wir bauen möchten.

00:28.540 --> 00:34.000
Wir möchten ein neuronales Netzwerk aufbauen und müssen einige Anweisungen machen, die alle in der Klasse

00:34.090 --> 00:35.080
enthalten sind.

00:35.140 --> 00:37.910
Und in dieser Klasse machen wir zwei Funktionen.

00:37.960 --> 00:42.810
Zuerst die Init-Funktion, welche die ganze Zeit während des Unterrichts auftritt.

00:43.000 --> 00:47.770
Und das definiert im Wesentlichen die Variable Ihres Objekts, das das neuronale Netzwerk ist.

00:47.920 --> 00:52.600
Sie kennen die an das Objekt angehängten Variablen im Gegensatz zu den globalen Variablen.

00:52.840 --> 00:57.910
Dies ist also in dieser Funktion, die die Architektur des neuen Netzwerks definiert, das Sie

00:57.910 --> 01:03.460
kennen, indem Sie die Eingabeschicht definieren, die aus fünf Eingangsneuronen besteht, da wir fünf Dimensionen für den

01:03.790 --> 01:05.680
kodierten Vektor der Eingangszustände haben.

01:05.890 --> 01:08.080
Dann definieren wir einige verborgene Ebenen.

01:08.110 --> 01:12.940
Möglicherweise beginnen Sie mit einer verborgenen Schicht, und Sie können dann andere Architekturen des neuronalen

01:12.940 --> 01:13.920
Netzwerks ausprobieren.

01:14.200 --> 01:20.080
Und dann erhalten wir natürlich die Ausgabeebene, die die möglichen Aktionen enthält, die

01:20.110 --> 01:21.940
wir jederzeit ausführen können.

01:22.180 --> 01:24.730
Genau das machen wir also in dieser Funktion.

01:24.850 --> 01:30.460
Und dann werden wir noch eine weitere Funktion innerhalb der Klasse erstellen, die die

01:30.460 --> 01:34.870
Vorwärtsfunktion ist und die die Neuronen im neuronalen Netzwerk aktivieren wird.

01:34.870 --> 01:40.570
Sie wissen, dass dies die Signale aktivieren wird. Daher verwenden wir eine gleichgerichtete Aktivierungsfunktion,

01:40.570 --> 01:46.920
da es sich natürlich um ein rein nichtlineares Problem handelt und diese korrigierte Funktion die Linearität bricht.

01:47.200 --> 01:53.340
Meistens machen wir diese Ford-Funktion jedoch, um die q-Werte zurückzugeben, die die Ausgänge des Netzwerks sind.

01:53.500 --> 01:56.110
Wir haben jedoch einen Schlüsselwert für jede Aktion.

01:56.200 --> 02:02.710
Später werden wir die endgültige Aktion zurückgeben, indem wir entweder das Maximum der Schlüsselwerte verwenden oder eine

02:02.710 --> 02:03.880
weiche Max-Methode verwenden.

02:04.030 --> 02:05.270
Das werden wir später sehen.

02:05.440 --> 02:10.330
In diesem Tutorial beginnen wir mit der Implementierung der init-Funktion, und als

02:10.330 --> 02:12.880
nächstes wird die forward-Funktion implementiert.

02:12.880 --> 02:13.810
Also lass uns das tun.

02:13.810 --> 02:17.060
Zuerst müssen wir unsere Klasse vorstellen.

02:17.200 --> 02:22.930
Wir beginnen mit dem Unterricht und geben unserer Klasse einen Namen, in dem wir es Netzwerk nennen können.

02:23.650 --> 02:29.980
Und dann werde ich in dieser Netzwerkklasse eine Objektprogrammiertechnik verwenden, die Vererbung genannt wird

02:30.310 --> 02:35.120
und nur von allen Werkzeugen einer übergeordneten Klasse erben soll.

02:35.200 --> 02:41.550
Unsere Netzwerkklasse, die wir gerade erstellen, ist also ein untergeordneter Test einer größeren Klasse.

02:41.770 --> 02:44.110
Und das Modul.

02:44.470 --> 02:50.790
Das ist also nur ein Erben von allen Werkzeugen dieser Modulklasse, die natürlich die Werkzeuge zum Implementieren eines

02:50.790 --> 02:51.940
neuronalen Netzwerks sind.

02:51.940 --> 02:57.880
Das ist also ein sehr mächtiger und evolutionärer Trick in der objektorientierten Programmierung.

02:57.910 --> 03:02.670
Und jetzt erben wir von dieser übergeordneten Modulklasse.

03:02.800 --> 03:06.000
Alles klar und jetzt können wir in die Klasse gehen.

03:06.130 --> 03:12.910
Ich drücke also zweimal die Eingabetaste, weil wir zwei Funktionen erstellen und mit der

03:13.140 --> 03:14.280
Endefunktion beginnen.

03:14.350 --> 03:20.470
Also die init-Funktion müssen wir so mit zwei auf diesem Kurs dann so benennen.

03:20.650 --> 03:25.750
Und dann nochmal zu unterstreichen, das ist nur Python-Syntax. Genau so müssen wir es tun.

03:25.930 --> 03:28.460
Und dann müssen wir die Argumente darlegen.

03:28.720 --> 03:30.340
Wir haben also drei Argumente.

03:30.340 --> 03:35.800
Der erste ist ein obligatorisches Argument, das eigentlich Selbst und Selbst ist.

03:35.800 --> 03:42.250
Es gibt kein Mysterium, das sich auf das Objekt bezieht, das aus dieser Klasse erstellt wird, die wir gerade

03:42.250 --> 03:42.810
erstellen.

03:42.820 --> 03:44.400
Sie wissen, dass wir diese Klasse machen.

03:44.470 --> 03:48.980
Es ist wie eine Anleitung eines Modells dieses neuronalen Netzwerks, das wir bauen wollen.

03:49.180 --> 03:53.620
Und wenn die Klasse fertig ist, können wir mit Netzwerken so viele machen, wie wir möchten.

03:53.620 --> 04:00.130
Und jedes dieser neuen Netzwerke wird ein Objekt dieser Klasse sein, und da wir

04:00.400 --> 04:07.630
das Objekt für andere Zwecke verwenden werden, müssen wir nur die Variablen des Objekts und

04:07.630 --> 04:11.900
für Spudis verwenden beziehen sich auf das Objekt.

04:12.100 --> 04:18.430
Wann immer ich verfügbar von meinem Objekt verwenden möchte, werde ich vor der Variablen selbst verwenden, um anzugeben,

04:18.430 --> 04:21.340
dass dies eine Variable des Objekts ist.

04:21.340 --> 04:25.680
In Ordnung, das ist also das erste Argument und dann haben wir zwei

04:25.680 --> 04:30.240
weitere Argumente, die natürlich die Anzahl der Eingangsneuronen und die Anzahl der Ausgangsneuronen sind.

04:30.550 --> 04:38.220
Die Anzahl der Eingabe-Neuronen nennen wir Eingangsgröße, und das sind eigentlich fünf, da unsere

04:38.310 --> 04:45.890
Eingangsvektoren fünf Dimensionen zu drei Signalen plus Orientierung plus Minus-Orientierung haben, Vektoren von

04:45.900 --> 04:51.020
codierten Werten, die einen Zustand der Umgebung beschreiben.

04:51.210 --> 04:54.960
Diese fünf Werte reichen aus, um den Zustand der Umgebung zu beschreiben.

04:54.960 --> 05:00.600
Wir hätten uns weniger Werte oder mehr Werte vorstellen können, aber ich habe es versucht und es macht

05:00.600 --> 05:05.520
tatsächlich Sinn, weil wir tatsächlich ein Signal von links vor uns und eines rechts benötigen.

05:05.520 --> 05:10.860
Weißt du, wenn wir ein Auto fahren, hätten wir uns für ein 360-Signal entschieden, das du kennst, wie

05:10.860 --> 05:17.370
die Signale an der Spitze der Google-Autos, dass wir mit drei Sensoren völlig selbst fahren können. Dann haben wir diese Orientierung und

05:17.400 --> 05:22.200
diese negative Orientierung für dich wissen, halten Sie das Ziel fest, das Sie erreichen wollten.

05:22.530 --> 05:29.160
Und dann haben wir natürlich die Ausgabeneuronen unseres Netzwerks, die den Aktionen entsprechen, und wir haben drei

05:29.160 --> 05:32.840
mögliche Aktionen, die nach links oder nach rechts gehen.

05:32.880 --> 05:38.520
Und deshalb werde ich es und die Aktion nennen und es werden drei davon sein.

05:38.520 --> 05:39.030
Gut.

05:39.120 --> 05:44.850
Bisher müssen wir nur die Eingänge benennen und dann diese Volleyball verwenden, um die Bedingungen innerhalb des neuronalen

05:44.940 --> 05:46.140
Netzwerks zu erfüllen.

05:47.090 --> 05:55.010
Also gut, und Sie beginnen mit einem anderen Fackel-Trick. Dieser Trick ist eine Superfunktion,

05:55.010 --> 05:59.310
eine Funktion, die tatsächlich vom Modul erbt.

05:59.390 --> 06:02.730
Deshalb mussten wir das Modul auch mit Vererbung erben.

06:02.750 --> 06:04.440
Dies ist das erste, das verwendet wird.

06:04.520 --> 06:11.120
Im Grunde verwenden wir diese Super-Trick-Superfunktion nur, um die Werkzeuge des Moduls verwenden zu können, die

06:11.580 --> 06:13.320
wesentlich effizienter sind.

06:13.670 --> 06:18.620
Und innerhalb der Superfunktion muss ich nur das Netzwerk angeben.

06:18.650 --> 06:25.100
Das ist also unsere Netzwerk-Chul-Klasse, die Sie kennen, da diese von der übergeordneten Modulklasse und

06:25.550 --> 06:27.360
dann unserem Objekt erbt.

06:27.380 --> 06:35.220
Und dann füge ich das nur hinzu und habe eine Funktion wie diese, wie wir es nannten.

06:35.570 --> 06:39.350
Also gut, das ist nur ein Trick, bei dem ich alle meine Werkzeuge benutzen muss.

06:39.360 --> 06:46.270
In diesem Modul können wir dann zum nächsten Schritt übergehen, der die Eingabeebene angibt.

06:46.550 --> 06:53.300
Im Grunde muss ich also eine neue Variable einführen, die an das Objekt angehängt wird.

06:53.300 --> 06:57.120
Diese Variable enthält die Anzahl der Eingabe-Neuronen.

06:57.170 --> 07:05.140
Nicht mit der Eingabegröße zu verwechseln. Die Eingabegröße ist das Argument der Endefunktion.

07:05.180 --> 07:09.710
Dies ist jedoch nicht die an das Objekt angehängte Variable, sondern die an das Objekt

07:09.710 --> 07:10.360
angehängte Variable.

07:10.520 --> 07:16.520
Nun, wie ich gerade erwähnte, müssen wir angeben, dass es stattdessen an das Objekt angehängt ist, also verwenden

07:17.230 --> 07:22.130
wir einen Autodidakt und geben dieser ersten an das Objekt angehängten Variablen einen Namen.

07:22.190 --> 07:24.870
Und so können wir einfach den gleichen Namen wie die Eingabe angeben.

07:24.920 --> 07:33.650
Wir können es Eingabegröße nennen und wir werden sagen, dass es den Argumenten einer Funktion entspricht, die Eingabegröße ist.

07:33.680 --> 07:34.080
Gut.

07:34.130 --> 07:39.900
Jedes Mal, wenn ich ein Objekt aus der Netzwerkklasse erstelle, wird die Eingabegröße

07:39.900 --> 07:41.170
angegeben, z.

07:41.180 --> 07:47.330
Hier wird es 5 sein, und daher wird die Eingangsgrößenvariable unseres Objekts den Wert

07:47.690 --> 07:54.110
5 haben, da diese Eingangsgröße hier 5 ist und unser neues Netzwerk daher 5 Eingangsneuronen in

07:54.110 --> 07:55.470
der Eingabeebene hat.

07:55.490 --> 07:55.790
Gut.

07:55.790 --> 08:02.180
Und das ist auch für die andere Variable, die wir an Objekte anhängen möchten, dasselbe.

08:02.210 --> 08:08.100
Und wie Sie vielleicht schon vermutet haben, wird dies eine Variable für die Anzahl der Ausgangsneuronen sein.

08:08.330 --> 08:15.030
Zu sagen, wir nehmen unser Objekt selbst und geben dieser zweiten Variablen des Objekts, das wir es

08:15.040 --> 08:17.740
nennen, und der Aktion einen Namen.

08:18.170 --> 08:23.600
Und dies wird diesem Argument hier gleich sein, wenn man die Anzahl der Aktionen, also die Anzahl der

08:23.600 --> 08:24.250
Ausgangsneuronen, berücksichtigt.

08:24.530 --> 08:30.850
Wir setzen es also der tatsächlichen Aktion gleich und die Aktion wird gleich drei sein.

08:30.890 --> 08:37.930
Daher erhalten die Variable und die Aktion, die unser Objekt einem Netzwerk angehängt, den Wert drei.

08:38.240 --> 08:41.680
Eigentlich sehen wir hier eine Warnung, die den Namen undefiniert nennt.

08:41.720 --> 08:44.180
Und das ist gut so, weil wir hier die verwenden.

08:44.230 --> 08:46.030
Und dann eine Verknüpfung.

08:46.350 --> 08:48.530
Und wir müssen hier eine Abkürzung verwenden.

08:48.590 --> 08:52.780
Und für unsere Fackel fangen wir in Mudgal an und dann wird es verschwinden.

08:52.880 --> 08:53.670
Auf geht's.

08:53.690 --> 08:54.580
Perfekt.

08:54.590 --> 09:00.800
Im Moment haben wir neue Warnungen. Alle Warnungen hier sollen nur angeben, dass das, was wir importieren, noch nicht

09:00.800 --> 09:01.520
verwendet wird.

09:01.580 --> 09:04.660
Das ist in Ordnung, wir werden sie später verwenden.

09:04.670 --> 09:10.010
In Ordnung, dann haben wir zwei weitere Variablen, die wir für das Objekt definieren wollen.

09:10.190 --> 09:15.820
Und dies wird die volle Verbindung sein, die volle Verbindung zwischen den verschiedenen Schichten unseres

09:15.830 --> 09:16.810
neuronalen Netzwerks.

09:16.820 --> 09:21.800
Da wir jetzt ein neuronales Netzwerk schaffen wollen, das aus nur einem Kopf in ihrer Welt besteht,

09:21.800 --> 09:23.440
gibt es zwei vollständige Verbindungen.

09:23.570 --> 09:27.740
Es gibt eine erste vollständige Verbindung zwischen der Eingabeebene und der verborgenen Ebene.

09:27.980 --> 09:32.450
Und eine Sekunde volle Verbindung zwischen dem Hügel und der Ausgabeschicht.

09:32.480 --> 09:34.770
Beginnen wir also mit der ersten vollständigen Verbindung.

09:34.890 --> 09:43.310
Wir werden es SE1 nennen. Und wieder benutze ich selbst, um anzugeben, dass FC eins eine Variable meines Objekts ist, um das zu

09:43.780 --> 09:44.530
lösen.

09:44.530 --> 09:47.490
FC einer, der gleich sein wird.

09:47.630 --> 09:55.160
Und jetzt verwenden wir das N in-Modul, und wir werden eine Funktion namens lineares R verwenden. Das ist genau das,

09:55.160 --> 10:02.080
um diese vollständige Verbindung zwischen den Neuronen und der Eingabeschicht mit den Neuronen der dort verborgenen Nerven herzustellen.

10:02.180 --> 10:04.090
Und was meine ich mit voller Verbindung?

10:04.160 --> 10:09.190
Das bedeutet, dass alle Neuronen der Eingabeschicht mit allen Neuronen des Hierin verbunden

10:09.190 --> 10:09.920
sind.

10:10.190 --> 10:16.140
Um diese Verbindung herzustellen, verwenden wir diese lineare Funktion, auf die wir einige Argumente setzen müssen.

10:16.190 --> 10:19.880
Und wie Sie sehen, sind diese Argumente in Features.

10:19.880 --> 10:25.370
Das ist also die Anzahl der Neuronen des ersten Gesetzes, die Sie verbinden möchten. Dabei handelt es sich um die Anzahl

10:25.370 --> 10:30.110
der Neuronen der zweiten Schicht, die Sie verbinden möchten. Dies ist die Schicht auf der rechten Seite,

10:30.110 --> 10:32.360
die die verborgene Schicht und das Fahrrad ist.

10:32.420 --> 10:38.850
Für das Fahrrad gilt also, dass wir den Standardwert beibehalten, um einen Vorurteil zu haben, und nicht nur etwas Gewicht, das mit

10:38.900 --> 10:43.350
dem Lauf zu tun hat, wir müssen warten und einen Vorrang für jede Schicht.

10:43.610 --> 10:46.140
Und so wollen wir mal sehen, was wir eingeben müssen.

10:46.280 --> 10:51.850
Das erste Argument in Features ist also die Anzahl der Eingabe-Neuronen in der Eingabeebene.

10:52.000 --> 10:52.930
Und wo ist es dann?

10:53.030 --> 10:55.080
Nun, das ist eigentlich ungenau.

10:55.100 --> 11:01.930
Das ist das Argument unserer init-Funktion, mit der wir später die drei Signale und die

11:02.200 --> 11:04.150
Mannus-Orientierung bekämpfen können.

11:04.160 --> 11:05.020
Auf geht's.

11:05.190 --> 11:14.300
Wenn die ersten Argumente und Put-Größe und dann das zweite Argument aus sind, ist dies die Anzahl der Neuronen, die wir

11:14.300 --> 11:17.090
in der zweiten Schicht haben möchten.

11:17.180 --> 11:20.450
Die zweite Schicht, die vollständig mit der ersten Schicht verbunden ist.

11:20.450 --> 11:24.960
Die Frage ist also, wie viele Neuronen wir in dieser verborgenen Schicht haben wollen.

11:25.220 --> 11:27.420
Nun, ich habe viel Parameter trainiert.

11:27.440 --> 11:29.110
Ich habe viel experimentiert.

11:29.210 --> 11:31.940
Das ist es, was wir tun, oder das tun wir tiefer.

11:31.940 --> 11:38.270
Im Allgemeinen experimentieren wir viel, um herauszufinden, welches das beste neuronale Netzwerk für unser spezielles

11:38.270 --> 11:39.170
Problem wäre.

11:39.170 --> 11:45.950
Ich versuche also viele Werte und habe letztendlich 30 30 Läufe in einer verborgenen Schicht gewählt. Sie werden sehen, dass wir

11:45.950 --> 11:50.750
mit dieser Zahl ziemlich gute Ergebnisse erzielen werden, aber dann die Architektur des neuronalen Netzwerks

11:50.750 --> 11:51.580
ändern können.

11:51.580 --> 11:53.120
Fühlen Sie sich frei, damit zu spielen.

11:53.180 --> 11:58.730
Sie können nicht nur die Anzahl der Neuronen im Hier und Da ändern, sondern Sie können auch weitere

11:59.150 --> 12:05.000
Schichten hinzufügen, so dass Sie vielleicht ein noch besseres Auto bekommen, aber 30 Hinna-Neuronen erhalten ein gutes neuronales Netzwerk und

12:05.000 --> 12:06.000
eine gute Sache.

12:06.020 --> 12:07.390
Das ist es, was wir wollen.

12:07.520 --> 12:08.410
Und da gehen wir hin.

12:08.420 --> 12:13.500
Wir haben unsere erste volle Verbindung wirklich mit dieser linearen Funktion.

12:13.520 --> 12:16.910
Wir stellen die Verbindung zwischen der Eingabeebene und dem verborgenen Bein her.

12:17.360 --> 12:23.270
Und nun ist es Zeit, die zweite vollständige Verbindung herzustellen, bei der es sich um die vollständige Verbindung zwischen der verborgenen

12:23.600 --> 12:25.180
Schicht und der Ausgabeebene handelt.

12:25.490 --> 12:26.750
Also los geht's.

12:26.750 --> 12:31.380
Wir werden diese zweite vollständige Verbindung bei C2 anrufen.

12:31.490 --> 12:32.280
Da gehen wir.

12:32.360 --> 12:36.400
Und dies ist immer noch für mehr Objekte verfügbar, die Saphir verwenden.

12:36.650 --> 12:38.330
Und dann benutzen wir wieder.

12:38.450 --> 12:45.310
Tatsächlich können wir dies kopieren, da wir das N in-Modul und dann die lineare Funktion verwenden werden.

12:45.530 --> 12:49.250
Dann müssen wir natürlich zuerst die Argumente ändern.

12:49.280 --> 12:55.050
Das Gleiche ist zunächst die Anzahl der Neuronen, die wir in der ersten Schicht der Verbindung haben werden.

12:55.190 --> 12:56.510
Das ist also das versteckte dort.

12:56.720 --> 13:03.810
Das ist also 30 und das zweite Argument ist die Anzahl der Neuronen in der zweiten Schicht der

13:04.010 --> 13:08.810
Verbindung, und dies entspricht der Ausgabeschicht und der Ausgabe, die dort vorliegt.

13:08.980 --> 13:15.020
Und die eigentlichen Neuronen werden später drei sein, weil wir drei mögliche Aktionen haben, aber bisher müssen wir die

13:15.020 --> 13:16.930
Namen verwenden, die wir definiert haben.

13:17.050 --> 13:23.990
Das ist der Name des Arguments der init-Funktion und deshalb geben wir hier und die Aktion ein und

13:23.990 --> 13:24.950
los geht's.

13:24.950 --> 13:27.760
Vor allem unsere Tupel-Verbindungen.

13:27.920 --> 13:30.980
Und zweitens ist jede Funktion Israel.

13:31.400 --> 13:36.940
Deshalb initialisieren wir unser Objekt immer dann, wenn wir ein Objekt aus der Netzwerkklasse erstellen.

13:37.130 --> 13:44.300
Sobald wir also ein Objekt erstellt haben, geben Sie hier alle diese Variablen ein. Geben Sie Größe und Reaktion ein.

13:44.380 --> 13:46.980
Sie und zwei werden definiert.

13:47.180 --> 13:52.060
Und so erhalten wir die Architektur unseres Tiernetzwerks für jedes Objekt, das wir erstellen.

13:52.160 --> 13:59.450
Jedes Objekt entspricht einem neuronalen Netzwerk mit fünf eingegebenen Neuronen, 30 verborgenen Neuronen und drei

13:59.450 --> 14:00.440
Ausgangsneuronen.

14:00.470 --> 14:01.430
Also los geht's.

14:01.430 --> 14:06.980
Wir sind mit dieser ersten Funktion fertig und können nun zu

14:06.980 --> 14:13.100
der zweiten Funktion übergehen, der Vorwärtsfunktion, mit der die Neuronen im neuronalen Netzwerk mit

14:13.100 --> 14:19.500
der Gleichrichteraktivierungsfunktion aktiviert werden und meistens zu den Cube-Werten zurückkehren die Ausgänge nur eines Netzwerks.

14:19.580 --> 14:23.420
Ich kann es also kaum erwarten, das im nächsten Tutorial zu tun und bis dahin ich.
