WEBVTT

00:00.530 --> 00:02.950
Hallo und willkommen zu diesem Python-Tutorial.

00:02.990 --> 00:08.520
Der nächste Schritt ist also, die Neuronen zählen zu lassen, die uns das geben, was wir wollen.

00:08.540 --> 00:14.130
Das ist diese Anzahl von Neuronen in diesem riesigen Vektor, nachdem die Windungen angewendet wurden.

00:14.300 --> 00:19.640
Das sind die einzigen fehlenden Informationen, die wir jetzt benötigen, und wir werden sie mit der Funktion erhalten.

00:19.700 --> 00:23.930
Lassen Sie uns diese Funktion so machen, dass wir sie als Zählungen bezeichnen.

00:24.280 --> 00:27.570
Und diese Kernneuronen ganz einfach.

00:27.830 --> 00:32.220
Und was ist die Anzahl der Neuronen, die als Argumente dienen.

00:32.510 --> 00:39.450
Nun, es wird das Objekt selbst brauchen, aber dann wird es etwas anderes brauchen, da diese Anzahl

00:39.450 --> 00:44.540
von Ausgangsneuronen in der Abflachungsebene tatsächlich nur von einer Sache abhängt.

00:44.660 --> 00:50.840
Es hängt von den Dominationen des ursprünglichen Eingangsbildes ab, die ganz am Anfang des neuronalen

00:50.840 --> 00:51.930
Netzwerks liegen.

00:52.160 --> 00:58.370
Das einzige Argument, das wir jetzt brauchen, ist die Zeit, die das Timing der Eingabebilder erwähnt.

00:58.370 --> 01:03.410
Geben wir diesem Argument also einen Namen, der die Raute und das Eingabebild darstellt.

01:03.520 --> 01:06.790
Und wir nennen es Bild.

01:07.220 --> 01:07.690
Gut.

01:07.850 --> 01:14.720
Und ich kann Ihnen jetzt sagen, dass die tatsächlichen Abmessungen der von Dume kommenden Eingabebilder 80

01:14.720 --> 01:16.850
mal 80 sein werden.

01:16.850 --> 01:23.330
Wir werden die Größe der Originalbilder auf 80 um 80 reduzieren, und dies ist das Format der

01:23.390 --> 01:26.270
Bilder, die in das neuronale Netzwerk eingehen.

01:26.270 --> 01:32.300
Image Image wird also eine 80 80 sein und die entspricht der Tatsache, dass wir

01:32.300 --> 01:33.750
mit Schwarzweißbildern arbeiten.

01:33.830 --> 01:41.040
Das heißt, mit nur einem Kanal wird das Bild mit den insgesamt achtzig und achtzig korreliert.

01:41.280 --> 01:41.560
Gut.

01:41.560 --> 01:43.590
Das ist also das einzige Argument, das wir brauchen.

01:43.660 --> 01:45.670
Und jetzt wollen wir die Neuronen untersuchen.

01:45.850 --> 01:47.280
Wie wirst du das tun?

01:47.500 --> 01:51.110
Zunächst einmal haben wir derzeit kein Eingabebild.

01:51.250 --> 01:54.070
Wir haben kein Doom-Image, das wir importieren können.

01:54.070 --> 01:55.330
Wir werden das später tun.

01:55.540 --> 02:01.240
Das erste, was wir tun müssen, ist ein gefälschtes Bild, aber das hat Introns 80 über 80 erreicht.

02:01.240 --> 02:06.160
Wir werden dieses gefälschte Bild mit falschen Pixeln erstellen, und dies wird uns schließlich

02:06.160 --> 02:12.280
die gewünschte Anzahl geben, da diese Anzahl nur von den Abmessungen und nicht von den Pixeln in den

02:12.280 --> 02:13.320
Bildern abhängt.

02:13.330 --> 02:15.640
So entsteht ein gefälschtes Bild.

02:15.730 --> 02:18.520
Und dann berechnen wir die Anzahl der Neuronen, die wir wollen.

02:18.520 --> 02:23.860
Der Trick, ein gefälschtes Bild zu erstellen, ist also gut, wir nennen es x.

02:23.890 --> 02:30.700
Zunächst einmal und dann haben wir die Fackel Rand verwendet, weil wir

02:30.700 --> 02:37.200
wissen, dass wir in diese Bilder einige zufällige Pixel einfügen werden.

02:37.250 --> 02:42.740
Dann werden wir drinnen eingehen, da Sie die Verdammungen der Bilder sehen können.

02:42.850 --> 02:44.400
Das ist eine 80 80.

02:44.560 --> 02:50.500
Da wir dieses Bild jedoch in das neuronale Netzwerk einfügen, kann das neuronale Netzwerk, wie Sie

02:50.500 --> 02:55.170
sich erinnern, nur Stapel von Eingabezuständen akzeptieren, dh Stapel von Eingabebildern.

02:55.370 --> 03:00.600
Wir werden diese gefälschten Diamanten erstellen, in denen wir diese Run-Funktion direkt ausführen können.

03:00.670 --> 03:05.720
Wir fangen einfach mit demjenigen an, der dem Stapel entsprechen wird,

03:05.730 --> 03:11.070
und können es dann alle 188 aufstellen, die den Dominierungen des Eingabebildes entsprechen.

03:11.110 --> 03:16.980
Und wie Sie verstanden haben, sind diese Nominierungen in diesem Bild als Argument

03:16.980 --> 03:19.330
enthalten, das diese Tabelle repräsentiert.

03:19.420 --> 03:23.290
Also müssen wir nur noch ein Bild hinzufügen.

03:23.620 --> 03:29.410
Aber um die Elemente der Tabelle zu übergeben, weil Sie gerade jetzt wissen, ist Image ein Doppeltes

03:29.410 --> 03:31.940
als Liste von Argumenten einer Funktion.

03:32.020 --> 03:39.460
Wir müssen hier hinzufügen, bevor das Image vorhanden ist, bevor der Apple Store den Store zulässt, die Elemente des Abbilds, das Apple für

03:39.550 --> 03:44.100
ihn erstellt hat, als Liste von Argumenten für die Funktion an Apple zu übergeben.

03:44.170 --> 03:49.600
Und wie Sie sehen, ist genau das, was hier mit dem Laden und dem Diamanten angegeben ist.

03:49.930 --> 03:56.640
Alles in Ordnung, so dass ein Bild aus falschen Pixeln entsteht, das nichts mit den Bildern zu tun hat.

03:56.800 --> 04:01.720
Aber wir werden immer noch in der Lage sein, die endgültige Anzahl

04:01.720 --> 04:11.080
von Neuronen zu erhalten. Jetzt müssen wir uns daran erinnern, dass dieser Eingangsvektor in eine Fackelvariable umgewandelt wird, da dies in das

04:11.380 --> 04:13.060
neuronale Netzwerk eingeht.

04:13.060 --> 04:13.380
Gut.

04:13.390 --> 04:20.650
Dies stellt also nun ein Eingabebild aus zufälligen Pixeln dar, das gerade in ein realisierbares umgewandelt wurde und nun in das

04:20.650 --> 04:22.440
neuronale Netzwerk gelangen wird.

04:22.570 --> 04:28.330
Und genauer gesagt, die Faltungsschichten des neuronalen Netzwerks, da wir nach der Anwendung der

04:28.330 --> 04:34.100
Windungen nur die Anzahl der Neuronen benötigen, gehen wir einfach bis zu den Windungen 3.

04:34.210 --> 04:36.440
Also bis zur dritten Faltungsschicht.

04:36.580 --> 04:39.630
Wir werden hier nicht auf die beiden vollständigen Verbindungen eingehen.

04:39.850 --> 04:45.490
Und das ist, weil die Anzahl der Neuronen, die wir wollen, zwischen Faltung 3 und f liegt. c 1.

04:45.520 --> 04:52.120
Nun, jetzt haben wir ein Eingabebild mit den richtigen Erwähnungen. Nun, es ist Zeit, dieses Bild in das neuronale

04:52.180 --> 04:58.330
Netzwerk zu verbreiten, um die Abflachungsebene zu erreichen. Dann werden wir die Neuronen in der Abflachungsebene bekommen

04:58.330 --> 05:03.850
und wir bekommen nur die Informationen, die wir möchten, sind die Anzahl der Neuronen in

05:03.850 --> 05:04.750
dieser Abflachungsschicht.

05:04.990 --> 05:08.950
Jetzt müssen wir genau das tun, was wir in einer Vorwärtsfunktion tun.

05:08.950 --> 05:14.560
Wir müssen die Signale in das neuronale Netzwerk übertragen, jedoch nur in den Faltungsschichten, bis

05:14.560 --> 05:16.120
wir die Flutungsschicht erreichen.

05:16.330 --> 05:17.360
Also lass uns das tun.

05:17.360 --> 05:25.660
Wir werden x jetzt aktualisieren, x ist das Eingabebild und mit dem zweiten X wird X hier zur

05:25.660 --> 05:27.050
ersten Faltungsschicht.

05:27.310 --> 05:32.930
Nun müssen wir den ersten Schritt in drei Schritten durchführen, indem wir die Dekonvolution auf die

05:32.950 --> 05:33.790
Eingabebilder anwenden.

05:33.850 --> 05:40.960
Der zweite Schritt, in dem wir die gewundenen Bilder mit einem Mix-Beschnitt versehen und Inserts einsetzen, dass wir

05:40.960 --> 05:48.160
die Neuronen in diesen pulierten gewundenen Bildern aktivieren, und das x wird zu dieser ersten Faltung, die sie aus

05:48.160 --> 05:50.590
all diesen Pools zusammengesetztem Energis bilden.

05:51.010 --> 05:56.840
In diesem ersten Schritt wenden Sie die erste Faltungsfaltung auf die Eingabebilder an.

05:57.040 --> 06:07.540
Was wir also tun, ist, dass wir unsere Faltung einnehmen und Lucian eine davon machen, dass wir sie auf unsere Eingabebilder

06:07.550 --> 06:11.360
anwenden, die bisher durch x dargestellt werden.

06:11.500 --> 06:14.290
Das ist also das erste, was zuerst gemacht wurde.

06:14.320 --> 06:22.630
Im zweiten Schritt wenden wir das Spoolen auf unsere verwundenen Bilder an, die durch die Faltung

06:22.640 --> 06:26.880
zurückgegeben werden, wenn X und zwei Höhepunkte ziehen.

06:26.920 --> 06:34.610
Also nehmen wir die Abkürzung als die, und dann verwenden wir die Funktion Max Pool für D.

06:34.810 --> 06:42.340
Das ist das, in das wir ein X-X der Selbstfaltung in die Klammern des max. Pull ziehen, da wir beim

06:42.360 --> 06:45.220
nächsten Pull in die gefalteten Bilder spielen.

06:45.750 --> 06:53.140
Diese nächste Funktion erfordert jedoch zusätzliche Argumente, die zuerst die Kerngröße sind.

06:53.190 --> 06:59.190
Das ist also wieder die Größe des Fensters, das durch Ihre Bilder gleitet, und nimmt das Maximum der

06:59.190 --> 07:00.710
Pixel in jeder Folie.

07:00.830 --> 07:06.750
So werden die Features immer noch erkannt, da die Features mit einem hohen Wert des Pixels in den Arrays

07:06.840 --> 07:07.750
verknüpft sind.

07:07.890 --> 07:09.580
Wie Sie sagen, Intuition Vorträge.

07:09.780 --> 07:14.020
Dieses erste dokumentierte menschliche Eingabeaufforderung ist also diese Kerngröße.

07:14.100 --> 07:15.560
Und wir werden drei nehmen.

07:15.660 --> 07:17.650
Dies ist eine übliche Wahl für die Kerngröße.

07:17.940 --> 07:25.200
Und dann müssen wir die Schritte angeben, die Sie kennen, um wie viele Pixel es in den Bildern gleitet.

07:25.200 --> 07:27.560
Und wir werden zwei Schritte machen.

07:27.610 --> 07:29.400
Das ist wieder eine gewöhnliche Entscheidung.

07:29.820 --> 07:30.670
Also los geht's.

07:30.690 --> 07:32.530
Nun ist der zweite Schritt getan.

07:32.620 --> 07:38.910
Nun zum dritten Schritt, der alle Neuronen in diesem Pool und die gefalteten Bilder aktivieren

07:38.910 --> 07:39.580
soll.

07:39.610 --> 07:46.090
Und diese erste Faltungsschicht und um dies noch einmal zu tun, werden wir auf all dies eine Funktion anwenden.

07:46.170 --> 07:51.960
Also hier und noch einmal, weil wir eine andere Funktion übernehmen werden, die, wie Sie vielleicht

07:52.050 --> 07:55.170
erraten haben, eine Aktivierungsfunktion sein wird, aber welche.

07:55.230 --> 08:01.410
Wie üblich wird die Aktivierungsfunktion korrigiert und vielleicht erinnern Sie sich noch an den Namen

08:01.620 --> 08:02.330
dafür.

08:02.790 --> 08:03.410
Da gehen wir.

08:03.450 --> 08:04.290
Das ist der eine

08:04.290 --> 08:12.540
Und so wenden wir uns wirklich auf unsere gepoolten gefalteten Bilder an.

08:12.540 --> 08:12.940
Gut.

08:12.990 --> 08:14.270
Und das ist es.

08:14.370 --> 08:15.320
Drei Schritte sind erledigt.

08:15.330 --> 08:16.370
Das war sehr schnell.

08:16.500 --> 08:23.460
Denken Sie also daran, dass wir die Art und Weise betrachten müssen, in der wir zuerst die Faltung auf unsere

08:23.460 --> 08:28.830
Eingabebilder anwenden und dann Max auf unsere mit einer Faltung erhaltenen gefalteten Bilder ziehen.

08:28.950 --> 08:35.730
Und dann aktivieren wir die Neuronen in dieser ganzen Poolfaltungsschicht mit der Gleichrichteraktivierungsfunktion, so

08:35.730 --> 08:43.960
perfekt, dass wir unsere erste Faltungsschicht erhalten, auf der ein Höhepunkt gezogen wurde und in der die

08:44.050 --> 08:46.200
Neuronen jetzt aktiviert werden.

08:46.260 --> 08:51.640
Im Grunde ist es also so, dass es die Signale von der ersten Faltungsschicht zur

08:51.640 --> 08:52.500
nächsten weiterleitet.

08:52.630 --> 08:56.580
Apropos nächstes, genau das werden wir jetzt tun.

08:56.570 --> 09:01.660
Wir werden dasselbe tun, wie wir es gerade bei der ersten Faltung auf der

09:01.660 --> 09:08.170
zweiten Faltungsschicht getan haben, um die Signale durch Aktivierung der Neuronen der zweiten Faltungsschicht erneut in das neuronale

09:08.170 --> 09:09.660
Netzwerk zu verbreiten.

09:09.850 --> 09:12.910
Aber bevor wir dies tun, müssen wir diese Faltungsschicht erhalten.

09:13.120 --> 09:18.330
Wir werden also Faltung auf X anwenden, das jetzt die erste Faltungsschicht ist.

09:18.460 --> 09:24.070
Nun, wir werden die Faltung auf 2 x anwenden, um die zweite Faltungsschicht

09:24.070 --> 09:25.120
zu erhalten.

09:25.240 --> 09:27.860
Und dann endlich Sirat aktivieren.

09:27.970 --> 09:29.070
Also lass uns das tun.

09:29.170 --> 09:35.350
Es ist eigentlich sehr einfach, das einfach zu kopieren und unten einzufügen.

09:35.350 --> 09:39.240
Jetzt müssen wir natürlich auch die Faltung durch die Faltung ersetzen.

09:39.520 --> 09:40.460
Und da gehen wir hin.

09:40.480 --> 09:43.650
Das ist eigentlich schon ganz leicht zu sehen.

09:43.900 --> 09:50.200
Mit dieser Linie verbreiten wir nun die Signale von der zweiten Faltung zur nächsten, die dort

09:50.260 --> 09:52.580
die dritte Faltung sein wird.

09:52.720 --> 09:57.220
Und um diese dritte Faltung zu erhalten, muss das erneut angewendet werden.

09:57.220 --> 10:04.630
Also kopiere ich das unten und füge auch Faltung durch Faltung

10:04.870 --> 10:06.340
3 ein.

10:06.340 --> 10:11.490
Wir verbreiten die Signale in den drei Faltungsbriefen in einer Taschenlampe.

10:11.500 --> 10:13.100
Dank dieser tollen Struktur.

10:14.020 --> 10:15.340
Alles klar so perfekt.

10:15.340 --> 10:21.250
Nun haben wir unsere Signale bis zur dritten Faltungsschicht und danach weitergeleitet.

10:21.360 --> 10:24.780
Und wenn wir danach reden, führt uns das, wonach wir suchen.

10:24.820 --> 10:28.510
Was uns interessiert, ist die Abflachung dort.

10:28.510 --> 10:33.620
In Ordnung, jetzt haben wir unsere dritte Faltung, das ist das letzte X hier.

10:33.790 --> 10:36.120
Es ist Zeit, unsere Abflachung auszubauen.

10:36.490 --> 10:37.990
Genau das tun wir also.

10:37.990 --> 10:44.200
Jetzt werden wir alle Pixel dieser dritten Faltungsschicht abflachen, dh wir nehmen

10:44.290 --> 10:48.430
alle Pixel aller Kanäle der dritten Faltungsschicht.

10:48.640 --> 10:51.920
Wir werden sie nacheinander in einen riesigen Vektor setzen.

10:52.150 --> 10:56.920
Und natürlich wird dieser riesige Vektor nichts anderes als die Abflachungsebene und gleichzeitig werden

10:56.920 --> 11:02.000
wir einen Trick anwenden, um die Anzahl der Neuronen in dieser Abflachung dort zu erhalten.

11:02.070 --> 11:03.790
Das ist es, wonach wir suchen.

11:03.790 --> 11:09.370
Das ist die Anzahl der Neuronen, die wir vermissen, und deshalb lasst uns direkt das zurückgeben, was wir

11:09.370 --> 11:15.130
wollen, und in dieser Rückkehr werden wir die dritte Faltungsschicht abflachen und gleich und die Anzahl der Neuronen in

11:15.130 --> 11:16.330
dieser Abflachungsebene erhalten.

11:16.630 --> 11:20.150
Also nehmen wir X. das ist unsere dritte Faltung dort.

11:20.320 --> 11:25.150
Wir werden alle Kanäle der dritten Faltung dorthin nehmen und eine Funktion

11:25.150 --> 11:32.160
verwenden, die die Größenfunktion ist, um alle Pixel aller dieser Kanäle in einem einzigen großen Vektor zu glätten.

11:32.230 --> 11:35.930
Und so kann man den Trick finden, den man im Pite finden kann.

11:36.130 --> 11:42.400
Nun, zuerst nehmen wir die Daten von X, da X eine

11:42.400 --> 11:44.250
spezielle Struktur ist.

11:44.320 --> 11:51.920
Aber zuerst müssen wir hier mit Daten darauf zugreifen, dann müssen wir sehen, was sich darin befindet.

11:52.090 --> 11:57.700
Wir verwenden also diese Ansichtsfunktion und müssen nun auf das zugreifen, wonach wir suchen.

11:57.700 --> 12:01.980
Das gilt sogar für die Argumente 1 und minus 1.

12:02.230 --> 12:04.390
Sie müssen verstehen, was sich in der Struktur befindet.

12:04.510 --> 12:10.060
Aber Sie können einfach verstehen, dass wir auf diese Weise diese Anzahl von Neuronen erhalten

12:10.150 --> 12:15.560
werden. Zum Abschluss müssen wir die Größe in Klammern und Eingaben 1 hinzufügen.

12:15.880 --> 12:21.610
Was wir hier tun, ist im Grunde genommen, wir nehmen alle Pixel aller Kanäle und fügen sie

12:21.610 --> 12:27.180
nacheinander in diesen riesigen Vektor ein, der der Eingang des vollständig verbundenen Netzwerks sein wird.

12:27.190 --> 12:29.250
Das ist im Grunde die Größe.

12:29.410 --> 12:34.060
Und damit bekommen wir so viele neue, die wir suchen.

12:34.060 --> 12:36.460
Also gut, jetzt bekommen wir, was wir wollen.

12:36.490 --> 12:44.350
Und so können wir schließlich die Anzahl der Neuronen durch das ersetzen, was von dieser Funktion zurückgegeben wird, wenn sie

12:44.530 --> 12:47.400
auf das Format der Bilder angewendet wird.

12:47.440 --> 12:50.140
Das ist eine von 80 von 80.

12:50.170 --> 13:00.040
Was wir jetzt tun müssen, ist die Anzahl Neuronen zu ersetzen, indem wir die Funktion der Neuronen zählen nehmen,

13:00.250 --> 13:09.040
die wir auf das Format der Bilder anwenden, das die Gesamtzahl 80 und 80 sein wird.

13:09.460 --> 13:10.400
Und da gehen wir hin.

13:10.510 --> 13:17.140
Und natürlich vergessen wir das Selbst nicht, weil Count Neuron tatsächlich eine Methode des CNN-Tests ist.

13:17.170 --> 13:18.490
Also müssen wir das hinzufügen.

13:18.700 --> 13:21.190
Und jetzt sollte die Warnung verschwinden.

13:21.190 --> 13:22.540
Und da gehen wir hin.

13:22.540 --> 13:23.890
Jetzt ist alles gut.

13:23.980 --> 13:29.930
Wir bekommen die Architektur des neuronalen Netzwerks, ohne dass es an nichts fehlt. Wir haben diese Gegenanzüge, wenn

13:30.140 --> 13:35.290
Sie wissen, dass Sie andere Architekturen ausprobieren möchten und die Anzahl der Neuronen nicht manuell gezählt

13:35.290 --> 13:36.210
werden soll.

13:36.340 --> 13:39.940
Verwenden Sie diese Funktion, indem Sie sie im Format Ihrer Bilder abspielen.

13:40.180 --> 13:42.130
Und das bringt dir direkt das, was du willst.

13:42.130 --> 13:45.810
Das ist die Anzahl der Neuronen in der Flutungsschicht, ohne etwas tun zu müssen.

13:45.820 --> 13:49.450
Und wo die Architektur ist, ist das entscheidend.

13:49.480 --> 13:57.040
Und jetzt sind wir mit dem ersten großen wichtigen Schritt dieses Gehirns fertig, den wir machen, und wir haben einen letzten

13:57.040 --> 13:57.720
Schritt.

13:57.790 --> 14:02.500
Dies ist eine letzte Funktion, die als Main Forward-Funktion erstellt wird.

14:02.590 --> 14:07.730
Wir verbreiten also die Signale vom Beginn des Gehirns, die von den Augen

14:07.730 --> 14:12.160
des Auges stammen, zur Ausgabeschicht, die nach der zweiten Verbindung liegt.

14:12.460 --> 14:15.850
Also machen wir das in den nächsten zwei Toile und bis dahin unsere KI.
