WEBVTT

00:00.270 --> 00:06.230
Hallo und herzlich willkommen zu dieser Pipe und zu Torro. Jetzt müssen wir die fünf Variablen dieser Funktion

00:06.240 --> 00:09.560
definieren, die die drei Windungen und die zeitlichen Verbindungen sind.

00:09.810 --> 00:11.100
Beginnen wir mit dem ersten.

00:11.250 --> 00:18.690
Convolutional 1 wendet Faltung auf die Eingabebilder an, sodass es sich um die Originalbilder handelt. Nun werden Sie sehen,

00:18.690 --> 00:22.710
wie alles so einfach wird, um diese Faltung zu erstellen.

00:22.770 --> 00:29.070
Nun, wir müssen tatsächlich ein Thema für eine bestimmte Klasse erstellen, und diese Klasse wird

00:29.070 --> 00:38.800
von und dann genommen, und dann kommen die Klassen zum Ziel, da wir mit 2D-Bildern arbeiten und jetzt, wie Sie sehen können,

00:38.800 --> 00:40.930
mehrere erforderlich sind Argumente.

00:40.930 --> 00:43.140
Zuerst ist man in Kanälen.

00:43.190 --> 00:45.910
Lassen Sie uns es in Kanälen setzen.

00:45.970 --> 00:49.210
Der zweite ist out-Kanäle.

00:49.330 --> 00:57.070
Die dritte ist die Kerno-Größe, und der Rest von ihnen füllt die Dilatationsgruppen und die Vorspannung auf.

00:57.130 --> 00:59.120
Und für all diese haben wir unterschiedliche Werte.

00:59.260 --> 01:02.290
Wir gehen also nicht weiter, aber wir behalten die Standardwerte bei.

01:02.470 --> 01:08.500
Was jedoch wichtig ist, sind diese drei Argumente in Channels und Channels sowie der Kernelgröße, und ich schätze,

01:08.500 --> 01:09.740
was ihnen entspricht.

01:09.880 --> 01:15.730
Nun, sehr einfach entspricht im Allgemeinen der Eingabe der Faltung und alle Kanäle entsprechen

01:15.730 --> 01:17.900
der Ausgabe der Schlussfolgerung.

01:17.920 --> 01:19.940
Was wird es also sein?

01:20.110 --> 01:24.460
Nun, ganz einfach, das ist die Anzahl der Kanäle in unseren Bildern.

01:24.610 --> 01:30.460
Und eigentlich werden wir mit Schwarz-Weiß-Bildern arbeiten, weil wir im Grunde keine Farben erkennen, um die Monster

01:30.460 --> 01:31.360
zu erkennen.

01:31.450 --> 01:35.310
Die KI ist in der Lage, die Monster in Schwarz und Weiß zu erkennen.

01:35.440 --> 01:39.200
So sehen wir die Farben überhaupt nicht, erkennen sie nur an ihrer Form.

01:39.250 --> 01:44.380
Deshalb werden wir einen Kanal verwenden, also einen Kanal, wenn Sie Schwarzweißbilder haben, und drei

01:44.380 --> 01:46.820
Kanäle, wenn Sie Bilder aufgerufen haben.

01:46.930 --> 01:51.320
Da wir also mit Schwarz-Weiß-Bildern in Kanälen arbeiten, wird es

01:51.340 --> 01:59.730
gleich einem Kanal sein, also mit unseren Kanälen. Daher werden unsere Kanäle den Bildern entsprechen, die Sie in

01:59.730 --> 02:02.970
der dortigen Faltung haben möchten ein.

02:02.970 --> 02:08.820
Grundsätzlich entspricht dies der Anzahl der gewünschten Features für den Text in den Originalbildern, denn wer wird

02:09.240 --> 02:15.040
ein Bild pro Feature erstellen, das wir erkennen möchten, weil Sie grundsätzlich wissen, wie es funktioniert.

02:15.120 --> 02:21.390
Wir haben einen Merkmalsdetektor auf das Eingabebild angewendet, um ein bestimmtes Merkmal im Eingabebild zu erkennen. Daher

02:21.390 --> 02:26.450
ist die Anzahl der Ausgabebilder hier die Anzahl der zu erkennenden Merkmale.

02:26.460 --> 02:30.110
Nun stellt sich die Frage, wie viele Features wir erkennen möchten.

02:30.240 --> 02:38.730
Eine übliche Praxis ist es, mit 32 Merkmalsdetektoren zu beginnen, so dass wir in dieser ersten Faltungsschicht zu 32 Prozent

02:38.820 --> 02:46.170
Bildern führen werden, so dass die Eingabe ein Schwarzweißbild eines realen Bildes ist und die Ausgabe in

02:46.170 --> 02:53.010
der ersten Faltung 32 verarbeitete Bilder ist und unter verarbeitet meine ich natürlich, dass die Schlussfolgerung

02:53.380 --> 02:59.750
auf das Eingabebild angewendet wurde, um 32 neue Bilder mit erkannten Merkmalen zu erhalten.

03:00.240 --> 03:06.990
Und dann müssen wir eine Kerngröße angeben, die nichts anderes ist als die Abmessungen des Quadrats,

03:07.080 --> 03:09.450
die durch das Originalbild gehen.

03:09.600 --> 03:15.350
Und in der üblichen Praxis kaufen wir entweder zwei oder drei breite drei oder fünf mal fünf.

03:15.660 --> 03:22.170
Und für den ersten verwenden wir einen fünf mal fünf Merkmalsdetektor, bei dem es sich um einen Merkmalsdetektor handelt, der

03:22.170 --> 03:24.580
über fünf mal fünf 10 Motoren verfügt.

03:24.810 --> 03:29.290
Und dann werden wir die Größe dieses Kerns für die nächsten Faltungsschichten reduzieren.

03:29.340 --> 03:32.320
Und davon zu reden, genau das werden wir jetzt tun.

03:32.390 --> 03:40.860
Wir werden dies kopieren, um die zweite Faltung zu definieren, und deshalb stelle ich fest, dass es hier und jetzt sehr lustig und sehr

03:40.890 --> 03:43.370
einfach ist, es ist wie ein Domino.

03:43.500 --> 03:49.260
Der Eingangskanal der zweiten Faltungsschicht ist der Ausgangskanal der ersten Faltung

03:49.260 --> 03:49.810
dort.

03:49.950 --> 03:55.300
Diese Anzahl der Ausgänge 32 ist hier also die gleiche Anzahl von Eingängen 32.

03:55.420 --> 04:01.290
Und das ist, weil wir 32 Bilder in der Eingangsfaltungsebene der zweiten Faltung haben.

04:01.440 --> 04:10.340
Und so wird die zweite Faltung auf diese zweite Faltungsschicht aufgebracht, um eine dritte Faltungsschicht zurückzugeben.

04:10.530 --> 04:13.280
Die Frage ist also, wie viele neue Bilder wir wollen.

04:13.410 --> 04:19.820
Dasselbe gilt auch für das Erstellen von 32 neuen Bildern. 32 ist eigentlich eine sehr häufige Zahl in neuronalen Faltungsnetzwerken, wenn

04:19.830 --> 04:23.710
Sie sich die Architekturen anschauen, die Sie in vielen von ihnen finden.

04:24.030 --> 04:29.910
Und dann für die Kerngröße Nun, wir müssen die Kerngröße, die die Abmessungen unseres Merkmalsdetektors sind,

04:29.910 --> 04:30.610
reduzieren.

04:30.780 --> 04:37.680
Und jetzt werden wir von fünf auf vier oder sogar drei gehen, und dann werden wir noch kleiner werden.

04:37.920 --> 04:40.790
Also gut, unsere zweite Faltung ist fertig.

04:40.830 --> 04:43.830
Als Eingänge werden 32 Prozessabbilder benötigt.

04:43.890 --> 04:51.130
Jedes in einem ersten Merkmal des ursprünglichen Eingabebildes und erstellt 32 neue Bilder.

04:51.270 --> 04:54.990
Dank dieser reduzierten Abmessungen des Merkmalsdetektors.

04:55.120 --> 04:57.250
Und jetzt lasst uns dies noch mehr vorantreiben.

04:57.300 --> 05:05.450
Also kopiere ich das und füge das hier ein, um eine dritte Faltung zu erzeugen, um einige Merkmale zu erkennen.

05:05.470 --> 05:08.010
Und so sind jetzt auch die Eingangskanäle.

05:08.010 --> 05:13.800
Hier ist die Anzahl der Eingabebilder links von der Dekonvolutionsverbindung, und dies ist die Anzahl der

05:13.800 --> 05:17.740
vorgeschriebenen Bilder, die sich rechts von den vorherigen Faltungsverbindungen befanden.

05:17.740 --> 05:18.710
Das ist 32.

05:18.750 --> 05:20.030
Es tut uns also leid zu hören.

05:20.030 --> 05:20.990
Das ist perfekt.

05:21.220 --> 05:25.220
Nun stellt sich wieder die Frage, wie viele neue Bilder wir entdecken möchten.

05:25.310 --> 05:31.130
Wir nehmen jetzt 64 und damit 64 Ausgaben von vorgefertigten Bildern.

05:31.260 --> 05:36.800
Natürlich nehmen wir jetzt eine kleinere Kerngröße und wir nehmen zwei.

05:36.800 --> 05:42.660
Das ist also eine sehr klassische Architektur einer Faltung, und es ist sehr effizient, ein

05:42.660 --> 05:45.840
hohes Maß an Feature-Erkennung in Bildern zu haben.

05:46.200 --> 05:53.010
Nun gut, und jetzt, da wir unsere drei Faltungen haben, gibt es hier unsere drei

05:53.010 --> 05:53.510
Faltungsverbindungen.

05:53.640 --> 05:59.970
Nun, es ist an der Zeit, unsere zahnvollen Verbindungen zu erhalten. Ich erinnere daran, dass wir diesen

05:59.970 --> 06:07.710
riesigen Vektor nehmen, den wir erhalten, nachdem wir alle 64-mal 32-mal 32 Bilder, die wir aus all diesen Windungen erhalten

06:08.160 --> 06:13.920
haben, flach gemacht haben Wir können einen riesigen Vektor bilden, der zur Eingabe eines neuen

06:14.190 --> 06:16.590
vollständig verbundenen neuronalen Netzwerks wird.

06:16.860 --> 06:22.230
Deshalb müssen wir zuerst diese Verbindungen zwischen diesem riesigen Vektor und einer verborgenen Schicht herstellen und dann

06:22.470 --> 06:27.710
eine zweite vollständige Verbindung zwischen der verborgenen Schicht und der Ausgabe, die sie aus den Ausgangsneuronen

06:27.730 --> 06:28.270
zusammensetzen.

06:28.320 --> 06:31.940
Jeder entspricht einem Würfelwert der möglichen Aktionen.

06:31.980 --> 06:33.960
Also lassen Sie uns diese beiden Verbindungen herstellen.

06:33.960 --> 06:35.220
Sie wissen, wie das geht.

06:35.220 --> 06:37.550
Genau das haben wir für das selbstfahrende Auto getan.

06:37.560 --> 06:38.800
Also machen wir das nochmal.

06:39.000 --> 06:46.890
Zuerst nehmen wir unser Maggio, dann nehmen wir die Lynnie, unsere Klasse, denn die Verbindung, die wir schaffen, ist wieder

06:46.920 --> 06:49.060
ein Objekt der herrschenden Klasse.

06:49.260 --> 06:50.550
Und dann in Klammern.

06:50.670 --> 06:58.620
Nun, das ist das Gleiche für die Eingabefunktionen, dh die Anzahl von ihnen, dann die Ausgabefunktionen.

06:58.850 --> 07:03.110
Und so gibt es die Eingabemöglichkeiten für die erste vollständige Verbindung.

07:03.340 --> 07:10.300
Nun, das ist gleich der Anzahl der Pixel in dieser großen Vektoränderung, nachdem alle Prozessbilder

07:10.480 --> 07:13.830
nach den drei Windungen abgeflacht wurden.

07:13.830 --> 07:15.110
Und was macht diese Nummer?

07:15.220 --> 07:17.350
Tatsächlich gibt es hier einen Trick.

07:17.380 --> 07:19.620
Diese Zahl ist eigentlich schwer zu bekommen.

07:19.660 --> 07:22.770
Wir müssen tatsächlich eine Funktion erstellen, um diese Zahl zu berechnen.

07:22.960 --> 07:25.570
Wir haben keine Variable, die uns diese Nummer liefert.

07:25.570 --> 07:29.040
Wir müssen es berechnen und deshalb, was wir jetzt tun werden.

07:29.150 --> 07:34.780
Und jetzt ist es sehr wichtig, die Denkweise des Programmierens zu verstehen, die wir haben

07:35.200 --> 07:40.930
müssen, und zu versuchen, Ihnen die Denkweise zu vermitteln, die Sie gerade jetzt denken müssen, um

07:41.110 --> 07:45.690
dieses Hindernis zu überwinden haben diese Anzahl von Neuronen im Flaten-Vektor.

07:45.730 --> 07:46.650
Was soll ich machen.

07:46.660 --> 07:47.600
Ich stecke hier fest.

07:47.800 --> 07:55.720
Nun, eigentlich nicht, denn was Sie jetzt tun können, ist, einfach einen Namen einzugeben, der die Anzahl der Neuronen darstellt, die so

07:55.720 --> 08:01.690
ungewöhnlich sind, dass die Anzahl der Neuronen die Anzahl der Neuronen ist. Dann erstellen wir einfach

08:01.690 --> 08:05.130
eine Funktion, die zurückkommt, und diese Anzahl der Neuronen.

08:05.180 --> 08:07.100
Diese Anzahl von Pixeln suchen wir.

08:07.330 --> 08:12.760
Wir können also völlig tun, dass wir diese Stimme komplett setzen können. Natürlich wird eine Warnung ausgegeben, weil

08:12.760 --> 08:17.090
sie noch nicht existiert, aber wir werden sie später mit einer Funktion erstellen.

08:17.350 --> 08:21.140
Das ist uns auch erlaubt, auch wenn die Funktion danach kommt.

08:21.170 --> 08:25.970
Das ist ein typisches Programmierdenken, das Sie haben müssen, wenn Sie diese Art von Hindernis bekommen.

08:26.020 --> 08:29.710
Nun, Sie können eine Funktion erstellen, um zu bekommen, was Sie vermissen.

08:29.740 --> 08:32.640
Alles klar und dann unsere Features und unsere Zukunft.

08:32.650 --> 08:37.830
Das ist die Anzahl der Neuronen in einer verborgenen Schicht, und diesmal liegt es an Ihnen.

08:37.870 --> 08:41.230
Das hängt von der Architektur des neuen Netzwerks ab, das Sie erstellen möchten.

08:41.230 --> 08:44.230
Und so wäre eine gute Anzahl keine kleine.

08:44.230 --> 08:46.960
So könnten zum Beispiel 40 Neuronen in Ordnung sein.

08:46.960 --> 08:48.660
Wir können versuchen, das zu erhöhen.

08:48.790 --> 08:51.280
Wenn das Training nicht zu langsam ist, können Sie versuchen, das zu erhöhen.

08:51.340 --> 08:56.750
Vielleicht werden dadurch die Vorhersagen verbessert, aber lasst uns mit 40 anfangen, vielleicht erhöhen wir sie danach.

08:57.130 --> 09:04.690
In Ordnung, das ist es für die erste vollständige Verbindung, dann kopieren wir diese Paste hier für die zweite vollständige

09:04.710 --> 09:09.300
Verbindung, nämlich die Verbindung zwischen der verborgenen Ebene und der Ausgabeebene.

09:09.370 --> 09:15.720
Und so werden die Features hier zu den Out-Features der vorherigen Ebene und das sind 40.

09:15.790 --> 09:18.020
Hier können wir also 40 setzen.

09:18.190 --> 09:20.500
Das ist natürlich die Anzahl der Neuronen in einer Schicht.

09:20.860 --> 09:27.280
Und unsere Zukunft wird der Anzahl der Ausgangsneuronen entsprechen, die kein neuronales Netzwerk haben sollte.

09:27.340 --> 09:33.360
Und da jedes Ausgangsneuron einem neuen Wert und einem Cuvee und einer Antwort auf eine

09:33.370 --> 09:38.440
Aktion entspricht, ist die Anzahl der Ausgangsneuronen hier natürlich die Anzahl

09:38.740 --> 09:47.320
der Aktionen, und wir haben eine Variable dafür, nämlich Anzahl Aktionen und daher hier Anzahl Aktionen und dort gehen wir Glückwünsche.

09:47.390 --> 09:53.850
Wir haben festgestellt, dass die Architektur unseres neuronalen Netzwerks aus drei Faltungsschichten und

09:53.850 --> 09:55.960
einer verborgenen Schicht besteht.

09:56.130 --> 10:03.020
All dies in einem großen CNN und diesem CNN erkennt Features im Spiel, sodass die KI weiß, wo sie hin

10:03.020 --> 10:06.550
muss, wo sie hin muss und wo sie schießen muss.

10:06.900 --> 10:08.240
Dann gehen wir diesen Schritt.

10:08.340 --> 10:10.720
Das ist ein erster sehr wichtiger Schritt.

10:10.720 --> 10:16.020
Nun geht es weiter mit dem nächsten Schritt, der natürlich die Anzahl der noch fehlenden

10:16.020 --> 10:17.010
Neuronen beinhaltet.

10:17.010 --> 10:21.930
Deshalb haben wir hier die Warnung und die Neuronen der Telefonnummer, aber keine Sorgen.

10:21.960 --> 10:26.970
Jetzt werden wir eine Funktion erstellen, die die Anzahl der Neuronen in diesem riesigen Vektor zurückgibt, und wir werden

10:26.970 --> 10:30.210
diese Zahl in eine Variable schreiben, die eine Anzahl von Neuronen nennt.

10:30.270 --> 10:32.070
Machen wir das im nächsten Tutorial.

10:32.070 --> 10:33.130
Das ist unser nächster Schritt.

10:33.180 --> 10:34.790
Und bis dahin genießen Sie AI.
