WEBVTT

00:00.300 --> 00:06.120
Hallo und willkommen zu dem super aufregenden Teil unserer Kreation, dem Teil, in dem wir es schlau machen.

00:06.270 --> 00:08.540
Genau das passiert beim Training der Luft.

00:08.590 --> 00:13.200
Ich werde seine Intelligenz trainieren, um das Ziel zu erreichen, das wir erreichen wollten.

00:13.350 --> 00:18.870
Und um dies zu tun, werden wir im Grunde das neuronale Netzwerk trainieren, um die richtigen Vorhersagen auszugeben.

00:19.110 --> 00:24.360
Und dann ist schon alles fertig, denn diese Ausgangssignale des Gehirns haben bereits die richtige

00:24.360 --> 00:27.300
Übertragung zum Körper, um die letzten Aktionen auszuführen.

00:27.660 --> 00:32.130
Im Grunde genommen tun wir jetzt etwas, was wir bereits zuvor getan haben.

00:32.280 --> 00:37.680
Wir werden nur einige zufällige Stapel aus dem Speicher entnehmen, unsere Eingaben aus diesen Stichproben abrufen,

00:37.680 --> 00:42.930
die Ausgabe abrufen, das Ziel abrufen, die Vorhersagen abrufen, den letzten Fehler zwischen den Vorhersagen und

00:42.930 --> 00:48.360
dem Ziel berechnen und dann die Rückwärtsausbreitung durchführen um den Gradientenabstieg zu veranlassen, die Gewichte entsprechend

00:48.360 --> 00:51.430
dem Beitrag zu diesem letzten Fehler zu aktualisieren.

00:51.900 --> 00:53.040
Also lass uns das alles machen.

00:53.040 --> 00:57.660
Sie werden sehen, wie einfach es sein wird, denn wir haben bereits alle Tools, um dies zu

00:57.660 --> 00:58.020
implementieren.

00:58.200 --> 01:04.230
Wir haben nicht nur den Weg zu Tools wie dem Optimierer und den Verlustfunktionen, sondern auch alle Klassen, die

01:04.440 --> 01:09.600
wir zuvor erstellt haben, wie natürlich unser Gehirn, die wir verwenden werden, um die Vorhersagen

01:09.600 --> 01:10.290
zu erhalten.

01:10.620 --> 01:17.970
Dann werden unsere Erfahrung, die Nachverfolgung der Implementierungsberechtigung und all diese Tools zusammen mit dem Piloten kombiniert. Diese

01:17.970 --> 01:23.790
Tools machen das Training zu einer Superleistung und daher erhalten wir schließlich ein superstarkes

01:23.790 --> 01:26.250
A. ICH. Lassen Sie uns dieses Training durchführen.

01:26.400 --> 01:28.110
Machen wir unsere Augen schlau.

01:28.290 --> 01:33.380
Und das erste, was wir jetzt tun werden, ist, die letzte Funktion zu erhalten, die wir während des Trainings

01:33.390 --> 01:36.200
verwenden, um den Fehler zu berechnen und zu optimieren.

01:36.540 --> 01:37.680
Das ist das erste, was wir tun werden.

01:37.980 --> 01:40.590
Erstellen wir also eine Variable für die letzte Funktion.

01:40.590 --> 01:42.150
Wir werden es Verlust nennen.

01:42.810 --> 01:50.340
Und dies entspricht der MSE-Verlustfunktion des Endmoduls.

01:50.850 --> 01:52.470
Und dann dieser Mercilus.

01:52.740 --> 01:56.940
Dies ist die letzte Funktion, die wir verwenden werden, da unsere Vorhersagen im Grunde genommen Werte sind.

01:56.940 --> 01:59.940
Sie wissen, wir prognostizieren die Grundwerte der verschiedenen Aktionen.

01:59.940 --> 02:05.970
Und deshalb, da dies reelle Zahlen sind, machen wir eine Art neuronales Netzwerk für die Regression und

02:05.970 --> 02:08.910
daher ist die Verlustfunktion das Mittel für Fehler.

02:09.120 --> 02:11.880
Das ist die Verlustfunktion, die wir im Allgemeinen für die Regression verwenden.

02:12.450 --> 02:12.960
Gut.

02:13.080 --> 02:18.180
Nachdem wir nun unsere letzte Funktion haben, lassen Sie uns unseren Optimierer hier so optimieren.

02:18.180 --> 02:21.240
Das ist die Variable, die wir für den Optimierer erstellen.

02:21.270 --> 02:23.940
Und wir werden wie gewohnt nehmen.

02:23.940 --> 02:30.750
Das selbstfahrende Auto, der Atomoptimierer, ist ein sehr leistungsfähiger Optimierer, der Wunder für das Training

02:30.930 --> 02:31.710
bewirkt.

02:32.130 --> 02:35.820
Also lasst uns dieses auf dieses Atom bringen.

02:36.810 --> 02:42.720
Und denken Sie daran, genau das ist das selbstfahrende Auto, für das wir zwei wesentliche Argumente eingeben müssen.

02:43.080 --> 02:49.200
Der erste ist derjenige, der die Verbindung zwischen dem Optimierer und den Parametern unseres neuronalen Netzwerks

02:49.200 --> 02:52.650
herstellt, dh den Gewichten der Neuronen unseres Gehirns.

02:53.040 --> 02:56.640
Und dazu nehmen wir unser Gehirn, das wir CNN nannten.

02:57.030 --> 02:59.040
Das ist das Objekt, das wir für unser Gehirn geschaffen haben.

02:59.280 --> 03:05.860
Und so CNN, die sich an Parameter erinnern, die wir gehen, und einige Klammern.

03:06.270 --> 03:11.970
Das stellt also die Verbindung zwischen dem Optimierer und den Gewichten der Neuronen im

03:11.970 --> 03:18.630
Gehirn unseres A her. ICH. Und dann ist das zweite Argument eine Lernrate, und das ist gegeben durch l. R.

03:18.990 --> 03:24.510
Deshalb müssen wir hier eine geringere Lernrate wählen, weil wir nicht zu schnell konvergieren wollen und etwas erforschen wollen,

03:24.510 --> 03:29.370
und daher ist eine gute Lernmethode, die wir hier sagen können, eine kleine, die vier Punkte

03:29.370 --> 03:33.150
oder eine solche ist ist 0. 01 Prozent.

03:33.390 --> 03:36.270
Ich denke, das ist das gleiche, was wir für das selbstfahrende Auto verwendet haben.

03:37.320 --> 03:43.410
Also gut, jetzt haben wir einen Funktionsoptimierer für verlorene Funktionen, sodass wir fast bereit sind, die vollständige Schleife zu starten.

03:43.470 --> 03:45.890
Nun, eigentlich werden wir jetzt die vollständige Schleife starten.

03:46.140 --> 03:52.100
Aber kurz bevor wir es tun, werden wir die Größe der Anzahl der Epochen bestimmen, in die

03:52.100 --> 03:58.170
wir uns verwandeln werden, und daher hier eine neue Variable erstellen, die auf diese Anzahl von Epochen reagiert.

03:59.320 --> 04:02.140
Und lassen Sie es uns gleich hundert setzen.

04:02.530 --> 04:08.350
Das wird gut genug sein, um die Luft zu trainieren, und ich wette sogar, dass die Luft es schaffen wird, den besten

04:08.500 --> 04:11.140
Weg vor einhundert wie zwanzig oder dreißig zu erreichen.

04:11.500 --> 04:12.000
Mal schauen.

04:12.010 --> 04:13.750
Aber jetzt nehmen wir hundert.

04:13.990 --> 04:15.940
Und wenn wir es brauchen, werden wir es erhöhen.

04:16.090 --> 04:17.710
Aber ich denke nicht, dass das notwendig sein wird.

04:18.370 --> 04:22.660
OK, jetzt, da wir unsere Anzahl an Flughäfen haben, können wir beginnen, die vollständige

04:22.840 --> 04:26.680
Schleife des Trainings zu machen, wenn wir über die Flughäfen trainieren.

04:27.010 --> 04:31.530
Dann wird also der gesamte Volleyball am Werk sein.

04:31.540 --> 04:34.240
Dafür wählen wir wieder.

04:34.990 --> 04:42.310
Jetzt werden wir natürlich die Bereichsfunktion verwenden, um zu sagen, dass wir von der ersten bis

04:42.670 --> 04:44.500
zur Anzahl von ca.

04:47.120 --> 04:52.730
Plus eins, denn denken Sie daran, dass die Obergrenze eines Bereichs nicht enthalten ist. Wenn Sie

04:52.730 --> 04:58.730
also auf 100 steigen möchten, müssen wir angeben und ein Plus eins sein, um auf 100 zu kommen.

04:59.390 --> 04:59.840
Gut.

04:59.840 --> 05:00.800
Also, Colin.

05:00.980 --> 05:02.800
Und jetzt kommen wir zur Schleife.

05:03.620 --> 05:03.980
Gut.

05:03.980 --> 05:08.300
Das erste, was wir tun werden, sind 200 Läufe mit zehn Schritten.

05:08.660 --> 05:13.630
Jede Epoche besteht also aus 200 Läufen nacheinander in 10 Schritten.

05:13.940 --> 05:19.550
Dazu haben wir diese Ein-Schritt-Funktion aus unserer Erfahrungsklasse und verwenden daher diese Funktion, die eigentlich

05:19.550 --> 05:24.770
eine Methode ist, da wir sie aus unserem Speicherobjekt abrufen, das ein

05:24.770 --> 05:30.080
Objekt aus der Ersatzklasse ist, um diese beiden Läufe zu generieren von zehn Schritten.

05:30.320 --> 05:36.020
Nun, wir müssen unser Erinnerungsobjekt nehmen, an das ich Sie erinnere, dass wir es hier erstellt haben.

05:36.170 --> 05:40.400
Speicher ist ein Ziel, um die Speicherklasse mit Insteps wiederzugeben.

05:40.400 --> 05:43.300
Das sind 10 Schritte und eine Kapazität von zehntausend.

05:43.910 --> 05:52.370
Wir haben dieses Objekt erstellt und von diesem Objekt nehmen wir gut, diese Rundstedt-Funktion führt Schritte aus und wir geben

05:52.370 --> 06:00.430
zweihundert aufeinanderfolgende Runden von zehn Schritten an, so dass wir bei jedem im Grunde genommen 200 Schritte ausführen.

06:00.860 --> 06:08.060
Und jetzt, da diese 200 Schritte bei jedem Apoc ausgeführt werden, ist es an der Zeit, einige Chargen aus diesen Läufen

06:08.060 --> 06:10.630
zu testen und diese Chargen zu testen.

06:10.640 --> 06:16.700
Wir haben eine andere Funktion aus unserem Speicher, nämlich den Beispielstapel, der genau einige Stapel

06:16.700 --> 06:18.910
aus diesen 200 Läufen generiert.

06:19.400 --> 06:26.720
Denken Sie jedoch daran, dass es sich bei diesen Stapeln diesmal um Stapel einer Reihe von Übergängen handelt, die eine Reihe von zehn Schritten umfassen, im Gegensatz

06:27.020 --> 06:31.630
zu zuvor, bei denen es sich bei den Stapeln hier nur um einige Stapel einzelner Übergänge handelte.

06:31.640 --> 06:37.040
Dieses Mal werden es Stapel von zehn Schritten, zehn Übergängen sein, und deshalb ist es jetzt an

06:37.040 --> 06:41.870
der Zeit, diese zufälligen Stapel aus unserem Gedächtnis zu holen und sie zu erhalten.

06:41.870 --> 06:48.320
Wir haben die einfache Chargenfunktion verwendet, auf die wir die Chargengröße anwenden müssen, und für die Chargengröße,

06:48.320 --> 06:53.480
bei der wir zweiunddreißig oder sogar vierundsechzig oder sogar einhundertachtundzwanzig nehmen können.

06:54.080 --> 06:57.830
Denken Sie daran, für diese Größe ist es üblich, zweiunddreißig zu verwenden.

06:58.070 --> 07:03.470
Das sehen Sie im Allgemeinen in den Architekturen neuronaler Netze, wenn Sie Batch-Lernen durchführen.

07:03.740 --> 07:05.470
Aber diesmal ist es ganz anders.

07:05.660 --> 07:11.530
Wir probieren nur einige Chargen in 10 Schritten aus, daher ist es besser, Chargen mit größeren Größen zu nehmen.

07:11.690 --> 07:14.710
Dort können wir also vierundsechzig, einhundertachtundzwanzig nehmen.

07:15.170 --> 07:16.940
Also nehmen wir einhundertachtundzwanzig.

07:17.150 --> 07:25.130
Und tatsächlich wird dies innerhalb der Schleife sein, weil wir mehrere Stapel aufnehmen möchten und sie in dem

07:25.130 --> 07:28.870
aufnehmen, was von dieser einfachen Stapelfunktion zurückgegeben wird.

07:29.420 --> 07:36.020
Diese vollständige Schleife für Batch in Memory-Beispiel-Batch, einhundertachtundzwanzig, bedeutet also, dass unser Speicher

07:36.020 --> 07:41.720
alle einhundertachtundzwanzig Schritte einen Stapel mit einer Größe von einhundertachtundzwanzig ergibt, der

07:41.720 --> 07:47.210
tatsächlich den letzten enthält Hundertundzwanzig Schritte, die wir gerade laufen.

07:47.960 --> 07:53.060
Wir bekommen nur ein paar Chargen von sechs, einhundertachtundzwanzig und das Lernen wird auf diesen

07:53.210 --> 07:54.080
Chargen stattfinden.

07:54.320 --> 07:58.910
Außerdem werden in diesen Stapeln alle 10 Schritte Eignungsabläufe ausgeführt, um zu

07:58.910 --> 07:59.480
lernen.

08:00.230 --> 08:00.620
Gut.

08:00.620 --> 08:06.950
Also jetzt in dieser Schleife, die immer noch in einer Epoche stattfindet, aber jetzt sind wir in einer bestimmten

08:06.950 --> 08:07.360
Charge.

08:07.790 --> 08:14.060
Und jetzt werden wir als erstes unsere Eingaben und unser Ziel getrennt erhalten.

08:14.570 --> 08:16.610
Und das ist, wie ich Ihnen sagte, sehr einfach.

08:16.610 --> 08:21.290
Wir können dies mit einem der von uns implementierten Tools tun, nämlich der Berechtigungsverfolgung.

08:21.620 --> 08:27.950
Wie Sie hier sehen können, nimmt diese Berechtigungsverfolgungsfunktion die Eingaben als und jetzt haben wir den Stapel

08:28.310 --> 08:32.060
und geben als Ausgabe die Eingaben und die Ziele zurück.

08:32.420 --> 08:37.490
Im Moment können wir also einfach zwei neue Variablen erstellen, die die Eingaben und das Ziel

08:37.490 --> 08:38.300
sein werden.

08:38.690 --> 08:48.610
Und kommen diese Eingaben zu Zielen, die genau dem entsprechen, was diese Berechtigungsverfolgungsfunktion für einen Stapel zurückgibt?

08:49.010 --> 08:51.950
Wir werden diese Funktion also auf den Stapel unserer Schleife anwenden.

08:52.280 --> 08:55.160
Was wir also tun werden, ist nur die Berechtigung.

08:56.460 --> 09:00.110
Trace bezog sich auf die Charge unserer Hoffnung.

09:00.660 --> 09:07.110
Also gut, das bringt uns die Inputs und die Ziele, aber in engen Schichten gibt es immer etwas mehr

09:07.110 --> 09:07.850
zu tun.

09:08.100 --> 09:13.530
Und dies dient natürlich dazu, die Eingabe des neuronalen Netzwerks und auch das Ziel in einige tahj-Variablen

09:13.530 --> 09:14.030
umzuwandeln.

09:14.340 --> 09:16.170
Aber es gibt auch nichts Neues.

09:16.200 --> 09:17.310
Wir wissen, wie es geht.

09:17.490 --> 09:18.450
Wir können es so machen.

09:18.460 --> 09:24.930
Wir nehmen unsere Eingaben, dann unsere Ziele und nun, sie werden gleich verbal sein.

09:25.820 --> 09:26.510
Eingaben.

09:27.750 --> 09:30.210
Das ist für die Eingabe und verbal.

09:31.150 --> 09:33.580
Ziele, und das ist für die Ziele.

09:34.090 --> 09:42.250
Also gut, die Eingaben des Gehirns werden in einige Tahj-Variablen umgewandelt, und die Ziele werden auch in

09:42.250 --> 09:43.900
einige Tahj-Variablen umgewandelt.

09:44.320 --> 09:48.320
Jetzt können wir die Eingaben in das neuronale Netzwerk erhalten.

09:48.640 --> 09:50.530
Und warum müssen wir das so machen?

09:50.530 --> 09:55.270
Da der nächste Schritt darin besteht, die Vorhersagen zu erhalten, haben wir die Eingaben, auf die wir abzielen müssen.

09:55.540 --> 09:59.980
Jetzt brauchen wir natürlich unsere Vorhersagen, denn dann werden wir den Verlust zwischen den

10:00.190 --> 10:02.120
Vorhersagen und den Zielen berechnen.

10:02.890 --> 10:06.350
Lassen Sie uns diese Vorhersagen erhalten, um sie zu erhalten.

10:06.640 --> 10:07.930
Nun, das ist wieder so einfach.

10:07.930 --> 10:14.650
Jetzt müssen wir nur noch unser Gehirn, CNN, unser Faltungsnetzwerk, nehmen und auf

10:14.830 --> 10:16.730
unsere Eingaben anwenden.

10:17.320 --> 10:17.950
Na, bitte.

10:18.320 --> 10:23.320
Die Eingaben gehen in das neuronale Netzwerk und das neuronale Netzwerk gibt die Vorhersagen aus.

10:24.170 --> 10:29.270
Perfekt, jetzt haben wir die Vorhersagen, wir haben die Ziele, damit wir die Gesetze bekommen können, und das

10:29.270 --> 10:34.640
ist der nächste Schritt, wir werden ein neues mehr einführen, weil wir jetzt den letzten Fehler bekommen, der anders

10:34.790 --> 10:39.660
ist als die letzte Funktion, weil wir sie als Funktion verwenden, um den letzten Fehler zu erhalten.

10:40.100 --> 10:50.570
So weniger Fehler hier und dass wir es mit der weniger Funktion bekommen, die auf unsere Vorhersagen und die Ziele angewendet wird, die wir

10:50.570 --> 10:54.860
gehen, um zu sehen, wie alles jetzt glatt ist.

10:55.070 --> 10:56.170
Alles ist logisch.

10:56.180 --> 11:00.590
Wir erhalten zuerst die Eingabe, die Ziele, und dank der Eingabe erhalten wir die Vorhersagen.

11:00.590 --> 11:03.800
Und dank der Vorhersagen und Ziele, die wir erhalten, desto weniger Fehler.

11:05.070 --> 11:08.850
Also sehr logisch und reibungslos, und was ist nun der nächste Schritt?

11:09.150 --> 11:14.940
Nun, der gleiche logische Pfad, jetzt wo wir den letzten haben, können wir diesen weniger Fehler zurück in das neue Netzwerk

11:14.940 --> 11:16.890
übertragen, um die Gewichte zu aktualisieren.

11:17.190 --> 11:21.540
Und das tun wir mit stochastischem Gradientenabstieg und um stochastischen Gradientenabstieg durchzuführen.

11:21.540 --> 11:24.010
Wir brauchen unseren Optimierer, aber wir haben ihn bereits.

11:24.030 --> 11:26.040
Hier sind Adam Optimizer.

11:26.430 --> 11:29.010
Aber jetzt denken Sie daran, was wir tun müssen.

11:29.370 --> 11:32.380
Wir müssen es initialisieren und initialisieren.

11:32.400 --> 11:40.620
Denken Sie daran, wir nehmen unser Optimierungsobjekt und wenden dann die Methode des Gradienten Null an.

11:41.440 --> 11:48.220
Los geht's, wir vergessen nicht die Klammern, die es initialisieren, und jetzt besteht der nächste Schritt darin,

11:48.220 --> 11:55.630
den letzten Fehler zurück in das neue Netzwerk zu übertragen und dies zu tun, wo wir unseren letzten

11:55.630 --> 11:58.950
Fehler nehmen und die Rückwärtsmethode darauf anwenden.

11:58.960 --> 12:01.800
Das ist also genau das, um die Rückwärtsausbreitung anzuwenden.

12:02.110 --> 12:06.380
Und schließlich, jetzt, da der letzte Fehler zurück ist, verbreiten Sie ihn in das neue Netzwerk.

12:06.610 --> 12:09.610
Nun, wir können die Gewichte mit dem Cassi-Gradientenabstieg aktualisieren.

12:10.300 --> 12:16.950
Denken Sie dazu daran, dass wir unseren Optimierer verwenden und dann die Schrittmethode anwenden.

12:17.500 --> 12:18.210
Na, bitte.

12:18.400 --> 12:19.900
Die Gewichte werden jetzt aktualisiert.

12:20.200 --> 12:25.500
Wie ich Ihnen sagte, haben wir es nicht nur bereits getan, sondern es scheint jetzt so einfach und so natürlich zu sein.

12:26.200 --> 12:28.440
Jetzt machen wir also etwas Spaß.

12:28.600 --> 12:31.650
Wir werden die durchschnittliche Belohnung für jeden Apoc drucken.

12:31.840 --> 12:35.830
Sie wissen also, wir können verfolgen, wie die A. ICH. geht, wie das Training läuft.

12:36.190 --> 12:40.420
Wir möchten, dass die durchschnittliche Belohnung über die Stufen hinweg steigt.

12:40.630 --> 12:44.070
Und zunächst gibt es natürlich diese Explorationsphase.

12:44.080 --> 12:49.690
Die durchschnittliche Belohnung steigt also zu Beginn möglicherweise nicht an, aber sobald sie die Ausbeutungsphase erreicht

12:49.690 --> 12:56.050
hat, steigt die durchschnittliche Belohnung definitiv an und steigt auf ein bestimmtes Niveau an, wenn sie den Westen

12:56.290 --> 12:58.740
so schnell wie möglich erreicht möglich.

12:59.380 --> 13:01.210
Beginnen wir also mit dem Druck.

13:02.200 --> 13:07.660
Weißt du, wir machen das in einem, also müssen wir zum Loopier-Druck zurückkehren und

13:07.660 --> 13:12.610
dann werden wir gut drucken, zuerst ungefähr eine Spalte, dann Prozent.

13:12.610 --> 13:18.850
S, weil wir alles in eine bessere Zeichenfolge konvertieren und dann die

13:18.850 --> 13:21.100
durchschnittliche Belohnung hinzufügen.

13:22.490 --> 13:27.620
Und dann addieren wir auch Prozent, dann schließen wir das Angebot.

13:28.890 --> 13:35.220
Und dann addieren wir ein Prozent und geben auf der anderen Seite die Variablen ein, die die erste Person

13:35.220 --> 13:41.430
sein werden, da dies hier das Epos ist, und die zweite Variable, die der durchschnittlichen Belohnung entspricht, die

13:41.610 --> 13:42.840
jetzt berechnet wird.

13:43.020 --> 13:45.560
Die durchschnittliche Belohnungsvariable existiert also noch nicht.

13:45.780 --> 13:47.600
Wir werden es jetzt schaffen.

13:48.120 --> 13:51.930
Also werden wir ETR bei der Arbeit verwenden.

13:52.470 --> 13:55.440
Selbst wenn Époque die Zahl ist, werden wir das in eine Zeichenfolge umwandeln.

13:55.440 --> 13:57.090
Das ist besser und.

13:58.110 --> 14:03.150
Wir werden hinzufügen, Estie, dass dies die durchschnittliche Belohnung sein wird, und deshalb werden wir

14:03.150 --> 14:09.810
eine Variable erstellen, die wir eine große Belohnung nennen werden, und jetzt werden wir diese Variable erstellen und sie berechnen ?

14:10.560 --> 14:12.430
OK, also lass uns das machen.

14:12.450 --> 14:13.980
Das ist das einzige, was wir noch tun müssen.

14:13.980 --> 14:15.900
Also Époque haben wir schon.

14:16.170 --> 14:20.040
Jetzt berechnen wir die durchschnittliche Welt und wir müssen sie genau hier berechnen.

14:20.130 --> 14:27.090
Immer noch in der Schleife, aber außerhalb der Schleife, denn jetzt haben wir unseren Batch abgetastet und unser Training findet im

14:27.090 --> 14:28.050
Batch statt.

14:28.350 --> 14:31.940
Aber jetzt erfolgt die Vorwärtsausbreitung plus die Rückwärtsausbreitung im Stapel.

14:32.190 --> 14:39.900
Wir kehren also in die Schleife zurück und können nun die kumulativen Belohnungen berechnen, die wir mit unserem Rist-Objekt

14:39.900 --> 14:41.100
erzielen können.

14:41.430 --> 14:47.910
Da unser Insteps-Objekt diese Funktion enthält, würden wir Schritte ausführen, mit denen wir die kumulativen Belohnungen erhalten,

14:47.910 --> 14:51.250
die in den Schritten während des Insteps-Laufs auftreten.

14:51.660 --> 14:57.330
Wir werden es jetzt verwenden, um die neuen Belohnungen der Schritte zu aktualisieren.

14:57.660 --> 15:05.640
Und dann werden wir das Objekt mit dem gleitenden Durchschnitt aktualisieren, indem wir die kumulativen Belohnungen zum Objekt mit dem sich bewegenden Alltag hinzufügen

15:05.640 --> 15:07.770
und dann den Durchschnitt neu berechnen.

15:07.780 --> 15:09.910
Und so bekommen wir die durchschnittliche Belohnung.

15:10.590 --> 15:11.510
Also lass uns das machen.

15:11.520 --> 15:14.640
Das erste, was wir brauchen, sind die Belohnungen der DARABA-Daten.

15:14.970 --> 15:16.950
Nennen wir sie also Belohnungen.

15:18.100 --> 15:27.700
Schritte und dann, wie gesagt, nehmen wir unser Endschritt-Objekt, das, wie ich mich erinnere, hier ein Objekt der Instant-Progress-Klasse aus unserer

15:27.700 --> 15:33.310
Erfahrung erstellt hat, die wir mit einem so sensiblen Thema verschmutzen.

15:34.000 --> 15:39.410
Dann fügen wir Belohnungen, Schritte und dann einige Klammern hinzu.

15:39.760 --> 15:40.150
Gut.

15:40.180 --> 15:43.690
Das bringt uns die neuen kumulativen Belohnungen der Schritte.

15:43.990 --> 15:44.500
Gut.

15:45.310 --> 15:50.800
Aber dann müssen wir diese neuen kumulativen Belohnungen zu unseren Objekten mit gleitendem Durchschnitt hinzufügen.

15:50.980 --> 15:57.760
Und dazu haben wir diesmal eine Methode in der Klasse des gleitenden Durchschnitts. Diese Anzeigenmethode ist sehr

15:57.760 --> 15:58.210
einfach.

15:58.220 --> 16:03.190
Wir nehmen unser gleitendes Durchschnittsobjekt, das wir hier mit hundert Schritten erstellt haben.

16:03.790 --> 16:11.710
Dann verwenden wir unsere ADD-Methode und geben dann in der Atmosphäre unsere Belohnungsschritte ein. Dadurch werden die

16:11.710 --> 16:15.130
Belohnungen der Schritte zum gleitenden Durchschnitt addiert.

16:15.970 --> 16:16.360
Gut.

16:16.360 --> 16:21.960
Und schließlich können wir die durchschnittliche Belohnung berechnen, und das ist gut, wissen Sie, das ist hier dieselbe Variable.

16:22.690 --> 16:26.440
Das ist es also, was der durchschnittlichen Belohnung entspricht.

16:26.860 --> 16:33.250
Und um es zu bekommen, müssen wir diesmal nur die Durchschnittsmethode von unserem Objekt mit gleitendem Durchschnitt verwenden.

16:33.700 --> 16:41.470
Und das ist, was wir tun und ein Punktdurchschnitt einfach so, weil unser gleitender Durchschnitt bereits mit den neuen Belohnungsschritten

16:41.710 --> 16:45.520
aktualisiert wurde, die wir gerade der ADD-Methode hinzugefügt haben.

16:46.430 --> 16:46.890
Toll.

16:46.960 --> 16:52.990
Jetzt haben wir unsere durchschnittliche Auszeichnung, die hier sehr beliebt ist und die jedes Jahr gedruckt wird.

16:53.420 --> 16:54.990
Also gut, wir sind fertig.

16:55.030 --> 16:57.170
Ich bin so gespannt auf die Ergebnisse.

16:57.170 --> 17:01.670
Und tatsächlich werde ich im nächsten Tutorial eine Überraschung für Sie haben, während ich mir die Ergebnisse ansehe.

17:01.700 --> 17:03.380
Es wird also ziemlich aufregend.

17:03.650 --> 17:06.740
Und jetzt ist es wohl Zeit, mit der Luft zu spielen und Spaß zu haben.

17:07.610 --> 17:08.060
Gut.

17:08.060 --> 17:11.240
Bereiten Sie sich also einen guten Kaffee oder einen guten Tee zu.

17:11.480 --> 17:17.410
Jetzt ist es Zeit, bequem auf unserem Stuhl zu sitzen und einige sehr coole Videos unseres Flugzeugs anzusehen, um zu sehen, das

17:17.430 --> 17:18.760
ist im nächsten Tutorial.

17:18.770 --> 17:20.160
Und bis dahin viel Spaß.
