WEBVTT

00:00.520 --> 00:02.690
Cześć i witamy w tutorialu Python.

00:02.860 --> 00:05.680
W porządku, więc ekscytuje nas gleba przed nami.

00:05.680 --> 00:10.690
Zaczniemy od stworzenia architektury sieci neuronowej, dzięki której zbudujemy sieć neuronową, która

00:10.690 --> 00:16.740
będzie w centrum naszej sztucznej inteligencji i która zwróci działanie, by grać w wieku 90 lat.

00:16.930 --> 00:18.060
Zróbmy to.

00:18.130 --> 00:23.130
Ponieważ chcemy, aby nasza sieć neuronowa była obiektywna, zamierzamy uczynić ją klasą.

00:23.200 --> 00:25.100
A to dlatego, że jest o wiele wygodniejszy.

00:25.180 --> 00:28.370
Wiesz, że klasa jest modelem czegoś, co chcemy zbudować.

00:28.540 --> 00:34.000
Chcemy zbudować sieć neuronową i musimy wykonać instrukcje, które będą zawarte w

00:34.090 --> 00:35.080
klasie.

00:35.140 --> 00:37.910
I w tej klasie zamierzamy wykonać dwie funkcje.

00:37.960 --> 00:42.810
Najpierw funkcja init, która jest funkcją, która pojawia się cały czas podczas tworzenia klasy.

00:43.000 --> 00:47.770
I to w zasadzie definiuje zmienną twojego obiektu, którym jest sieć neuronowa.

00:47.920 --> 00:52.600
Znasz zmienne związane z obiektem, w przeciwieństwie do zmiennych globalnych.

00:52.840 --> 00:57.910
I to właśnie w tej funkcji zdefiniujemy architekturę nowej sieci, którą znacie, definiując

00:57.910 --> 01:03.460
warstwę wejściową, która będzie składała się z pięciu neuronów wejściowych, ponieważ mamy pięć wymiarów dla

01:03.790 --> 01:05.680
zakodowanego wektora stanów wejściowych.

01:05.890 --> 01:08.080
Następnie zdefiniujemy kilka ukrytych warstw.

01:08.110 --> 01:12.940
Może zaczniesz od jednej ukrytej warstwy, a potem będziesz mógł wypróbować inne architektury

01:12.940 --> 01:13.920
sieci neuronowej.

01:14.200 --> 01:20.080
I wtedy oczywiście otrzymamy warstwę wyjściową, która będzie zawierała możliwe akcje, które możemy

01:20.110 --> 01:21.940
grać za każdym razem.

01:22.180 --> 01:24.730
Tak właśnie zrobimy w tej funkcji.

01:24.850 --> 01:30.460
A następnie utworzymy jeszcze jedną funkcję wewnątrz klasy, która będzie funkcją naprzód

01:30.460 --> 01:34.870
i która będzie funkcją aktywującą neurony w sieci neuronowej.

01:34.870 --> 01:40.570
Wiesz, że to aktywuje sygnały, więc użyjemy wyprostowanej funkcji aktywacji, ponieważ

01:40.570 --> 01:46.920
oczywiście mamy do czynienia z czysto nieliniowym problemem, a ta poprawiona funkcja przełamuje liniowość.

01:47.200 --> 01:53.340
Ale głównie sprawiamy, że funkcja Forda zwraca wartości q, które są wyjściami sieci.

01:53.500 --> 01:56.110
Ale mamy jedną kluczową wartość dla każdego działania.

01:56.200 --> 02:02.710
Później zwrócimy ostatnią akcję, przyjmując maksimum kluczowych wartości lub stosując miękką metodę

02:02.710 --> 02:03.880
Max.

02:04.030 --> 02:05.270
Zobaczymy to później.

02:05.440 --> 02:10.330
W tym tutorialu zaczniemy od zaimplementowania funkcji init, a

02:10.330 --> 02:12.880
następnie zaimplementujemy funkcję forward.

02:12.880 --> 02:13.810
Zróbmy to.

02:13.810 --> 02:17.060
Najpierw musimy przedstawić naszą klasę.

02:17.200 --> 02:22.930
Zaczynamy od klasy, a my nadajemy nazwę naszej klasie, którą możemy nazwać siecią.

02:23.650 --> 02:29.980
A potem w tej klasie sieciowej zamierzam użyć techniki programowania obiektowego, która jest nazywana dziedziczeniem,

02:30.310 --> 02:35.120
a która po prostu dziedziczy po wszystkich narzędziach klasy macierzystej.

02:35.200 --> 02:41.550
Nasza klasa sieciowa, którą zamierzamy stworzyć, jest testem dla dzieci większej klasy.

02:41.770 --> 02:44.110
I ten moduł.

02:44.470 --> 02:50.790
To po prostu dziedziczy po wszystkich narzędziach tej klasy modułów, które oczywiście są narzędziami do implementacji

02:50.790 --> 02:51.940
sieci neuronowej.

02:51.940 --> 02:57.880
Jest to bardzo potężna i ewolucyjna sztuczka w programowaniu zorientowanym obiektowo, która idzie w parze z dziedzictwem.

02:57.910 --> 03:02.670
I właśnie teraz dziedziczymy z tej klasy nadrzędnej modułu.

03:02.800 --> 03:06.000
W porządku, a teraz jesteśmy gotowi wejść do klasy.

03:06.130 --> 03:12.910
Tak więc dwukrotnie wciskam enter, ponieważ będziemy wykonywać dwie funkcje i zaczynamy od

03:13.140 --> 03:14.280
funkcji zakończenia.

03:14.350 --> 03:20.470
Tak więc funkcja init, którą musimy nazwać w ten sposób, z dwoma na tym kursie, a następnie w nim.

03:20.650 --> 03:25.750
I jeszcze raz, aby podkreślić, że jest to po prostu składnia Pythona, tak jak musimy to zrobić.

03:25.930 --> 03:28.460
A potem musimy przedstawić argumenty.

03:28.720 --> 03:30.340
Mamy więc trzy argumenty.

03:30.340 --> 03:35.800
Pierwszy to obowiązkowy argument, który jest w rzeczywistości Self i Self.

03:35.800 --> 03:42.250
Nie ma w tym tajemnicy, która odnosi się do przedmiotu, który zostanie stworzony z tej klasy, którą zamierzamy

03:42.250 --> 03:42.810
stworzyć.

03:42.820 --> 03:44.400
Wiesz, że tworzymy tę klasę.

03:44.470 --> 03:48.980
To trochę jak instrukcja jakiegoś modelu tej sieci neuronowej, którą chcemy zbudować.

03:49.180 --> 03:53.620
A kiedy klasa będzie już gotowa, możemy stworzyć tyle sieci, ile chcemy.

03:53.620 --> 04:00.130
Każda z tych nowych sieci będzie przedmiotem tej klasy, a ponieważ będziemy używać tego

04:00.400 --> 04:07.630
obiektu do innych celów, musimy to zrobić, ale jakie są zmienne obiektu i Spudis, używamy tego

04:07.630 --> 04:11.900
tutaj, aby określić, że odnosi się do obiektu.

04:12.100 --> 04:18.430
Kiedykolwiek chcę użyć dostępnego z mojego obiektu, użyję self przed zmienną, aby określić,

04:18.430 --> 04:21.340
że jest to zmienna obiektu.

04:21.340 --> 04:25.680
W porządku, to jest pierwszy argument, a następnie mamy dwa

04:25.680 --> 04:30.240
inne argumenty, które są oczywiście liczbą neuronów wejściowych i liczbą neuronów wyjściowych.

04:30.550 --> 04:38.220
Tak więc liczba neuronów wejściowych nazwiemy wielkością wejściową, która w rzeczywistości wynosi pięć, ponieważ nasze

04:38.310 --> 04:45.890
wektory wejściowe mają pięć wymiarów do trzech sygnałów plus orientacja plus orientacja ujemna, które

04:45.900 --> 04:51.020
są wektorami zakodowanych wartości, które opisują jeden stan środowiska.

04:51.210 --> 04:54.960
Te pięć wartości wystarczy, aby opisać stan środowiska.

04:54.960 --> 05:00.600
Moglibyśmy pomyśleć o mniej wartościach lub więcej wartościach, ale tego właśnie próbowałem i ma to

05:00.600 --> 05:05.520
sens, ponieważ potrzebujemy jednego sygnału od lewego przed nami i po prawej.

05:05.520 --> 05:10.860
Wiesz, kiedy jedziemy samochodem, mogliśmy poszukać sygnału 360, który znamy jak sygnały na

05:10.860 --> 05:17.370
górze samochodów Google, które możemy całkowicie samozasilać z trzema czujnikami, a następnie mamy orientację i

05:17.400 --> 05:22.200
orientację względem ciebie wiedzieć, śledzić cel, do którego próbujesz dotrzeć.

05:22.530 --> 05:29.160
A potem mamy oczywiście neurony wyjściowe naszej sieci, które odpowiadają akcjom i mamy trzy możliwe działania idące

05:29.160 --> 05:32.840
w lewo idąc prosto lub idąc w prawo.

05:32.880 --> 05:38.520
I dlatego nazwę to i działaniem, a będzie ich trzech.

05:38.520 --> 05:39.030
W porządku.

05:39.120 --> 05:44.850
Do tej pory wystarczy podać nazwy wejść, a następnie użyjemy tych siatkówki, aby wykonać warunki

05:44.940 --> 05:46.140
wewnątrz sieci neuronowej.

05:47.090 --> 05:55.010
W porządku, a ty zaczynasz od użycia innej sztuczki latarki, ta sztuczka to superfunkcja, która

05:55.010 --> 05:59.310
jest funkcją, która faktycznie dziedziczy z modułu.

05:59.390 --> 06:02.730
Właśnie dlatego musieliśmy wykorzystać dziedziczenie, aby odziedziczyć moduł.

06:02.750 --> 06:04.440
To jest pierwszy w użyciu.

06:04.520 --> 06:11.120
Zasadniczo używamy tylko tej superfunkcji super-sztuczki, aby móc korzystać z narzędzi modułu, które są

06:11.580 --> 06:13.320
znacznie bardziej wydajne.

06:13.670 --> 06:18.620
Wewnątrz superfunkcji muszę najpierw określić sieć.

06:18.650 --> 06:25.100
Więc to jest nasza chul klasa sieci, którą znasz, ponieważ dziedziczy ona z klasy nadrzędnej modułu,

06:25.550 --> 06:27.360
a następnie naszego obiektu.

06:27.380 --> 06:35.220
A potem dodajemy to i funkcjonujemy w taki sposób, jak to nazwaliśmy.

06:35.570 --> 06:39.350
W porządku, to tylko sztuczka polegająca na użyciu wszystkich dostępnych narzędzi.

06:39.360 --> 06:46.270
W tym module możemy przejść do kolejnego kroku, który ma określić warstwę wejściową.

06:46.550 --> 06:53.300
Więc w zasadzie muszę wprowadzić nową zmienną, która będzie dołączona do obiektu, a

06:53.300 --> 06:57.120
ta zmienna będzie zawierała liczbę neuronów wejściowych.

06:57.170 --> 07:05.140
Więc nie mylić z wielkością wejściową rozmiar wejściowy jest argumentem funkcji końca.

07:05.180 --> 07:09.710
Ale to nie jest zmienna dołączona do obiektu, ale zmienna dołączona do

07:09.710 --> 07:10.360
obiektu.

07:10.520 --> 07:16.520
Jak już wspomniałem, musimy określić, że jest on dołączony do obiektu, więc używamy samouka

07:17.230 --> 07:22.130
i teraz podajemy nazwę tej pierwszej zmiennej dołączonej do obiektu.

07:22.190 --> 07:24.870
Możemy więc podać tę samą nazwę, co dane wejściowe.

07:24.920 --> 07:33.650
Możemy nazwać to wielkością wejściową i powiemy, że jest równa argumentom funkcji, która jest wielkością wejściową.

07:33.680 --> 07:34.080
W porządku.

07:34.130 --> 07:39.900
Za każdym razem, gdy tworzę obiekt z klasy sieci i podaję rozmiar wejściowy jak na

07:39.900 --> 07:41.170
przykład kładę 5.

07:41.180 --> 07:47.330
Będzie tutaj 5, a zatem wielkość wejściowa zmiennej naszego obiektu będzie miała wartość 5, ponieważ

07:47.690 --> 07:54.110
ten rozmiar wejściowy będzie wynosił 5, a zatem nasza nowa sieć będzie miała 5 neuronów wejściowych

07:54.110 --> 07:55.470
w warstwie wejściowej.

07:55.490 --> 07:55.790
W porządku.

07:55.790 --> 08:02.180
A to samo dotyczy innej zmiennej, którą chcemy przywiązać do obiektów.

08:02.210 --> 08:08.100
I jak można się domyślić, będzie to zmienna dla liczby neuronów wyjściowych.

08:08.330 --> 08:15.030
I mówimy, że bierzemy własny obiekt, a następnie nadajemy tej drugiej zmiennej obiekt,

08:15.040 --> 08:17.740
który nazwiemy i działaniem.

08:18.170 --> 08:23.600
I będzie to równe temu argumentowi, biorąc pod uwagę liczbę działań, jaką jest liczba neuronów

08:23.600 --> 08:24.250
wyjściowych.

08:24.530 --> 08:30.850
Tak więc ustawiliśmy to samo, co działanie, a działanie będzie równe trzy.

08:30.890 --> 08:37.930
Dlatego zmienna i akcja dołączona do naszego obiektu do sieci otrzymają wartość trzy.

08:38.240 --> 08:41.680
Właściwie to widzimy ostrzeżenie tutaj, gdy mówi niezdefiniowana nazwa.

08:41.720 --> 08:44.180
A to dobrze, bo tutaj używamy.

08:44.230 --> 08:46.030
A potem skrót.

08:46.350 --> 08:48.530
I musimy użyć skrótu tutaj.

08:48.590 --> 08:52.780
I na początek torche i w Mudgalu, a potem zniknie.

08:52.880 --> 08:53.670
No to ruszamy.

08:53.690 --> 08:54.580
Idealny.

08:54.590 --> 09:00.800
W tej chwili mamy nowe ostrzeżenia, wszystkie ostrzeżenia mają na celu tylko wskazanie, że to, co importujemy, nie jest

09:00.800 --> 09:01.520
jeszcze używane.

09:01.580 --> 09:04.660
W porządku, będziemy je później wykorzystywać.

09:04.670 --> 09:10.010
W porządku, mamy dwie kolejne zmienne, które chcemy zdefiniować dla obiektu.

09:10.190 --> 09:15.820
I to będą pełne połączenia pełne połączenia między różnymi warstwami naszej sieci

09:15.830 --> 09:16.810
neuronowej.

09:16.820 --> 09:21.800
Ponieważ teraz chcemy stworzyć sieć neuronową złożoną z tylko jednej głowy w ich świecie,

09:21.800 --> 09:23.440
będą dwa pełne połączenia.

09:23.570 --> 09:27.740
Wystąpi jedno pierwsze pełne połączenie pomiędzy warstwą wejściową a warstwą ukrytą.

09:27.980 --> 09:32.450
I jedno drugie pełne połączenie między wzgórzem a warstwą wyjściową.

09:32.480 --> 09:34.770
Zacznijmy więc od pierwszego pełnego połączenia.

09:34.890 --> 09:43.310
Nazwiemy to SE1 I znowu używam tutaj siebie, aby określić, że FC jeden jest zmienną mojego obiektu, aby to

09:43.780 --> 09:44.530
rozwiązać.

09:44.530 --> 09:47.490
FC, który będzie równy.

09:47.630 --> 09:55.160
Teraz używamy modułu N w module i zamierzamy użyć funkcji o nazwie liniowy R, a to dokładnie

09:55.160 --> 10:02.080
sprawia, że to pełne połączenie między neuronami i warstwą wejściową do neuronów ukrytego tam.

10:02.180 --> 10:04.090
I co mam na myśli przez pełne połączenie.

10:04.160 --> 10:09.190
Oznacza to, że wszystkie neurony warstwy wejściowej będą połączone ze wszystkimi neuronami

10:09.190 --> 10:09.920
tutaj.

10:10.190 --> 10:16.140
Aby uzyskać to połączenie, używamy tej funkcji liniowej, do której musimy podać kilka argumentów.

10:16.190 --> 10:19.880
I jak widać te argumenty są w funkcji.

10:19.880 --> 10:25.370
Tak więc jest to liczba neuronów pierwszego prawa, które chcesz połączyć je z funkcjami, która

10:25.370 --> 10:30.110
jest liczbą neuronów drugiej warstwy, którą chcesz połączyć, czyli warstwą po prawej, która

10:30.110 --> 10:32.360
jest warstwą ukrytą i prawdziwą rowerem.

10:32.420 --> 10:38.850
Tak więc rower jest prawdziwy, zachowamy domyślną wartość, aby mieć odchylenie, a nie tylko pewną wagę związaną z

10:38.900 --> 10:43.350
biegiem, który będziemy musieli poczekać i jedno odchylenie dla każdej warstwy.

10:43.610 --> 10:46.140
A więc zobaczmy, co musimy wprowadzić.

10:46.280 --> 10:51.850
Pierwszym argumentem w funkcji jest liczba neuronów wejściowych w warstwie wejściowej.

10:52.000 --> 10:52.930
I gdzie to jest.

10:53.030 --> 10:55.080
To jest właściwie nieprecyzyjne.

10:55.100 --> 11:01.930
To jest argument naszej funkcji init, która później będzie w stanie walczyć z orientacją trzech

11:02.200 --> 11:04.150
sygnałów i orientacją Mannusa.

11:04.160 --> 11:05.020
Więc zaczynamy.

11:05.190 --> 11:14.300
Kiedy pierwsze argumenty i rozmiar put, a następnie drugi argument są poza funkcjami to jest to liczba neuronów, które

11:14.300 --> 11:17.090
chcemy mieć w drugiej warstwie.

11:17.180 --> 11:20.450
Druga warstwa, która będzie w pełni połączona z pierwszą warstwą.

11:20.450 --> 11:24.960
I tak teraz pytanie brzmi, ile neuronów chcemy w tej ukrytej warstwie.

11:25.220 --> 11:27.420
Zrobiłem dużo treningu parametrów.

11:27.440 --> 11:29.110
Zrobiłem dużo eksperymentów.

11:29.210 --> 11:31.940
To właśnie robimy lub robimy to głębiej.

11:31.940 --> 11:38.270
Generalnie przeprowadzamy wiele eksperymentów, aby zobaczyć, jaka jest najlepsza sieć neuronowa dla naszego konkretnego

11:38.270 --> 11:39.170
problemu.

11:39.170 --> 11:45.950
Tak więc próbuję wielu wartości i ostatecznie wybrałem 30 30 przebiegów w ukrytej warstwie, a zobaczysz, że

11:45.950 --> 11:50.750
z tą liczbą otrzymamy całkiem dobre wyniki, ale wtedy możemy zmienić architekturę

11:50.750 --> 11:51.580
sieci neuronowej.

11:51.580 --> 11:53.120
Zapraszam do zabawy.

11:53.180 --> 11:58.730
Możesz nie tylko zmienić liczbę neuronów w tu i tam, ale także możesz dodać więcej

11:59.150 --> 12:05.000
warstw, abyś mógł otrzymać jeszcze lepszy samochód, ale neurony 30 hinna zapewnią nam dobrą sieć neuronową i

12:05.000 --> 12:06.000
dobrą przyczynę.

12:06.020 --> 12:07.390
Właśnie o to idziemy.

12:07.520 --> 12:08.410
I oto idziemy.

12:08.420 --> 12:13.500
Mamy pierwsze pełne połączenie z tą funkcją liniową.

12:13.520 --> 12:16.910
Tworzymy połączenie między warstwą wejściową a ukrytą nogą.

12:17.360 --> 12:23.270
A teraz czas na drugie pełne połączenie, które jest pełnym połączeniem między warstwą ukrytą

12:23.600 --> 12:25.180
a warstwą wyjściową.

12:25.490 --> 12:26.750
Więc idziemy.

12:26.750 --> 12:31.380
Nazwiemy to drugie pełne połączenie w C2.

12:31.490 --> 12:32.280
No to jedziemy.

12:32.360 --> 12:36.400
I nadal jest to dostępne dla większej liczby obiektów korzystających z Saphir.

12:36.650 --> 12:38.330
I znowu używamy.

12:38.450 --> 12:45.310
Właściwie możemy to skopiować, ponieważ zamierzamy użyć N w module, a następnie w funkcji liniowej.

12:45.530 --> 12:49.250
Ale najpierw musimy najpierw zmienić argumenty.

12:49.280 --> 12:55.050
To samo dotyczy liczby neuronów, które będziemy mieć w pierwszej warstwie połączenia.

12:55.190 --> 12:56.510
Więc to jest ukryte.

12:56.720 --> 13:03.810
A zatem jest to 30, a następnie drugi argument to liczba neuronów w drugiej

13:04.010 --> 13:08.810
warstwie połączenia, która odpowiada warstwie wyjściowej, a wyjście ma.

13:08.980 --> 13:15.020
I rzeczywiste neurony, które później będą trzy, ponieważ mamy trzy możliwe działania, ale do tej pory

13:15.020 --> 13:16.930
musimy użyć nazw, które zdefiniowaliśmy.

13:17.050 --> 13:23.990
To jest nazwa argumentu funkcji init, dlatego też wprowadzamy tutaj i akcję, i

13:23.990 --> 13:24.950
idziemy.

13:24.950 --> 13:27.760
Przede wszystkim nasze połączenia krotkowe ponownie.

13:27.920 --> 13:30.980
A po drugie są jakąkolwiek funkcją Izraela.

13:31.400 --> 13:36.940
Tak właśnie zainicjujemy nasz obiekt za każdym razem, gdy stworzymy obiekt z klasy sieci.

13:37.130 --> 13:44.300
A więc, gdy tylko stworzymy obiekt dobrze wszystkie te zmienne dla zmiennych tutaj wielkość wejściowa i reakcja.

13:44.380 --> 13:46.980
Ty i dwa zostaną zdefiniowani.

13:47.180 --> 13:52.060
I tak otrzymamy architekturę naszej sieci zwierząt dla każdego tworzonego przez nas obiektu.

13:52.160 --> 13:59.450
Każdy obiekt będzie odpowiadał sieci neuronowej z pięcioma neuronami wejściowymi, 30 ukrytymi neuronami i trzema

13:59.450 --> 14:00.440
wyjściowymi neuronami.

14:00.470 --> 14:01.430
Więc idziemy.

14:01.430 --> 14:06.980
Skończymy z tą pierwszą funkcją, a teraz możemy przejść do drugiej funkcji, która

14:06.980 --> 14:13.100
jest funkcją do przodu i która będzie używana do aktywacji neuronów w sieci neuronowej za pomocą

14:13.100 --> 14:19.500
funkcji aktywacji prostownika i głównie do powrotu do wartości kostek, które są wyjścia tylko jednej sieci.

14:19.580 --> 14:23.420
Nie mogę się doczekać, aby to zrobić w następnym samouczku i do tego czasu.
