WEBVTT

00:00.450 --> 00:03.170
Hallo und willkommen zu diesem Python-Tutorial.

00:03.240 --> 00:09.180
Nun, da wir bereit sind, das Netzwerk zu trainieren, um den Abstand zwischen den Ausgängen und dem Ziel zu

00:09.180 --> 00:13.820
minimieren, dank der Aktivitäten, die wir im vorherigen Abschnitt mit der Berechtigungsüberwachung durchgeführt haben.

00:14.010 --> 00:19.560
Nun, im Grunde waren wir bereit, das gesamte Training zu beginnen, indem Sie wissen,

00:19.560 --> 00:24.600
wie wir unsere Vorhersagen mit unserem Input abschätzen und dann den letzten

00:24.600 --> 00:28.420
Fehler zwischen den Vorhersagen und dem Ziel berechnen.

00:28.470 --> 00:35.460
Wir waren also bereit, all dies zu tun, da wir jedoch den gleitenden Durchschnitt und 100 Schritte berechnen möchten, die Sie kennen,

00:35.460 --> 00:38.040
um den Durchschnitt während des Trainings zu verfolgen.

00:38.160 --> 00:45.060
Kurz bevor wir dieses ganze Training absolvieren, werden wir jetzt eine Klasse bilden, in der wir diesen gleitenden

00:45.060 --> 00:47.360
Durchschnitt von 100 Schritten erhalten.

00:47.550 --> 00:49.450
Keine Sorge, wir werden es schnell tun.

00:49.500 --> 00:54.270
Wir machen es mit drei Funktionen klasse, was wir alles und das einzige Tutorial machen werden, damit wir es schnell

00:54.270 --> 00:54.950
machen können.

00:54.960 --> 00:55.890
Wir haben es schon gemacht.

00:55.890 --> 01:00.680
Außerdem wollen wir uns jetzt auf das Training konzentrieren, denn das ist das Wichtigste.

01:00.840 --> 01:04.500
Also machen wir diese Klasse jetzt in diesem Tutorial.

01:04.500 --> 01:10.710
Also gut, also werden wir eine neue Klasse einführen, die wir nennen werden, und einen gleitenden Durchschnitt. Dann

01:11.220 --> 01:13.290
gehen wir zu unserer ersten Funktion.

01:13.290 --> 01:20.490
Das heißt, die angeborene Funktion, die sich niemals ändert, und diese und diese Funktion wird

01:20.490 --> 01:22.140
zwei Argumente erfordern.

01:22.140 --> 01:30.450
Die erste ist selbst für das zukünftige Objekt und die Größe des sich bewegenden Durchschnitts, die der Größe der

01:30.540 --> 01:34.620
Liste der Wörter entspricht, deren Durchschnittswert berechnet wird.

01:34.620 --> 01:36.850
Das wird also 100 sein.

01:36.870 --> 01:39.800
Also gut, wir haben Argumente für die Funktion.

01:39.840 --> 01:42.120
Gehen wir jetzt in die Funktion.

01:42.120 --> 01:47.460
Jetzt wissen Sie, was zu tun ist, um die für das Objekt spezifischen Variablen zu initialisieren.

01:47.460 --> 01:48.250
Und das sind.

01:48.330 --> 01:56.820
Zuerst wird es eine Liste von Wörtern geben, die 100 Wörter enthält, von denen wir

01:56.910 --> 01:59.310
den Durchschnitt berechnen.

01:59.310 --> 02:05.450
Deshalb initialisieren wir diese Liste hier einfach mit dieser leeren Liste.

02:05.850 --> 02:13.020
Listen Sie jedes Wort auf, und dann ist die zweite Variable unseres zukünftigen Objekts natürlich die Größe

02:13.500 --> 02:19.440
und die Größe wird den Argumenten entsprechen, die beim Erstellen der zukünftigen gleitenden Durchschnittsobjekte eingegeben

02:19.440 --> 02:20.250
werden.

02:20.580 --> 02:22.140
Also Sightseer.

02:22.400 --> 02:29.850
Und schon sind wir bereit, zur nächsten Funktion überzugehen, die die Add-Funktion sein wird und die

02:29.850 --> 02:32.210
kumulative Belohnung hinzufügen wird.

02:32.220 --> 02:35.530
Seien Sie vorsichtig, es ist nicht die einfache Belohnung, sondern die kumulative Belohnung.

02:35.610 --> 02:40.660
Und das ist so, weil Sie wissen, dass wir die Berechtigungsnachverfolgung durchführen und daher alle 10 Schritte lernen.

02:40.770 --> 02:44.480
Und deshalb lernen mit kumulativer Belohnung und nicht mit einer einfachen Belohnung.

02:44.700 --> 02:52.830
Durch diese Funktion, die wir gerade erstellen, wird die kumulative Belohnung zu dieser Belohnungsliste hinzugefügt.

02:52.830 --> 02:59.370
Jeff nennen wir das natürlich als Ad, und diese Funktion braucht zwei Argumente.

02:59.370 --> 03:05.070
Das erste ist das Ich, weil wir diese Liste von Wörtern hier verwenden werden, weil wir

03:05.070 --> 03:08.350
einfach die kumulative Belohnung an diese Wortliste anhängen.

03:08.490 --> 03:11.650
Also brauchen wir das Selbst, um dies zu sich selbst zu bringen.

03:11.670 --> 03:18.070
Die zweite wird die Belohnung sein, die die kumulative Belohnung darstellt.

03:18.570 --> 03:21.810
In Ordnung, also gibt es zwei Argumente für die Funktion.

03:21.810 --> 03:25.370
Gehen wir jetzt in die Funktion und definieren, was zu tun ist.

03:25.710 --> 03:32.150
Ok, so ganz einfach ist das erste, was wir tun müssen, wenn wir uns ansammeln, wollen wir ein neues.

03:32.190 --> 03:38.460
Sie wissen, wenn wir in zehn Schritten vorankommen. Nun müssen wir diese kumulativen Wörter der Liste

03:38.460 --> 03:39.270
hinzufügen.

03:39.270 --> 03:43.650
Und genau das werden wir tun. Wir werden eine Codezeile schreiben,

03:43.650 --> 03:49.240
die diese neue kumulative Belohnung hinzufügen wird, die wir nach zehn Schritten zu dieser Wortliste erhalten.

03:49.320 --> 03:56.290
Und dazu müssen wir zwei Bedingungen trennen, da er mit Batches arbeiten wird. Nun, wir wollen in einigen Listen

03:56.340 --> 04:02.430
sein, aber in einigen anderen Fällen können wir Wörter auch als ein einzelnes Element und die Syntax

04:02.430 --> 04:09.840
sein, um einem Element ein Element hinzuzufügen Liste, bei der es sich um die Liste der Wörter handelt, ist nicht gleich,

04:09.840 --> 04:13.330
ob Sie eine Liste oder ein einzelnes Element hinzufügen.

04:13.350 --> 04:17.020
Wir müssen also nur eine Bedingung machen, die diese beiden Fälle voneinander trennt.

04:17.190 --> 04:22.800
Beginnen wir mit dem ersten Fall, der der Fall ist, wenn wir zu

04:22.800 --> 04:30.240
dieser Liste von Wörtern eine Liste hinzufügen. Um dies zu tun, fügen wir in Klammern hinzu, dass wir zwei

04:30.240 --> 04:32.880
Argumente vorlegen Wörter, die wir hinzufügen.

04:33.180 --> 04:34.510
Also waren wir nicht.

04:34.680 --> 04:37.470
Und das zweite ist LIST.

04:37.620 --> 04:45.050
Wenn die Liste der Instanzwörter also bedeutet, dass die Belohnungen in einer Liste enthalten sind.

04:45.060 --> 04:56.280
Wenn also die Belohnungen in einer Liste stehen, ist das, was wir tun, ganz einfach selbst, dass wir unsere Belohnungsliste nehmen und

04:57.550 --> 05:05.110
wir werden diese Liste hinzufügen, da es sich hierbei um eine einfache Liste handelt

05:05.110 --> 05:09.220
einige Tulis, um die Belohnungen zu erhalten.

05:09.220 --> 05:13.380
Hier ist eine Liste, weil dies in diesem Fall mit wahrer Bedeutung bezeichnet wird.

05:13.380 --> 05:21.160
Daher können wir diese Liste einfach zu unserer Liste von Wörtern summieren, und daher können wir einfach eine

05:21.160 --> 05:24.300
Liste mit Belohnungen und gleichwertigen Belohnungen haben.

05:24.880 --> 05:30.620
Damit erweitern wir die Liste einfach um einige in diesen beiden Listen.

05:31.090 --> 05:31.560
Gut.

05:31.600 --> 05:33.860
Und dann zweite Bedingung.

05:33.860 --> 05:41.470
Wir können also einfach anderes hinzufügen, so dass, wenn die Belohnung keine Liste ist, und daher, wenn es ein einzelnes Element ist und

05:42.130 --> 05:44.260
was sonst in diesem Fall passiert.

05:44.470 --> 05:49.120
Nun, das ist das Gleiche, wir möchten unserer Wortliste zwei Wörter hinzufügen.

05:49.420 --> 05:53.810
Wir können die Syntax jedoch nicht verwenden, da wir Wörter keine Liste mehr sind.

05:53.860 --> 05:55.320
Es wird ein einzelnes Element sein.

05:55.540 --> 06:00.130
Was wir also brauchen, ist eine andere Syntax, die Append-Funktion.

06:00.130 --> 06:04.020
Wenn Sie einer Liste ein einzelnes Element hinzufügen möchten, können Sie etwas hinzufügen.

06:04.030 --> 06:05.890
Sie müssen die Append-Funktion verwenden.

06:05.890 --> 06:07.860
Und genau das tun wir jetzt.

06:07.890 --> 06:18.550
Wir nehmen unsere Liste der Wörter des Objekts und fügen diese hier ein, fügen dann einen Punkt hinzu und dann gehen

06:18.550 --> 06:20.080
wir zuerst einen.

06:20.560 --> 06:24.560
In Klammern setzen wir natürlich die Elemente, die wir anfügen möchten.

06:24.790 --> 06:29.420
Und das ist natürlich ein Wort, aber Wörter werden in diesem Fall keine Liste sein.

06:29.500 --> 06:34.880
Es wird ein einzelnes Element sein, wie ein einzelnes kumulatives Wort, das nicht in einer Liste enthalten ist.

06:34.910 --> 06:39.490
Alles klar und dann wollen wir das tun, aber jetzt müssen wir noch etwas hinzufügen.

06:39.490 --> 06:45.310
Das passiert, wenn diese Liste von Wörtern mehr als 100 Elemente enthält.

06:45.580 --> 06:51.760
In diesem Fall müssen wir das erste Element dieser Liste jedes Wort löschen, um sicherzustellen,

06:51.940 --> 06:56.440
dass diese Wortliste immer nicht mehr als 100 Elemente enthält.

06:56.440 --> 07:01.330
So wie wir es für das Auto im Süden gemacht haben, als wir dieses

07:01.330 --> 07:11.170
Go-Fenster erstellt haben, und um dies zu gewährleisten, werden wir eine Bedingung für eine Weile hinzufügen, in der festgelegt wird, dass die Länge unserer Liste von Wörtern die Anzahl

07:11.530 --> 07:19.060
der Elemente in unserem Element ist Liste von Wörtern, wann immer diese Zahl größer als self ist, die Größe, die der Größe

07:19.060 --> 07:23.900
entspricht, die wir hier angegeben haben und die später gleich 100 sein wird.

07:24.070 --> 07:25.390
Wenn wir das Objekt erstellen.

07:25.540 --> 07:30.250
Nun, sobald die Anzahl der Elemente dieser Wortliste größer als 100 ist.

07:30.370 --> 07:38.760
Nun, wir wollen die ersten Elemente unserer Wortliste löschen, die wir erhalten können, wenn wir den Index 0

07:38.860 --> 07:43.300
nehmen, der der erste Index unserer Liste ist.

07:43.570 --> 07:51.400
Dies ist das erste Element unserer Wortliste. Wir möchten es löschen, wenn unsere Wortliste mehr

07:51.400 --> 07:53.590
als 100 Elemente enthält.

07:53.590 --> 08:00.100
Damit wir mit dieser Bedingung hier sicherstellen, dass unsere Wortliste niemals mehr als 100

08:00.100 --> 08:08.290
Elemente enthält. Deshalb können wir jetzt eine neue Funktion erstellen, um den Durchschnitt unserer Wortliste zu berechnen, die

08:08.290 --> 08:12.490
auf dem Lauf eine enthalten wird Hundert Elemente.

08:12.610 --> 08:17.400
Deshalb berechnen wir jedes Mal den gleitenden Durchschnitt von 100 Schritten.

08:18.090 --> 08:23.040
Lassen Sie uns also die Funktion so gestalten, dass sie sehr einfach sein wird, da es in Python

08:23.220 --> 08:27.550
die Hauptfunktion gibt, die eine Funktion von Nicht-Piloten ist, die den Durchschnitt einer Liste berechnet.

08:27.690 --> 08:32.820
Wir wollen hier unsere letzte Funktion einführen, die wir als Durchschnitt bezeichnen, und

08:32.820 --> 08:38.430
diese Funktion wird ein Argument benötigen, das sich selbst verhält, weil wir natürlich immer noch unsere

08:38.430 --> 08:44.360
Liste von Wörtern verwenden werden, die eine Variable von ist unser objekt zu sich selbst und farbgebung.

08:44.660 --> 08:51.450
Und nun lasst uns den Durchschnitt vergleichen und so werden wir den Durchschnitt direkt zurückgeben, weil wir ihn mit

08:51.780 --> 08:55.510
der mittleren Funktion erhalten können, zu der wir natürlich spielen.

08:55.860 --> 09:01.840
Nun, was wir berechnen wollen, ist die Liste dessen, was ich denke, ich kopiere das immer noch.

09:01.980 --> 09:03.000
Ja da gehen wir hin.

09:03.210 --> 09:08.430
Wir geben also einfach den Mittelwert unserer Wortliste und den Mittelwert zurück.

09:08.520 --> 09:11.230
Wie gesagt ist eine Funktion von Nicht-Thai.

09:11.490 --> 09:16.770
Also hier und Anglish schauen sich diese gemeine Liste von Wörtern an.

09:16.770 --> 09:21.670
Und dann haben wir unseren Durchschnitt auf 100 Stufen perfekt.

09:21.720 --> 09:24.210
Also haben wir diese Klasse sehr effizient gemacht.

09:24.210 --> 09:29.060
Nun erhalten wir die Anweisungen, wie Sie einen gleitenden Durchschnitt von 100 Schritten erhalten.

09:29.280 --> 09:36.750
Und da wir beim Bewegen des Trainings ein gleitendes Durchschnittsobjekt verwenden werden, erstellen wir dieses

09:36.750 --> 09:38.640
gleitende Durchschnittsobjekt bereits.

09:38.730 --> 09:46.340
Also nennen wir es ein A und werden einfach ein Objekt und eine Klasse sein.

09:46.560 --> 09:55.010
Und wie gesagt, wir wollen die Größe 100, weil wir den gleitenden Durchschnitt in 100 Schritten berechnen wollen.

09:55.200 --> 09:56.100
So perfekt.

09:56.100 --> 09:57.080
Da gehen wir.

09:57.120 --> 10:01.830
Wir sind jetzt bereit, unsere KI zu trainieren, um endlich intelligent zu sein.

10:01.860 --> 10:06.120
Es ist an der Zeit, dass ab diesem Zeitpunkt unser Zeitalter schlau wird.

10:06.210 --> 10:07.890
Ich kann es kaum erwarten, es zu trainieren.

10:07.920 --> 10:11.260
Das wird ziemlich einfach, weil wir tot sind.

10:11.400 --> 10:12.660
Aber das wird Spaß machen.

10:12.750 --> 10:18.090
Außerdem ist es an der Zeit, noch mehr Spaß zu haben, denn im Grunde unseres Alters

10:18.090 --> 10:23.500
werde ich voll darauf aufbauen, was gebaut wird und auch Intelligenz, und deshalb werden wir den Code ausführen.

10:23.700 --> 10:30.540
Und dann werde ich Doom spielen und irgendwann schauen wir uns die Videos unserer AI an, die Doom spielen, und

10:30.540 --> 10:33.420
wir werden sehen, ob es die Weste erreicht.

10:33.510 --> 10:34.520
Ich kann es kaum erwarten.

10:34.560 --> 10:35.810
Lass uns das Training machen.

10:35.820 --> 10:37.360
Und bis dahin ich
