WEBVTT

00:00.390 --> 00:02.710
Witam i zapraszam do przyprawy Intertoto.

00:03.000 --> 00:07.800
W porządku, więc w tej nowej sekcji kodu zamierzamy wprowadzić doświadczenie z grą.

00:07.920 --> 00:13.850
Zrobimy więc nową klasę, którą nazwiemy pamięcią powtórki i która zaimplementuje doświadczenie, by grać dokładnie

00:13.850 --> 00:16.700
tak, jak widzieliście w wykładach intuicyjnych.

00:16.890 --> 00:21.540
Najpierw jednak przypomnijmy, co jest powtórką doświadczenia.

00:21.540 --> 00:27.750
Więc wiesz, że cała ta sztuczna inteligencja jest oparta na procesach decyzyjnych Markowa, a

00:27.750 --> 00:31.840
proces decyzyjny Markowa polega na oglądaniu serii wydarzeń.

00:32.010 --> 00:38.770
Więc wydarzenia są znane, na przykład przechodząc od jednego stanu do następnego stanu i tipis jeden.

00:39.060 --> 00:44.410
Ale jeśli wydarzenia były tak dobre, od następnego dnia są bardzo skorelowane z obecnym stanem.

00:44.550 --> 00:46.820
Cóż, sieć nie radziłaby sobie zbyt dobrze.

00:46.980 --> 00:52.710
Tak więc dla tych, którzy przybyli z kursu głębokiego uczenia się dokładnie tak samo, jak w przypadku, gdy nauczyliśmy się

00:52.710 --> 00:54.860
naszych szeregów czasowych z tylko jednym taktem.

00:55.020 --> 01:00.300
Nie uczył się niczego, ponieważ jeden czas nie był wystarczający, aby model

01:00.300 --> 01:03.070
mógł nauczyć się rozumieć długoterminowe korelacje.

01:03.090 --> 01:07.060
Więc to jest to samo i dlatego musimy wprowadzić powtórkę doświadczenia.

01:07.230 --> 01:08.230
Jak to działa.

01:08.340 --> 01:13.960
Cóż, to bardzo proste, zamiast tylko brać pod uwagę obecny stan, który jest tylko jednym stanem w

01:13.960 --> 01:14.640
czasie t.

01:14.680 --> 01:16.830
Zamierzamy rozważyć więcej w przeszłości.

01:16.830 --> 01:22.560
Tak samo jak w przypadku litów, a zatem nasza seria wydarzeń nie będzie taka.

01:22.560 --> 01:27.450
I przypuszczam, że będzie to na przykład sto stanów w przeszłości.

01:27.450 --> 01:33.770
Zatem jako T-minus sto osiemdziesiąt minus 99 aż do minus 1, a następnie S-T.

01:34.020 --> 01:40.830
Innymi słowy, wprowadzamy 100 mniej przejść do pamięci, którą nazywamy pamięcią, i dlatego mamy pamięć długotrwałą

01:40.830 --> 01:47.040
w przeciwieństwie do pamięci krótkotrwałej, a nawet powinienem powiedzieć natychmiastową pamięć i to sprawia,

01:47.040 --> 01:49.950
że cały proces działa znacznie lepiej.

01:50.310 --> 01:57.690
A potem, gdy stworzymy pamięć ostatnich 100 zdarzeń, będzie to proste, że zajmiemy kilka

01:57.690 --> 02:02.300
losowych partii tych przejść, aby dokonać kolejnej aktualizacji.

02:02.310 --> 02:09.270
To jest nasz następny ruch, wybierając następną sekcję, a zatem w tej klasie pamięci powtórek,

02:09.270 --> 02:13.450
którą implementujemy do odtwarzania powtórzeń, wykonamy trzy funkcje.

02:13.530 --> 02:17.490
Przede wszystkim funkcja jak zwykle ma miejsce w przypadku każdej klasy.

02:17.520 --> 02:23.400
I tak w tej funkcji określimy zmienne, które będą dołączone do przyszłych wystąpień klasy, która

02:23.400 --> 02:27.210
jest przyszłymi obiektami, które zostaną utworzone z tej klasy.

02:27.540 --> 02:32.790
I tak po prostu te zmienne będą pamięcią 100 przejść do 100 zdarzeń.

02:32.970 --> 02:38.790
A pojemność, która jest liczbą 100, pozwoli ci wypróbować dłuższe wspomnienie, zwiększając

02:38.790 --> 02:39.550
pojemność.

02:39.780 --> 02:46.170
Jest to więc pierwsza funkcja w nim działająca, a następnie udostępnimy dwie inne funkcje, jedną funkcję push,

02:46.500 --> 02:51.050
aby upewnić się, że pamięć nie zawiera więcej niż 100 przejść.

02:51.180 --> 02:57.150
W tym celu wykorzystamy pojemność, wykonując jeden prosty warunek, a następnie ostatecznie

02:57.360 --> 03:03.300
wykonamy prostą funkcję, która będzie oczywiście próbą pewnych przejść w pamięci

03:03.390 --> 03:05.060
ostatnich 100 przejść.

03:05.520 --> 03:08.440
W porządku, zacznijmy od wprowadzenia klasy.

03:08.520 --> 03:17.460
Jak wiesz, zaczynamy od klasy, a następnie przekazujemy je klasie, którą nazywamy pamięcią powtórzenia, a

03:17.460 --> 03:25.500
następnie w nawiasach wstawiamy obiekt, następnie Cullin, a następnie zaczynamy od pierwszej funkcji.

03:25.560 --> 03:26.860
Koniec jest funkcją.

03:27.150 --> 03:30.730
Więc to dokładnie to samo, co przed rozpoczęciem śmierci.

03:30.870 --> 03:36.750
Następnie dwa podkreślenia w nim dwa ponownie podkreślają, a następnie zmienne.

03:36.750 --> 03:42.750
Więc istnieje oczywiście jaźń, która jest zmienną związaną z przyszłymi instancjami klasy

03:42.750 --> 03:48.810
przyszłych obiektów, a następnie będziemy mieć kolejną zmienną, abyś mógł spróbować innych doświadczeń

03:48.810 --> 03:52.950
z niektórymi wspomnieniami i to będzie być pojemnością.

03:52.950 --> 03:58.020
Więc ta zdolność będzie po prostu liczbą sto, ponieważ zamierzamy doświadczyć,

03:58.020 --> 04:00.960
aby grać ze stoma mniejszymi przejściami.

04:00.960 --> 04:03.910
W porządku, a potem Collon. Idziemy.

04:03.930 --> 04:10.430
Wejdźmy do funkcji i określmy zmienne naszego obiektu pamięci replay.

04:10.440 --> 04:19.400
Tak więc pierwsza z nich będzie zdolnością samokształceniową i jak zapewne zrozumieliście, będzie to maksymalna

04:19.670 --> 04:24.690
liczba przejść, jakie chcemy mieć w pamięci zdarzeń.

04:24.830 --> 04:30.980
I będzie to równe argumentom, które wprowadzą podczas tworzenia obiektu klasy pamięci

04:31.000 --> 04:34.530
powtórzeń, a zatem jest to pojemność.

04:34.550 --> 04:36.480
To jest argument funkcji init.

04:36.660 --> 04:38.180
Więc pojemność.

04:38.180 --> 04:44.960
Więc znowu nie mylić siebie, że pojemność jest nazwą zmiennej, która jest dołączona

04:45.470 --> 04:52.670
do obiektu, a pojemność tutaj jest argumentem, który wprowadzi podczas tworzenia obiektu klasy pamięci powtórki.

04:52.810 --> 04:53.620
W porządku.

04:53.830 --> 04:55.880
A potem mamy drugiego wojewodę.

04:56.170 --> 04:57.890
To oczywiście pamięć.

04:58.000 --> 05:01.620
Tak samo uczony Nemec.

05:01.760 --> 05:02.650
W porządku.

05:02.800 --> 05:05.730
I do czego będzie potrzebne to wspomnienie Wojewody.

05:05.990 --> 05:13.950
Cóż, ta pamięć ma zawierać ostatnie 100 zdarzeń i dlatego powinien to być prosty test.

05:14.100 --> 05:20.300
Znasz listę, która będzie zawierać 100 ostatnich zdarzeń ostatnich 100 przejść i zainicjować

05:20.300 --> 05:20.850
listę.

05:20.870 --> 05:24.620
Nie ma nic prostszego, po prostu dodajemy takie nawiasy.

05:24.740 --> 05:26.040
I oto idziemy.

05:26.060 --> 05:31.490
Nasza pamięć jest inicjowana, więc oczywiście na początku eksperymentu lub dokładniej na

05:31.490 --> 05:36.430
początku eksploracji pamięć będzie pustą listą, a następnie wprowadzimy przejścia.

05:36.500 --> 05:38.350
Za każdym razem, gdy osiągamy przyszły stan.

05:38.600 --> 05:43.370
I mówiąc o tym, właśnie to zrobimy z następną funkcją, którą nazwiemy

05:43.520 --> 05:44.720
funkcją wypychania.

05:44.790 --> 05:51.380
Uczynimy tę funkcję wypychania, aby obsadzić zdarzenia na tej liście pamięci, a następnie wykorzystamy pojemność, aby

05:51.620 --> 05:57.170
upewnić się, że ta lista pamięci zawiera zawsze 100 zdarzeń i nigdy więcej.

05:57.500 --> 05:59.660
W porządku, zróbmy to również w następnym.

05:59.690 --> 06:01.250
I do tego czasu I.
