Sieci neuronowe

1. Sztuczna sieć neuronowa

Co to jest sztuczna sieć neuronowa (ang. artificial neural networks) lub, w innych słowach głębokie ucznie (and. deep learning)? W uproszczeniu to algorytmy lub mechanizmy, które próbują naśladować mózg człowieka, a mówiąc konkretniej komórki neuronowe, w celu stworzenia mechanizmu umożliwiającego maszynie ( np. komputerowi, telefonowi, robotowi) posiadać zdolność do samodzielnego uczenia. Wygląd komórki mózgowej jest pokazany na rysunku (Rys. 1) , można wyróżnić elementy składowe neuronu : dendryty które pryzmują sygnały z zewnątrz i przekazują je do ciała neuronu, jeśli ten sygnały są wystarczająco silne lub ich liczba jest wystarczająca, to ciało jest pobudzone, a sygnał przychodzi przez ciało i jest przykazywany dalej do akson co w efekcie dochodzi do innego neuronu. (W uproszczeniu ).

Rys. 1.

Sztuczna sieć neuronowa składa się z kilku do kilkuset sztucznych neuronów, które są matematycznym modelem prawdziwych ludzkich neuronów. Poniższa ilustracja (Rys. 2) pokazuje budowę jednego sztucznego neuronu:

Rys. 2

Neuron składa się z czterech elementów:

• warstwa wejściowa;
• wagi neurona;
• ciało neurona;
• funkcja aktywacji, która daje odpowiedzi neurona.

Warstwa wejściowa :

Neuron może pryzmować wiele sygnałów wejściowych (tu są oznaczone jako  „x”). Fachowo nazwane jest to jako warstwa wejściowa, która przyjmuje wartości z zewnątrz  i przykazuje je do neuronu. Warstwa wejściowa jest wektorem o rozmiarze równym liczbie sygnałów wejściowych. Przykładowo: jeśli mamy neuron, który przyjmuje dwa sygnały (wartości) wejściowe, to warstwa wejściowa jest wektorem o rozmiarze dwuelementowym, który jest zapisany w sposób, który jak pokazuje poniższe równanie (wzr. 1.1.):

x= [x 1, x 2] T      (wzr. 1.1.)

W przypadku, gdy mamy trzy sygnały (wartości) wejściowe, wektor byłby trójelementowy,  a zapisany byłby według równania (wzr. 1.2.):

x= [x 1, x 2, x 3 ] T    (wzr. 1.2.)

Analogicznie postępuje się w przypadku pięć, sześć i więcej wejść. Ogólna postać wektora wejściowego jest pokazana na wzorze (wzr. 2.3.):

x= [x 1, x 2, …x n ] T   (wzr. 1.3.)

Wagi:

Wagi neurona to wektor, który ma rozmiar podobny do wektora wejściowego. Każdy element tego wektora jest przeznaczony dla danego sygnału wejściowego z wektora wejściowego. Cała wiedza (doświadczenie) neurona jest zapisane (zachowane) w wagach neurona. Gdy wykonujemy proces uczenia sieci neuronowej, to wagi neuronów są zmieniane dotąd, aż dojedziemy do odpowiednich wag – wówczas mówi się, że dana sieć jest nauczona. Ogólna postać danego wektora wag jest pokazana na równaniu (wzr. 1.4.):

w= [w1, w2, … wn ] T   (wzr. 1.4.)

Ciało neurona:

Ciało neurona (ang. transfer function) wykonuje iloczyn skarny dwóch wektorów (wektor wag oraz wektor wejściowy) według wzoru (wzr. 1.5.). Gdy będziemy mieć wartość iloczynu neuronu, to dodajemy do niego odchylenie (bias), które zazwyczaj jest równe +1, i przekazuje tą wartość do funkcji aktywacji.

 (wzór 1.5)

Funkcja aktywacji:

Działanie sieci neuronowej opiera się na aproksymowaniu pewnej funkcji. Wartość funkcji aktywacji jest sygnałem wyjściowym neuronu, a następnie jest ona przesyłana do neuronów kolejnej warstwy, jeśli ta istnieje. Funkcja aktywacji może przyjmować jedną z trzech poniższych postaci:

• skoku jednostkowego;
• liniowa;
• nieliniowa.

Właśnie przez tego typu sztuczne neurony tworzy się sieć neuronowa. Właściwość nieliniowości umożliwia sieci na osobne uczenie się rożnych wariacji obiektu o tej samej klasie. Natomiast neuron liniowy, w podobnej sytuacji, podejmie próbę nauki wszystkich odmian tej samej klasy dostępnych w danym zestawie wag. Warto tutaj zaznaczyć, że im więcej neuronów oraz warstw będzie poddawanych procesowi uczenia, tym lepiej, jednakże wówczas należy posiadać więcej danych do uczenia.

Rys. 3

Powyższy rysunek (Rys. 3) pokazuje przykładową sieć neuronową, która składa się z kilku neuronów oraz dwóch warstw. Pierwsza warstwa posiada trzy neurony, natomiast druga warstwa ma jeden neuron wyjściowy (są one zaznaczone na pomarańczowo). Każdy neuron posiada składa się z tych samych elementów, które był wspomniane powyżej. Neurony z pierwszej warstwy przyjmują trzy sygnały wejściowe x1, x2, x3 (są zaznaczone na niebiesko) oraz bias (+1).

2. Jak zbudować sieci neuronowe:

Budowę sieci można wykonać na różne sposoby. Na przykład możemy to zrobić samodzielnie z wykorzystaniem własnego ulubionego języka programowania, jak np. Java, Python, JavaScript itd., aczkolwiek istnieją gotowe narzędzia, biblioteki lub frameworki, które dają nam możliwość zbudowania sieci w sposób szybki i łatwy. Oto lista najpopularniejszych bibliotek przeznaczonych do budowy sztucznej inteligencji :

TensorFlow™ to biblioteka oprogramowania typu open source, przeznaczona głównie do obliczeń o wysokiej wydajności. Posiada elastyczną architekturę, która pozwala na łatwe wdrażanie obliczeń na różnych platformach (procesorach, GPU, TPU), a także na komputerach stacjonarnych, klastrach serwerów, urządzeniach przenośnych. Pierwotnie opracowana została przez naukowców i inżynierów z zespołu Google Brain w ramach organizacji AI Google. Zapewnia ona silne wsparcie dla uczenia maszynowego  i głębokiego uczenia się, a elastyczny rdzeń obliczeniowy jest wykorzystywany w wielu innych dziedzinach nauki.

Theano to biblioteka Pythona, która umożliwia efektywne definiowanie, optymalizowanie i ocenianie wyrażeń matematycznych obejmujących wielowymiarowe tablice.

CNTK Microsoft Cognitive Toolkit (CNTK) to zestaw narzędzi open-source do rozpowszechniania na poziomie komercyjnym. Opisuje sieci neuronowe jako serię kroków obliczeniowych za pomocą skierowanego wykresu. CNTK pozwala użytkownikowi łatwo realizować i łączyć popularne typy modeli, takie jak feed-forward DNN, splotowe sieci neuronowe (CNN) oraz rekurencyjne sieci neuronowe (RNN / LSTM). CNTK implementuje stochastyczne pochodzenie gradientowe (SGD, backpropagation)  z automatycznym rozróżnianiem i równoległością wielu GPU oraz serwerów.

Keras jest interfejsem API sieci wysokiego poziomu, napisanym w języku Python, mogącym również działać na platformie TensorFlow, CNTK lub Theano. Został opracowany z naciskiem na umożliwienie szybkiego eksperymentowania. Możliwość przejścia od pomysłu do wyniku z najmniejszą możliwą zwłoką jest kluczem do dobrych badań.

3. Przykład zastosowania sieci neuronowej.

Sieć neuronowa jest wykorzystana w wielu dziedzinach do rozwiązania różnego typu problemów. W tym artykule pokażę, w jaki sposób stworzyć prostą sieć neuronową  z wykorzystaniem TensorFlow w celu predykcji cen kursu firmie Google z wykorzystaniem języka Python. Dla miesiąca styczeń z roku 2017 na podstawie cen z roku 2012 do roku 2016, czyli ostanie pięć lat.

W celu ułatwiania zrozumienia zagadnienia, podzielmy proces na pięć etapów, które są  z zazwyczaj podstawowe i najczęściej powtarzają się, gdy próbujemy rozwiązać dany problem  z wykorzystaniem sieci neuronowych.

Etap 1. Przetwarzanie danych uczących

Jak wspominałem, chcemy przewidzieć ceny kursu akcji firmy Google dla miesiąca styczeń na podstawie ostatnich pięciu lat. Potrzebujemy zatem danych uczących, które będą posiadać informacje na temat kursu firmy Google z ostatnich pięciu lat. Możemy pobrać je ze stron internetowych, np. Yahoo Finance, Kaggel, Reddit itp. Dolna ramka danych pokazuje fragment moich danych uczących oraz ich strukturę:

Jak widzimy, każdy rekord zestawu to dany dzień z zakresu lat 2012 – 2016. Poszczególny rekord posiada różne informacje, jak np. cena otwarcia kursu w giełdzie danego dnia, cena zamknięcia itd. W naszym prostym przykładzie wystarczy cena otwarcia. Wczytujemy nasz zestaw, a następnie wydzielmy z niego tylko cenę otwarcia. Później następuje normalizacja danych do zakresu [0, 1]. W tym celu korzystamy z j biblioteki scikit-learn. Ostatnim krokiem w pierwszym etapie jest podzielenie aktualnych danych na rekordy. Każdy z nich będzie posiadać 60 elementów czyli 60 dni po kolei. Następny rekord będzie posiadać też 60 dni, tylko z jednym przesunięciem, czyli pierwszy dziedzin będzie usunięty a końcu rekordu dodamy następny dzień i tak poklei, aż dojedziemy do dnia 31-12-2016. To ostatni element (dzień) w naszym zestawie do uczenia, ponieważ następny dzień byłby 01-01-2017, – a to data, dla której chcemy za pomocą sieci przewidzieć cenę kursu dla tego dnia. Cały etap jest zakodowany za pomocą Python.

Rys. 5

#########################
# Part 1 – Data Preprocessing
################################

[code lang="python"]
<import pandas as pd>
<from sklearn.preprocessing import MinMaxScaler>

<dataset_train = pd.read_csv('path/to/dataset')>

<x_train_sc = dataset_train.iloc[:, 1:2].values>
<sc = MinMaxScaler(feature_range=(0,1))>

<sc.fit(x_train_sc)>
<x_train_sc = sc.transform(x_train_sc)>

<NUMBER_OF_DAYS = 60>
<x_train = []>
<y_train = []>

<for i in range(NUMBER_OF_DAYS, len(x_train_sc)):>
<x_train.append(x_train_sc[i-NUMBER_OF_DAYS:i, 0])>
<y_train.append(x_train_sc[i, 0])>

<x_train = np.array(x_train)>
<y_train = np.array(y_train)>

[/code]

Etap 2. Budowa sieci

Nasza sieć będzie przejmować 60 sygnałów wejściowych (60 dni) oraz składać się z trzech warstw :

• pierwsza warstwa to 128 neuronów, z których każdy posiada Rectfied jako funkcję aktywacji;
• druga warstwa to również 128 neuronów, a każdy neuron posiada Rectfied jako funkcjaę aktywacji;
• ostania warstwa posiada jeden neuron wejściowy, który będzie nam pokazywać predykcje sieci; ten neuron posiada sigmoidalną funkcję aktywacji.

Kod, który buduje naszą sieć jest ukazany poniżej:

##########################
# Part 2 – ANN, Build the model
################################

[code language="python"]

<import tensorflow as tf>
<from tensorflow import keras>

<NUMBER_OF_DAYS = 60>
<NUMBER_OF_NEURONS = 128>
<NUMBER_OF_OUTPUTS = 1>

<def build_model():>
<model = keras.Sequential([
<keras.layers.Dense(units = NUMBER_OF_NEURONS, activation = tf.nn.relu, input_shape = <(NUMBER_OF_DAYS, )),>
<keras.layers.Dense(units = NUMBER_OF_NEURONS, activation = tf.nn.relu),>
<keras.layers.Dense(units = NUMBER_OF_OUTPUTS)>
<])>

<optimizer = tf.train.RMSPropOptimizer(learning_rate = 0.001)>
<model.compile(loss='mse',optimizer=optimizer,metrics=['mae'])>

<return model>
<##>

<model = build_model()>
<model.summary()>

[/code]

Etap 3. Uczenie sieci

W momencie, gdy nasz model już będzie zbudowany, możemy przejść do jego trenowania. TensorFlow oferuje różne algorytmy uczenia. W nich znajduje się moduł o nazwie „tf.train”.  W naszym przypadku wykorzystamy przykładowy algorytm uczenia, który jest umieszczony  w rodzinie algorytmów optymalizacji gradientów prostych. Będziemy trenować nasz model przez 500 epok:

##########################
# Part 3 – Train the model
################################

[code language="python"]

<EPOCHS = 500>
<history = model.fit(x_train, y_train, epochs=EPOCHS)>

[/code]

Etap 4. Predykcja za pomocą sieci

Kiedy już mamy w posiadaniu konkretny nauczony model, możemy już przejść do predykcji cen kursu firmy Google dla miesiąca styczeń z roku 2017. Biorąc pod uwagę, że nasza sieć była nauczona na danych z zakresu lat 2012 – 2016.

Podsumowanie:

Rys. 6

Jak widzimy na poprzedniej ilustracji (Rys. 6), ceny realne kursu firmy Google są zaznaczone czerwonym wykresem, natomiast niebieski wykres to przepowiednia naszego modelu. Sieć nie była dokładna w 100% z rożnych powodów. Po pierwsze, nasz model jest prosty, po drugie na ceny kursu wpływają różne czynniki zewnętrzne, jak polityka, sentyment giełdy, kryzysy itd., co trzeba w przyszłości uwzględnić w naszym modelu , aby zwiększyć jego dokładność.

Mimo że nasz model był prosty, to pokazywał rewelacyjne odpowiedzi. Zakładając, że nie posiadamy w ogóle ceny kursu z miesiąca styczeń roku 2017, możemy za pomocą sieci dokonać przedwstępnej analizy rynku i przygotować się odpowiednio.

Co więcej sprawa, jeśli wiemy, że przewidywane przez sieć ceny zachowywały prawie tak samo, jak prawdziwe ceny (trend, czyli wzrost był w cenie kursu), to sieć była w stanie wykryć upadek, co też pokazała to.

autor:

Salem Albarudy

AI Developer@AI FORCE 1