WEBVTT

00:00.240 --> 00:02.790
Cześć i witamy w tutorialu Python.

00:02.790 --> 00:07.230
W porządku mamy ostatnią funkcję do implementacji w naszej klasie pamięci powtórek.

00:07.230 --> 00:12.060
To jest prosta funkcja i oczywiście chcemy pobrać losowe próbki z naszej pamięci.

00:12.210 --> 00:16.080
I dlatego funkcja ta zwróci te losowe próbki.

00:16.080 --> 00:17.850
W porządku, więc wejdźmy do tego.

00:17.870 --> 00:20.630
Nazwiemy to prosto.

00:20.640 --> 00:21.330
No to ruszamy.

00:21.420 --> 00:25.030
Ta funkcja pobiera dwa argumenty jako dane wejściowe.

00:25.260 --> 00:32.490
Pierwszy jak zwykle sam nasz przyszły obiekt do powtórzenia klasy pamięci, a drugim argumentem jest próba

00:32.490 --> 00:33.430
odgadnięcia.

00:33.510 --> 00:40.290
Cóż, pobieramy próbki o ustalonym rozmiarze i dlatego musimy wybrać rozmiar dla próbek, a dokładniej

00:40.290 --> 00:42.610
nazywamy to wielkością partii.

00:42.820 --> 00:47.910
To jest nazwa, którą zamierzamy nadać naszemu drugiemu argumentowi wielkości partii.

00:48.180 --> 00:49.530
I oto idziemy.

00:49.560 --> 00:54.490
Mamy nasze dwa argumenty i teraz możemy zaimplementować prostą funkcję.

00:54.500 --> 01:00.780
Więc teraz chcę cię ostrzec, że to będzie trochę techniczne, ale postaram się wszystko wyjaśnić.

01:01.250 --> 01:05.140
Zaczniemy od utworzenia zmiennej próbek.

01:05.150 --> 01:09.620
Jest to tylko zmienna, która będzie zawierała próbki pamięci.

01:09.620 --> 01:11.340
W porządku, tak proste jest równe.

01:11.360 --> 01:14.090
A więc jak mamy zdobyć te próbki.

01:14.450 --> 01:20.960
Przede wszystkim musimy wziąć naszą pamięć, ponieważ pobieramy próbki z naszej pamięci.

01:20.960 --> 01:26.870
Wtedy prawdopodobnie będziemy potrzebować wielkości partii, ponieważ próbki będą zawierały wielkość partii

01:26.930 --> 01:27.720
Elona.

01:27.830 --> 01:33.920
Potrzebujemy pamięci, potrzebujemy partii, a następnie potrzebujemy trochę torche lub sztuczek żubrów, aby uzyskać dobry

01:34.040 --> 01:35.600
format tych próbek.

01:35.600 --> 01:40.790
Więc co zamierzam zrobić, napiszę linię kodu, a następnie wyjaśnię ten element

01:40.790 --> 01:41.900
po elemencie.

01:41.990 --> 01:42.860
Więc zróbmy to.

01:42.860 --> 01:48.580
Zaczynam od skorzystania z funkcji zip, wyjaśnię bardzo szybko, co robi.

01:48.620 --> 01:51.980
Wewnątrz tej funkcji dodam gwiazdę.

01:52.100 --> 01:53.800
Mam zamiar również to rozwinąć.

01:53.900 --> 02:02.600
Gwiazda i przypadkowe myślenie Centralne, tak przypadkowe, jak się domyślasz, to losowa biblioteka, którą tutaj

02:02.600 --> 02:03.360
zaimportowaliśmy.

02:03.410 --> 02:08.900
To główny powód, dla którego musieliśmy zaimportować te losowe biblioteki, ponieważ pobieramy losowe

02:08.900 --> 02:09.730
próbki.

02:10.040 --> 02:15.570
Z tej przypadkowej biblioteki skorzystamy z prostej funkcji.

02:15.600 --> 02:20.060
Więc to są nasze zmienne i to jest funkcja, więc zamierzam dodać trochę nawiasów.

02:20.210 --> 02:26.110
A teraz, jak widać, próbka jest funkcją i musimy podać kilka argumentów, aby można

02:26.110 --> 02:27.850
było zobaczyć pierwszy argument.

02:27.850 --> 02:34.660
A właściwie mówiąc o sobie, odpowiada to pamięci samoprzypadkowej pamięci o naszym przyszłym obiekcie instancji naszej

02:34.870 --> 02:36.970
pamięci powtórkowej dla nas.

02:37.180 --> 02:44.290
Zamierzam tu dodać do siebie tę pamięć, a potem drugi argument, tak jakbyś domyślił się rozmiaru

02:44.530 --> 02:51.360
Bechuany, który losowo wyjął z naszej pamięci i nadaliśmy mu nazwę, która jest wielkością partii.

02:51.550 --> 02:55.690
Więc drugim argumentem będzie Bachche do bani.

02:55.870 --> 02:56.410
W porządku.

02:56.470 --> 03:01.080
Więc wiersz kodu jest wpisany i zamierzam wyjaśnić, co robi.

03:01.510 --> 03:08.260
Przede wszystkim z tą funkcją losowej kropki pobieramy kilka losowych próbek z pamięci

03:08.800 --> 03:11.820
o ustalonym rozmiarze tego rozmiaru.

03:12.550 --> 03:13.940
To zrozumiałe.

03:14.150 --> 03:18.230
Ale co robi ta funkcja gwiazdy Zipp?

03:18.530 --> 03:20.500
Cóż, nie ma w tym tajemnicy.

03:20.540 --> 03:22.870
To jest tak jak funkcja przekształcenia.

03:22.880 --> 03:28.460
Na przykład zamierzam dodać trochę tutaj, aby wyjaśnić, że zamierzam go usunąć.

03:28.460 --> 03:34.680
Załóżmy na przykład, że mamy na przykład listę następujących elementów.

03:34.820 --> 03:37.900
Najpierw jeden dwa trzy.

03:38.180 --> 03:39.680
A potem drugi element.

03:39.680 --> 03:43.180
Cztery pięć sześć.

03:43.190 --> 03:48.020
Mamy więc listę dwóch dubli trzech elementów jeden dwa trzy cztery pięć sześć.

03:48.380 --> 03:52.690
No cóż, jeśli zastosuję funkcję zip z gwiazdką.

03:52.880 --> 04:02.840
Cóż by się stało, że lista gwiazd Zip będzie równa nowej liście, ale o innym

04:03.380 --> 04:12.440
kształcie, a inny kształt będzie jeden dla dwóch, a potem trzech sześciu.

04:12.460 --> 04:12.770
W porządku.

04:12.800 --> 04:13.950
Tak właśnie to robi.

04:13.970 --> 04:16.640
Zmienia tylko twoją listę.

04:16.990 --> 04:21.610
OK, teraz zrozum, co robi lista gwiazd Zipp.

04:21.680 --> 04:24.560
Teraz wyjaśnijmy, dlaczego musieliśmy to zrobić.

04:24.590 --> 04:30.360
Tak jak zrozumieliście, dodamy wydarzenia do pamięci, a wydarzenia mają formę.

04:30.440 --> 04:34.530
Najpierw państwo, następnie akcja, a potem nagroda.

04:34.820 --> 04:40.330
Ale dla naszego algorytmu nie chcemy tego formatu, chcemy, aby nasze próbki miały następujący format.

04:40.330 --> 04:47.540
Format składa się z trzech próbek: jedna próbka dla stanów jedna próbka dla akcji i jedna próbka

04:47.540 --> 04:48.660
dla nagrody.

04:48.800 --> 04:53.690
Powiedzmy na przykład, że ten jeden do trzech jest stanem jednym akcją.

04:53.800 --> 05:01.100
Chcemy jednego, a następnie przekazać do działania dwa, a my mamy się dobrze, czego chcemy, to jedna partia dla każdej partii

05:01.100 --> 05:03.630
dla stanu pierwszego i stan dwóch.

05:03.680 --> 05:10.090
Jedna to gra akcji w akcji drugiej i jedna trzecia, ponieważ byliśmy jeden, a my dwaj.

05:10.190 --> 05:15.680
To jest właśnie ten format, którego można się spodziewać po następnym, ponieważ wtedy będziemy owijać te

05:15.770 --> 05:22.610
partie w ciasto w kierunku okropnego wpływu, o którym zapamięta się, że jest zmienną zawierającą zarówno tensor, jak i

05:22.610 --> 05:23.280
gradient.

05:23.510 --> 05:29.750
A to, aby móc odróżnić w odniesieniu do tensora, aby móc odróżnić

05:29.750 --> 05:35.480
w odniesieniu do intensera w strukturze strasznego tensora zawierającego gradient.

05:35.540 --> 05:37.820
I znowu tak działa Pi Torch.

05:37.820 --> 05:44.480
Podsumowując, tworzymy jedną partię dla każdego działania i nagród państwa, a następnie umieszczamy każdą z

05:44.480 --> 05:50.600
tych wyselekcjonowanych osobno w bajtach, które są straszne, a każdy z nich dostanie gradient,

05:50.840 --> 05:54.360
aby ostatecznie móc rozróżnić każda z nich.

05:54.620 --> 05:57.430
W porządku, więc taki jest cel funkcji Zipp.

05:57.480 --> 06:00.350
Pozwolę sobie tylko usunąć ten komentarz.

06:00.530 --> 06:05.980
A teraz jedyną rzeczą, którą musimy zrobić, to zwrócić próbki.

06:06.230 --> 06:12.650
Tak więc, jak właśnie wyjaśniłem, nie możemy zwrócić próbek bezpośrednio z tego prostego powodu, dla

06:12.830 --> 06:15.670
którego chcemy umieścić próbki w torbe.

06:15.680 --> 06:22.580
Aby to zrobić, dla każdej próbki użyjemy funkcji mapowania, a funkcja

06:22.580 --> 06:30.180
map wykona odwzorowanie z próbek na tortury zmiennych, które będą zawierać tensor i gradient.

06:30.200 --> 06:33.550
Tak więc, jak widać, ta funkcja mapowa przyjmuje kilka argumentów.

06:33.620 --> 06:38.600
Pierwszy argument jest funkcją i ta funkcja będzie funkcją, która zamieni próbki

06:38.600 --> 06:40.590
na pewne zmienne torche.

06:40.760 --> 06:45.340
Drugim argumentem jest to, do czego chcemy zastosować tę funkcję.

06:45.590 --> 06:50.580
Więc to będą argumenty tej funkcji, a zatem, co to będzie.

06:50.600 --> 06:52.780
To będą oczywiście próbki.

06:52.790 --> 06:55.510
Tak więc drugim argumentem będą symbole.

06:55.870 --> 06:59.440
Ale potem określmy funkcję, w której chcemy zastosować.

06:59.480 --> 07:00.620
Każdy z symboli.

07:01.040 --> 07:06.890
Aby zdefiniować tutaj funkcję, musimy najpierw nadać nazwę funkcji, która wywoła lambdę.

07:07.070 --> 07:14.330
To tylko imię i podanie Lendy, a następnie X, która będzie zmienną tej funkcji.

07:14.420 --> 07:18.390
To jest tylko nazwa i podanie zmiennej, a następnie.

07:18.500 --> 07:24.140
I tutaj dajemy wyraz funkcji, której chcemy, aby funkcja lambda powróciła i

07:25.400 --> 07:32.010
zobaczyła, że to będzie dobrze, że ma to być coś, co przekształci nasze próbki w

07:32.250 --> 07:34.800
zmienną pochodni i to zrobi.

07:34.800 --> 07:37.370
Wspomnieliśmy już o tym w niektórych poprzednich samouczkach.

07:37.560 --> 07:39.880
Mamy dla nich funkcję Wojewody.

07:40.110 --> 07:46.680
Głos będzie działał, a my dokonamy konwersji z tancerza pochodni na zmienną, która będzie

07:46.690 --> 07:48.590
zawierała czujnik i największy.

07:48.810 --> 07:55.830
Pierwszą rzeczą, którą tutaj dodam, jest zmienna zmienna, w której zamierzam przekonwertować X,

07:56.010 --> 08:01.540
ponieważ X będzie prostymi, które zostaną zastosowane na próbkach.

08:02.420 --> 08:09.080
Ale to wszystko jest jedna ostatnia rzecz techniczna, którą musimy wdrożyć, to fakt, że dla

08:09.140 --> 08:15.680
każdej partii, która jest zawarta w próbce, na przykład partia działań, a 1

08:15.680 --> 08:23.080
8 2 3 i inne czynności, musimy ją złączyć z szacunkiem. do pierwszego silnika, który odpowiada państwom.

08:23.120 --> 08:25.380
I dlaczego musimy dokonać tej konkatenacji.

08:25.550 --> 08:27.610
Po prostu wszystko musi być dobrze dopasowane.

08:27.710 --> 08:34.740
Oznacza to, że w każdym rzędzie do określenia akcji i nagrody odpowiada ten sam czas t ..

08:35.180 --> 08:42.240
W ten sposób otrzymujemy listę wszystkich partii, które są dobrze wyrównane, a każda partia to ciasto w stosunku do Voivod.

08:42.470 --> 08:44.700
Jak więc możemy dokonać tej konkatenacji?

08:44.840 --> 08:48.030
Cóż, musimy użyć funkcji kotów z biblioteki pochodni.

08:48.170 --> 08:55.400
Więc dodamy tutaj latarkę, do której dodamy, która zostanie zastosowana do X, ale wtedy w tej funkcji

08:55.400 --> 09:00.820
musimy określić wymiar, w odniesieniu do którego chcemy dokonać tego połączenia.

09:00.860 --> 09:05.460
Jak już wspomniałem, jest to pierwszy silnik, który ma era indeksów.

09:05.900 --> 09:12.320
I oto zaczynamy mieć naszą funkcję gotową, Lunda, ta funkcja pobierze próbki łącząc je z silnikiem

09:12.320 --> 09:18.110
po raz pierwszy, a następnie w końcu zamieniamy czujniki na pewne zmienne torche, które

09:18.110 --> 09:24.230
zawierają zarówno tensor jak i gradient tak, że później, kiedy stosuj się do castigate w tym

09:24.230 --> 09:28.610
sensie, że będziemy w stanie rozróżnić, aby mieć wagi danych.

09:28.610 --> 09:30.170
W porządku, więc ta funkcja jest gotowa.

09:30.410 --> 09:35.270
A oto drugi argument funkcji mapy.

09:35.270 --> 09:42.960
Musimy określić, do czego chcemy zastosować tę funkcję i która dotyczy wszystkich naszych próbek.

09:43.040 --> 09:43.850
No to jedziemy.

09:43.850 --> 09:50.750
Zastosujemy tę funkcję lambda na wszystkich próbkach, aby ostatecznie uzyskać listę meczów, w

09:50.990 --> 09:53.840
których każdy mecz jest opłacalny.

09:53.840 --> 09:58.810
W porządku, to było dość techniczne, ale teraz przynajmniej wszystko będzie dobrze działać.

09:58.850 --> 10:00.060
Chcemy skorzystać z tej techniki.

10:00.080 --> 10:05.150
Potem używamy go tylko tutaj, więc jeśli nie chcesz dobrze rozumieć szczegółów

10:05.150 --> 10:11.060
technicznych, dobrze, możesz skopiować te trzy linijki kodu, aby uprościć pamięć, jeśli chcesz zrobić

10:11.060 --> 10:14.460
sztuczną inteligencję za pomocą latarki tak jak chcesz.

10:14.600 --> 10:21.110
Ale teraz dobrą wiadomością jest to, że skończyliśmy z tą powtórką odtwarzania klasy pamięci, odtworzono teraz powtórkę

10:21.470 --> 10:26.780
i możemy przejść do następnej i ostatniej klasy, która będzie całym trybem bezpieczeństwa.

10:26.960 --> 10:34.520
Tak więc w tym modelu będziemy mieć oczywiście naszą sieć, która będzie doświadczać powtórki, a następnie

10:34.640 --> 10:36.600
całą resztę algorytmu bezpieczeństwa.

10:36.620 --> 10:39.150
Więc będzie to o wiele większa klasa.

10:39.200 --> 10:44.240
Wykonamy około 10 funkcji, ale to tylko dlatego, że robimy to krok po kroku, abyś mógł

10:44.240 --> 10:46.130
lepiej zrozumieć, co się dzieje.

10:46.520 --> 10:49.260
Nie mogę się doczekać, aby wdrożyć nasz model bezpieczeństwa.

10:49.280 --> 10:50.900
I do tego czasu I.
