Neurális hálózat Tensorflow osztályozáshoz

Ez a cikk részeként jelent meg Adattudományi Blogaton

Ebben a cikkben neurális hálózati modelleket fogok felépíteni TensorFlow segítségével egy osztályozási probléma megoldására. Vizsgáljuk meg együtt, hogyan közelíthetünk meg egy osztályozási problémát a Tensorflow-ban. De először is szeretném megbizonyosodni arról, hogy meg tudunk válaszolni a következő kérdéseket:

a neurális hálózat?

A neurális hálózat fő célja, hogy megpróbálja megtalálni a kapcsolatot egy adathalmaz jellemzői között., és olyan algoritmusok halmazából áll, amelyek utánozzák az emberi agy munkáját. A „neuron” egy neurális hálózatban egy matematikai függvény, amely információkat gyűjt és osztályoz egy adott architektúra szerint.

Mi az osztályozás?

Az osztályozási probléma magában foglalja annak előrejelzését, hogy valami egy osztályba tartozik-e vagy sem. Más szóval, miközben ezt csináljuk, megpróbáljuk belátni, hogy valami ilyesmi vagy más.

Az osztályozás típusai

• Tegyük fel, hogy szeretné megjósolni, hogy egy személy cukorbeteg-e vagy sem. Ha ilyen helyzettel állsz szemben, két lehetőség van, igaz? Ezt nevezik Bináris osztályozás.
• Tegyük fel, hogy azonosítani szeretné, hogy egy fénykép egy játékról, egy személyről vagy egy macskáról készült-e, igaz? ezt nevezik Több osztályos osztályozás mert kettőnél több lehetőség van.
• Tegyük fel, hogy szeretné eldönteni, hogy mely kategóriákat kell hozzárendelni egy cikkhez. Ha igen, akkor úgy hívják Többcímkés osztályozás, mert egy cikkhez több kategória is hozzárendelhető. Nézzük meg magyarázatunkat ezen a cikken keresztül. Ehhez a cikkhez kategóriákat rendelhetünk hozzá, például „Mély tanulás, TensorFlow, Osztályozás” stb

Most léphetünk előre, mert közösen értjük azt a problémát, amelyen dolgozni fogunk. Tehát itt az ideje a kódolásnak. Remélem, leírod őket velem, mert az egyetlen módja annak, hogy jobbá válj és kevesebb hibát kövess el, ha több kódot írsz.

Kezdjük az általunk használt könyvtárak importálásával:

import numpy as np import panda as pd import matplotlib.pyplot as plt import tensorflow as tf print(tf.__version__)

Adatkészlet létrehozása

Ideje létrehozni egy adatkészletet, amelyen dolgozni fog:

a sklearn.datasets-ből make_circles minták importálása = 1000 X, y = make_circles(minták, zaj = 0.03, random_state = 42)

print(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 XNUMX]]

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

Oké, részletesebben láttuk az adatkészletünket, de még mindig nem tudunk róla semmit, igaz? Éppen ezért itt az egyik fontos lépés az, hogy eggyé váljunk az adatokkal, és a vizualizáció a legjobb módja ennek.

circle = pd.DataFrame({ 'X0' : X[:, 0], 'X1' : X[:, 1], 'címke' : y}) circle.head()

Felmerül itt egy kérdés, hogy milyen címkékkel van dolgunk?

circle.label.value_counts() >> 1 500 0 500 Név: címke, dtype: int64

Úgy tűnik, dolgunk van bináris osztályozási probléma, mert 2 címkénk van (0 és 1).

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

Ahogy fentebb említettem, a vizualizáció a legjobb módja annak, hogy egyet szerezzen az adatokkal. Most a cselekmény maga mondja meg, hogy milyen modellt kell építeni. Olyan modellt készítünk, amely képes megkülönböztetni a kék pontokat a pirostól.

Mielőtt bármilyen neurális hálózati modellt készítenénk, ellenőriznünk kell a bemeneti és kimeneti jellemzőink alakját. egyformának kell lenniük!

nyomat(X.alak, y.alak) print(len(X), len(y)) >> (1000, 2) (1000,) 1000 1000

Minden jellemzőnél ugyanannyi értékünk van, de az X alakja más? Miért? Nézzük meg.

X[0], y[0] >> (tömb([0.75424625, 0.23148074]), 1)

Rendben, 2 X funkciónk van 1 évre. Így probléma nélkül haladhatunk előre.

A neurális hálózat modellezésének lépései a Tensorflow-val történő osztályozáshoz

A TensorFlow-ban rögzített szakaszok vannak a modell létrehozásához:

• Modell készítése – rakja össze a neurális hálózat rétegeit a Funkcionális vagy Szekvenciális API segítségével
• Modell összeállítása – annak meghatározása, hogy egy modell teljesítményét hogyan kell mérni, és hogyan kell javítani (vesztési funkció és optimalizáló)
• Üzemmód illesztésel – hagyjuk, hogy egy modell mintákat találjon az adatokban

A Sequential API-t fogjuk használni. Tehát kezdjük

tf.random.set_seed(42)

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

 optimalizáló = tf.keras.optimizers.SGD(), #SGD a sztochasztikus gradiens süllyedés metrika = ['pontosság']) model_1.fit(X, y, epochs = 5)

>> Epoch 1/5 32/32 [===============================] - 1 mp 1 ms/lépés - veszteség: 2.8544 - Pontosság: 0.4600 Epocha 2/5 32/32 [===============================] - 0 s 2 ms/lépés - veszteség : 0.7131 - pontosság: 0.5430 korszak 3/5 32/32 [==============================] - 0 mp 2 ms/lépés - Veszteség: 0.6973 - Pontosság: 0.5090 Epocha 4/5 32/32 [==============================] - 0 s 2 ms /lépés – veszteség: 0.6950 – pontosság: 0.5010 Epocha 5/5 32/32 [==============================] - 0 s 1 ms/lépés - veszteség: 0.6942 - pontosság: 0.4830

A modell pontossága hozzávetőlegesen 50%, ami lényegében azt jelenti, hogy a modell csak találgat, próbáljuk tovább képezni

model_1.fit(X, y, epochs = 200, verbose = 0) #beállítjuk a verbose = 0 értéket a betanítási eljárás eltávolításához ) model_1.evaluate(X, y)

>> 32/32 [==============================] - 0 s 1 ms/lépés - veszteség: 0.6935 - pontosság: 0.5000 [0.6934829950332642, 0.5]

Még 200 korszak után is úgy teljesít, mint ahogy sejti. Következő lépésként több réteget ad hozzá, és tovább edz.

tf.random.set_seed(42)

modell_2 = tf.keras.Sequential([ tf.keras.layers.Dense(1), tf.keras.layers.Dense(1) ]) model_2.compile(loss = tf.keras.losses.BinaryCrossentropy(), optimalizáló = tf.keras.optimizers.SGD(), metrics = ['pontosság']) model_2.fit(X, y, epochs = 100, verbose = 0)

 model_2.evaluate(X,y)

>> 32/32 [==============================] - 0 s 1 ms/lépés - veszteség: 0.6933 - pontosság: 0.5000 [0.6933314800262451, 0.5]

Ennek ellenére még csak egy kis változás sincs, úgy tűnik, valami nincs rendben.

A neurális hálózat osztályozási modelljének fejlesztése a Tensorflow segítségével

A modell különböző szakaszaiban különböző módon javítható:

• Modell készítés – több réteg hozzáadása, a rejtett egységek (neuronok) számának növelése, az egyes rétegek aktiválási funkcióinak módosítása
• Modell összeállítás – próbáljon ki különböző optimalizálási függvényeket, például használja az Adam()-et az SGD() helyett.
• Modell illesztés – növelhetnénk a korszakok számát

Próbáljuk meg adjunk hozzá több neuront és próbálja Ádám optimalizáló

tf.random.set_seed(42)

model_3 = tf.keras.Sequential([ tf.keras.layers.Dense(100), # add 100 sűrű neuron tf.keras.layers.Dense(10), # add még egy réteg 10 neuronnal tf.keras.layers.Dense (1) ]) model_3.compile(loss=tf.keras.losses.BinaryCrossentropy(), optimizer=tf.keras.optimizers.Adam(), metrics=['pontosság']) model_3.fit(X, y, epochs =100, bőbeszédű=0)

model_3.evaluate(X,y) >> 32/32 [===============================] - 0 mp 1 ms/lépés - veszteség: 0.6980 - pontosság: 0.5080 [0.6980254650115967, 0.5080000162124634]

Még mindig nem javul! Vizualizáljuk az adatokat, hogy lássuk, mi a hiba.

Vizualizálja a neurális hálózat modelljét

Modellünk előrejelzéseinek megjelenítéséhez létrehozunk egy plot_decision_boundary() függvényt, amely:

• Képzett modellt, jellemzőket és címkéket fogad be
• Hozzon létre egy hálóhálót a különböző X értékekből.
• Jóslatokat készít a hálóhálón keresztül.
• Az előrejelzéseket vonallal ábrázolja.

Jegyzet:  Ez a funkció két forrásból lett adaptálva:

CS231n ML alapokkal készült 

def plot_decision_boundary(modell, X, y): # Határozza meg a plot tengelyhatárait, és hozzon létre egy hálóhálót 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)) # Hozzon létre X értékeket (mindegyikre jósolni fogunk) x_in = np.c_[xx.ravel(), yy.ravel()] # Készítsen előrejelzéseket a betanított model y_pred = model.predict(x_in) # Több osztály ellenőrzése

 if len(y_pred[0]) > 1: print("többosztályos osztályozás elvégzése...") # Át kell formáznunk az előrejelzéseinket, hogy készen álljanak az ábrázolásra y_pred = np.argmax(y_pred, axis=1).reshape( xx.shape) else: print("bináris osztályozás elvégzése...") y_pred = np.round(y_pred).reshape(xx.shape) # Döntési határvonal ábrázolása plt.contourf(xx, yy, y_pred, cmap=plt. cm.RdYlBu, alfa=0.7) plt.szórás(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(modell_3, X, y)

Itt van! A vizualizáció ismét megmutatja, mi a baj, és mit tegyünk? Modellünk megpróbál egyenes vonalat húzni az adatokon, de adataink nem választhatók el egyenessel. Hiányzik valami az osztályozási problémánkból? Ami?

Ez non-linearitás! Szükségünk van néhány nemlineáris vonalra. Most összezavarodhat, ha azt gondolja, hogy korábban nem látott ilyen funkciót, akkor téved, mert igen. Lássuk őket vizuálisan. A vizualizáció mindig jobban működik!

Van néhány aktiváló funkció a neurális hálózatban, amelyeket használhatunk, mint pl ReLu, szigmabél. Alkossunk egy kicsit játék tenzor és ellenőrizze rajta azokat a funkciókat.

Aktiválási funkciók neurális hálózatokhoz

A = tf.cast(tf.tartomány(-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.], alak=(24,), dtype=float32)

Nézzük, hogyan néz ki a játéktenzorunk?

plt.plot(A)

Így néz ki, egyenes vonal! 

Most hozzuk létre újra az aktiválási függvényeket, hogy megnézzük, mit tesznek a tenzorunkkal?

Szigmoid:

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

Nem egyenes vonal!

ReLu:

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

Még egy nem egyenes vonal!

Most láttál nemlineáris aktiváló függvényeket, és nálunk ezek működnek, a modell nem tanul meg semmit egy lineáris aktiváló függvényekkel rendelkező nemlineáris adathalmazon! Ha ezt megtanultuk, ideje felosztani adatainkat képzési és tesztkészletekre, és erős modelleket építeni.

X_train, y_train = X[:800], y[:800] X_teszt, y_teszt = X[800:], y[800:] X_train.shape, X_test.shape >>((800, 2), (200, 2) ))

tf.random.set_seed(42)

model_4 = tf.keras.Sequential([ tf.keras.layers.Dense(4, activation = 'relu'), #helyesíthetjük "tf.keras.activations.relu" is tf.keras.layers.Dense(4 , activation = 'relu'), tf.keras.layers.Dense(1, activation = 'szigmoid') ]) model_4.compile( loss= tf.keras.losses.binary_crossentropy, optimizer = tf.keras.optimizers.Adam( lr = 0.01), metrics = ['pontosság']) model_4.fit(X_train, y_train, epochs = 25, verbose = 0)

Értékelje a modellt

veszteség, pontosság = modell_4.értékelni(X_teszt, y_teszt) print(f' Modellvesztés a tesztkészleten: {veszteség}') print(f' Modell pontossága a tesztkészleten: {100*pontosság}')

>> 7/7 [==============================] - 0 mp 2 ms/lépés - veszteség: 0.1247 - pontosság: 1.0000 Modellveszteség a tesztkészleten: 0.1246885135769844 Modellpontosság a tesztkészleten: 100.0

plt.figure(figsize=(12, 6)) plt.subplot(1, 2, 1) plt.title("Vonat") plot_decision_boundary(modell_4, X=X_train, y=y_train) plt.subplot(1, 2, 2) plt.title("Teszt") plot_decision_boundary(modell_4, X=X_test, y=y_test) plt.show()

Nézzük meg röviden, miről is beszélünk ebben a cikkben. Együtt megvizsgáltuk, hogyan közelítsünk meg egy osztályozási feladatot a neurális hálózatban a TensorFlow segítségével. 3 modellt készítettünk elsőre, ami eszünkbe jutott, és a vizualizáció segítségével rájöttünk, hol tévedtünk, feltártuk a linearitást, a nemlinearitást, végül sikerült egy általánosított modellt felépíteni. Ezekkel a kódokkal és az általam követett lépésekkel azt próbáltam megmutatni, hogy semmi sem 100 százalékig pontos vagy rögzített, minden napról napra változik. Ahhoz, hogy kitaláljuk, melyik probléma milyen típusú adatokkal kell szembenéznie, és hogy melyik kombinációk vezetnek jobb eredményhez, csak sokkal több kódot kell írnia és tapasztalatot kell szereznie.

Remélem, hogy a cikk egy kicsit hasznos volt számodra, és segített valamit.

Az ebben a cikkben bemutatott média nem az Analytics Vidhya tulajdona, és a Szerző belátása szerint használja azokat

Összefüggő

Forrás: https://www.analyticsvidhya.com/blog/2021/11/neural-network-for-classification-with-tensorflow/