Neuronales Netzwerk zur Klassifizierung mit Tensorflow

Dieser Artikel wurde als Teil des veröffentlicht Data-Science-Blogathon

In diesem Artikel werde ich mit TensorFlow neuronale Netzwerkmodelle erstellen, um ein Klassifizierungsproblem zu lösen. Lassen Sie uns gemeinsam untersuchen, wie wir ein Klassifizierungsproblem in Tensorflow angehen können. Aber zunächst möchte ich sicherstellen, dass wir diese Fragen beantworten können:

ist ein neuronales Netzwerk?

Der Hauptzweck eines neuronalen Netzwerks besteht darin, die Beziehung zwischen Merkmalen in einem Datensatz zu finden. Es besteht aus einer Reihe von Algorithmen, die die Arbeit des menschlichen Gehirns nachahmen. Ein „Neuron“ in einem neuronalen Netzwerk ist eine mathematische Funktion, die Informationen gemäß einer bestimmten Architektur sammelt und klassifiziert.

Was ist Klassifizierung?

Beim Klassifizierungsproblem geht es darum, vorherzusagen, ob etwas zu einer Klasse gehört oder nicht. Mit anderen Worten: Während wir es tun, versuchen wir zu erkennen, dass etwas das eine oder andere ist.

Arten der Klassifizierung

• Angenommen, Sie möchten vorhersagen, ob eine Person Diabetes hat oder nicht. Wenn Sie mit einer solchen Situation konfrontiert sind, gibt es doch zwei Möglichkeiten, oder? Das wird .. genannt Binäre Klassifizierung.
• Angenommen, Sie möchten feststellen, ob ein Foto ein Spielzeug, eine Person oder eine Katze zeigt, richtig? das nennt man Klassifizierung mehrerer Klassen denn es gibt mehr als zwei Möglichkeiten.
• Angenommen, Sie möchten entscheiden, welche Kategorien einem Artikel zugeordnet werden sollen. Wenn ja, heißt es Multi-Label-Klassifizierung, da einem Artikel mehr als eine Kategorie zugeordnet sein könnte. Lassen Sie uns unsere Erklärung durch diesen Artikel weiterführen. Wir können diesem Artikel Kategorien wie „Deep Learning, TensorFlow, Klassifizierung“ usw. zuordnen

Jetzt können wir weitermachen, weil wir ein gemeinsames Verständnis für das Problem haben, an dem wir arbeiten werden. Es ist also Zeit für das Codieren. Ich hoffe, Sie schreiben sie mit mir auf, denn der einzige Weg, besser zu werden und weniger Fehler zu machen, besteht darin, mehr Code zu schreiben.

Wir beginnen mit dem Importieren von Bibliotheken, die wir verwenden werden:

numpy als np importieren
Pandas als PD importieren
matplotlib.pyplot als plt importieren
Tensorflow als tf importieren
print(tf.__version__)

Einen Datensatz erstellen

Es ist Zeit, einen Datensatz zu erstellen, an dem Sie arbeiten können:

aus sklearn.datasets import make_circles Proben = 1000
X, y = make_circles(samples, noise = 0.03, random_state = 42)

drucken(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]]

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

Okay, wir haben unseren Datensatz genauer gesehen, wissen aber immer noch nichts darüber, oder? Deshalb ist es hier ein wichtiger Schritt, mit den Daten eins zu werden, und die Visualisierung ist der beste Weg, dies zu tun.

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

Hier stellt sich die Frage: Mit was für Etiketten haben wir es zu tun?

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

Sieht so aus, als hätten wir es damit zu tun ein binäres Klassifizierungsproblem, weil wir 2 Labels haben (0 und 1).

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

Wie ich oben erwähnt habe, ist die Visualisierung der beste Weg, einen Überblick über die Daten zu erhalten. Jetzt sagt die Handlung selbst, welche Art von Modell wir bauen müssen. Wir werden ein Modell bauen, das blaue Punkte von roten Punkten unterscheiden kann.

Bevor wir ein neuronales Netzwerkmodell erstellen, müssen wir die Formen unserer Eingabe- und Ausgabemerkmale überprüfen. sie müssen gleich sein!

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

Wir haben für jedes Merkmal die gleiche Anzahl an Werten, aber die Form von X ist unterschiedlich? Warum? Schauen wir es uns an.

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

Okay, wir haben 2 X-Funktionen für 1 Jahr. So können wir problemlos vorankommen.

Schritte bei der Modellierung eines neuronalen Netzwerks zur Klassifizierung mit Tensorflow

In TensorFlow gibt es feste Phasen zum Erstellen eines Modells:

• Modell erstellen – Fügen Sie die Schichten eines neuronalen Netzwerks mithilfe der funktionalen oder sequentiellen API zusammen
• Kompilieren eines Modells – Definieren, wie die Leistung eines Modells gemessen und verbessert werden soll (Verlustfunktion und Optimierer)
• Anpassen eines Modusl – ein Modell Muster in den Daten finden lassen

Wir werden die Sequential API verwenden. Also lasst uns anfangen

tf.random.set_seed(42)

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

 Optimizer = tf.keras.optimizers.SGD(), #SGD steht für Stochastic Gradient Descent metrics = ['accuracy']) model_1.fit(X, y, epochs = 5)

>> Epoche 1/5 32/32 [==============================] - 1s 1ms/Schritt - Verlust: 2.8544 - Genauigkeit: 0.4600 Epoche 2/5 32/32 [=============================] - 0s 2ms/Schritt - Verlust : 0.7131 - Genauigkeit: 0.5430 Epoche 3/5 32/32 [==============================] - 0s 2ms/Schritt - Verlust: 0.6973 - Genauigkeit: 0.5090 Epoche 4/5 32/32 [=============================] - 0s 2ms /Schritt - Verlust: 0.6950 - Genauigkeit: 0.5010 Epoche 5/5 32/32 [=============================] - 0s 1ms/Schritt - Verlust: 0.6942 - Genauigkeit: 0.4830

Die Genauigkeit des Modells beträgt ungefähr 50 %, was im Grunde bedeutet, dass das Modell nur rät. Versuchen wir, es länger zu trainieren

model_1.fit(X, y, epochs = 200, verbose = 0) #wir setzen verbose = 0, um den Trainingsvorgang zu entfernen)
model_1.evaluate(X, y)

>> 32/32 [=============================] - 0s 1ms/Schritt - Verlust: 0.6935 - Genauigkeit: 0.5000 [0.6934829950332642, 0.5]

Selbst nach 200 Epochen verhält es sich immer noch so, als würde es raten. Der nächste Schritt besteht darin, weitere Schichten hinzuzufügen und länger zu trainieren.

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(), Optimizer = tf.keras.optimizers.SGD(), metrics = ['accuracy']) model_2.fit(X, y, epochs = 100, verbose = 0)

 model_2.evaluate(X,y)

>> 32/32 [=============================] - 0s 1ms/Schritt - Verlust: 0.6933 - Genauigkeit: 0.5000 [0.6933314800262451, 0.5]

Dennoch gibt es nicht einmal eine kleine Veränderung, es scheint, als ob etwas nicht stimmt.

Verbesserung des Modells „Neuronales Netzwerk für die Klassifizierung“ mit Tensorflow

Es gibt verschiedene Möglichkeiten, ein Modell in verschiedenen Phasen zu verbessern:

• Modell erstellen – Fügen Sie weitere Schichten hinzu, erhöhen Sie die Anzahl der verborgenen Einheiten (Neuronen) und ändern Sie die Aktivierungsfunktionen jeder Schicht
• Ein Modell zusammenstellen – Probieren Sie verschiedene Optimierungsfunktionen aus, verwenden Sie beispielsweise Adam() anstelle von SGD().
• Ein Modell anpassen – wir könnten die Anzahl der Epochen erhöhen

Versuchen wir es Fügen Sie weitere Neuronen hinzu und versuchen Marcus Optimierer

tf.random.set_seed(42)

model_3 = tf.keras.Sequential([ tf.keras.layers.Dense(100), # füge 100 dichte Neuronen hinzu tf.keras.layers.Dense(10), # füge eine weitere Ebene mit 10 Neuronen hinzu tf.keras.layers.Dense (1) ]) model_3.compile(loss=tf.keras.losses.BinaryCrossentropy(), optimierer=tf.keras.optimizers.Adam(), metrics=['accuracy']) model_3.fit(X, y, epochs =100, ausführlich=0)

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

Es wird immer noch nicht besser! Lassen Sie uns die Daten visualisieren, um zu sehen, was falsch läuft.

Visualisieren Sie das Modell des neuronalen Netzwerks

Um die Vorhersagen unseres Modells zu visualisieren, erstellen wir eine Funktion plot_decision_boundary(), die:

• Nimmt ein trainiertes Modell, Funktionen und Beschriftungen auf
• Erstellen Sie ein Meshgrid der verschiedenen X-Werte.
• Macht Vorhersagen im gesamten Meshgrid.
• Stellt die Vorhersagen mit einer Linie dar.

Hinweis:  Diese Funktion wurde aus zwei Quellen angepasst:

CS231n Hergestellt mit ML-Grundlagen 

def plot_decision_boundary(model, X, y): # Definieren Sie die Achsengrenzen des Diagramms und erstellen Sie ein Meshgrid x_min, x_max = X[:, 0].min() - 0.1, 0 y_min, y_max = X[:, 0.1].min() - 1, X[:, 0.1].max() + 1 xx, yy = np.meshgrid(np.linspace(x_min, x_max, 0.1), np .linspace(y_min, y_max, 100)) # X-Werte erstellen (wir werden diese alle vorhersagen) x_in = np.c_[xx.ravel(), yy.ravel()] # Vorhersagen anhand der trainierten Werte treffen model y_pred = model.predict(x_in) # Auf Mehrklassen prüfen

 if len(y_pred[0]) > 1: print("Doing Multiclass Classification...") # Wir müssen unsere Vorhersagen umformen, um sie für die Darstellung vorzubereiten y_pred = np.argmax(y_pred, axis=1).reshape( xx.shape) else: print("binäre Klassifizierung durchführen...") y_pred = np.round(y_pred).reshape(xx.shape) # Entscheidungsgrenze darstellen 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 ist es! Wieder zeigt uns die Visualisierung, was falsch ist und was zu tun ist? Unser Modell versucht, eine gerade Linie durch die Daten zu zeichnen, aber unsere Daten sind nicht durch eine gerade Linie trennbar. Fehlt bei unserem Klassifizierungsproblem etwas? Was es ist?

Das ist Nichtlinearität! Wir brauchen einige nichtlineare Linien. Sie könnten jetzt verwirrt sein, wenn Sie denken, dass Sie diese Art von Funktion vorher nicht gesehen haben, liegen Sie falsch, denn das ist der Fall. Schauen wir sie uns visuell an. Visualisierung funktioniert immer besser!

Es gibt einige Aktivierungsfunktionen im Neural Network, die wir verwenden können, z ReLu, Sigma. Lasst uns ein wenig kreieren Spielzeugtensor und überprüfen Sie die Funktionen darauf.

Aktivierungsfunktionen für neuronale Netze

A = tf.cast(tf.range(-12,12), tf.float32)
drucken(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.], shape=(24,), dtype=float32)

Mal sehen, wie unser Spielzeugtensor aussieht?

plt.plot(A)

Es sieht so aus, eine gerade Linie! 

Lassen Sie uns nun Aktivierungsfunktionen neu erstellen, um zu sehen, was sie mit unserem Tensor machen.

Sigma:

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

Eine nicht gerade Linie!

ReLu:

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

Wieder eine nicht gerade Linie!

Jetzt haben Sie nichtlineare Aktivierungsfunktionen gesehen, und diese werden für uns funktionieren. Das Modell kann aus einem nichtlinearen Datensatz mit linearen Aktivierungsfunktionen nichts lernen! Wenn Sie dies gelernt haben, ist es an der Zeit, unsere Daten in Trainings- und Testsätze aufzuteilen und starke Modelle zu erstellen.

X_train, y_train = X[:800], y[:800] X_test, y_test = X[800:], y[800:] ))

tf.random.set_seed(42)

model_4 = tf.keras.Sequential([ tf.keras.layers.Dense(4, activate = 'relu'), #we can right it "tf.keras.activations.relu" too tf.keras.layers.Dense(4 , Aktivierung = 'relu'), tf.keras.layers.Dense(1, Aktivierung = 'sigmoid') ]) model_4.compile( loss= tf.keras.losses.binary_crossentropy, Optimizer = tf.keras.optimizers.Adam( lr = 0.01), metrics = ['accuracy']) model_4.fit(X_train, y_train, epochs = 25, verbose = 0)

Bewerten Sie das Modell

Verlust, Genauigkeit = model_4.evaluate(X_test, y_test)
print(f' Modellverlust im Testsatz: {loss}')
print(f' Modellgenauigkeit im Testsatz: {100*accuracy}')

>> 7/7 [==============================] – 0s 2ms/Schritt – Verlust: 0.1247 – Genauigkeit: 1.0000 Modellverlust im Testsatz: 0.1246885135769844 Modellgenauigkeit im Testsatz: 100.0

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

Werfen wir einen kurzen Blick darauf, worüber wir in diesem Artikel sprechen. Gemeinsam haben wir uns angeschaut, wie man mit TensorFlow eine Klassifizierungsaufgabe im Neural Network angehen kann. Wir haben drei Modelle auf die erste Weise erstellt, die uns in den Sinn kam, und mithilfe der Visualisierung erkannten wir, wo wir falsch lagen, wir untersuchten Linearität und Nichtlinearität und schließlich gelang es uns, ein verallgemeinertes Modell zu erstellen. Was ich mit all diesen Codes und den Schritten, die ich befolgte, zeigen wollte, war, dass nichts zu 3 Prozent genau oder behoben ist, sondern dass sich jeden Tag alles ändert. Um zu erraten, mit welchem ​​Problem Sie bei welcher Art von Daten wahrscheinlich konfrontiert werden und welche Kombinationen zu einem besseren Ergebnis führen, müssen Sie lediglich viel mehr Code schreiben und Erfahrung sammeln.

Ich hoffe, der Artikel war ein wenig hilfreich für Sie und hat einige Beiträge geliefert.

Die in diesem Artikel gezeigten Medien sind nicht Eigentum von Analytics Vidhya und werden nach Ermessen des Autors verwendet

Verbunden

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