Neuraal netwerk voor classificatie met Tensorflow

Dit artikel is gepubliceerd als onderdeel van het Data Science-blogathon

In dit artikel ga ik neurale netwerkmodellen bouwen met TensorFlow om een ​​classificatieprobleem op te lossen. Laten we samen onderzoeken hoe we een classificatieprobleem in Tensorflow kunnen aanpakken. Maar eerst wil ik er zeker van zijn dat we deze vragen kunnen beantwoorden:

is een neuraal netwerk?

Het belangrijkste doel van een neuraal netwerk is om te proberen de relatie tussen kenmerken in een dataset te vinden. Het bestaat uit een reeks algoritmen die het werk van het menselijk brein nabootsen. Een ‘neuron’ in een neuraal netwerk is een wiskundige functie die informatie verzamelt en classificeert volgens een specifieke architectuur.

Wat is classificatie?

Classificatieprobleem houdt in dat wordt voorspeld of iets tot één klasse behoort of niet. Met andere woorden, terwijl we dit doen, proberen we te zien dat iets het een of het ander is.

Soorten classificatie

• Stel dat u wilt voorspellen of iemand diabetes heeft of niet. Als u met een dergelijke situatie wordt geconfronteerd, zijn er twee mogelijkheden, toch? Dat is genoemd Binaire classificatie.
• Stel dat u wilt identificeren of een foto van speelgoed, een persoon of een kat is, toch? dit heet Classificatie met meerdere klassen omdat er meer dan twee opties zijn.
• Stel dat u wilt beslissen welke categorieën aan een artikel moeten worden toegewezen. Als dat zo is, wordt er gebeld Classificatie met meerdere labels, omdat aan één artikel meer dan één categorie kan worden toegewezen. Laten we onze uitleg door dit artikel heen nemen. We kunnen categorieën als “Deep Learning, TensorFlow, Classificatie” etc. aan dit artikel toewijzen

Nu kunnen we verder gaan, omdat we een gemeenschappelijk begrip hebben van het probleem waaraan we gaan werken. Het is dus tijd voor coderen. Ik hoop dat je ze samen met mij opschrijft, want de enige manier om beter te worden en minder fouten te maken, is door meer code te schrijven.

We beginnen met het importeren van bibliotheken die we gaan gebruiken:

importeer numpy als np importeer panda's als pd importeer matplotlib.pyplot als plt importeer tensorflow als tf print(tf.__version__)

Een gegevensset maken

Het is tijd voor het creëren van een dataset om aan te werken:

uit sklearn.datasets import make_circles samples = 1000 X, y = make_circles (samples, noise = 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]]

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

Oké, we hebben onze dataset in meer detail bekeken, maar we weten er nog steeds niets van, toch? Daarom is een belangrijke stap om één te worden met de data, en visualisatie is de beste manier om dit te doen.

cirkel = pd.DataFrame({ 'X0': X[:, 0], 'X1': X[:, 1], 'label': y}) cirkel.head()

Hier rijst de vraag: met wat voor soort labels hebben we te maken?

Circle.label.value_counts() >> 1 500 0 500 Naam: label, dtype: int64

Het lijkt erop dat we ermee te maken hebben een binair classificatieprobleem, omdat we 2 labels hebben (0 en 1).

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

Zoals ik hierboven al zei, is visualisatie de beste manier om met de gegevens aan de slag te gaan. Nu zegt de plot zelf wat voor soort model we moeten bouwen. We gaan een model bouwen dat blauwe stippen van rode stippen kan onderscheiden.

Voordat we een neuraal netwerkmodel bouwen, moeten we de vorm van onze invoer- en uitvoerfuncties controleren. ze moeten hetzelfde zijn!

print(X.vorm, y.vorm) print(len(X), len(y)) >> (1000, 2) (1000,) 1000 1000

We hebben voor elk kenmerk hetzelfde aantal waarden, maar de vorm van X is anders? Waarom? Laten we het bekijken.

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

Oké, we hebben 2 X-functies voor 1 jaar. We kunnen dus probleemloos verder.

Stappen bij het modelleren van een neuraal netwerk voor classificatie met Tensorflow

In TensorFlow zijn er vaste fasen voor het maken van een model:

• Een model maken – voeg de lagen van een neuraal netwerk samen met behulp van de functionele of sequentiële API
• Het samenstellen van een model – definiëren hoe de prestaties van een model moeten worden gemeten en hoe deze moeten worden verbeterd (verliesfunctie en optimalisatie)
• Een modus aanpassenl – een model patronen in de gegevens laten vinden

We zullen de Sequential API gebruiken. Dus laten we beginnen

tf.random.set_seed(42)

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

 optimizer = tf.keras.optimizers.SGD(), #SGD staat voor Stochastic Gradient Descent metrics = ['nauwkeurigheid']) model_1.fit(X, y, tijdperken = 5)

>> Epoch 1/5 32/32 [=============================] - 1s 1ms/stap - verlies: 2.8544 - nauwkeurigheid: 0.4600 Epoch 2/5 32/32 [=============================] - 0s 2ms/stap - verlies : 0.7131 - nauwkeurigheid: 0.5430 Epoch 3/5 32/32 [=============================] - 0s 2ms/stap - verlies: 0.6973 - nauwkeurigheid: 0.5090 Epoch 4/5 32/32 [=============================] - 0s 2ms /stap - verlies: 0.6950 - nauwkeurigheid: 0.5010 Epoch 5/5 32/32 [============================] - 0s 1ms/stap - verlies: 0.6942 - nauwkeurigheid: 0.4830

De nauwkeurigheid van het model is ongeveer 50%, wat in feite betekent dat het model alleen maar gokt. Laten we proberen het langer te trainen

model_1.fit(X, y, tijdperken = 200, uitgebreid = 0) #we stellen uitgebreid = 0 in om de trainingsprocedure te verwijderen) model_1.evaluate(X, y)

>> 32/32 [==============================] - 0s 1ms/stap - verlies: 0.6935 - nauwkeurigheid: 0.5000 [0.6934829950332642, 0.5]

Zelfs na 200 tijdperken presteert het nog steeds zoals het verwacht. De volgende stap is het toevoegen van meer lagen en langer trainen.

tf.random.set_seed(42)

model_2 = tf.keras.Sequential([ tf.keras.layers.Dense(1), tf.keras.layers.Dense(1) ]) model_2.compile(verlies = tf.keras.losses.BinaryCrossentropy(), optimizer = tf.keras.optimizers.SGD(), metrics = ['nauwkeurigheid']) model_2.fit(X, y, tijdperken = 100, uitgebreid = 0)

 model_2.evalueer(X,y)

>> 32/32 [==============================] - 0s 1ms/stap - verlies: 0.6933 - nauwkeurigheid: 0.5000 [0.6933314800262451, 0.5]

Toch is er niet eens een kleine verandering, het lijkt erop dat er iets mis is.

Verbetering van het neurale netwerk voor classificatiemodel met Tensorflow

Er zijn verschillende manieren om een ​​model in verschillende stadia te verbeteren:

• Een model maken – voeg meer lagen toe, verhoog het aantal verborgen eenheden (neuronen), verander de activeringsfuncties van elke laag
• Een model samenstellen – probeer verschillende optimalisatiefuncties, gebruik bijvoorbeeld Adam() in plaats van SGD().
• Een model passen – we zouden het aantal tijdperken kunnen vergroten

Laten we proberen voeg meer neuronen toe en probeer Adam optimizer

tf.random.set_seed(42)

model_3 = tf.keras.Sequential([ tf.keras.layers.Dense(100), # voeg 100 dichte neuronen toe tf.keras.layers.Dense(10), # voeg nog een laag toe met 10 neuronen tf.keras.layers.Dense (1) ]) model_3.compile(loss=tf.keras.losses.BinaryCrossentropy(), optimizer=tf.keras.optimizers.Adam(), metrics=['nauwkeurigheid']) model_3.fit(X, y, tijdperken =100, uitgebreid=0)

model_3.evaluate(X,y) >> 32/32 [=============================] - 0s 1ms/stap - verlies: 0.6980 - nauwkeurigheid: 0.5080 [0.6980254650115967, 0.5080000162124634]

Het wordt nog steeds niet beter! Laten we de gegevens visualiseren om te zien wat er misgaat.

Visualiseer het neurale netwerkmodel

Om de voorspellingen van ons model te visualiseren gaan we een functie plot_decision_boundary() maken die:

• Neemt een getraind model, functies en labels in zich op
• Maak een meshgrid van de verschillende X-waarden.
• Maakt voorspellingen over het meshgrid.
• Geeft de voorspellingen weer met een lijn.

Opmerking:  Deze functie is aangepast op basis van twee bronnen:

CS231n Gemaakt met de basisprincipes van ML 

def plot_decision_boundary(model, X, y): # Definieer de asgrenzen van de plot en maak een meshgrid 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)) # Creëer X-waarden (we gaan deze allemaal voorspellen) x_in = np.c_[xx.ravel(), yy.ravel()] # Maak voorspellingen met behulp van de getrainde model y_pred = model.predict(x_in) # Controleer op meerdere klassen

 if len(y_pred[0]) > 1: print("classificatie met meerdere klassen uitvoeren...") # We moeten onze voorspellingen opnieuw vormgeven om ze klaar te maken voor het plotten van y_pred = np.argmax(y_pred, axis=1).reshape( xx.shape) else: print("binaire classificatie uitvoeren...") y_pred = np.round(y_pred).reshape(xx.shape) # Plotbeslissingsgrens plt.contourf(xx, yy, y_pred, cmap=plt. cm.RdYlBu, alpha=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)

Hier is het! Opnieuw laat visualisatie ons zien wat er mis is en wat we moeten doen? Ons model probeert een rechte lijn door de gegevens te trekken, maar onze gegevens zijn niet door een rechte lijn te scheiden. Mist er iets in ons classificatieprobleem? Wat het is?

Dit is niet-lineariteit! We hebben een aantal niet-lineaire lijnen nodig. Misschien raak je nu in de war. Als je denkt dat je zo'n functie nog niet eerder hebt gezien, heb je het mis, want dat is wel zo. Laten we ze visueel bekijken. Visualisatie werkt altijd beter!

Er zijn enkele activeringsfuncties in Neural Network die we kunnen gebruiken, zoals ReLu, sigmoïde. Laten we een beetje creëren speelgoedtensor en controleer die functies erop.

Activeringsfuncties voor neurale netwerken

A = tf.cast(tf.bereik(-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.], vorm=(24,), dtype=float32)

Laten we eens kijken hoe onze speelgoedtensor eruit ziet?

plt.plot(A)

Het ziet er zo uit: een rechte lijn! 

Laten we nu activeringsfuncties opnieuw maken om te zien wat ze met onze tensor doen?

sigmoïd:

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

Een niet-rechte lijn!

ReLu:

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

Nog een niet-rechte lijn!

Nu je niet-lineaire activeringsfuncties hebt gezien, en dit is wat voor ons zal werken, kan het model niets leren over een niet-lineaire dataset met lineaire activeringsfuncties! Als we dit hebben geleerd, is het tijd om onze gegevens te verdelen in trainings- en testsets en sterke modellen te bouwen.

X_train, y_train = X[:800], y[:800] X_test, y_test = 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, activatie = 'relu'), #we kunnen het ook "tf.keras.activations.relu" corrigeren tf.keras.layers.Dense(4 , activatie = 'relu'), tf.keras.layers.Dense(1, activatie = 'sigmoid') ]) model_4.compile( loss= tf.keras.losses.binary_crossentropy, optimizer = tf.keras.optimizers.Adam( lr = 0.01), metrische gegevens = ['nauwkeurigheid']) model_4.fit(X_train, y_train, tijdperken = 25, uitgebreid = 0)

Evalueer het model

verlies, nauwkeurigheid = model_4.evaluate(X_test, y_test) print(f' Modelverlies op de testset: {loss}') print(f' Modelnauwkeurigheid op de testset: {100*nauwkeurigheid}')

>> 7/7 [==============================] - 0s 2ms/stap - verlies: 0.1247 - nauwkeurigheid: 1.0000 Modelverlies op de testset: 0.1246885135769844 Modelnauwkeurigheid op de testset: 100.0

plt.figure(figsize=(12, 6)) plt.subplot(1, 2, 1) plt.title("Trein") 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()

Laten we even kort bekijken waar we het in dit artikel over hebben. Samen hebben we gekeken hoe we een classificatietaak in het neurale netwerk met TensorFlow kunnen aanpakken. We creëerden 3 modellen op de eerste manier die in ons opkwam, en met behulp van visualisatie beseften we waar we fout zaten, we onderzochten lineariteit en niet-lineariteit, en uiteindelijk slaagden we erin een algemeen model te bouwen. Wat ik probeerde te laten zien met al deze codes en de stappen die ik volgde, was dat niets 100 procent accuraat of vaststaat, alles blijft elke dag veranderen. Om te raden welk probleem je bij welk soort data waarschijnlijk tegenkomt en om te zien welke combinaties tot een beter resultaat leiden, hoef je alleen maar veel meer code te schrijven en ervaring op te doen.

Ik hoop dat het artikel je een beetje heeft geholpen en een aantal bijdragen heeft geleverd.

De media die in dit artikel worden getoond, zijn geen eigendom van Analytics Vidhya en worden gebruikt naar goeddunken van de auteur

Verwant

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