WEBVTT

00:00.300 --> 00:06.120
Witam i zapraszam do super ekscytującej części naszego stworzenia, części, w której sprawiamy, że jest inteligentna.

00:06.270 --> 00:08.540
Tak właśnie dzieje się podczas treningu w powietrzu.

00:08.590 --> 00:13.200
Będę trenować jego inteligencję, aby osiągnąć cel, który chcieliśmy osiągnąć.

00:13.350 --> 00:18.870
Aby to zrobić, zamierzamy po prostu wyszkolić sieć neuronową, aby generowała prawidłowe prognozy.

00:19.110 --> 00:24.360
A potem wszystko jest już gotowe, ponieważ te sygnały wyjściowe z mózgu mają już właściwą

00:24.360 --> 00:27.300
transmisję do organizmu, aby odegrać ostatnie działania.

00:27.660 --> 00:32.130
Więc w zasadzie teraz to, co zamierzamy zrobić, jest czymś, co już zrobiliśmy wcześniej.

00:32.280 --> 00:37.680
Po prostu weźmiemy kilka losowych partii z pamięci, uzyskamy dane wejściowe z tych próbek, uzyskamy

00:37.680 --> 00:42.930
dane wyjściowe, uzyskamy cel, uzyskamy prognozy, obliczymy ostatni błąd między przewidywaniami a celem, a

00:42.930 --> 00:48.360
następnie wykonamy propagację wsteczną aby uzyskać spadek gradientu, aby zaktualizować wagi w zależności od tego,

00:48.360 --> 00:51.430
jak bardzo przyczyniły się do tego ostatniego błędu.

00:51.900 --> 00:53.040
Więc zróbmy to wszystko.

00:53.040 --> 00:58.020
Zobaczysz, jak to będzie takie łatwe, ponieważ mamy już wszystkie narzędzia do implementacji.

00:58.200 --> 01:04.230
Nie tylko mamy ścieżkę do narzędzi takich jak optymalizator i funkcje strat, ale także mamy wszystkie

01:04.440 --> 01:09.600
klasy, które stworzyliśmy wcześniej, jak oczywiście nasz mózg, których będziemy używać do uzyskiwania

01:09.600 --> 01:10.290
prognoz.

01:10.620 --> 01:17.970
Następnie nasze doświadczenie, śledzenie kwalifikowalności wdrożenia powtórek i wszystkie te narzędzia połączone z pilotem, które narzędzia

01:17.970 --> 01:23.790
sprawią, że szkolenie będzie super wydajne, a zatem ostatecznie otrzymamy super potężne

01:23.790 --> 01:26.250
A. JA. Zróbmy więc to szkolenie.

01:26.400 --> 01:28.110
Sprawmy, by nasze oczy były inteligentne.

01:28.290 --> 01:33.380
Pierwszą rzeczą, którą teraz zrobimy, jest pobranie ostatniej funkcji, której użyjemy podczas szkolenia

01:33.390 --> 01:36.200
podczas obliczania błędu i zoptymalizowanie jej.

01:36.540 --> 01:37.680
To pierwsza rzecz, którą zrobimy.

01:37.980 --> 01:40.590
Stwórzmy więc zmienną dla ostatniej funkcji.

01:40.590 --> 01:42.150
Nazwiemy to stratą.

01:42.810 --> 01:50.340
A to będzie równe funkcji strat MSE z modułu końcowego.

01:50.850 --> 01:52.470
A potem ten Mercilus.

01:52.740 --> 01:56.940
To ostatnia funkcja, której użyjemy, ponieważ w zasadzie nasze przewidywania są wartościami.

01:56.940 --> 01:59.940
Wiesz, przewidujemy podstawowe wartości różnych działań.

01:59.940 --> 02:05.970
A zatem, ponieważ są to liczby rzeczywiste, cóż, robimy coś w rodzaju sieci neuronowej w celu regresji,

02:05.970 --> 02:08.910
a zatem funkcja straty jest środkiem do błędu.

02:09.120 --> 02:11.880
To jest funkcja straty, której używamy ogólnie do regresji.

02:12.450 --> 02:12.960
W porządku.

02:13.080 --> 02:18.180
Więc teraz, gdy mamy naszą ostatnią funkcję, pobierzmy tutaj nasz optymalizator.

02:18.180 --> 02:21.240
To jest zmienna, którą tworzymy dla niego optymalizator.

02:21.270 --> 02:23.940
I będziemy postępować jak zwykle.

02:23.940 --> 02:30.750
Jeśli chodzi o samojezdny samochód, optymalizator atomów, to bardzo potężny optymalizator, który zdziała cuda podczas

02:30.930 --> 02:31.710
treningu.

02:32.130 --> 02:35.820
Więc przenieśmy ten do tego atomu.

02:36.810 --> 02:42.720
I pamiętajcie, że właśnie to auto jeżdżące musimy wprowadzić dwa zasadnicze argumenty.

02:43.080 --> 02:49.200
Pierwsza to ta, która połączy optymalizator z parametrami naszej sieci neuronowej,

02:49.200 --> 02:52.650
czyli wagami neuronów naszego mózgu.

02:53.040 --> 02:56.640
Aby to zrobić, bierzemy mózg, który nazwaliśmy CNN.

02:57.030 --> 02:59.040
To obiekt, który stworzyliśmy dla naszego mózgu.

02:59.280 --> 03:05.860
A więc CNN, które pamiętają parametry, które idziemy i kilka nawiasów.

03:06.270 --> 03:11.970
To tworzy związek między optymalizatorem a wagą neuronów w mózgu

03:11.970 --> 03:18.630
naszego A. JA. A następnie drugim argumentem jest współczynnik uczenia się, który jest określony przez l. R.

03:18.990 --> 03:24.510
Więc tutaj musimy przyjąć mniejszy współczynnik uczenia się, ponieważ nie chcemy zbieżności zbyt szybko i chcemy mieć trochę

03:24.510 --> 03:29.370
eksploracji, a zatem dobry sposób uczenia się, który możemy tutaj powiedzieć, jest mały, który ma cztery

03:29.370 --> 03:33.150
punkty lub taki, który wynosi 0. 01 proc.

03:33.390 --> 03:36.270
Myślę, że tego samego używaliśmy w przypadku samochodu autonomicznego.

03:37.320 --> 03:43.410
W porządku, więc mamy teraz optymalizator utraconych funkcji, więc jesteśmy prawie gotowi do rozpoczęcia pełnej pętli.

03:43.470 --> 03:45.890
Cóż, właściwie zaczniemy teraz pełną pętlę.

03:46.140 --> 03:52.100
Ale tuż przed tym, zanim to zrobimy, zdecydujemy o liczbie epok, w które

03:52.100 --> 03:58.170
będziemy się przekształcać, i stworzymy tutaj nową zmienną, która będzie odpowiadać tej liczbie epok.

03:59.320 --> 04:02.140
Ustawmy to na sto.

04:02.530 --> 04:08.350
To wystarczy, aby wytrenować powietrze, a nawet założę się, że powietrze zdoła dotrzeć na najlepszą drogę

04:08.500 --> 04:11.140
przed setką, na przykład dwadzieścia lub trzydzieści.

04:11.500 --> 04:12.000
Zobaczmy.

04:12.010 --> 04:13.750
Ale na razie weźmy sto.

04:13.990 --> 04:15.940
A jeśli tego będziemy potrzebować, zwiększymy go.

04:16.090 --> 04:17.710
Ale nie sądzę, żeby to było konieczne.

04:18.370 --> 04:22.660
OK, więc teraz, gdy mamy naszą liczbę lotnisk, możemy zacząć robić pełną pętlę,

04:22.840 --> 04:26.680
wiesz, tę główną pełną pętlę treningu, kiedy trenujemy nad lotniskami.

04:27.010 --> 04:31.530
Więc wtedy cała siatkówka będzie w pracy.

04:31.540 --> 04:34.240
Właśnie to wybieramy z powrotem.

04:34.990 --> 04:42.310
Teraz oczywiście użyjemy funkcji zakresu, aby powiedzieć, że chcemy przejść od pierwszej

04:42.670 --> 04:44.500
do liczby ok.

04:47.120 --> 04:52.730
Plus jeden, ponieważ pamiętaj, że górna granica zakresu nie jest uwzględniana, a zatem,

04:52.730 --> 04:58.730
jeśli chcesz podnieść do 100, cóż, musimy określić i być dodatnim, aby wzrosnąć do 100.

04:59.390 --> 04:59.840
W porządku.

04:59.840 --> 05:00.800
Więc, Colin.

05:00.980 --> 05:02.800
A teraz przejdźmy do pętli.

05:03.620 --> 05:03.980
W porządku.

05:03.980 --> 05:08.300
Więc pierwszą rzeczą, którą zamierzamy zrobić, jest wykonanie 200 przebiegów po dziesięć kroków.

05:08.660 --> 05:13.630
Tak więc każda epoka będzie trwała 200 biegów, jeden po drugim po 10 kroków.

05:13.940 --> 05:19.550
Aby to zrobić, mamy tę jednoetapową funkcję z naszej klasy doświadczenia i dlatego używamy tej

05:19.550 --> 05:24.770
funkcji, która jest w rzeczywistości metodą, ponieważ otrzymamy ją z naszego obiektu

05:24.770 --> 05:30.080
pamięci, który jest obiektem z klasy zastępczej, aby wygenerować te dwa przebiegi dziesięciu kroków.

05:30.320 --> 05:36.020
Cóż, musimy wziąć nasz obiekt pamięci, który przypominam, że stworzyliśmy tutaj.

05:36.170 --> 05:40.400
Pamięć jest celem odtworzenia klasy pamięci z Insteps.

05:40.400 --> 05:43.300
To jest 10 kroków i pojemność dziesięciu tysięcy.

05:43.910 --> 05:52.370
Stworzyliśmy ten obiekt i z tego obiektu bierzemy dobrze, ta funkcja Rundstedt wykonuje kroki i

05:52.370 --> 06:00.430
określamy dwieście kolejnych rund po dziesięć kroków, abyśmy po prostu wykonali 200 kroków.

06:00.860 --> 06:08.060
A teraz, gdy mamy te 200 kroków uruchomionych w każdym apoc, cóż, czas na pobranie próbek z

06:08.060 --> 06:10.630
tych serii i pobranie próbek.

06:10.640 --> 06:16.700
Mamy inną funkcję z naszej pamięci, która jest próbką, która dokładnie wygeneruje kilka partii

06:16.700 --> 06:18.910
z tych 200 uruchomień.

06:19.400 --> 06:26.720
Ale pamiętaj, te partie są tym razem partiami serii przejść, które stanowią serię dziesięciu kroków, w przeciwieństwie

06:27.020 --> 06:31.630
do wcześniejszych, gdzie partie były tylko partiami pojedynczych przejść tutaj.

06:31.640 --> 06:37.040
Tym razem będą to partie dziesięciu kroków, dziesięciu przejść, a zatem teraz nadszedł czas,

06:37.040 --> 06:41.870
aby wydobyć z naszej pamięci te losowe partie i je pobrać.

06:41.870 --> 06:48.320
Skorzystaliśmy z prostej funkcji wsadowej, do której musimy zastosować wielkość partii, i do wielkości partii, gdzie możemy

06:48.320 --> 06:53.480
wziąć trzydzieści dwie lub nawet sześćdziesiąt cztery lub nawet sto dwadzieścia osiem.

06:54.080 --> 06:57.830
Pamiętaj, że przy tym rozmiarze często używa się trzydziestu dwóch.

06:58.070 --> 07:03.470
To właśnie zobaczysz ogólnie w architekturach sieci neuronowych podczas uczenia wsadowego.

07:03.740 --> 07:05.470
Ale tym razem jest zupełnie inaczej.

07:05.660 --> 07:11.530
My, pobieramy tylko kilka partii po 10 kroków, więc lepiej jest wziąć partie o większych rozmiarach.

07:11.690 --> 07:14.710
Tak więc możemy wziąć sześćdziesiąt cztery, sto dwadzieścia osiem.

07:15.170 --> 07:16.940
Więc weźmiemy sto dwadzieścia osiem.

07:17.150 --> 07:25.130
I faktycznie będzie to wewnątrz pętli, ponieważ chcemy wziąć kilka partii i bierzemy je w tym, co

07:25.130 --> 07:28.870
jest zwracane przez tę prostą funkcję wsadową.

07:29.420 --> 07:36.020
Więc ta pełna pętla dla partii w pamięci próbki, sto dwadzieścia osiem, oznacza, że co

07:36.020 --> 07:41.720
sto dwadzieścia osiem kroków, cóż, nasza pamięć da nam partię rozmiaru, sto dwadzieścia

07:41.720 --> 07:47.210
osiem, która będzie zawierać ostatnią sto dwadzieścia osiem kroków, które właśnie pokonaliśmy.

07:47.960 --> 07:53.060
Otrzymujemy tylko sześć, sto dwadzieścia osiem partii i uczenie się będzie odbywać się na

07:53.210 --> 07:54.080
tych partiach.

07:54.320 --> 07:58.910
Poza tym w tych partiach będziemy mieć uruchomione tacki kwalifikacyjne, aby uczyć się co 10

07:58.910 --> 07:59.480
kroków.

08:00.230 --> 08:00.620
W porządku.

08:00.620 --> 08:06.950
Więc teraz w tej pętli, która wciąż dzieje się w jednej epoce, ale teraz jesteśmy w określonej

08:06.950 --> 08:07.360
partii.

08:07.790 --> 08:14.060
Więc teraz pierwszą rzeczą, którą zamierzamy zrobić, jest oddzielne uzyskanie naszych danych wejściowych i celu.

08:14.570 --> 08:16.610
A to, jak ci powiedziałem, jest bardzo łatwe.

08:16.610 --> 08:21.290
Możemy to zrobić za pomocą jednego z wdrożonych przez nas narzędzi, jakim jest śledzenie uprawnień.

08:21.620 --> 08:27.950
Jak widać tutaj, ta funkcja śledzenia uprawnień przyjmuje jako dane wejściowe, a teraz mamy partię i

08:28.310 --> 08:32.060
zwroty jako dane wyjściowe, dane wejściowe i cele.

08:32.420 --> 08:37.490
Teraz możemy po prostu stworzyć dwie nowe zmienne, które będą wejściami i

08:37.490 --> 08:38.300
celem.

08:38.690 --> 08:48.080
I czy te dane wejściowe dochodzą do celów, równa się dokładnie temu, co zwraca tę funkcję śledzenia kwalifikowalności stosowaną do

08:48.080 --> 08:48.610
partii.

08:49.010 --> 08:51.950
Więc zastosujemy tę funkcję do wsadu naszej pętli.

08:52.280 --> 08:55.160
Więc to, co zrobimy, to tylko kwalifikowalność.

08:56.460 --> 09:00.110
Ślad zastosowany do partii naszej nadziei.

09:00.660 --> 09:07.110
W porządku, więc to daje nam dane wejściowe i cele, ale w przypadku ciosów zawsze jest coś więcej, co

09:07.110 --> 09:07.850
musimy zrobić.

09:08.100 --> 09:13.530
I oczywiście ma to na celu konwersję danych wejściowych sieci neuronowej, a także celu, na pewne zmienne

09:13.530 --> 09:14.030
tahj.

09:14.340 --> 09:16.170
Ale nie ma też nic nowego.

09:16.200 --> 09:17.310
Wiemy, jak to zrobić.

09:17.490 --> 09:18.450
Możemy to zrobić w ten sposób.

09:18.460 --> 09:24.930
Bierzemy nasze dane wejściowe, potem nasze cele i cóż, będą one równe słowom.

09:25.820 --> 09:26.510
Wejścia.

09:27.750 --> 09:30.210
To na wejście i werbalne.

09:31.150 --> 09:33.580
Cele, a to dla celów.

09:34.090 --> 09:42.250
W porządku, więc dane wejściowe mózgu są zamieniane na pewne zmienne tahj, a cele również są przekształcane w

09:42.250 --> 09:43.900
niektóre zmienne tahj.

09:44.320 --> 09:48.320
Więc teraz możemy uzyskać dane wejściowe do sieci neuronowej.

09:48.640 --> 09:50.530
I dlaczego musimy to zrobić?

09:50.530 --> 09:55.270
Ponieważ następnym krokiem jest uzyskanie prognoz, mamy dane wejściowe, które musimy namierzyć.

09:55.540 --> 09:59.980
Teraz oczywiście potrzebujemy naszych przewidywań, ponieważ wtedy obliczymy stratę między

10:00.190 --> 10:02.120
przewidywaniami a celami.

10:02.890 --> 10:06.350
Więc pobierzmy te prognozy, aby je uzyskać.

10:06.640 --> 10:07.930
Cóż, znowu, to takie proste.

10:07.930 --> 10:14.650
Teraz musimy tylko wziąć nasz mózg, którym jest CNN, nasza konwolucyjna sieć neuronowa, i zastosować go

10:14.830 --> 10:16.730
do naszych danych wejściowych.

10:17.320 --> 10:17.950
No to jedziemy.

10:18.320 --> 10:23.320
Dane wejściowe trafiają do sieci neuronowej, a sieć neuronowa generuje prognozy.

10:24.170 --> 10:29.270
Idealnie, więc teraz mamy prognozy, mamy cele, abyśmy mogli uzyskać prawa i to

10:29.270 --> 10:34.640
jest następny krok, wprowadzimy nowy, więcej, ponieważ teraz otrzymamy ostatni błąd, który jest inny

10:34.790 --> 10:39.660
niż ostatnia funkcja, ponieważ używamy jej jako funkcji do uzyskania ostatniego błędu.

10:40.100 --> 10:50.570
Tak więc mniej błędów tutaj i otrzymamy go z mniejszą liczbą funkcji zastosowanych do naszych prognoz, a cele, do których

10:50.570 --> 10:54.860
idziemy, zobaczą, jak wszystko jest teraz gładkie.

10:55.070 --> 10:56.170
Wszystko jest logiczne.

10:56.180 --> 11:00.590
Najpierw otrzymujemy dane wejściowe, cele, a następnie dzięki danym wejściowym otrzymujemy prognozy.

11:00.590 --> 11:03.800
A potem dzięki przewidywaniom i otrzymanym celom mniej błędów.

11:05.070 --> 11:08.850
Tak bardzo logiczne i płynne, a teraz jaki jest następny krok?

11:09.150 --> 11:14.940
Cóż, ta sama ścieżka logiczna teraz, gdy mamy ostatnią, możemy z powrotem propagować ten mniejszy błąd z powrotem

11:14.940 --> 11:16.890
do nowej sieci, aby zaktualizować wagi.

11:17.190 --> 11:21.540
Robimy to ze stochastycznym zejściem w gradiencie i aby wykonać stochastyczne zejście w gradiencie.

11:21.540 --> 11:24.010
Potrzebujemy naszego optymalizatora, ale już go mamy.

11:24.030 --> 11:26.040
Oto Adam Optimizer.

11:26.430 --> 11:29.010
Ale teraz w tym miejscu pamiętaj, co musimy zrobić.

11:29.370 --> 11:32.380
Musimy go zainicjalizować i zainicjować.

11:32.400 --> 11:40.620
Pamiętaj, bierzemy nasz obiekt optymalizatora, a następnie stosujemy metodę zerowego gradientu.

11:41.440 --> 11:48.220
Idziemy, nie zapominamy o nawiasach, które go inicjalizują, a teraz następnym krokiem jest cofnięcie propagacji

11:48.220 --> 11:55.630
ostatniego błędu z powrotem do nowej sieci i zrobienie tego, w którym bierzemy nasz ostatni błąd

11:55.630 --> 11:58.950
i stosujemy na nim metodę wsteczną.

11:58.960 --> 12:01.800
Więc to jest dokładnie w celu zastosowania propagacji wstecznej.

12:02.110 --> 12:06.380
I wreszcie, teraz, gdy ostatni błąd powrócił, przenieś go do nowej sieci.

12:06.610 --> 12:09.610
Cóż, możemy zaktualizować wagi za pomocą gradientu Cassiego.

12:10.300 --> 12:16.950
Aby to zrobić, pamiętaj, bierzemy nasz optymalizator, a następnie stosujemy metodę krokową.

12:17.500 --> 12:18.210
No to jedziemy.

12:18.400 --> 12:19.900
Wagi są teraz zaktualizowane.

12:20.200 --> 12:25.500
Jak już mówiłem, nie tylko już to zrobiliśmy, ale teraz wydaje się to takie proste i naturalne.

12:26.200 --> 12:28.440
Więc teraz zrobimy coś fajnego.

12:28.600 --> 12:31.650
Zamierzamy wydrukować średnią nagrodę na każdy apoc.

12:31.840 --> 12:35.830
Więc wiesz, możemy śledzić, jak A. JA. idzie, jak idzie szkolenie.

12:36.190 --> 12:40.420
Chcemy zobaczyć, jak średnia nagroda rośnie wraz z krokami, ponad pudełkiem.

12:40.630 --> 12:44.070
Na początku jest oczywiście faza eksploracji.

12:44.080 --> 12:49.690
Więc średnia nagroda może nie wzrosnąć na początku, ale potem, gdy osiągnie fazę eksploatacji,

12:49.690 --> 12:56.050
zobaczymy, że średnia nagroda zdecydowanie wzrośnie i wzrośnie do pewnego poziomu, czyli wtedy, gdy dotrze na

12:56.290 --> 12:58.740
zachód tak szybko, jak możliwy.

12:59.380 --> 13:01.210
Zacznijmy więc od druku.

13:02.200 --> 13:07.660
Wiesz, robimy to w jednym, więc musimy wrócić do bardziej zapętlonego wydruku,

13:07.660 --> 13:12.610
a potem wypisujemy dobrze, najpierw około kolumny, potem procent.

13:12.610 --> 13:18.850
S, ponieważ zamierzamy przekształcić wszystko w ciąg, który jest lepszy, a następnie

13:18.850 --> 13:21.100
dodamy średnią nagrodę.

13:22.490 --> 13:27.620
Następnie dodajemy również procent, a następnie zamykamy wycenę.

13:28.890 --> 13:35.220
A potem dodajemy procent, a po drugiej stronie, wiesz, wprowadzamy zmienne, które będą pierwszą

13:35.220 --> 13:41.430
osobą, ponieważ jest to epicka tutaj i druga zmienna odpowiadająca średniej nagrodzie, która zostanie

13:41.610 --> 13:42.840
obliczona teraz.

13:43.020 --> 13:45.560
Więc średnia zmienna nagrody jeszcze nie istnieje.

13:45.780 --> 13:47.600
Stworzymy go teraz.

13:48.120 --> 13:51.930
Więc zamierzamy używać ETR w pracy.

13:52.470 --> 13:55.440
Nawet jeśli Époque jest liczbą, zamienimy ją na ciąg.

13:55.440 --> 13:57.090
Tak jest lepiej i.

13:58.110 --> 14:03.150
Dodamy, Estie, czy to będzie średnia nagroda, więc utworzymy

14:03.150 --> 14:09.810
zmienną, którą nazwiemy dużą nagrodą, a teraz utworzymy tę zmienną i obliczymy ją ?

14:10.560 --> 14:12.430
OK, więc zróbmy to.

14:12.450 --> 14:13.980
To jedyna rzecz, którą musimy zrobić.

14:13.980 --> 14:15.900
Tak więc Époque już mamy.

14:16.170 --> 14:20.040
Teraz obliczmy średni świat i musimy obliczyć go tutaj.

14:20.130 --> 14:27.090
Wciąż w pętli, ale poza pętlą, ponieważ teraz mamy próbkowanie partii i nasze szkolenie odbywa się

14:27.090 --> 14:28.050
w serii.

14:28.350 --> 14:31.940
Ale teraz propagacja do przodu plus propagacja do tyłu jest wykonywana w partii.

14:32.190 --> 14:39.900
Więc wracamy do pętli i możemy teraz obliczyć skumulowane nagrody, które możemy zrobić z naszym

14:39.900 --> 14:41.100
obiektem insteps.

14:41.430 --> 14:47.910
Ponieważ nasz obiekt insteps zawiera tę funkcję, moglibyśmy wykonać kroki, które pozwolą nam uzyskać skumulowane nagrody, które mają

14:47.910 --> 14:51.250
miejsce w tych krokach, wiesz, podczas wykonywania kroków.

14:51.660 --> 14:57.330
Więc zamierzamy go teraz użyć, aby zaktualizować nowe nagrody za kroki.

14:57.660 --> 15:05.640
Następnie zaktualizujemy obiekt średniej ruchomej, dodając skumulowane nagrody do poruszającego się obiektu codziennego użytku, a

15:05.640 --> 15:07.770
następnie ponownie obliczymy średnią.

15:07.780 --> 15:09.910
W ten sposób otrzymamy średnią nagrodę.

15:10.590 --> 15:11.510
Więc zróbmy to.

15:11.520 --> 15:14.640
Pierwszą rzeczą, której potrzebujemy, są dane dotyczące nagród DARABA.

15:14.970 --> 15:16.950
Nazwijmy je więc nagrodami.

15:18.100 --> 15:27.700
Kroki, a następnie, jak powiedzieliśmy, bierzemy nasz obiekt kroków końcowych, który, przypominam, został tutaj stworzony jako obiekt klasy

15:27.700 --> 15:33.310
natychmiastowego postępu z naszego doświadczenia, który zrażamy tak wrażliwym podmiotem.

15:34.000 --> 15:39.410
Następnie dodajemy nagrody, kroki i kilka nawiasów.

15:39.760 --> 15:40.150
W porządku.

15:40.180 --> 15:43.690
To zapewni nam nowe skumulowane nagrody za kroki.

15:43.990 --> 15:44.500
W porządku.

15:45.310 --> 15:50.800
Ale potem musimy dodać te nowe skumulowane nagrody do naszych ruchomych średnich obiektów.

15:50.980 --> 15:57.760
Aby to zrobić, tym razem mamy metodę w klasie średniej ruchomej, która jest bardzo prostą metodą

15:57.760 --> 15:58.210
reklam.

15:58.220 --> 16:03.190
Bierzemy naszą średnią ruchomą obiekt, który stworzyliśmy tutaj w stu krokach.

16:03.790 --> 16:11.710
Następnie użyjemy naszej metody ADD, a następnie w atmosferze wprowadzimy nasze kroki nagrody, a to doda

16:11.710 --> 16:15.130
nagrody za kroki do średniej ruchomej.

16:15.970 --> 16:16.360
W porządku.

16:16.360 --> 16:21.960
Wreszcie możemy obliczyć średnią nagrodę i dobrze, wiesz, to jest ta sama zmienna.

16:22.690 --> 16:26.440
Więc to będzie równe średniej nagrodzie.

16:26.860 --> 16:33.250
Aby to uzyskać, musimy tym razem użyć metody średniej z naszego obiektu średniej ruchomej.

16:33.700 --> 16:41.470
I to jest robimy i średnia kropkowa tak po prostu, ponieważ nasza średnia ruchoma została już zaktualizowana o nowe

16:41.710 --> 16:45.520
kroki nagród, które właśnie dodaliśmy do metody ADD.

16:46.430 --> 16:46.890
Wspaniały.

16:46.960 --> 16:52.990
Więc teraz mamy naszą średnią nagrodę, więc to jest naprawdę popularne i to będzie drukowane każdego roku.

16:53.420 --> 16:54.990
W porządku, więc skończyliśmy.

16:55.030 --> 16:57.170
Tak więc nie mogę się doczekać wyników.

16:57.170 --> 17:01.670
I faktycznie, w następnym samouczku będę miał dla Ciebie niespodziankę, oglądając wyniki.

17:01.700 --> 17:03.380
Więc to będzie całkiem ekscytujące.

17:03.650 --> 17:06.740
Więc teraz chyba pora pobawić się powietrzem i dobrze się bawić.

17:07.610 --> 17:08.060
W porządku.

17:08.060 --> 17:11.240
Dlatego przygotuj sobie dobrą kawę lub dobrą herbatę.

17:11.480 --> 17:17.410
Teraz nadszedł czas, aby usiąść wygodnie w naszym fotelu i obejrzeć kilka bardzo fajnych filmów o naszym samolocie, aby zobaczyć, o czym

17:17.430 --> 17:18.760
mowa w następnym samouczku.

17:18.770 --> 17:20.160
I do tego czasu baw się dobrze.
