AI z Pythonem - sieci neuronowe

Sieci neuronowe to równoległe urządzenia obliczeniowe, które są próbą stworzenia komputerowego modelu mózgu. Głównym celem jest opracowanie systemu do wykonywania różnych zadań obliczeniowych szybciej niż systemy tradycyjne. Zadania te obejmują rozpoznawanie i klasyfikację wzorców, przybliżenie, optymalizację i grupowanie danych.

Co to są sztuczne sieci neuronowe (ANN)

Sztuczna sieć neuronowa (ANN) to wydajny system obliczeniowy, którego motyw przewodni został zapożyczony z analogii biologicznych sieci neuronowych. SSN są również nazywane sztucznymi systemami neuronowymi, równoległymi systemami przetwarzania rozproszonego i systemami łącznikowymi. ANN pozyskuje duży zbiór jednostek, które są ze sobą połączone w pewien sposób, aby umożliwić komunikację między nimi. Jednostki te, nazywane równieżnodes lub neurons, to proste procesory, które działają równolegle.

Każdy neuron jest połączony z innym neuronem za pomocą connection link. Każdemu łączu przypisana jest waga zawierająca informacje o sygnale wejściowym. Jest to najbardziej przydatna informacja dla neuronów do rozwiązania konkretnego problemu, ponieważ plikweightzwykle pobudza lub hamuje przesyłany sygnał. Każdy neuron ma swój stan wewnętrzny, który nazywa sięactivation signal. Sygnały wyjściowe, które powstają po połączeniu sygnałów wejściowych i reguły zadziałania, mogą być wysyłane do innych jednostek.

Jeśli chcesz szczegółowo zbadać sieci neuronowe, możesz skorzystać z linku - Sztuczna sieć neuronowa .

Instalowanie przydatnych pakietów

Do tworzenia sieci neuronowych w Pythonie możemy użyć potężnego pakietu dla sieci neuronowych o nazwie NeuroLab. Jest to biblioteka podstawowych algorytmów sieci neuronowych z elastycznymi konfiguracjami sieci i algorytmami uczenia się dla Pythona. Możesz zainstalować ten pakiet za pomocą następującego polecenia w wierszu polecenia -

pip install NeuroLab

Jeśli korzystasz ze środowiska Anaconda, użyj następującego polecenia, aby zainstalować NeuroLab -

conda install -c labfabulous neurolab

Budowanie sieci neuronowych

W tej sekcji zbudujemy kilka sieci neuronowych w Pythonie przy użyciu pakietu NeuroLab.

Klasyfikator oparty na perceptronie

Perceptrony są budulcem ANN. Jeśli chcesz dowiedzieć się więcej o Perceptronie, możesz skorzystać z linku - artificial_neural_network

Poniżej przedstawiono krokowe wykonanie kodu Pythona w celu zbudowania prostego klasyfikatora opartego na perceptronie sieci neuronowej -

Zaimportuj niezbędne pakiety, jak pokazano -

import matplotlib.pyplot as plt
import neurolab as nl

Wprowadź wartości wejściowe. Zauważ, że jest to przykład nadzorowanego uczenia się, dlatego będziesz musiał również podać wartości docelowe.

input = [[0, 0], [0, 1], [1, 0], [1, 1]]
target = [[0], [0], [0], [1]]

Utwórz sieć z 2 wejściami i 1 neuronem -

net = nl.net.newp([[0, 1],[0, 1]], 1)

Teraz wytrenuj sieć. Tutaj używamy reguły Delta do treningu.

error_progress = net.train(input, target, epochs=100, show=10, lr=0.1)

Teraz zwizualizuj dane wyjściowe i wykreśl wykres -

plt.figure()
plt.plot(error_progress)
plt.xlabel('Number of epochs')
plt.ylabel('Training error')
plt.grid()
plt.show()

Możesz zobaczyć następujący wykres przedstawiający postęp szkolenia przy użyciu metryki błędów -

Jednowarstwowe sieci neuronowe

W tym przykładzie tworzymy jednowarstwową sieć neuronową, która składa się z niezależnych neuronów działających na danych wejściowych, aby wygenerować wynik. Zauważ, że używamy pliku tekstowego o nazwieneural_simple.txt jako nasz wkład.

Zaimportuj przydatne pakiety, jak pokazano -

import numpy as np
import matplotlib.pyplot as plt
import neurolab as nl

Załaduj zestaw danych w następujący sposób -

input_data = np.loadtxt(“/Users/admin/neural_simple.txt')

Poniżej znajdują się dane, których będziemy używać. Zwróć uwagę, że w tych danych pierwsze dwie kolumny to funkcje, a ostatnie dwie kolumny to etykiety.

array([[2. , 4. , 0. , 0. ],
      [1.5, 3.9, 0. , 0. ],
      [2.2, 4.1, 0. , 0. ],
      [1.9, 4.7, 0. , 0. ],
      [5.4, 2.2, 0. , 1. ],
      [4.3, 7.1, 0. , 1. ],
      [5.8, 4.9, 0. , 1. ],
      [6.5, 3.2, 0. , 1. ],
      [3. , 2. , 1. , 0. ],
      [2.5, 0.5, 1. , 0. ],
      [3.5, 2.1, 1. , 0. ],
      [2.9, 0.3, 1. , 0. ],
      [6.5, 8.3, 1. , 1. ],
      [3.2, 6.2, 1. , 1. ],
      [4.9, 7.8, 1. , 1. ],
      [2.1, 4.8, 1. , 1. ]])

Teraz podziel te cztery kolumny na dwie kolumny danych i dwie etykiety -

data = input_data[:, 0:2]
labels = input_data[:, 2:]

Wykreśl dane wejściowe za pomocą następujących poleceń -

plt.figure()
plt.scatter(data[:,0], data[:,1])
plt.xlabel('Dimension 1')
plt.ylabel('Dimension 2')
plt.title('Input data')

Teraz zdefiniuj minimalne i maksymalne wartości dla każdego wymiaru, jak pokazano tutaj -

dim1_min, dim1_max = data[:,0].min(), data[:,0].max()
dim2_min, dim2_max = data[:,1].min(), data[:,1].max()

Następnie zdefiniuj liczbę neuronów w warstwie wyjściowej w następujący sposób -

nn_output_layer = labels.shape[1]

Teraz zdefiniuj jednowarstwową sieć neuronową -

dim1 = [dim1_min, dim1_max]
dim2 = [dim2_min, dim2_max]
neural_net = nl.net.newp([dim1, dim2], nn_output_layer)

Trenuj sieć neuronową z liczbą epok i szybkością uczenia się, jak pokazano -

error = neural_net.train(data, labels, epochs = 200, show = 20, lr = 0.01)

Teraz wizualizuj i wykreśl postęp treningu za pomocą następujących poleceń -

plt.figure()
plt.plot(error)
plt.xlabel('Number of epochs')
plt.ylabel('Training error')
plt.title('Training error progress')
plt.grid()
plt.show()

Teraz użyj testowych punktów danych w powyższym klasyfikatorze -

print('\nTest Results:')
data_test = [[1.5, 3.2], [3.6, 1.7], [3.6, 5.7],[1.6, 3.9]] for item in data_test:
   print(item, '-->', neural_net.sim([item])[0])

Wyniki testu można znaleźć, jak pokazano tutaj -

[1.5, 3.2] --> [1. 0.]
[3.6, 1.7] --> [1. 0.]
[3.6, 5.7] --> [1. 1.]
[1.6, 3.9] --> [1. 0.]

Możesz zobaczyć następujące wykresy jako wynik omawianego do tej pory kodu -

Wielowarstwowe sieci neuronowe

W tym przykładzie tworzymy wielowarstwową sieć neuronową, która składa się z więcej niż jednej warstwy, aby wyodrębnić podstawowe wzorce z danych uczących. Ta wielowarstwowa sieć neuronowa będzie działać jak regresor. Mamy zamiar wygenerować kilka punktów danych na podstawie równania: y = 2x ² +8.

Zaimportuj niezbędne pakiety, jak pokazano -

import numpy as np
import matplotlib.pyplot as plt
import neurolab as nl

Wygeneruj punkt danych na podstawie powyższego równania -

min_val = -30
max_val = 30
num_points = 160
x = np.linspace(min_val, max_val, num_points)
y = 2 * np.square(x) + 8
y /= np.linalg.norm(y)

Teraz zmień kształt tego zestawu danych w następujący sposób -

data = x.reshape(num_points, 1)
labels = y.reshape(num_points, 1)

Wizualizuj i wykreśl zestaw danych wejściowych za pomocą następujących poleceń -

plt.figure()
plt.scatter(data, labels)
plt.xlabel('Dimension 1')
plt.ylabel('Dimension 2')
plt.title('Data-points')

Teraz zbuduj sieć neuronową mającą dwie ukryte warstwy z neurolab z ten neurony w pierwszej ukrytej warstwie, six w drugiej ukrytej warstwie i one w warstwie wyjściowej.

neural_net = nl.net.newff([[min_val, max_val]], [10, 6, 1])

Teraz użyj algorytmu treningu gradientowego -

neural_net.trainf = nl.train.train_gd

Teraz wytrenuj sieć, aby uczyć się na danych wygenerowanych powyżej -

error = neural_net.train(data, labels, epochs = 1000, show = 100, goal = 0.01)

Teraz uruchom sieci neuronowe w szkoleniowych punktach danych -

output = neural_net.sim(data)
y_pred = output.reshape(num_points)

Teraz zadanie kreślenia i wizualizacji -

plt.figure()
plt.plot(error)
plt.xlabel('Number of epochs')
plt.ylabel('Error')
plt.title('Training error progress')

Teraz będziemy wykreślać rzeczywistą i przewidywaną produkcję -

x_dense = np.linspace(min_val, max_val, num_points * 2)
y_dense_pred = neural_net.sim(x_dense.reshape(x_dense.size,1)).reshape(x_dense.size)
plt.figure()
plt.plot(x_dense, y_dense_pred, '-', x, y, '.', x, y_pred, 'p')
plt.title('Actual vs predicted')
plt.show()

W wyniku powyższych poleceń można obserwować wykresy, jak pokazano poniżej -