WEBVTT

00:00.360 --> 00:06.030
Witam i zapraszam do pierwszej części tej implementacji sztucznej inteligencji, część pierwsza, budując sztuczną inteligencję.

00:06.120 --> 00:12.570
Jak widzicie, dodałem już wymiar w strukturze tego wcięcia za pomocą tych trzech sekcji tworzących część 1,

00:12.660 --> 00:16.620
które wyraźnie pokazują, jak zamierzamy zbudować tę sztuczną inteligencję.

00:16.620 --> 00:18.750
Najpierw zrobimy mózg.

00:18.840 --> 00:23.760
Nie ma nic innego, jak sieć neuronowa, a następnie stworzymy ciało, które określi, w jaki

00:23.760 --> 00:25.400
sposób będą rozgrywane działania.

00:25.590 --> 00:31.620
A potem, gdy już mamy mózg i ciało, połączymy je, aby stworzyć sztuczną inteligencję, która będzie w

00:31.620 --> 00:33.840
ostatniej części tej pierwszej części.

00:33.840 --> 00:37.890
Teraz możesz już mieć dobrą wizję struktury tej implementacji.

00:37.890 --> 00:42.760
Najpierw robimy mózg, potem robimy ciało, a potem montujemy dwa, aby stworzyć sztuczną inteligencję.

00:43.050 --> 00:48.520
I to wszystko, co zamierzamy zacząć od pierwszej części, która dotyczy tworzenia mózgu.

00:48.810 --> 00:51.330
I to zabierze nas do tutoriali.

00:51.360 --> 00:54.810
Możesz sobie wyobrazić, że tworzenie mózgu nie jest jak robienie ciasta.

00:54.900 --> 00:57.100
Będzie to wymagało więcej niż jednego samouczka.

00:57.270 --> 01:03.690
I oczywiście jak zwykle będziemy reprezentować ten mózg w klasie, ponieważ będziemy potrzebować

01:03.690 --> 01:10.200
kilku funkcji i aby mieć strukturę kilku funkcji, które będą zorganizowane w jakieś

01:10.200 --> 01:11.160
instrukcje.

01:11.310 --> 01:16.010
Oczywiście potrzebujemy klasy, a to Berkeley, ponieważ kiedyś zrobiliśmy tę klasę.

01:16.080 --> 01:22.080
Cóż, będziemy w stanie stworzyć tyle mózgów, ile chcemy, po prostu tworząc obiekty tej klasy.

01:22.080 --> 01:28.050
Więc znowu klasy w Pythonie i ogólnie rzecz biorąc języki programowania zorientowane obiektowo są bardzo praktyczne, ponieważ

01:28.200 --> 01:33.510
tworzysz model czegoś, co chcesz zbudować, a następnie jesteś w stanie stworzyć tyle obiektów, ile

01:33.510 --> 01:37.820
chcesz i będą one miały wszystkie funkcje, które ty zdefiniuj w klasie.

01:38.010 --> 01:40.470
I dla naszego mózgu cechy będą oczywiście.

01:40.500 --> 01:45.930
Przede wszystkim architektura sieci neuronowej, którą przypominam, będzie CNN i oczywiście

01:45.930 --> 01:51.780
dwiema różnymi funkcjami, jak na przykład przekazywanie sygnałów z neuronów wejściowych do

01:51.780 --> 01:55.520
neuronów wyjściowych, które będą oczywiście funkcją Forda.

01:55.920 --> 01:58.940
Zróbmy to, zacznijmy tworzyć mózg.

01:58.950 --> 02:00.600
To będzie ekscytujące.

02:00.650 --> 02:02.380
To jedna z moich ulubionych części.

02:02.520 --> 02:04.860
I dlatego przejdźmy od razu do tego.

02:04.890 --> 02:10.880
Zaczniemy od przedstawienia klasy kursu i będziemy ją nazywać.

02:10.950 --> 02:18.570
Cóż, zawahałem się nazwać to mózgiem, ale bądźmy bardziej bezpośredni i nazwijmy to CNN, ponieważ w rzeczywistości

02:18.570 --> 02:20.570
mózg jest siecią CNN.

02:20.580 --> 02:22.510
Konwolucyjna sieć neuronowa.

02:22.530 --> 02:27.440
Kiedy więc patrzysz, możesz zadzwonić do mózgu, jeśli chcesz, ale przynajmniej teraz wiemy, co budujemy.

02:28.710 --> 02:35.040
A CNN Jeśli chodzi o sieć samozasilającego się samochodu, będzie ona dziedziczyć po zakończeniu Mudgala.

02:35.220 --> 02:42.870
Więc pamiętaj, że koniec modułu jest tym, co tutaj umieściliśmy i chcemy móc korzystać ze wszystkich

02:42.870 --> 02:49.050
narzędzi tego i modułu, dlatego chcemy używać tej techniki w programowaniu obiektowym, który

02:49.050 --> 02:55.870
jest dziedziczeniem i który pozwala nam poznać dobrze wykorzystaj wszystkie narzędzia z klasy nadrzędnej,

02:55.900 --> 02:59.970
a ta klasa będzie w tym module.

02:59.970 --> 03:00.830
No to jedziemy.

03:00.930 --> 03:05.510
Teraz możemy używać wszystkich narzędzi i obiektów na końcu tego modułu.

03:05.510 --> 03:12.100
W porządku, więc teraz, gdy mamy nasze dziedzictwo, możemy wejść do klasy, aby pełnić naszą pierwszą funkcję.

03:12.150 --> 03:18.360
Jak zapewne domyślacie się, pierwszą funkcją jest funkcja końcowa, która definiuje wszystkie zmienne

03:18.720 --> 03:20.330
przyszłych obiektów mózgu.

03:20.370 --> 03:23.440
Znasz przyszłość i obiekty, które zostaną stworzone.

03:23.700 --> 03:24.890
W porządku, więc zróbmy to.

03:24.900 --> 03:29.800
Def, a następnie dwa podkreślenia w nim ponownie do wyników.

03:29.910 --> 03:31.910
A teraz musimy wprowadzić kilka zmiennych.

03:32.100 --> 03:37.460
Przede wszystkim zamierzałem być sobą, co oczywiście dotyczy obiektu.

03:37.490 --> 03:42.380
Teraz domyślam się, że czujesz się z tym dobrze, a my dodamy kolejną zmienną,

03:42.380 --> 03:45.310
która będzie liczbą akcji w środowisku Dumah.

03:45.500 --> 03:48.900
Więc nazwiemy te działania liczbowe.

03:49.010 --> 03:50.380
Liczba działań.

03:50.570 --> 03:54.390
I faktycznie ta zmienna nie jest obowiązkowa dla funkcji.

03:54.500 --> 03:59.360
Chodzi o to, że jeśli chcesz przetestować pomysł, który będziemy budować w innych środowiskach.

03:59.540 --> 04:06.100
No cóż, będzie to bardzo praktyczne, ponieważ zaimportujemy tę liczbę działań strasznych z owijki zagłady

04:06.120 --> 04:12.290
i Varmana z dwoma dyskretnymi, a kiedy to zrobimy, będziemy wiedzieć, że wejście do

04:12.510 --> 04:13.980
środowiska powoduje zerowanie.

04:14.180 --> 04:21.050
Jeśli więc chcesz, abyś eksperymentował z tym w innych środowiskach i dobrze grałeś w inne gry, nie będziesz

04:21.050 --> 04:26.300
miał nic do roboty, ponieważ ta liczba akcji bezpośrednio wpłynie na liczbę akcji w

04:26.300 --> 04:27.470
środowisku Dumora.

04:27.470 --> 04:28.650
Będziesz grał.

04:29.110 --> 04:32.710
OK, to tyle dla dwóch argumentów tej funkcji.

04:32.780 --> 04:36.500
Teraz możemy wejść do środka i teraz przypomnieć sobie, co musimy zrobić.

04:36.530 --> 04:41.560
Pierwszą rzeczą, którą musimy zrobić, to aktywować dziedziczenie za pomocą superfunkcji.

04:41.570 --> 04:43.840
Tak samo jest w przypadku samochodu do samodzielnego prowadzenia.

04:43.970 --> 04:50.940
Przyjmujemy superfunkcję, a następnie zaczynamy od wprowadzenia klasy, która zdefiniuje sieć neuronową,

04:51.470 --> 04:53.330
a mianowicie CNN.

04:53.690 --> 04:56.950
Następnie musimy wprowadzić self, aby odnieść się do obiektu.

04:57.190 --> 05:05.230
Ale pamiętaj, że to nie wszystko, co musimy dodać w DOT, a następnie funkcję init z nawiasem.

05:05.270 --> 05:07.880
A przez to aktywujemy dziedziczenie.

05:07.950 --> 05:11.470
A teraz możemy używać wszystkich narzędzi od końca i modułu.

05:11.510 --> 05:17.070
W porządku, więc teraz myślę, że nadszedł czas na zbudowanie architektury sieci neuronowej.

05:17.270 --> 05:23.330
Tak więc, jak pamiętacie, zbudujemy splotową sieć neuronową CNN, ponieważ tym razem

05:23.330 --> 05:30.290
AI będzie miała oczy, a oczy oka będą splotowymi warstwami tej splotowej sieci

05:30.290 --> 05:31.220
neuronowej.

05:31.520 --> 05:38.240
A potem, po tym, jak ai ai wizualizuje obrazy z warstwami splotowymi, przekaże je do

05:38.330 --> 05:41.040
klasycznej naszej wizualnej sieci neuronowej.

05:41.180 --> 05:44.510
To jest ten, który mieliśmy wcześniej z całkowicie połączonymi warstwami.

05:44.660 --> 05:50.730
I właśnie tam spróbuje przewidzieć wartości kostek dla każdej możliwej akcji, którą możemy zagrać.

05:51.290 --> 05:56.930
Więc masz na myśli architekturę najpierw, że będziemy mieli kilka splotowych warstw, a następnie kilka

05:56.930 --> 06:01.270
w pełni połączonych warstw, a to będzie mózg naszej sztucznej inteligencji.

06:01.550 --> 06:07.530
Więc co zrobimy, aby móc cofnąć się o to, co robimy.

06:07.670 --> 06:11.840
Cóż, po prostu stwórzmy tę architekturę ze zmiennymi, które chcemy stworzyć.

06:11.840 --> 06:18.890
Tak więc mówiąc o tej architekturze, zamierzamy zbudować CNN z trzema splotowymi warstwami.

06:18.920 --> 06:24.530
A potem po tej jednej ukrytej warstwie, co oznacza, że będziemy potrzebować trzech połączeń splotowych i

06:24.530 --> 06:26.020
dwóch pełnych połączeń.

06:26.180 --> 06:31.340
Mówiąc o połączeniach, które właśnie zamierzamy zdefiniować, będą to zmienne dla klasy

06:31.370 --> 06:35.030
CNN i dlatego teraz zdefiniuję pięć zmiennych.

06:35.150 --> 06:39.100
Trzy dla splotowych połączeń i dwóch politycznych powiązań.

06:39.350 --> 06:40.100
Zróbmy to.

06:40.100 --> 06:42.570
Zaczniemy od połączeń splotowych.

06:42.770 --> 06:47.250
Więc zamierzam je nazwać samoukiem.

06:47.540 --> 06:53.620
Ktoś zamierza to skopiować i na podstawie niskich.

06:54.020 --> 07:01.640
I wtedy dochodzimy do przekonania i do przekonania, że są to konwergentne powiązania z tym

07:01.640 --> 07:08.450
pierwszym wnioskiem. Tutaj zastosujemy splot do obrazów wejściowych, aby uzyskać pierwszą warstwę splotową,

07:08.460 --> 07:15.860
wtedy drugi wkład do tego zajmie pierwszy splot. warstwa jako dane wejściowe i ponownie nakładając

07:15.860 --> 07:21.180
splot, stworzy tam drugi splot, a następnie ten splot dostarczy nowych

07:21.180 --> 07:25.920
obrazów, z których każdy wykryje jedną konkretną cechę.

07:26.030 --> 07:32.840
Więc dostaniemy te nowe obrazy w splotach, wtedy zastosujemy tę splot, aby

07:32.870 --> 07:40.300
połączyć te nowe obrazy z tej pierwszej warstwy splotowej z nowymi obrazami drugiej warstwy splotu.

07:40.430 --> 07:46.120
Te nowe obrazy ponownie wykryją pewne cechy na obrazach pierwszego splotu tam.

07:46.220 --> 07:52.100
Chodzi więc o wzmocnienie przyszłego wykrycia, a następnie pojawienie się tam drugiego

07:52.100 --> 07:52.650
splotu.

07:52.790 --> 07:57.000
Zastosowaliśmy trzeci splot tutaj, aby uzyskać go dla każdego z nich.

07:57.050 --> 08:01.900
Jeszcze więcej zdjęć, które wykrywają jeszcze więcej funkcji w obrazach wejściowych.

08:02.050 --> 08:07.300
I dlatego im bardziej to robimy, tym bardziej stosujemy zwinięcia na różnych warstwach obrazów.

08:07.520 --> 08:13.580
Cóż, tym bardziej jesteśmy w stanie wykryć niektóre funkcje i tak przez detekcję funkcji oko zrozumie, gdzie

08:13.580 --> 08:18.360
potwory są, gdzie musi strzelać, aby je zabić i dokąd powinno się udać.

08:18.500 --> 08:21.290
Wykryje również przeszkody na ścianach.

08:21.440 --> 08:28.100
Dosłownie, dokąd musi iść, a to dzięki temu, co wszystkie te splotowe warstwy wykrywają

08:28.130 --> 08:29.680
w oryginalnych obrazach.

08:30.450 --> 08:34.980
W porządku, więc to dla splotu części CNN.

08:35.100 --> 08:42.720
Ale pamiętajmy, że po warstwach splotu musimy spłaszczyć wszystkie piksele uzyskane przez różne serie zwojów,

08:42.720 --> 08:48.660
które zostały zastosowane i spłaszczając wszystkie tablice pikseli otrzymujemy ten ogromny wektor,

08:48.810 --> 08:53.260
który stanie się wejściem klasycznej sztucznej sieci neuronowej.

08:53.490 --> 08:58.600
I tu dostajemy nasze w pełni połączone listy, a więc nasze połączenia.

08:58.710 --> 09:04.560
Teraz musimy stworzyć dwie nowe zmienne, ponieważ będziemy je mieć tu i tam w tej

09:04.810 --> 09:09.330
klasycznej sztucznej sieci neuronowej, która będzie następna i dlatego potrzebujemy jednego

09:09.330 --> 09:16.260
pełnego połączenia z tego ogromnego, płaskiego wektora do tego tutaj i tam i drugie pełne połączenie między tym

09:16.260 --> 09:21.620
tu i tam, a warstwą wyjściową złożoną z wyjściowych neuronów, które są wartościami kluczowymi.

09:21.960 --> 09:27.090
Zróbmy więc te dwa pierwsze połączenia, a następnie zdefiniujemy wszystkie te połączenia.

09:27.240 --> 09:36.200
Poproszę więc o ścieżkę dźwiękową w kodzie, którą nazwalibyśmy "ja" tym, a potem samemu nauczałem C.

09:36.240 --> 09:41.010
W porządku, więc teraz mamy wszystkie nasze kosztowności i wiemy, co musimy zrobić,

09:41.250 --> 09:44.300
to oczywiście zdefiniowane w klasach modułu silnika.

09:44.310 --> 09:49.110
Oznacza to, że zasadniczo stworzymy architekturę sieci neuronowej i to zrobimy w

09:49.190 --> 09:50.340
następnym jutro.

09:50.490 --> 09:51.920
Do tego czasu I.
