Sieć neuronowa do klasyfikacji za pomocą Tensorflow

Ten artykuł został opublikowany jako część Blogathon Data Science

W tym artykule zamierzam zbudować modele sieci neuronowych za pomocą TensorFlow, aby rozwiązać problem klasyfikacji. Zbadajmy razem, jak możemy podejść do problemu klasyfikacji w Tensorflow. Ale najpierw chciałbym się upewnić, że jesteśmy w stanie odpowiedzieć na następujące pytania:

jest sieć neuronowa?

Głównym celem sieci neuronowej jest próba znalezienia związku między cechami w zbiorze danych. Składa się ona z zestawu algorytmów naśladujących pracę ludzkiego mózgu. „Nuron” w sieci neuronowej to funkcja matematyczna, która zbiera i klasyfikuje informacje zgodnie z określoną architekturą.

Co to jest klasyfikacja?

Problem klasyfikacji polega na przewidywaniu, czy coś należy do jednej klasy, czy nie. Innymi słowy, robiąc to, staramy się dostrzec, że coś jest takie czy inne.

Rodzaje klasyfikacji

• Załóżmy, że chcesz przewidzieć, czy dana osoba ma cukrzycę, czy nie. Jeśli masz do czynienia z tego rodzaju sytuacją, istnieją dwie możliwości, prawda? To nazywa się Klasyfikacja binarna.
• Załóżmy, że chcesz określić, czy zdjęcie przedstawia zabawkę, osobę czy kota, prawda? to się nazywa Klasyfikacja wieloklasowa ponieważ jest więcej niż dwie opcje.
• Załóżmy, że chcesz zdecydować, jakie kategorie mają być przypisane do artykułu. Jeśli tak, to tzw Klasyfikacja wielu etykiet, ponieważ jeden artykuł mógł mieć przypisaną więcej niż jedną kategorię. Przeanalizujmy nasze wyjaśnienie w tym artykule. Do tego artykułu możemy przypisać kategorie, takie jak „Deep Learning, TensorFlow, Classification” itp

Teraz możemy iść do przodu, ponieważ mamy wspólne zrozumienie problemu, nad którym będziemy pracować. Czas więc na kodowanie. Mam nadzieję, że zapisujesz je razem ze mną, ponieważ jedynym sposobem na poprawę i popełnianie mniejszej liczby błędów jest pisanie większej ilości kodu.

Zaczynamy od zaimportowania bibliotek, z których będziemy korzystać:

importuj numpy jako np importuj pandy jako pd importuj matplotlib.pyplot jako plt importuj tensorflow jako tf print(tf.__version__)

Tworzenie zestawu danych

Nadszedł czas na utworzenie zestawu danych do pracy nad:

z sklearn.datasets importuj próbki make_circles = 1000 X, y = make_circles (próbki, szum = 0.03, stan losowy = 42)

drukuj(X >>[[ 0.75424625 0.23148074] [-0.75615888 0.15325888] [-0.81539193 0.17328203] ... [-0.13690036 -0.81001183] [ 0.67036156 -0.76750154 0.28105665] [ 0.96382443 XNUMX]]

drukuj(y) >> [1 1 1 1 0 1 1 1 1 0]

Dobra, widzieliśmy nasz zestaw danych bardziej szczegółowo, ale nadal nic o nim nie wiemy, prawda? Dlatego tutaj jednym ważnym krokiem jest zjednoczenie się z danymi, a wizualizacja jest na to najlepszym sposobem.

koło = pd.DataFrame({ 'X0' : X[:, 0], 'X1' : X[:, 1], 'etykieta': y}) koło.głowa()

Tu pojawia się pytanie, z jakimi etykietami mamy do czynienia?

circle.label.value_counts() >> 1 500 0 500 Nazwa: etykieta, typ d: int64

Wygląda na to, że mamy do czynienia problem klasyfikacji binarnej, ponieważ mamy 2 etykiety (0 i 1).

plt.rozproszenie(X[:,0], X[:,1], c = y, cmap = plt.cm.RdYlBu)

Jak wspomniałem powyżej, najlepszym sposobem na uzyskanie takiego z danymi jest wizualizacja. Teraz fabuła sama mówi, jaki model musimy zbudować. Zbudujemy model, który potrafi odróżnić kropki niebieskie od kropek czerwonych.

Przed zbudowaniem jakiegokolwiek modelu sieci neuronowej musimy sprawdzić kształty naszych cech wejściowych i wyjściowych. muszą być takie same!

print(kształt X, kształt y) print(dł.(X), dł.(y)) >> (1000, 2) (1000,) 1000 1000

Mamy taką samą ilość wartości dla każdej cechy, ale kształt X jest inny? Dlaczego? Sprawdźmy to.

X[0], y[0] >> (tablica([0.75424625, 0.23148074]), 1)

Dobra, mamy 2 X funkcji na 1 rok. Możemy więc bez problemu iść do przodu.

Etapy modelowania sieci neuronowej do klasyfikacji za pomocą Tensorflow

W TensorFlow są ustalone etapy tworzenia modelu:

• Tworzenie modelu – łącz warstwy sieci neuronowej za pomocą funkcjonalnego lub sekwencyjnego interfejsu API
• Kompilacja modelu – zdefiniowanie, w jaki sposób należy mierzyć wydajność modelu i jak należy go poprawić (funkcja strat i optymalizator)
• Dopasowanie trybul – umożliwienie modelowi znalezienia wzorców w danych

Będziemy używać Sequential API. Więc zacznijmy

tf.random.set_seed(42)

model_1 = tf.keras.Sequential([tf.keras.layers.Dense(1)])

 optymalizator = tf.keras.optimizers.SGD(), #SGD oznacza Stochastic Gradient Descent metrics = ['accuracy']) model_1.fit(X, y, epoki = 5)

>> Epoka 1/5 32/32 [==============================] - 1s 1ms/krok - strata: 2.8544 - dokładność: 0.4600 Epoka 2/5 32/32 [=============================] - 0s 2ms/krok - strata : 0.7131 - dokładność: 0.5430 Epoka 3/5 32/32 [=============================] - 0s 2ms/krok - strata: 0.6973 - dokładność: 0.5090 Epoka 4/5 32/32 [==============================] - 0s 2ms /krok - strata: 0.6950 - dokładność: 0.5010 Epoka 5/5 32/32 [=============================] - 0s 1ms/krok - strata: 0.6942 - dokładność: 0.4830

Dokładność modelu wynosi około 50%, co w zasadzie oznacza, że ​​model tylko zgaduje, spróbujmy go dłużej trenować

model_1.fit(X, y, epoki = 200, verbose = 0) #ustawiamy verbose = 0, aby usunąć procedurę uczącą) model_1.evaluate(X, y)

>> 32/32 [==============================] - 0s 1ms/krok - strata: 0.6935 - dokładność: 0.5000 [0.6934829950332642, 0.5]

Nawet po 200 epokach nadal zachowuje się tak, jakby zgadywał Następnym krokiem jest dodanie kolejnych warstw i dłuższy trening.

tf.random.set_seed(42)

model_2 = tf.keras.Sequential([ tf.keras.layers.Dense(1), tf.keras.layers.Dense(1) ]) model_2.compile(loss = tf.keras.losses.BinaryCrossentropy(), optymalizator = tf.keras.optimizers.SGD(), metryki = ['dokładność']) model_2.fit(X, y, epoki = 100, gadatliwe = 0)

 model_2.ocena(X,y)

>> 32/32 [==============================] - 0s 1ms/krok - strata: 0.6933 - dokładność: 0.5000 [0.6933314800262451, 0.5]

Mimo to nie ma nawet małej zmiany, wydaje się, że coś jest nie tak.

Udoskonalanie modelu sieci neuronowej do klasyfikacji za pomocą Tensorflow

Istnieją różne sposoby ulepszania modelu na różnych etapach:

• Tworzenie modelu – dodaj więcej warstw, zwiększ liczbę ukrytych jednostek (neuronów), zmień funkcje aktywacji każdej warstwy
• Kompilacja modelu – wypróbuj różne funkcje optymalizacyjne, na przykład użyj Adam() zamiast SGD().
• Dopasowanie modelu – moglibyśmy zwiększyć liczbę epok

Spróbujmy dodaj więcej neuronów i spróbuj Adam optymalizator

tf.random.set_seed(42)

model_3 = tf.keras.Sequential([ tf.keras.layers.Dense(100), # dodaj 100 gęstych neuronów tf.keras.layers.Dense(10), # dodaj kolejną warstwę z 10 neuronami tf.keras.layers.Dense (1) ]) model_3.compile(loss=tf.keras.losses.BinaryCrossentropy(), Optimizer=tf.keras.optimizers.Adam(), metrics=['dokładność']) model_3.fit(X, y, epoki =100, pełne =0)

model_3.evaluate(X,y) >> 32/32 [=============================] - 0s 1ms/krok - strata: 0.6980 - dokładność: 0.5080 [0.6980254650115967, 0.5080000162124634]

Nadal nie poprawia się! Zwizualizujmy dane, aby zobaczyć, co jest nie tak.

Wizualizuj model sieci neuronowej

Aby zwizualizować przewidywania naszego modelu, stworzymy funkcję plot_decision_boundary(), która:

• Przyjmuje przeszkolony model, funkcje i etykiety
• Utwórz siatkę siatkową różnych wartości X.
• Wykonuje prognozy w siatce siatki.
• Wykreśla prognozy za pomocą linii.

Uwaga:  Ta funkcja została zaadaptowana z dwóch zasobów:

CS231n Wykonane z podstawami ML 

def plot_decision_boundary(model, X, y): # Zdefiniuj granice osi wykresu i utwórz siatkę x_min, x_max = X[:, 0].min() - 0.1, X[:, 0].max() + 0.1 y_min, y_max = X[:, 1].min() - 0.1, X[:, 1].max() + 0.1 xx, yy = np.meshgrid(np.linspace(x_min, x_max, 100), np .linspace(y_min, y_max, 100)) # Utwórz wartości X (będziemy przewidywać na podstawie tych wszystkich) x_in = np.c_[xx.ravel(), yy.ravel()] # Przewiduj używając przeszkolonego model y_pred = model.predict(x_in) # Sprawdź wieloklasowość

 if len(y_pred[0]) > 1: print("przeprowadzam klasyfikację wieloklasową...") # Musimy zmienić kształt naszych przewidywań, aby przygotować je do wykreślenia y_pred = np.argmax(y_pred, oś=1).reshape( xx.shape) else: print("wykonywanie klasyfikacji binarnej...") y_pred = np.round(y_pred).reshape(xx.shape) # Wykreśl granicę decyzyjną plt.contourf(xx, yy, y_pred, cmap=plt. cm.RdYlBu, alfa=0.7) plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.RdYlBu) plt.xlim(xx.min( ), xx.max()) plt.ylim(yy.min(), yy.max()) plot_decision_boundary(model_3, X, y)

Oto jest! Znów wizualizacja pokazuje nam, co jest nie tak i co robić? Nasz model próbuje narysować linię prostą przez dane, ale naszych danych nie można oddzielić linią prostą. Czy czegoś brakuje w naszym problemie z klasyfikacją? Co to jest?

To jest nieliniowość! Potrzebujemy kilku linii nieliniowych. Możesz się teraz pomylić, jeśli myślisz, że wcześniej nie widziałeś tego rodzaju funkcji, to się mylisz, bo tak. Zobaczmy je wizualnie. Wizualizacja zawsze działa lepiej!

W sieci neuronowej jest kilka funkcji aktywacyjnych, z których możemy skorzystać, np Relu, esicy. Stwórzmy trochę tensor zabawka i sprawdź na nim te funkcje.

Funkcje aktywacji dla sieci neuronowych

A = tf.cast(tf.range(-12,12), tf.float32) print(A) >> tf.Tensor( [-12. -11. -10. -9. -8. -7. - 6. -5. -4. -3. -2. -1. 0. 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11.], kształt = (24,), dtype=float32)

Zobaczmy, jak wygląda nasz zabawkowy tensor?

plt.wykres(A)

Wygląda to tak, linia prosta! 

Teraz odtwórzmy funkcje aktywacji, aby zobaczyć, co robią z naszym tensorem?

esicy:

def sigmoid(x): return 1 / (1 + tf.exp(-x)) sigmoid(A) plt.plot(sigmoid(A))

Nieprosta linia!

ReLu:

def relu(x): return tf.maximum(0,x) plt.plot(relu(A))

Kolejna nieprosta linia!

Teraz widziałeś nieliniowe funkcje aktywacji i to właśnie będzie dla nas działać, model nie może się niczego nauczyć na nieliniowym zbiorze danych z liniowymi funkcjami aktywacji! Jeśli już się tego nauczyłeś, nadszedł czas na podzielenie naszych danych na zestawy treningowe i testowe oraz zbudowanie mocnych modeli.

X_pociąg, y_pociąg = X[:800], y[:800] X_test, y_test = X[800:], y[800:] X_pociąg.kształt, X_test.kształt >>((800, 2), (200, 2 ))

tf.random.set_seed(42)

model_4 = tf.keras.Sequential([ tf.keras.layers.Dense(4, aktywacja = 'relu'), #możemy to naprawić również „tf.keras.activations.relu” tf.keras.layers.Dense(4 , aktywacja = 'relu'), tf.keras.layers.Dense(1, aktywacja = 'sigmoid') ]) model_4.compile(loss= tf.keras.losses.binary_crossentropy, optymalizator = tf.keras.optimizers.Adam( lr = 0.01), metryki = ['dokładność']) model_4.fit(pociąg_X, ciąg_y, epoki = 25, gadatliwy = 0)

Oceń model

strata, dokładność = model_4.evaluate(X_test, y_test) print(f' Strata modelu na zbiorze testowym: {loss}') print(f' Dokładność modelu na zbiorze testowym: {100*accuracy}')

>> 7/7 [==============================] - 0s 2ms/krok - strata: 0.1247 - dokładność: 1.0000 Utrata modelu na zbiorze testowym: 0.1246885135769844 Dokładność modelu na zbiorze testowym: 100.0

plt.figure(figsize=(12, 6)) plt.subplot(1, 2, 1) plt.title("Pociąg") plot_decision_boundary(model_4, X=X_train, y=y_train) plt.subplot(1, 2, 2) plt.title("Test") plot_decision_boundary(model_4, X=X_test, y=y_test) plt.show()

Przyjrzyjmy się pokrótce, o czym mówimy w tym artykule. Wspólnie przyjrzeliśmy się, jak podejść do zadania klasyfikacji w sieci neuronowej za pomocą TensorFlow. Stworzyliśmy 3 modele w pierwszy sposób, który przyszedł nam do głowy, i za pomocą wizualizacji zdaliśmy sobie sprawę, gdzie się myliliśmy, zbadaliśmy liniowość, nieliniowość i ostatecznie udało nam się zbudować uogólniony model. To, co starałem się pokazać za pomocą tych wszystkich kodów i kroków, które wykonywałem, polegało na tym, że nic nie jest w 100% dokładne ani naprawione, wszystko zmienia się każdego dnia. Aby odgadnąć, z jakim problemem możesz się spotkać w przypadku jakiego rodzaju danych i zobaczyć, które kombinacje prowadzą do lepszego wyniku, wystarczy napisać o wiele więcej kodu i zdobyć doświadczenie.

Mam nadzieję, że artykuł był dla ciebie trochę pomocny i wniósł trochę wkładu.

Media pokazane w tym artykule nie są własnością Analytics Vidhya i są używane według uznania Autora

Związane z

Źródło: https://www.analyticsvidhya.com/blog/2021/11/neural-network-for-classification-with-tensorflow/