WEBVTT

00:00.240 --> 00:06.600
Cześć i witamy w tutorialu Pythona w Statoil, zrobimy pierwszy krok do wdrożenia

00:06.630 --> 00:08.270
modelu głębokiej teorii.

00:08.280 --> 00:13.590
Zasadniczo więc zaimplementujemy cały proces algorytmu dyfuzji.

00:13.830 --> 00:16.580
A więc wykorzystamy to, co stworzyliśmy wcześniej.

00:16.590 --> 00:22.460
Taka jest architektura sieci neuronowej, która odtwarza pamięć, aby zintegrować ją z całym

00:22.530 --> 00:24.180
procesem uczenia się.

00:24.180 --> 00:28.320
Cały ten algorytm uczenia się zmieści się w jednej klasie.

00:28.380 --> 00:32.340
To ostatnie, co robimy, aby wprowadzić sztuczną inteligencję.

00:32.340 --> 00:35.650
Klasa ta będzie zawierała tylko różne funkcje.

00:35.700 --> 00:41.790
Będziemy mieli w nim funkcje, które stworzą i zainicjują wszystkie zmienne związane

00:41.790 --> 00:48.450
z naszymi przyszłymi obiektami objazdowymi, które będą reprezentować sam model i będą miały inne funkcje.

00:48.510 --> 00:52.830
Jednym z nich będzie oczywiście wybór odpowiedniego działania za każdym razem.

00:52.950 --> 00:59.250
Będziemy mieć także podstawową funkcję funkcji aktualizacji, aby uzyskać ten rdzeń i mieć pojęcie o tym, jak nauka

00:59.250 --> 01:01.030
idzie, jeśli wszystko idzie dobrze.

01:01.090 --> 01:07.080
Jeśli eksploracja idzie dobrze i jeśli może przejść do eksploatacji, a następnie będziemy mieć bezpieczną

01:07.080 --> 01:12.430
funkcję, aby zaoszczędzić jutro, to jest uratować mózg samochodu, a następnie załadować funkcję.

01:12.480 --> 01:14.590
Mamy więc kilka funkcji do wykonania.

01:14.640 --> 01:17.440
Zamierzamy wykonać jedną funkcję, aby każdy mógł pracować.

01:17.490 --> 01:22.820
A dzisiaj zaczniemy od funkcji końcowej, jak zwykle, kiedy robimy zajęcia.

01:23.010 --> 01:30.040
Ale najpierw nie zapominajmy o wprowadzeniu klasy, więc nazwiemy ją D.

01:30.200 --> 01:35.970
Q A dla twojej sieci wywołujemy nawias.

01:36.030 --> 01:39.440
A potem idziemy z naszą pierwszą funkcją.

01:39.500 --> 01:47.910
Zróbmy więc def, a następnie podwójny podkreślenie, a następnie jego podwójne podkreślenie i nawias.

01:48.170 --> 01:53.530
Tak jak zrozumieliście w tej funkcji, zamierzamy wprowadzić zmienne związane z naszym obiektem.

01:53.570 --> 01:59.240
Tak więc będziemy mieć kilka linii rozpoczynających się od siebie, a my w zasadzie stworzymy

01:59.300 --> 02:03.530
i zainicjujemy wszystkie zmienne, które są potrzebne do wdrożenia sieci D2.

02:03.530 --> 02:09.740
Tak więc na przykład stworzymy obiekt lub sieć, ponieważ oczywiście potrzebujemy naszej głębokiej sieci neuronowej,

02:10.310 --> 02:12.190
wtedy potrzebujemy naszej pamięci.

02:12.300 --> 02:14.630
Stworzymy kolejną zmienną dla pamięci.

02:14.740 --> 02:20.430
Więc będziemy mieć kolejną zmienną samouwielbienie, ale to nie wszystko, co będziemy musieli stworzyć.

02:20.480 --> 02:22.390
Niektóre zmienne dla ostatniej daty.

02:22.490 --> 02:24.820
Ostatnia akcja i ostatnie słowo.

02:24.920 --> 02:30.520
To oczywiście znasz zmienne, które widzisz w algorytmie dyfuzji.

02:30.920 --> 02:31.830
A co jeszcze.

02:31.940 --> 02:38.150
No cóż, potrzebujemy również optymalizatora, który znamy, aby wykonać siatkę stochastyczną w znaczeniu wag danych w

02:38.510 --> 02:42.170
zależności od tego, ile przyczynią się do błędu.

02:42.320 --> 02:48.650
Kiedy sztuczna inteligencja robi błąd, a potem myślę, że to w zasadzie zmienne, które musimy teraz

02:48.650 --> 02:50.230
stworzyć i zainicjować.

02:50.510 --> 02:58.460
Ale w tej funkcji init najpierw wstawimy kilka argumentów jako zwykłe self, które jest argumentami odnoszącymi się

02:58.460 --> 03:00.190
do naszego obiektu.

03:00.200 --> 03:05.210
Odkąd wiesz, że stworzymy obiekt klasy sieciowej.

03:05.390 --> 03:12.740
No cóż, ponieważ klasa sieci przyjmuje argumenty w rozmiarze wejściowym funkcji init, a akcja Cóż jest

03:12.740 --> 03:13.740
taka sama.

03:13.850 --> 03:19.110
Tworząc obiekt klasy sieciowej, musimy wybrać argument wielkości wejściowej i faktyczny

03:19.160 --> 03:20.180
argument.

03:20.180 --> 03:22.140
Dlatego możemy po prostu skopiować je

03:25.660 --> 03:27.520
tutaj i tutaj idziemy.

03:27.710 --> 03:30.450
Te argumenty staną się teraz.

03:30.560 --> 03:33.160
Również niektóre argumenty nie trwały długo.

03:33.170 --> 03:39.680
Ilekroć tworzymy jakieś przyszłe obiekty różnych klas, które będą miały pewne przyszłe modele ról, będziemy

03:39.680 --> 03:45.010
musieli określić rozmiar wejściowy, który przypominam, to liczba wymiarów w wektorach, które zawierają

03:45.010 --> 03:46.330
twoje stany.

03:46.370 --> 03:52.940
Twoje stany wejściowe i liczba akcji, czyli liczba możliwych działań, które może wykonać samochód.

03:53.150 --> 03:54.000
Więc wam przypomina.

03:54.110 --> 03:57.830
Są to albo idź w lewo idź prosto, albo idź w prawo.

03:58.190 --> 03:59.270
W porządku, doskonale.

03:59.270 --> 04:04.640
Wtedy wiesz, że będziesz tworzyć nowy obiekt klasy pamięci powtórek, aby utworzyć

04:04.640 --> 04:10.680
obiekt pamięci, aby uzyskać naszą pamięć przejść oraz w informacji, którą mamy argument pojemności.

04:10.850 --> 04:16.640
Ale ponieważ będziemy go używać tylko raz, kiedy tworzymy pamięć, a nie później,

04:16.640 --> 04:20.000
więc nie będziemy musieli określać argumentu wydajności.

04:20.030 --> 04:25.330
Moglibyśmy to zrobić, ale bezpośrednio wprowadzimy liczbę przejść, które chcemy mieć w naszej pamięci.

04:26.150 --> 04:32.390
Ale wtedy potrzebujemy ostatniego argumentu, który ma uzyskać parametr w modelu nauczyciela.

04:32.480 --> 04:35.470
Pamiętaj, że parametr gamma to opóźnienie.

04:35.750 --> 04:41.300
I to jest parametr równania, dlatego go tutaj umieścimy, ponieważ będziemy go później

04:41.510 --> 04:42.920
używać kilka razy.

04:43.160 --> 04:44.990
Więc, ułóżmy to tutaj.

04:45.070 --> 04:47.140
Nazwiemy to Gamma.

04:47.150 --> 04:52.610
W związku z tym jest to tylko nazwa argumentu, a następnie podajemy wszystkie argumenty potrzebne do tego celu

04:52.610 --> 04:53.740
w jego funkcji.

04:53.750 --> 05:00.320
Oznacza to, że ilekroć tworzymy nasz słownikowy model, ilekroć tworzymy obiekt nauczyciela w

05:00.320 --> 05:01.390
klasie.

05:01.520 --> 05:08.060
Będziemy musieli określić jako argumenty wielkość wejściową liczbę akcji i parametr.

05:08.360 --> 05:10.590
I skończymy z prawdziwymi wartościami dla nich.

05:11.210 --> 05:13.870
W porządku, więc teraz wejdźmy do funkcji.

05:14.100 --> 05:14.400
DOBRZE.

05:14.410 --> 05:16.480
Więc teraz to w zasadzie będzie łatwe.

05:16.510 --> 05:21.090
Zaraz stworzymy i zainicjujemy wszystkie potrzebne nam zmienne.

05:21.110 --> 05:22.770
Zacznijmy więc od pierwszego.

05:22.910 --> 05:24.460
Zacznijmy od gamma.

05:24.530 --> 05:26.090
Właściwie współczynnik opóźnienia.

05:26.330 --> 05:31.850
Ponieważ wojewoda chce być przywiązany do jej obiektu, zaczynamy od siebie.

05:31.880 --> 05:39.500
Więc gamma będzie zmienną naszego nauczyciela i samego modelu, że gamma równa się argumentom, które będą

05:39.530 --> 05:42.930
wprowadzane podczas tworzenia obiektu klasy detune.

05:42.950 --> 05:46.900
Więc Janna i tam idziemy z drugim argumentem.

05:47.040 --> 05:50.560
Drugim argumentem będzie okno nagrody.

05:50.840 --> 05:52.340
Czym jest to okno?

05:52.520 --> 05:57.950
Cóż, to będzie przesuwane okno średniej z ostatnich 100 słów, które użyjesz tylko do

05:58.010 --> 06:04.280
oceny ewolucji wykonania, o którym wiesz, że będzie miało znaczenie tego słowa w tym wojennym Windu,

06:04.280 --> 06:06.320
które z czasem ześlizgnie.

06:06.440 --> 06:11.680
A tym, co chcemy zaobserwować, jest znaczenie ostatnich 100 słów narastających z czasem.

06:11.930 --> 06:18.610
Więc zainicjujmy to samo, aby nagradzać okno podkreślenia.

06:18.710 --> 06:24.690
A więc, ponieważ będzie to przesuwane okno ewoluującej średniej z ostatnich 100 słów.

06:24.860 --> 06:31.710
Cóż, zamierzamy go zainicjować jako pustą listę, a następnie rozszerzymy, aby oznaczać, że pracujemy w godzinach nadliczbowych.

06:32.860 --> 06:35.320
W porządku, potem bardziej ekscytujące.

06:35.420 --> 06:37.430
Stwórzmy naszą sieć neuronową.

06:37.580 --> 06:43.780
Więc nazwiemy to samoukiem Mario, ponieważ to jest sedno modeli.

06:43.790 --> 06:51.890
Nazywam to modelem, a ten model będzie niczym innym jak przedmiotem w tej klasie i stworzeniem

06:51.890 --> 06:53.270
takiego obiektu.

06:53.300 --> 07:02.630
Przyjmujemy naszą klasową sieć w nawiasach i tutaj właśnie podajemy argumenty klasy, ale argumenty te umieszczamy w argumentach

07:02.750 --> 07:08.930
funkcji init i dlatego po prostu musimy je skopiować tutaj i

07:08.930 --> 07:15.290
wkleić je do klasy sieci, a potem idź z tym wierszem kodu.

07:15.350 --> 07:22.690
Tworzymy jedną sieć neuronową do nauki modelu idealnego, a następnie stwórzmy pamięć.

07:22.880 --> 07:29.930
Znowu zamierzamy stworzyć nowe Vargo, które nazywamy samoukiem.

07:29.930 --> 07:34.190
I znowu będzie to obiekt klasy pamięci powtórzeń.

07:34.220 --> 07:42.320
Po prostu weźmy nazwę lub klasę, dajmy skopiować, spójrzmy prawdzie w oczy, że w tym nawiasie musimy umieścić

07:42.320 --> 07:48.680
pojemność, ponieważ pojemność jest argumentem funkcji i jest to jedyny argument, który musimy

07:48.680 --> 07:49.880
tu zastosować.

07:50.240 --> 07:55.100
Jaką więc pojemność wybieramy pamiętajmy, że odpowiada liczbie przejść, na końcu

07:55.100 --> 07:59.800
liczba ostatnich zdarzeń wskazuje na ostatnią akcję i ostatnie słowo.

07:59.830 --> 08:07.550
I tak, jak wspomniano w jednym z trudów z Priester, przeniesiemy do pamięci sto tysięcy sto

08:07.550 --> 08:14.390
tysięcy przejść, a potem spróbujemy z tej pamięci, aby uzyskać niewielką liczbę losowych przejść

08:14.390 --> 08:18.670
i tego, na którym model będzie w porządku.

08:18.720 --> 08:21.210
Teraz mamy doskonałą pamięć.

08:21.210 --> 08:23.180
Teraz pobierzmy nasz optymalizator.

08:23.430 --> 08:31.800
Znowu więc tworzymy nową zmienną, którą nazywamy optymalizatorem, więc optymalizator to kolejna zmienna naszego przyszłego

08:31.800 --> 08:35.320
wycofywania obiektu z tego optymalizatora.

08:35.520 --> 08:44.130
A teraz, gdy wrócimy, zobaczysz, że przywieźliśmy torturowany Upton, który jest modułową pochodnią, zawierającą wszystkie narzędzia do wykonania,

08:44.160 --> 08:47.080
aby uzyskać siatkę w środku.

08:47.130 --> 08:54.260
Oczywiście zawiera on kilka optymalizatorów, a my daliśmy mu skrót Upton, a więc tutaj, co zamierzamy zrobić,

08:54.270 --> 09:00.900
to wziąć model do niego, który jest pochodnią do niego i z tego modułu mamy zamiar

09:00.900 --> 09:03.060
wziąć jeden z optymalizatory.

09:03.180 --> 09:05.670
Jak widać, wszystkie są tutaj wymienione.

09:05.880 --> 09:10.630
Wiele z nich jest doskonałych, na przykład Propp jest doskonałym optymalizatorem.

09:10.640 --> 09:16.170
Jest na przykład wysoce zalecany do zapisu sieci neuronowych lub bez głębokiego uczenia się bez nadzoru.

09:16.230 --> 09:22.140
Ale drugi, który jest doskonały i że wybierze, to optymalizator atomu.

09:22.500 --> 09:26.400
To właśnie zobaczysz, że dzięki temu otrzymasz dobry samochód do samodzielnego prowadzenia.

09:26.580 --> 09:32.000
Ale znów jesteście mile widziani, aby wypróbować inne, z którymi możecie wypróbować rekwizyty, ale do metalu

09:32.000 --> 09:32.810
wybierzemy Adama.

09:32.850 --> 09:34.290
Więc naciskam enter.

09:34.560 --> 09:37.240
I faktycznie zauważysz, że tu jest stolica.

09:37.260 --> 09:40.430
To dlatego, że tworzymy obiekt klasy Atom.

09:40.430 --> 09:44.990
To jest klasa, ale obiektem będzie sam optymalizator atomu.

09:45.060 --> 09:50.970
Ale ponieważ jest to klasa, musimy podać kilka argumentów, argumenty klasy Atom i

09:51.060 --> 09:55.270
argumenty są parametrami, które mogą dostosować twój i optymalizator.

09:55.380 --> 10:00.330
Na przykład zwykle jest to szybkość uczenia się zaniku lub inne parametry.

10:00.510 --> 10:05.690
A oprócz podjęcia wszystkich parametrów Ormeau określimy współczynnik uczenia się.

10:05.970 --> 10:08.650
To początek parametrów naszego modelu.

10:08.670 --> 10:12.830
Możemy uzyskać je z własnym modelem wątpliwości.

10:12.870 --> 10:17.530
Więc to jest model, który stworzyliśmy w tym modelu samouka z naszej własnej klasy.

10:17.580 --> 10:24.780
Tak więc samouk modelu, a następnie, aby uzyskać dostęp do parametrów modelu, dodajemy po prostu kolejną kropkę,

10:25.500 --> 10:28.170
a następnie parametry z pewnym nawiasem.

10:28.170 --> 10:35.860
Chodzi o to, aby podłączyć optymalizator addonów do naszej sieci neuronowej, którą stworzyliśmy tutaj ponownie, a jak

10:35.880 --> 10:42.810
już wspomnieliśmy, dodamy współczynnik uczenia się, a argumentem jest to, że jest to nasz.

10:43.170 --> 10:50.540
I ustawimy wartość równą wartości takiej, że uczenie się nie nastąpi zbyt szybko, jeśli uzyskamy zbyt duży stopień uczenia

10:50.540 --> 10:53.910
się, wtedy AI AI będzie się uczyć poprawnie.

10:53.910 --> 10:58.890
Chcemy dać naszej AI trochę czasu na zbadanie uczyć się na błędach.

10:58.890 --> 11:04.320
Wiesz, kiedy karzemy, gdy popełnia się błędy, takie jak przechodzenie przez jakiś sens lub zbliżanie

11:04.320 --> 11:05.510
się do ściany.

11:05.770 --> 11:08.780
Chcemy dać trochę czasu na naukę.

11:08.880 --> 11:12.030
Chcemy, aby droga do sieci neuronowej była na bieżąco.

11:12.180 --> 11:21.010
I tak dobra wartość dla szybkości uczenia się, którą otrzymałem po wypróbowaniu kilku z nich, wynosi 0. 2 lub jeden.

11:21.210 --> 11:24.540
W porządku i to wszystko, czego potrzebujemy do stworzenia optymalizatora.

11:24.720 --> 11:28.320
Zasadniczo tworzysz obiekt klasy Atom.

11:28.530 --> 11:29.050
Świetny.

11:29.070 --> 11:35.980
A ostatnie trzy zmienne, których potrzebujemy, to zmienne składające się na nasze zdarzenia przejściowe.

11:36.150 --> 11:40.130
To jest ostatnia data ostatniej akcji i ostatniego słowa.

11:40.170 --> 11:45.280
W zasadzie to właśnie teraz stworzymy i będziemy musieli je zainicjować.

11:45.300 --> 11:50.130
Zacznijmy więc od ostatniej daty ostatniej daty, którą nazwijmy to samoukiem.

11:50.400 --> 11:56.000
Ostatni stan podkreślenia, a następnie w jaki sposób zamierzasz go zainicjować.

11:56.190 --> 12:03.840
Pamiętajmy, że ostatnia data to wektor 5 dominacji wektora zakodowanego w jednym stanie

12:03.840 --> 12:04.700
środowiska.

12:04.950 --> 12:10.800
Dla przypomnienia, te pięć wymiarów to trzy sygnały z trzech czujników w linii

12:10.800 --> 12:15.180
prostej i prawej oraz orientacji i orientacji ujemnej.

12:15.210 --> 12:18.350
Jest to więc wektor i intuicyjny zmysł.

12:18.420 --> 12:21.060
Ale przez pochodnie musi być czymś więcej niż wektorem.

12:21.210 --> 12:23.640
W rzeczywistości musi to być tensor palnika.

12:23.820 --> 12:29.970
Ale nie tylko musi to być czujnik palnika, ale także musi mieć jeszcze jeden wymiar,

12:29.970 --> 12:33.510
który chciałbym nazwać fałszywym wymiarem, który odpowiada partii.

12:33.630 --> 12:39.810
A to dlatego, że ostatnie osiem będzie wejściem sieci neuronowej, ale podczas pracy ze mną, kiedy to

12:39.810 --> 12:46.220
działa w ogóle, czy to z gęstszym przepływem niesie pochodnię, podczas gdy wektor wejściowy nie może sam w

12:46.290 --> 12:48.040
sobie być zwykłym wektorem.

12:48.210 --> 12:49.760
Musi być w partii.

12:49.830 --> 12:57.660
Sieć może akceptować tylko wsad obserwacji wejściowych i dlatego nie tylko stworzy tensor

12:57.870 --> 13:05.140
dla wektorów stanu wejściowego, ale także utworzy ten fałszywy wymiar odpowiadający partii.

13:05.190 --> 13:11.490
Zróbmy to i zacznijmy od zainicjowania tensora palnika, aby to zrobić, nie ma nic

13:11.490 --> 13:12.340
prostszego.

13:12.510 --> 13:21.810
Przyjmujemy bibliotekę torche, a następnie kropkę, a następnie użyjemy klasy tensorów, ponieważ jak można się domyślić,

13:21.810 --> 13:27.950
stworzy to obiekt klasy tensorowej, która jest obiektem tensorowym.

13:28.120 --> 13:34.660
I w tym tensorze musimy postawić argument, który określi wielkość tensora.

13:34.660 --> 13:38.720
Możesz to zrobić, jak tablicę z jednym rodzajem.

13:38.890 --> 13:45.430
Ale w zasadzie to, co teraz będzie reprezentować, jest oczywiście tym stanem wejściowym, który widzisz ma wektor, a

13:46.180 --> 13:49.380
więc określenie liczby elementów, które musi mieć odległość.

13:49.570 --> 13:55.180
Musimy oczywiście użyć wielkości wejściowej, ponieważ wielkość wejściowa jest dokładnie liczbą wymiarów

13:55.510 --> 13:57.520
naszych wektorów stanu wejściowego.

13:57.520 --> 13:59.050
Teraz powinienem powiedzieć tensory.

13:59.170 --> 14:05.650
A więc po prostu musimy wprowadzić w naszej klasie tensorów, aby stworzyć obiekt tensorowy.

14:06.010 --> 14:07.260
Cóż, to jest nieprecyzyjne.

14:07.540 --> 14:10.230
Później wielkość wejściowa zostanie określona ilościowo.

14:11.350 --> 14:12.430
W porządku, to dobrze.

14:12.430 --> 14:13.670
To pierwsza rzecz wykonana.

14:13.720 --> 14:17.390
Właśnie zainicjowaliśmy tensor tak, jak powinien.

14:17.530 --> 14:23.080
Ale pamiętajmy, że musimy zrobić jeszcze jedną rzecz, której potrzebujemy, aby stworzyć ten fałszywy wymiar,

14:23.080 --> 14:30.070
ponieważ jest to tym, czego sieć oczekuje od swoich danych wejściowych i aby stworzyć ten do badania, który przy

14:30.070 --> 14:35.840
okazji musi być pierwszym mechanizmem, w którym znasz obrażenia wrzucony do partii pierwszy raz o tym

14:35.940 --> 14:37.800
wspomnę, powiedzmy bardzo dobrze.

14:38.230 --> 14:46.050
Cóż, aby to zrobić, musimy po prostu dodać to i wycisnąć, a następnie w jakimś nawiasie.

14:46.050 --> 14:49.580
Musimy umieścić indeks tego wielkiego wymiaru.

14:49.620 --> 14:55.790
I jak właśnie powiedziałem, ten fałszywy wymiar musi być pierwszą animacją z ostatniej daty, a ponieważ

14:55.790 --> 15:02.460
indeksy i bajty i początkowe zero, musimy wprowadzić zero, aby ten nowy silnik paradygmatu stał się silnikiem

15:02.460 --> 15:03.570
pierwszego rzędu.

15:03.570 --> 15:09.360
Mamy zatem pierwszy silnik czasu odpowiadający partii, a następnie diament powinien odpowiedzieć na

15:09.360 --> 15:15.960
ten czujnik, który będzie zawierał pięć elementów twojego wejścia, wskazując trzy orientacje sygnałów i orientację

15:15.990 --> 15:16.910
ujemną.

15:17.370 --> 15:21.960
A potem zaczynamy poprawnie inicjować nasze stany wejściowe.

15:21.960 --> 15:22.850
Idealny.

15:23.310 --> 15:30.840
A następnie dwie zmienne, które należy przejść i to będzie znacznie łatwiejsze, ponieważ następna zmienna jest ostatnią

15:31.110 --> 15:31.850
akcją.

15:32.190 --> 15:36.340
Oto nowy Roybal, który tworzymy dla ostatniej akcji obiektu.

15:36.510 --> 15:43.440
I pamiętajcie w pierwszym samouczku sekcji Powiedziałem wam, że działania będą miały wartość

15:43.440 --> 15:52.470
0 1 lub 2, a następnie za pomocą wektora obrotu akcji przekształcimy te indeksy tych działań w

15:52.470 --> 15:58.010
kąty obrotu, które przypominam 0 20 lub minus 20.

15:58.050 --> 16:00.980
Możemy dzięki temu odświeżyć naszą pamięć.

16:01.200 --> 16:03.170
Cóż, jest dokładnie tutaj.

16:03.170 --> 16:06.260
Akcja do rotacji, jeśli akcja wynosi zero.

16:06.390 --> 16:11.650
Cóż, to będzie odpowiadać pierwszemu indeksowi zerowemu, jeśli czynność wynosi 1.

16:11.700 --> 16:17.310
Będzie to odpowiadało indeksowi jednego z tych wektorów o 20 stopniach, a

16:17.310 --> 16:23.490
jeśli to działanie, otrzymamy minus 20 stopni, czyli kąt obrotu naszego samochodu, kiedy gramy akcję.

16:23.510 --> 16:24.200
W porządku.

16:24.380 --> 16:31.040
A zatem, ponieważ akcja będzie miała wartość 0 1 lub 2, akcja jest wykonywana dla prostej

16:31.040 --> 16:31.740
liczby.

16:31.850 --> 16:35.440
I tak po prostu możemy go zainicjować do zera.

16:35.660 --> 16:38.330
Nie musimy tworzyć dziesiątek ani słyszeć niczego innego.

16:38.360 --> 16:40.880
Musimy tylko zainicjować go zerem.

16:41.420 --> 16:42.850
I w końcu.

16:43.010 --> 16:44.460
Cóż, to jest ostatnie słowo.

16:44.550 --> 16:48.840
To ja, to ostatnie słowo.

16:48.860 --> 16:49.940
No to jedziemy.

16:49.940 --> 16:56.510
I znowu słowo jest liczbą zmiennoprzecinkową, którą przypominam między minus 1 a plus 1.

16:56.510 --> 16:57.790
To znowu numer.

16:57.860 --> 16:59.400
A co do akcji.

16:59.510 --> 17:02.900
Zainicjujemy go na zero, a następnie jedziemy.

17:02.900 --> 17:06.330
Gratulacje są w nim funkcja jest gotowa.

17:06.350 --> 17:08.930
Teraz jesteśmy gotowi przejść do ekscytujących rzeczy.

17:08.930 --> 17:16.040
A tak naprawdę to najważniejsza rzecz w sztucznej inteligencji, która decyduje o tym, które akcje należy grać

17:16.080 --> 17:23.240
za każdym razem i za każdym razem. A to właśnie zamierzamy zrobić w następnym ćwiczeniu, tworząc metodę wyboru akcji.

17:23.510 --> 17:27.310
Zróbmy to w następnej pracy i do tego czasu I.
