WEBVTT

00:00.360 --> 00:06.030
Hallo und willkommen zum ersten Teil dieser KI-Implementierung, Teil 1, der die KI aufbaut.

00:06.120 --> 00:12.570
Und wie Sie sehen, habe ich mit diesen drei Abschnitten, die Teil 1 ausmachen, der Struktur dieser Einrückung bereits

00:12.660 --> 00:16.620
Dimension hinzugefügt, die deutlich zeigt, wie wir diese KI bauen werden.

00:16.620 --> 00:18.750
Zuerst machen wir das Gehirn.

00:18.840 --> 00:23.760
Es gibt nichts anderes als das neuronale Netzwerk. Dann werden wir den Körper schaffen, der bestimmt,

00:23.760 --> 00:25.400
wie die Aktionen gespielt werden.

00:25.590 --> 00:31.620
Sobald wir das Gehirn und den Körper haben, werden wir sie zusammensetzen, um die KI zu bilden, die sich im

00:31.620 --> 00:33.840
letzten Abschnitt dieses ersten Teils befindet.

00:33.840 --> 00:37.890
So haben Sie jetzt schon eine gute Vorstellung von der Struktur dieser Implementierung.

00:37.890 --> 00:42.760
Zuerst machen wir das Gehirn, dann machen wir den Körper und dann montieren wir die beiden, um die KI zu machen.

00:43.050 --> 00:48.520
Und dann beginnen wir mit dem ersten Abschnitt, in dem es darum geht, das Gehirn zu bauen.

00:48.810 --> 00:51.330
Und dies wird uns für Tutorials brauchen.

00:51.360 --> 00:54.810
Man kann sich vorstellen, dass es nicht wie Kuchen machen ist, ein Gehirn zu machen.

00:54.900 --> 00:57.100
Dies erfordert also mehr als ein Tutorial.

00:57.270 --> 01:03.690
Und natürlich werden wir wie üblich dieses Gehirn mit einer Klasse darstellen, weil wir mehrere

01:03.690 --> 01:10.200
Funktionen benötigen und um eine Struktur aus mehreren Funktionen zu haben, die in einer Art Anweisungen

01:10.200 --> 01:11.160
angeordnet werden.

01:11.310 --> 01:16.010
Natürlich brauchen wir eine Klasse und das ist Berkeley, weil wir diese Klasse einmal gemacht haben.

01:16.080 --> 01:22.080
Nun, wir können so viele Gehirne erstellen, wie wir möchten, indem wir nur einige Objekte dieser Klasse erstellen.

01:22.080 --> 01:28.050
Daher sind Klassen in Python und im Allgemeinen objektorientierte Programmiersprachen sehr praktisch, da Sie ein Modell aus etwas

01:28.200 --> 01:33.510
erstellen, das Sie erstellen möchten, und dann können Sie so viele Objekte erstellen, wie Sie möchten, und

01:33.510 --> 01:37.820
sie verfügen über alle Funktionen, die Sie haben in der Klasse definieren.

01:38.010 --> 01:40.470
Und für unser Gehirn werden die Features natürlich sein.

01:40.500 --> 01:45.930
Nun, zunächst einmal wird die Architektur des neuronalen Netzwerks, an die ich mich erinnere, von

01:45.930 --> 01:51.780
CNN und natürlich zwei verschiedenen Funktionen sein, wie beispielsweise dem Weiterleiten der Signale von den Eingangsneuronen

01:51.780 --> 01:55.520
an die Ausgangsneuronen, die natürlich die Ford-Funktion sein werden.

01:55.920 --> 01:58.940
Also lass uns das machen, lass uns das Gehirn machen.

01:58.950 --> 02:00.600
Das wird ziemlich aufregend.

02:00.650 --> 02:02.380
Es ist einer meiner Lieblingsteile.

02:02.520 --> 02:04.860
Und deshalb lasst uns gleich hineingehen.

02:04.890 --> 02:10.880
Wir werden also zunächst den Kurs vorstellen und diesen Kurs nennen.

02:10.950 --> 02:18.570
Nun, ich habe gezögert, es Gehirn zu nennen, aber lass uns direkter sein und es CNN nennen, weil das Gehirn

02:18.570 --> 02:20.570
eigentlich ein CNN-Netzwerk ist.

02:20.580 --> 02:22.510
Faltungsneurales Netzwerk.

02:22.530 --> 02:27.440
Wenn Sie also zusehen, können Sie ein Gehirn anrufen, wenn Sie möchten, aber jetzt wissen wir, was wir bauen.

02:28.710 --> 02:35.040
Und CNN wie für das Netzwerk des selbstfahrenden Autos wird vom Ende von Mudgal erben.

02:35.220 --> 02:42.870
Denken Sie also daran, dass das Ende des Moduls das ist, was wir hier formuliert haben, und wir möchten alle

02:42.870 --> 02:49.050
Werkzeuge dieses Moduls und eines Moduls verwenden. Daher möchten wir diese Technik in der objektorientierten Programmierung

02:49.050 --> 02:55.870
verwenden, die Vererbung ist und die Sie wissen lässt Verwenden Sie alle Werkzeuge einer übergeordneten Klasse, und

02:55.900 --> 02:59.970
genau diese Klasse wird in diesem Modul enthalten sein.

02:59.970 --> 03:00.830
Da gehen wir.

03:00.930 --> 03:05.510
Jetzt können wir alle Werkzeuge und Objekte am Ende dieses Moduls verwenden.

03:05.510 --> 03:12.100
Nun gut, jetzt, da wir unser Erbe haben, können wir in die Klasse gehen, um unsere erste Funktion zu erfüllen.

03:12.150 --> 03:18.360
Und wie Sie wahrscheinlich vermuten, ist die erste Funktion die Endfunktion, die alle Variablen der

03:18.720 --> 03:20.330
zukünftigen Gehirnobjekte definiert.

03:20.370 --> 03:23.440
Sie kennen die Zukunft und die Objekte, die erstellt werden.

03:23.700 --> 03:24.890
Also gut, lass uns das tun.

03:24.900 --> 03:29.800
Def dann zwei Unterstriche darin wieder zu den Noten.

03:29.910 --> 03:31.910
Und jetzt müssen wir einige Variablen setzen.

03:32.100 --> 03:37.460
Also zuerst war ich selbst, das bezieht sich natürlich auf das Objekt.

03:37.490 --> 03:42.380
Nun, ich denke, Sie sind ziemlich zufrieden damit, dann fügen wir eine weitere Variable hinzu, die

03:42.380 --> 03:45.310
die Anzahl der Aktionen in der Dumah-Umgebung sein wird.

03:45.500 --> 03:48.900
Wir werden diese Nummer Aktionen nennen.

03:49.010 --> 03:50.380
Anzahl der Aktionen

03:50.570 --> 03:54.390
Und tatsächlich ist diese Variable für die Funktion nicht obligatorisch.

03:54.500 --> 03:59.360
Wenn Sie die Idee testen möchten, bauen wir auf anderen Umgebungen auf.

03:59.540 --> 04:06.100
Nun, das wird sehr praktisch sein, weil wir diese Anzahl von Aktionen, die aus dem Untergang und den Varman-Wrapper mit

04:06.120 --> 04:12.290
zwei diskreten Aktionen schrecklich sind, importieren werden, und wenn Sie dies tun, werden Sie wissen, dass der Name der

04:12.510 --> 04:13.980
Umgebung den Nullpunkt darstellt.

04:14.180 --> 04:21.050
Wenn Sie also möchten, dass Sie mit anderen Umgebungen experimentieren und andere Spiele gut spielen, haben Sie nichts

04:21.050 --> 04:26.300
zu tun, da diese Anzahl von Aktionen direkt die Anzahl von Aktionen in der

04:26.300 --> 04:27.470
Dumor-Umgebung erfasst.

04:27.470 --> 04:28.650
Du wirst mit spielen.

04:29.110 --> 04:32.710
OK, also für die beiden Argumente dieser Funktion.

04:32.780 --> 04:36.500
Also können wir jetzt hineingehen und uns erinnern, was wir tun müssen.

04:36.530 --> 04:41.560
Als erstes müssen wir die Vererbung mit der Überfunktion aktivieren.

04:41.570 --> 04:43.840
Das ist also genau wie beim selbstfahrenden Auto.

04:43.970 --> 04:50.940
Wir nehmen die übergeordnete Funktion in uns und beginnen mit der Eingabe der Klasse, die das neuronale Netzwerk definiert,

04:51.470 --> 04:53.330
und das ist CNN.

04:53.690 --> 04:56.950
Dann müssen wir selbst eingeben, um auf das Objekt zu verweisen.

04:57.190 --> 05:05.230
Aber denken Sie daran, das ist nicht alles, was wir hier bei DOT hinzufügen müssen, und dann die Init-Funktion mit einigen Klammern.

05:05.270 --> 05:07.880
Und damit aktivieren wir das Erbe.

05:07.950 --> 05:11.470
Und jetzt können wir alle Werkzeuge vom Ende und vom Modul verwenden.

05:11.510 --> 05:17.070
Nun gut, jetzt denke ich, es ist Zeit, die Architektur des neuronalen Netzwerks aufzubauen.

05:17.270 --> 05:23.330
Und wenn Sie sich erinnern, werden wir ein CNN-Faltungsneuralnetzwerk aufbauen, nur weil die

05:23.330 --> 05:30.290
KI diesmal Augen hat und die Augen des Auges die Faltungsschichten dieses Faltungsneuralnetzwerks sein

05:30.290 --> 05:31.220
werden.

05:31.520 --> 05:38.240
Und nachdem das ai ai die Bilder mit den Faltungsschichten visualisiert, leitet es die Signale in

05:38.330 --> 05:41.040
ein klassisches visuelles neuronales Netzwerk ein.

05:41.180 --> 05:44.510
Das ist also das, was wir zuvor mit vollständig verbundenen Schichten hatten.

05:44.660 --> 05:50.730
Hier wird versucht, die Würfelwerte für jede mögliche Aktion vorherzusagen, die wir ausführen können.

05:51.290 --> 05:56.930
Sie haben also die Architektur im Kopf, wir werden einige Faltungsschichten und dann einige vollständig

05:56.930 --> 06:01.270
verbundene Schichten haben, und dies wird das Gehirn unserer KI sein.

06:01.550 --> 06:07.530
Also, was werden wir tun, um einen Schritt zurück bei dem zu machen, was wir machen.

06:07.670 --> 06:11.840
Nun lassen Sie uns diese Architektur einfach mit den Variablen erstellen, die wir erstellen möchten.

06:11.840 --> 06:18.890
Wenn wir also von dieser Architektur sprechen, bauen wir ein CNN mit drei Faltungsschichten.

06:18.920 --> 06:24.530
Nach dieser einen versteckten Schicht bedeutet dies, dass wir drei Faltungsverbindungen und zwei

06:24.530 --> 06:26.020
vollständige Verbindungen benötigen.

06:26.180 --> 06:31.340
Apropos Verbindungen. Genau das sind die Definitionen für die CNN-Klasse.

06:31.370 --> 06:35.030
Deshalb werde ich jetzt fünf Variablen definieren.

06:35.150 --> 06:39.100
Drei für die Faltungszusammenhänge und zwei politische Verbindungen.

06:39.350 --> 06:40.100
Also lass uns das tun.

06:40.100 --> 06:42.570
Wir werden mit den Faltungsverbindungen beginnen.

06:42.770 --> 06:47.250
Ich werde sie als autodidaktische Faltung bezeichnen.

06:47.540 --> 06:53.620
Man wird das kopieren und basiert auf dem Tiefpunkt.

06:54.020 --> 07:01.640
Und dann gehen wir zur Selbstüberzeugung und Selbstüberzeugung drei, die Faltungsverknüpfungen zu dieser ersten Schlussfolgerung sind.

07:01.640 --> 07:08.450
Hier wenden wir eine gewisse Faltung auf die Eingabebilder an, um eine erste Faltungsschicht

07:08.460 --> 07:15.860
zu erhalten Schicht als Eingabe und durch erneutes Anwenden einer Faltung wird dort eine zweite

07:15.860 --> 07:21.180
Faltung erzeugt und dann wird diese Faltung dort einige neue Bilder

07:21.180 --> 07:25.920
erhalten, von denen jedes ein bestimmtes Merkmal erkennt.

07:26.030 --> 07:32.840
Wir werden diese neuen Bilder also in eine Faltung bringen, dann werden wir diese Faltung hier

07:32.870 --> 07:39.740
anwenden, um diese neuen Bilder von dieser ersten Faltungsschicht mit einigen neuen Bildern einer zweiten Faltungsschicht zu

07:39.740 --> 07:40.300
verbinden.

07:40.430 --> 07:46.120
Und diese neuen Bilder werden wieder einige Merkmale in den Bildern der ersten Faltung erkennen.

07:46.220 --> 07:52.100
Es geht also nur darum, die zukünftige Erkennung zu verstärken und dann die zweite Faltung dort

07:52.100 --> 07:52.650
aufzubauen.

07:52.790 --> 07:57.000
Wir haben hier die dritte Faltung angewendet, um sie für jeden von ihnen zu erhalten.

07:57.050 --> 08:01.900
Einige weitere Bilder, die noch mehr Funktionen in den Eingabebildern erkennen.

08:02.050 --> 08:07.300
Je mehr wir dies tun, desto mehr wenden wir einige Faltungen auf die verschiedenen Bildebenen an.

08:07.520 --> 08:13.580
Nun, je mehr wir in der Lage sind, einige Merkmale zu erkennen, und durch das Erkennen von Merkmalen erkennt das Auge, wo

08:13.580 --> 08:18.360
sich die Monster befinden, wo sie schießen müssen, um sie zu töten und wohin sie gehen sollen.

08:18.500 --> 08:21.290
Es werden auch die Wände der Hindernisse erkannt.

08:21.440 --> 08:28.100
Nun, wortwörtlich, wohin es gehen muss, und das liegt an dem, was all diese Faltungsschichten in

08:28.130 --> 08:29.680
den Originalbildern erkennen.

08:30.450 --> 08:34.980
Also gut, das ist für den Faltungs-Teil des CNN.

08:35.100 --> 08:42.720
Denken Sie jedoch daran, dass wir nach den Faltungsschichten alle durch die verschiedenen angewendeten Windungsreihen erhaltenen Pixel

08:42.720 --> 08:48.660
abflachen müssen. Durch das Abflachen aller Pixelanordnungen erhalten Sie diesen riesigen Vektor, der

08:48.810 --> 08:53.260
zur Eingabe eines klassischen künstlichen neuronalen Netzwerks wird.

08:53.490 --> 08:58.600
Und hier bekommen wir unsere vollständig verbundenen Briefe und damit unsere Verbindungen.

08:58.710 --> 09:04.560
Nun müssen wir also zwei neue Variablen erstellen, da wir in diesem klassischen künstlichen neuronalen Netzwerk, das

09:04.810 --> 09:09.330
als nächstes kommt, eine hier und dort haben werden, und deshalb brauchen

09:09.330 --> 09:16.260
wir eine vollständige Verbindung von diesem riesigen Flaten-Vektor zu diesem hier und hier dort und eine zweite vollständige Verbindung zwischen

09:16.260 --> 09:21.620
dieser hier und dort und der Ausgabeschicht, die aus den Ausgabeneuronen besteht, die die Schlüsselwerte darstellen.

09:21.960 --> 09:27.090
Nehmen wir also diese beiden ersten Verbindungen auf und definieren wir dann alle diese Verbindungen.

09:27.240 --> 09:36.200
Fragen Sie nach dem Soundtrack im Code, den wir uns selbst als diesen und dann als selbstlernendes C bezeichnen.

09:36.240 --> 09:41.010
In Ordnung, jetzt haben wir alle unsere Wertsachen und zu wissen, was wir tun müssen,

09:41.250 --> 09:44.300
wird dann natürlich mit den Klassen des Motormoduls definiert.

09:44.310 --> 09:49.110
Das bedeutet, dass wir im Wesentlichen die Architektur des neuronalen Netzwerks erstellen werden. Dies werden

09:49.190 --> 09:50.340
wir morgen tun.

09:50.490 --> 09:51.920
Bis dahin ich