Cześć i witamy w tutorialu Python.
W porządku, więc ekscytuje nas gleba przed nami.
Zaczniemy od stworzenia architektury sieci neuronowej, dzięki której zbudujemy sieć neuronową, która
będzie w centrum naszej sztucznej inteligencji i która zwróci działanie, by grać w wieku 90 lat.
Zróbmy to.
Ponieważ chcemy, aby nasza sieć neuronowa była obiektywna, zamierzamy uczynić ją klasą.
A to dlatego, że jest o wiele wygodniejszy.
Wiesz, że klasa jest modelem czegoś, co chcemy zbudować.
Chcemy zbudować sieć neuronową i musimy wykonać instrukcje, które będą zawarte w
klasie.
I w tej klasie zamierzamy wykonać dwie funkcje.
Najpierw funkcja init, która jest funkcją, która pojawia się cały czas podczas tworzenia klasy.
I to w zasadzie definiuje zmienną twojego obiektu, którym jest sieć neuronowa.
Znasz zmienne związane z obiektem, w przeciwieństwie do zmiennych globalnych.
I to właśnie w tej funkcji zdefiniujemy architekturę nowej sieci, którą znacie, definiując
warstwę wejściową, która będzie składała się z pięciu neuronów wejściowych, ponieważ mamy pięć wymiarów dla
zakodowanego wektora stanów wejściowych.
Następnie zdefiniujemy kilka ukrytych warstw.
Może zaczniesz od jednej ukrytej warstwy, a potem będziesz mógł wypróbować inne architektury
sieci neuronowej.
I wtedy oczywiście otrzymamy warstwę wyjściową, która będzie zawierała możliwe akcje, które możemy
grać za każdym razem.
Tak właśnie zrobimy w tej funkcji.
A następnie utworzymy jeszcze jedną funkcję wewnątrz klasy, która będzie funkcją naprzód
i która będzie funkcją aktywującą neurony w sieci neuronowej.
Wiesz, że to aktywuje sygnały, więc użyjemy wyprostowanej funkcji aktywacji, ponieważ
oczywiście mamy do czynienia z czysto nieliniowym problemem, a ta poprawiona funkcja przełamuje liniowość.
Ale głównie sprawiamy, że funkcja Forda zwraca wartości q, które są wyjściami sieci.
Ale mamy jedną kluczową wartość dla każdego działania.
Później zwrócimy ostatnią akcję, przyjmując maksimum kluczowych wartości lub stosując miękką metodę
Max.
Zobaczymy to później.
W tym tutorialu zaczniemy od zaimplementowania funkcji init, a
następnie zaimplementujemy funkcję forward.
Zróbmy to.
Najpierw musimy przedstawić naszą klasę.
Zaczynamy od klasy, a my nadajemy nazwę naszej klasie, którą możemy nazwać siecią.
A potem w tej klasie sieciowej zamierzam użyć techniki programowania obiektowego, która jest nazywana dziedziczeniem,
a która po prostu dziedziczy po wszystkich narzędziach klasy macierzystej.
Nasza klasa sieciowa, którą zamierzamy stworzyć, jest testem dla dzieci większej klasy.
I ten moduł.
To po prostu dziedziczy po wszystkich narzędziach tej klasy modułów, które oczywiście są narzędziami do implementacji
sieci neuronowej.
Jest to bardzo potężna i ewolucyjna sztuczka w programowaniu zorientowanym obiektowo, która idzie w parze z dziedzictwem.
I właśnie teraz dziedziczymy z tej klasy nadrzędnej modułu.
W porządku, a teraz jesteśmy gotowi wejść do klasy.
Tak więc dwukrotnie wciskam enter, ponieważ będziemy wykonywać dwie funkcje i zaczynamy od
funkcji zakończenia.
Tak więc funkcja init, którą musimy nazwać w ten sposób, z dwoma na tym kursie, a następnie w nim.
I jeszcze raz, aby podkreślić, że jest to po prostu składnia Pythona, tak jak musimy to zrobić.
A potem musimy przedstawić argumenty.
Mamy więc trzy argumenty.
Pierwszy to obowiązkowy argument, który jest w rzeczywistości Self i Self.
Nie ma w tym tajemnicy, która odnosi się do przedmiotu, który zostanie stworzony z tej klasy, którą zamierzamy
stworzyć.
Wiesz, że tworzymy tę klasę.
To trochę jak instrukcja jakiegoś modelu tej sieci neuronowej, którą chcemy zbudować.
A kiedy klasa będzie już gotowa, możemy stworzyć tyle sieci, ile chcemy.
Każda z tych nowych sieci będzie przedmiotem tej klasy, a ponieważ będziemy używać tego
obiektu do innych celów, musimy to zrobić, ale jakie są zmienne obiektu i Spudis, używamy tego
tutaj, aby określić, że odnosi się do obiektu.
Kiedykolwiek chcę użyć dostępnego z mojego obiektu, użyję self przed zmienną, aby określić,
że jest to zmienna obiektu.
W porządku, to jest pierwszy argument, a następnie mamy dwa
inne argumenty, które są oczywiście liczbą neuronów wejściowych i liczbą neuronów wyjściowych.
Tak więc liczba neuronów wejściowych nazwiemy wielkością wejściową, która w rzeczywistości wynosi pięć, ponieważ nasze
wektory wejściowe mają pięć wymiarów do trzech sygnałów plus orientacja plus orientacja ujemna, które
są wektorami zakodowanych wartości, które opisują jeden stan środowiska.
Te pięć wartości wystarczy, aby opisać stan środowiska.
Moglibyśmy pomyśleć o mniej wartościach lub więcej wartościach, ale tego właśnie próbowałem i ma to
sens, ponieważ potrzebujemy jednego sygnału od lewego przed nami i po prawej.
Wiesz, kiedy jedziemy samochodem, mogliśmy poszukać sygnału 360, który znamy jak sygnały na
górze samochodów Google, które możemy całkowicie samozasilać z trzema czujnikami, a następnie mamy orientację i
orientację względem ciebie wiedzieć, śledzić cel, do którego próbujesz dotrzeć.
A potem mamy oczywiście neurony wyjściowe naszej sieci, które odpowiadają akcjom i mamy trzy możliwe działania idące
w lewo idąc prosto lub idąc w prawo.
I dlatego nazwę to i działaniem, a będzie ich trzech.
W porządku.
Do tej pory wystarczy podać nazwy wejść, a następnie użyjemy tych siatkówki, aby wykonać warunki
wewnątrz sieci neuronowej.
W porządku, a ty zaczynasz od użycia innej sztuczki latarki, ta sztuczka to superfunkcja, która
jest funkcją, która faktycznie dziedziczy z modułu.
Właśnie dlatego musieliśmy wykorzystać dziedziczenie, aby odziedziczyć moduł.
To jest pierwszy w użyciu.
Zasadniczo używamy tylko tej superfunkcji super-sztuczki, aby móc korzystać z narzędzi modułu, które są
znacznie bardziej wydajne.
Wewnątrz superfunkcji muszę najpierw określić sieć.
Więc to jest nasza chul klasa sieci, którą znasz, ponieważ dziedziczy ona z klasy nadrzędnej modułu,
a następnie naszego obiektu.
A potem dodajemy to i funkcjonujemy w taki sposób, jak to nazwaliśmy.
W porządku, to tylko sztuczka polegająca na użyciu wszystkich dostępnych narzędzi.
W tym module możemy przejść do kolejnego kroku, który ma określić warstwę wejściową.
Więc w zasadzie muszę wprowadzić nową zmienną, która będzie dołączona do obiektu, a
ta zmienna będzie zawierała liczbę neuronów wejściowych.
Więc nie mylić z wielkością wejściową rozmiar wejściowy jest argumentem funkcji końca.
Ale to nie jest zmienna dołączona do obiektu, ale zmienna dołączona do
obiektu.
Jak już wspomniałem, musimy określić, że jest on dołączony do obiektu, więc używamy samouka
i teraz podajemy nazwę tej pierwszej zmiennej dołączonej do obiektu.
Możemy więc podać tę samą nazwę, co dane wejściowe.
Możemy nazwać to wielkością wejściową i powiemy, że jest równa argumentom funkcji, która jest wielkością wejściową.
W porządku.
Za każdym razem, gdy tworzę obiekt z klasy sieci i podaję rozmiar wejściowy jak na
przykład kładę 5.
Będzie tutaj 5, a zatem wielkość wejściowa zmiennej naszego obiektu będzie miała wartość 5, ponieważ
ten rozmiar wejściowy będzie wynosił 5, a zatem nasza nowa sieć będzie miała 5 neuronów wejściowych
w warstwie wejściowej.
W porządku.
A to samo dotyczy innej zmiennej, którą chcemy przywiązać do obiektów.
I jak można się domyślić, będzie to zmienna dla liczby neuronów wyjściowych.
I mówimy, że bierzemy własny obiekt, a następnie nadajemy tej drugiej zmiennej obiekt,
który nazwiemy i działaniem.
I będzie to równe temu argumentowi, biorąc pod uwagę liczbę działań, jaką jest liczba neuronów
wyjściowych.
Tak więc ustawiliśmy to samo, co działanie, a działanie będzie równe trzy.
Dlatego zmienna i akcja dołączona do naszego obiektu do sieci otrzymają wartość trzy.
Właściwie to widzimy ostrzeżenie tutaj, gdy mówi niezdefiniowana nazwa.
A to dobrze, bo tutaj używamy.
A potem skrót.
I musimy użyć skrótu tutaj.
I na początek torche i w Mudgalu, a potem zniknie.
No to ruszamy.
Idealny.
W tej chwili mamy nowe ostrzeżenia, wszystkie ostrzeżenia mają na celu tylko wskazanie, że to, co importujemy, nie jest
jeszcze używane.
W porządku, będziemy je później wykorzystywać.
W porządku, mamy dwie kolejne zmienne, które chcemy zdefiniować dla obiektu.
I to będą pełne połączenia pełne połączenia między różnymi warstwami naszej sieci
neuronowej.
Ponieważ teraz chcemy stworzyć sieć neuronową złożoną z tylko jednej głowy w ich świecie,
będą dwa pełne połączenia.
Wystąpi jedno pierwsze pełne połączenie pomiędzy warstwą wejściową a warstwą ukrytą.
I jedno drugie pełne połączenie między wzgórzem a warstwą wyjściową.
Zacznijmy więc od pierwszego pełnego połączenia.
Nazwiemy to SE1 I znowu używam tutaj siebie, aby określić, że FC jeden jest zmienną mojego obiektu, aby to
rozwiązać.
FC, który będzie równy.
Teraz używamy modułu N w module i zamierzamy użyć funkcji o nazwie liniowy R, a to dokładnie
sprawia, że to pełne połączenie między neuronami i warstwą wejściową do neuronów ukrytego tam.
I co mam na myśli przez pełne połączenie.
Oznacza to, że wszystkie neurony warstwy wejściowej będą połączone ze wszystkimi neuronami
tutaj.
Aby uzyskać to połączenie, używamy tej funkcji liniowej, do której musimy podać kilka argumentów.
I jak widać te argumenty są w funkcji.
Tak więc jest to liczba neuronów pierwszego prawa, które chcesz połączyć je z funkcjami, która
jest liczbą neuronów drugiej warstwy, którą chcesz połączyć, czyli warstwą po prawej, która
jest warstwą ukrytą i prawdziwą rowerem.
Tak więc rower jest prawdziwy, zachowamy domyślną wartość, aby mieć odchylenie, a nie tylko pewną wagę związaną z
biegiem, który będziemy musieli poczekać i jedno odchylenie dla każdej warstwy.
A więc zobaczmy, co musimy wprowadzić.
Pierwszym argumentem w funkcji jest liczba neuronów wejściowych w warstwie wejściowej.
I gdzie to jest.
To jest właściwie nieprecyzyjne.
To jest argument naszej funkcji init, która później będzie w stanie walczyć z orientacją trzech
sygnałów i orientacją Mannusa.
Więc zaczynamy.
Kiedy pierwsze argumenty i rozmiar put, a następnie drugi argument są poza funkcjami to jest to liczba neuronów, które
chcemy mieć w drugiej warstwie.
Druga warstwa, która będzie w pełni połączona z pierwszą warstwą.
I tak teraz pytanie brzmi, ile neuronów chcemy w tej ukrytej warstwie.
Zrobiłem dużo treningu parametrów.
Zrobiłem dużo eksperymentów.
To właśnie robimy lub robimy to głębiej.
Generalnie przeprowadzamy wiele eksperymentów, aby zobaczyć, jaka jest najlepsza sieć neuronowa dla naszego konkretnego
problemu.
Tak więc próbuję wielu wartości i ostatecznie wybrałem 30 30 przebiegów w ukrytej warstwie, a zobaczysz, że
z tą liczbą otrzymamy całkiem dobre wyniki, ale wtedy możemy zmienić architekturę
sieci neuronowej.
Zapraszam do zabawy.
Możesz nie tylko zmienić liczbę neuronów w tu i tam, ale także możesz dodać więcej
warstw, abyś mógł otrzymać jeszcze lepszy samochód, ale neurony 30 hinna zapewnią nam dobrą sieć neuronową i
dobrą przyczynę.
Właśnie o to idziemy.
I oto idziemy.
Mamy pierwsze pełne połączenie z tą funkcją liniową.
Tworzymy połączenie między warstwą wejściową a ukrytą nogą.
A teraz czas na drugie pełne połączenie, które jest pełnym połączeniem między warstwą ukrytą
a warstwą wyjściową.
Więc idziemy.
Nazwiemy to drugie pełne połączenie w C2.
No to jedziemy.
I nadal jest to dostępne dla większej liczby obiektów korzystających z Saphir.
I znowu używamy.
Właściwie możemy to skopiować, ponieważ zamierzamy użyć N w module, a następnie w funkcji liniowej.
Ale najpierw musimy najpierw zmienić argumenty.
To samo dotyczy liczby neuronów, które będziemy mieć w pierwszej warstwie połączenia.
Więc to jest ukryte.
A zatem jest to 30, a następnie drugi argument to liczba neuronów w drugiej
warstwie połączenia, która odpowiada warstwie wyjściowej, a wyjście ma.
I rzeczywiste neurony, które później będą trzy, ponieważ mamy trzy możliwe działania, ale do tej pory
musimy użyć nazw, które zdefiniowaliśmy.
To jest nazwa argumentu funkcji init, dlatego też wprowadzamy tutaj i akcję, i
idziemy.
Przede wszystkim nasze połączenia krotkowe ponownie.
A po drugie są jakąkolwiek funkcją Izraela.
Tak właśnie zainicjujemy nasz obiekt za każdym razem, gdy stworzymy obiekt z klasy sieci.
A więc, gdy tylko stworzymy obiekt dobrze wszystkie te zmienne dla zmiennych tutaj wielkość wejściowa i reakcja.
Ty i dwa zostaną zdefiniowani.
I tak otrzymamy architekturę naszej sieci zwierząt dla każdego tworzonego przez nas obiektu.
Każdy obiekt będzie odpowiadał sieci neuronowej z pięcioma neuronami wejściowymi, 30 ukrytymi neuronami i trzema
wyjściowymi neuronami.
Więc idziemy.
Skończymy z tą pierwszą funkcją, a teraz możemy przejść do drugiej funkcji, która
jest funkcją do przodu i która będzie używana do aktywacji neuronów w sieci neuronowej za pomocą
funkcji aktywacji prostownika i głównie do powrotu do wartości kostek, które są wyjścia tylko jednej sieci.
Nie mogę się doczekać, aby to zrobić w następnym samouczku i do tego czasu.