WEBVTT

00:00.270 --> 00:02.590
Cześć i witamy w tutorialu Python.

00:02.820 --> 00:08.730
W porządku, więc dzisiaj zrobimy funkcję aktualizacji, która zaktualizuje wszystko, co jest do tej

00:08.850 --> 00:12.240
pory, gdy tylko oka dojdzie do nowego stanu.

00:12.510 --> 00:16.140
Kiedy osiągnie nowy etap, wiesz, że musimy zaktualizować akcję.

00:16.200 --> 00:19.320
Ostatni to właściwie nowa gra, która właśnie została zagrana.

00:19.530 --> 00:22.630
Ale także ostatnia data, która staje się nowym stanem.

00:22.680 --> 00:27.450
I wreszcie ostatnie słowo, które staje się nowym słowem, które otrzymujemy, gdy gramy akcję.

00:27.480 --> 00:31.480
Tak więc jest to logiczna ścieżka, która dzieje się zaraz po wybraniu akcji.

00:31.530 --> 00:35.100
Musimy zaktualizować wszystkie elementy przejść.

00:35.310 --> 00:37.370
I oczywiście dostaniesz nowe przejście.

00:37.420 --> 00:40.300
Musimy więc dołączyć to nowe przejście do pamięci.

00:40.350 --> 00:46.200
I w końcu zaktualizujemy lub nagrodzimy okno, aby wiedzieć, jak przebiega

00:46.200 --> 00:49.460
szkolenie i jak przebiega eksploracja.

00:49.680 --> 00:55.380
Ale najważniejsze, abyś zrozumiał, że teraz możemy w końcu stworzyć związek pomiędzy sztuczną inteligencją,

00:55.530 --> 01:01.650
którą teraz wdrażamy, a naszą mapą, ponieważ jeśli wrócimy do naszej mapy, pamiętaj, że ta

01:01.650 --> 01:08.580
funkcja Beiji jest włączona do klasy gry i Właśnie tam robiliśmy grę z samochodem i określiliśmy, w

01:08.580 --> 01:12.940
jaki sposób samochód powinien zostać ukarany, gdy popełni błąd.

01:13.170 --> 01:19.140
Ale w tej klasie gry zauważyliśmy tę funkcję aktualizacji i w tej funkcji aktualizacji

01:19.500 --> 01:24.700
zauważyliśmy tę akcję linii, ponieważ aktualizacja mózgu na końcu pracowaliśmy mniej sygnału.

01:24.900 --> 01:28.410
I faktycznie to właśnie zamierzamy zrobić.

01:28.410 --> 01:36.300
Niedługo uruchomimy tę funkcję aktualizacji, która zajmie ostatnie słowo i ostatni sygnał, aby uzyskać kolejną akcję

01:36.300 --> 01:37.860
do odegrania.

01:37.860 --> 01:41.640
Nie tylko zaktualizuje wszystkie różne elementy przejścia.

01:41.910 --> 01:48.390
Ale przede wszystkim będziemy grać akcję, którą powinniśmy zagrać, gdy otrzymamy ostatnie

01:48.390 --> 01:55.920
słowo i ostatni sygnał, więc oczywiście w tej funkcji aktualizacji użyjemy właśnie wybranej funkcji

01:55.920 --> 02:02.400
działania, zanim zintegrujemy funkcję wyboru akcji w przyszłą funkcję aktualizacji, którą zamierzamy

02:02.400 --> 02:07.740
wprowadzić, aby wybrać kierunek gry oprócz robienia wszystkich aktualizacji.

02:07.860 --> 02:11.200
Tak więc bardzo ważne jest teraz nawiązanie tego połączenia z mapą.

02:11.310 --> 02:18.480
To, co zaraz zrobimy, to połączenie naszego oka z grą, którą tworzymy w

02:18.480 --> 02:19.750
tej klasie.

02:19.770 --> 02:24.030
Teraz możemy wykonać tę aktualizację bezpośrednio.

02:24.060 --> 02:29.970
Ostatni byliśmy mniejszym sygnałem, ponieważ taka jest właśnie funkcja, którą będziemy wykonywać za pomocą tych dwóch argumentów

02:29.970 --> 02:30.430
tutaj.

02:30.720 --> 02:38.530
I podobnie jak szybkie przypomnienie mózgu jest naszym obiektem sztucznej inteligencji, który jest obiektem klasy Dejuan.

02:38.540 --> 02:45.690
Więc teraz zrobimy, że skopiujemy tę aktualizację mniejszym sygnałem dźwiękowym, a to będzie nasza

02:45.690 --> 02:48.390
kolejna funkcja, którą tworzymy.

02:48.480 --> 02:54.120
A zatem i wklejając to tutaj, aby zachować ostrożność, chciałbym podać trochę inne nazwy

02:54.120 --> 02:56.190
niż te, które mamy tutaj.

02:56.200 --> 03:00.820
Wiesz, że mamy tu ostatnie słowo i nie chcę mylić tego ostatniego słowa z tym.

03:00.900 --> 03:02.060
To może być niebezpieczne.

03:02.220 --> 03:06.100
Zamierzam zastąpić ostatnie słowo tutaj słowem.

03:06.390 --> 03:13.880
A przy okazji tak samo dla mniejszego sygnału, po prostu daj sygnał, a nawet nowy sygnał, aby określić, że wiesz,

03:13.920 --> 03:18.900
że chcemy to zmierzyć, gdy osiągniemy nowy stan, a zatem otrzymamy nowy sygnał.

03:18.900 --> 03:26.100
Ale oczywiście to słowo tutaj będzie ostatnią nagrodą, którą tu otrzymamy.

03:26.280 --> 03:32.400
Wiesz, kiedy wchodzisz na piasek lub gorzej docierasz zbyt blisko krawędzi mapy, gdzie

03:32.670 --> 03:34.130
definiujemy ostatnie słowo.

03:34.200 --> 03:39.400
To ostatnie słowo będzie wprowadzeniem funkcji aktualizacji, dlatego mamy tu ostatnie słowo.

03:39.600 --> 03:43.660
Ale właśnie tutaj podaję inną nazwę dla argumentu.

03:43.710 --> 03:47.640
Nie chcemy tego mylić z ostatnim słowem tutaj.

03:47.640 --> 03:50.160
W porządku, więc to jest funkcja aktualizacji.

03:50.310 --> 03:54.090
A teraz wejdźmy do środka i zróbmy te dwie rzeczy.

03:54.090 --> 03:58.970
To są dane wszystkich elementów naszego przejścia i oczywiście wybierz akcję.

03:59.290 --> 04:01.670
OK, więc co musimy najpierw zaktualizować.

04:01.950 --> 04:06.760
Jak rozumiesz, chcemy umówić się na randkę, kiedy osiągniemy jakikolwiek stan.

04:06.840 --> 04:12.800
Tak więc pierwszą rzeczą, którą będziemy aktualizować, jest oczywiście ta wiadomość, że to jest wiadomość, do której docieramy.

04:12.840 --> 04:17.340
Więc zamierzam nazwać ten nowy stan nowym państwem, a potem to nastąpi.

04:17.340 --> 04:19.810
A więc jak możemy uzyskać ten nowy stan.

04:20.040 --> 04:25.460
Oczywiście zależy to od sygnału, jaki nowy sygnał wykrywają właśnie czujniki.

04:25.830 --> 04:32.760
I jako przypomnienie stan jest samym sygnałem złożonym z trzech sygnałów, że czujniki sygnalizują jeden

04:32.760 --> 04:37.470
sygnał do sygnalizowania trzech plus orientacji i orientacji ujemnej.

04:37.530 --> 04:38.600
To nasz stan.

04:38.610 --> 04:42.470
Dlatego upewnij się, że sygnał jest stanem.

04:42.660 --> 04:46.160
Ale teraz jest to prosta lista pięciu elementów.

04:46.200 --> 04:51.540
A ponieważ będzie to sygnał wejściowy do wykonania całej tej pracy, pamiętaj, że musimy ją przekonwertować na

04:51.540 --> 04:52.200
czujnik palnika.

04:52.490 --> 04:54.960
Tak właśnie zrobimy teraz.

04:54.960 --> 05:03.910
Weźmiemy naszą bibliotekę pochodni, a potem weźmiemy tam klasę tensorów, która zamieni nasz nowy sygnał w gęstszą

05:04.450 --> 05:12.420
pochodni, lepiej więc upewnić się, że wszystkie elementy pochodni, które mają odpowiedzieć, są pływakami, więc

05:12.420 --> 05:19.650
zamierzam Wykonaj konwersję typu, aby przekonwertować je do postaci pływających w ten sposób.

05:19.900 --> 05:24.500
A potem wreszcie spróbuj odruchu tego, co musimy zrobić dalej.

05:24.530 --> 05:29.590
Oczywiście do stworzenia tego fałszywego silnika dodajemy diamenty i korespondujemy

05:29.590 --> 05:37.080
z partią, a robimy to oczywiście z funkcją ściśnięcia, do której musimy wstawić indeks tego dużego diamentu.

05:37.100 --> 05:40.210
I chcemy dla partii, która wynosi zero.

05:40.770 --> 05:41.320
W porządku.

05:41.320 --> 05:47.110
Teraz mamy nowe stany złożone z trzech sygnałów z trzech czujników plus

05:47.110 --> 05:54.290
orientacja minus orientacja i oczywiście zależy to od nowego sygnału, który otrzymujemy dzięki tej funkcji aktualizacji.

05:54.400 --> 05:57.940
Dokładnie w tym momencie ostatni sygnał otrzymujemy trzy sygnały.

05:57.940 --> 06:04.450
Więc dodatkowo minus lub dodatkowo i jako przypomnienie trzy sygnały to gęstość czujnika

06:04.720 --> 06:06.490
wykrytego wokół czujników.

06:06.490 --> 06:06.940
W porządku.

06:06.970 --> 06:13.710
Więc mamy nowy etap, więc oznacza to, że osiągnęliśmy nowy etap i teraz musimy dokonać kolejnej aktualizacji.

06:13.750 --> 06:16.440
Więc według ciebie, co musimy teraz zaktualizować.

06:16.660 --> 06:22.320
Jaka byłaby logiczna rzecz do tej pory, po osiągnięciu tego nowego stanu.

06:22.630 --> 06:25.940
Cóż, teraz potrzebujemy pamięci.

06:25.960 --> 06:27.010
Dlaczego.

06:27.010 --> 06:34.200
Dzieje się tak, ponieważ za każdym razem t przejście składa się z obecnego stanu Estey następnego dnia jako

06:34.220 --> 06:37.660
tipis, gdy nagrodą jest arti i akcja 80.

06:37.860 --> 06:44.020
A teraz mamy już S-T, mamy już nasz zespół i mamy już 80 i

06:44.020 --> 06:47.540
właśnie dostaliśmy ostatni element przejścia Estep plus jeden.

06:47.590 --> 06:55.720
Tak więc, zdobywając ten nowy stan tak głęboki jak jeden, otrzymujemy jedno całkowicie nowe przejście pamięci i dlatego musimy dołączyć

06:55.720 --> 07:01.910
to zupełnie nowe przejście do pamięci, ponieważ jest to po prostu nasza następna transformacja.

07:01.930 --> 07:03.980
Dlatego właśnie mamy tę pamięć teraz.

07:04.120 --> 07:10.990
I dlatego zamierzam zrobić, że mój obiekt pamięciowy zostanie utworzony z klasy

07:10.990 --> 07:17.130
pamięci powtórzeń i dlatego zamierzam zabrać swoją pamięć do obiektu.

07:17.160 --> 07:22.700
Ale odkąd używam siebie, muszę włączyć jaźń w tę funkcję.

07:22.950 --> 07:25.440
Teraz możesz naprawdę zobaczyć, do czego służy ta jaźń.

07:25.550 --> 07:32.600
Za każdym razem, gdy użyjesz jednej zmiennej, która została utworzona i zainicjalizowana w funkcji init, będzie to pamięć.

07:32.600 --> 07:33.960
A teraz to zrobiliśmy.

07:34.190 --> 07:36.950
I według ciebie, jak to zaktualizujemy.

07:37.160 --> 07:41.290
Dobra wiadomość jest taka, że już zrobiliśmy funkcję, aby to zrobić.

07:41.300 --> 07:46.990
Jest to funkcja push, która blokuje wydarzenie lub przejście do pamięci.

07:47.190 --> 07:49.060
Właśnie tego teraz będziemy używać.

07:49.070 --> 07:55.460
Zamierzamy użyć funkcji wypychania do zapisania naszej nowej transformacji, którą właśnie wprowadziliśmy do pamięci i

07:55.760 --> 08:01.820
dlatego nie biorę równych sobie, ponieważ zamierzamy użyć tej metody i dlatego możemy

08:02.320 --> 08:04.200
bezpośrednio użyć tego pchnięcia.

08:04.280 --> 08:10.010
Najpierw dodam przejście, które właśnie otrzymaliśmy, i to jest ostatnia

08:10.010 --> 08:10.780
data.

08:10.850 --> 08:14.010
Więc siebie, ta ostatnia randka.

08:14.270 --> 08:18.680
To jest S-T To właśnie to już istnieje.

08:18.680 --> 08:23.620
Kolejnym elementem tego przejścia jest oczywiście nowy stan, który właśnie osiągnęliśmy.

08:23.840 --> 08:29.720
A zatem, ponieważ nie jest on wykonalny z obiektu, który stworzyliśmy i zainicjowaliśmy w tej funkcji init,

08:30.080 --> 08:31.470
nie stawiamy się tutaj.

08:31.580 --> 08:39.940
Bezpośrednio umieszczamy Newstead, następnie kolejnym elementem transformacji jest akcja i mówimy, że mamy już ostatnią sekcję, która

08:39.940 --> 08:43.690
jest tą jaźnią, tą ostatnią akcją tutaj.

08:43.840 --> 08:45.320
Więc oczywiście jest równa zero.

08:45.350 --> 08:50.050
Ale wtedy oczywiście zostanie zaktualizowany za pomocą funkcji wyboru akcji.

08:50.170 --> 08:51.190
Ale to jest ten.

08:51.190 --> 08:55.620
Więc to jest samo, to ostatnie działanie.

08:55.840 --> 08:57.120
Ale teraz bądź ostrożny.

08:57.190 --> 09:01.540
Elementy, które zostały uwzględnione w tym przejściu, powinny być wszystkie podpalonymi odpowiedziami.

09:01.870 --> 09:03.860
Jak widać, tak jest w przypadku ostatniej daty.

09:03.880 --> 09:05.200
To czujnik palnika.

09:05.350 --> 09:07.860
Nowy stan jest również podpaloną odpowiedzią.

09:07.900 --> 09:12.050
I tak musi być to samo dla akcji, a następnie oczywiście z nagrody.

09:12.190 --> 09:17.320
Ale teraz pomyślisz, jak to może być podpalona odpowiedź, biorąc pod uwagę, że to po prostu liczba.

09:17.410 --> 09:20.700
Wiesz, że akcja to 0 1 lub 2.

09:20.890 --> 09:22.370
Ale w rzeczywistości to nie problem.

09:22.390 --> 09:28.640
Nadal możemy przekształcić tę zmienną 0 1 lub 2 w czujnik palnika.

09:28.660 --> 09:31.530
To będzie właśnie to, co nazywamy długim tensorem.

09:31.540 --> 09:36.910
Long jest typem i jest to tensor, który będzie zawierał liczbę całkowitą, ponieważ ostatnia akcja to

09:36.910 --> 09:39.660
liczba całkowita równa 0 1 lub 2.

09:39.670 --> 09:47.650
Więc teraz weźmiemy naszą bibliotekę torche, a następnie zajmiemy się długą klasą tensorów,

09:48.190 --> 09:53.470
która stworzy obiekt, który sam będzie nieuregulowany.

09:53.710 --> 10:00.370
Przyjmując tę funkcję samo-działania jako dane wejściowe, utworzy on ten długi obiekt tensora, ale nadal

10:00.370 --> 10:08.590
będzie zawierał 0 1 lub 2 w długim tensorze, a to jest zgodne z przejściem, które zawiera tylko tensory,

10:08.830 --> 10:14.070
ponieważ jesteśmy praca z latarką PI i pracujemy z siecią neuronową.

10:14.170 --> 10:18.480
Musimy więc pracować z czujnikami, abyśmy mogli długo czekać na odpowiedź.

10:18.580 --> 10:20.780
I ostatnia konwersja do zrobienia.

10:20.860 --> 10:27.520
Musimy być pewni, że to, co jest w środku tej długiej odpowiedzi, jest liczbą całkowitą i aby

10:27.520 --> 10:34.000
się upewnić, nawet jeśli wiemy już, że ostatnia czynność to 0 1 lub 2, aby upewnić

10:34.000 --> 10:39.310
się, że zamierzamy ponownie dokonać konwersji typu int. ostatnia akcja na liczbę całkowitą.

10:39.310 --> 10:46.450
Idziemy tam, a następnie musimy umieścić tę bezinteresowną liczbę całkowitą w nawiasach właśnie tutaj, abyśmy teraz

10:46.450 --> 10:52.810
otrzymali długi tensor jednego elementu, który będzie ostatnim działaniem 0 lub 1 lub 2.

10:52.810 --> 10:59.880
Kluczową sprawą jest to, w jaki sposób konwertujesz prostą liczbę zero lub dwie na tensor z torche.

11:00.060 --> 11:00.360
W porządku.

11:00.360 --> 11:06.820
I wreszcie ostatni element przejścia i to oczywiście ostatnie słowo, które otrzymaliśmy.

11:06.880 --> 11:12.980
To jest właśnie ostatnia siatkówka, którą stworzyliśmy w każdej funkcji, która została zainicjowana do zera.

11:13.110 --> 11:19.720
Ale oczywiście jest aktualizowany tutaj, w tym kodzie, albo gdy przechodzimy do jakiegoś sensu, który jest negatywnym słowem,

11:19.770 --> 11:24.020
albo gdy oddalamy się od celu, który jest ponownie negatywną nagrodą.

11:24.180 --> 11:30.090
Jeśli zbliżyliśmy się do celu, który jest pozytywną nagrodą i najgorszą karą, jeśli znajdziemy się zbyt

11:30.090 --> 11:34.080
blisko krawędzi mapy. Cóż, to straszne negatywne słowo minus jeden.

11:34.290 --> 11:36.190
I to jest.

11:36.260 --> 11:40.810
Dodajmy więc ten ostatni element przejścia, by samokierować słowo.

11:41.060 --> 11:47.660
Więc kopiuję to wklejanie tutaj i teraz musimy dokonać kolejnej konwersji, która będzie oczywiście dokładnie taka

11:47.750 --> 11:53.570
sama jak ta tylko dlatego, że słowo nie jest liczbą całkowitą, ale liczbą zmiennoprzecinkową.

11:53.780 --> 12:00.350
Zrobimy po prostu pochodnię konwersji tensorów, ale bez tego zachowamy tutaj nawiasy, ponieważ wiesz najpierw, że

12:00.350 --> 12:06.200
musimy umieścić numer na liście, a potem ta lista pójdzie i umieści pochodnię w klasie,

12:06.200 --> 12:11.510
ale nie mamy aby to zmienić, ponieważ ostatnie słowo jest liczbą zmiennoprzecinkową.

12:11.510 --> 12:21.400
To, co mamy zamiar zrobić, to po prostu dodać tutaj tensor torche dot spalony tensor, a następnie nawiasy nawiasów.

12:21.680 --> 12:27.470
I zamierzamy zamknąć tutaj nawiasy i zamknąć nawias.

12:27.470 --> 12:28.820
No to jedziemy.

12:28.820 --> 12:35.180
Podsumowując Co powiedziałeś, że właśnie osiągnęliśmy i słowo, które obserwujemy, to nowe wydarzenie przejścia, które

12:35.540 --> 12:37.150
dodajemy do pamięci.

12:37.550 --> 12:44.240
To przejście zawiera ostatnią datę i nowy stan to tipis, gdy ostatnia akcja

12:44.540 --> 12:47.640
gra 80, a ostatnie słowo Archie.

12:48.020 --> 12:48.390
W porządku.

12:48.440 --> 12:51.220
A teraz idziemy z naszą pamięcią dat.

12:51.410 --> 12:55.710
Zróbmy więc krótką przerwę, a my zajmiemy się kolejną aktualizacją w następnym samouczku.

12:55.970 --> 12:57.440
Do tego czasu I.
