Dieses Tutorial zeigt, wie man mit Python und TensorFlow eine Bildklassifizierung durchführt. In diesem Projekt erstellen wir einen Klassifikator, um zwischen verschiedenen Arten von Kleidungsstücken zu unterscheiden. Wir verwenden das vortrainierte Modell fashion_mnist. Es ist ein gutes Beispiel dafür, wie man vortrainierte Modelle in TensorFlow verwenden kann.

Was ist Bildklassifizierung?

Die Bildklassifizierung ist eine Klasse von Algorithmen des maschinellen Lernens, die Computer dazu verwenden, Bilder zu betrachten und sie zu klassifizieren. Die Klassifizierung von Bildern ist eine Möglichkeit für Maschinen, etwas über die Welt um uns herum zu lernen. Die Bildklassifizierung eignet sich gut für die visuelle Erkennung, da die Bilder eine natürliche Eins-zu-eins-Entsprechung mit den Daten für die Klassen haben. Dies unterscheidet sich von der Textklassifizierung, bei der die Klassen nur eine geringe oder gar keine natürliche Eins-zu-Eins-Entsprechung mit den Wörtern in einer textlichen Beschreibung der Kategorisierung haben. Die Bildklassifizierung ist in der Astronomie weit verbreitet, um Objekte wie Galaxien und Planeten zu identifizieren.

Voraussetzungen

Anaconda:

Die Anaconda-Distribution ist eine Sammlung von Paketen, die aus Python, R und über 120 der beliebtesten Open-Source-Pakete für Wissenschaft und Datenverarbeitung besteht. Das bedeutet, dass diese Distribution auf einem einzigen Rechner installiert werden kann, was die Durchführung von Datenanalysen in großem Maßstab enorm erleichtert! Sie können conda über den folgenden Link herunterladen und installieren.

https://www.anaconda.com/products/individual

Danach erhalten Sie Zugriff auf das Terminal, mit dem Sie alle Ihre Bibliotheken installieren können.

Jupyter notebook:

Das Jupyter-Notebook ist eine kostenlose und quelloffene Webanwendung. Es wird häufig von Datenwissenschaftlern und anderen technischen Nutzern verwendet, die ihre Arbeit mit anderen teilen möchten, aber jeder kann diese Plattform für den Wissensaustausch nutzen. Sie können das Jupyter-Notebook mit dem folgenden Befehl in Ihrem conda-Terminal installieren. 

pip install jupyter notebook

Für den Zugriff auf das Notebook können Sie diesen Befehl verwenden. 

jupyter notebook

Tensorflow:

TensorFlow ist eine Open-Source-Softwarebibliothek für numerische Berechnungen mit Datenflussgraphen. Die Knoten des Graphen stellen mathematische Operationen dar, während die Kanten des Graphen die mehrdimensionalen Datenarrays (Tensoren) darstellen, die zwischen ihnen fließen. Die flexible Architektur ermöglicht es Ihnen, Berechnungen auf einer oder mehreren CPUs oder GPUs auf einem Desktop, Server oder mobilen Gerät mit einer einzigen API durchzuführen.

Sie können das Jupyter-Notebook mit dem folgenden Befehl in Ihrem conda-Terminal installieren. 

pip install --upgrade tensorflow

Numpy:

NumPy, kurz für Numerical Python, ist eine Python-Bibliothek, die für wissenschaftliche Berechnungen und Datenverarbeitung verwendet wird. Diese Bibliothek erleichtert die Ausführung von Python-Code auf Arrays und Matrizen anstelle von Listen. Sie hat viele Funktionen, die Ihre Mathematik schneller machen.

Sie können das Jupyter-Notebook mit dem folgenden Befehl in Ihrem conda-Terminal installieren. 

pip install numpy

Code

Importieren Sie die Abhängigkeit 

import tensorflow as tf
from tensorflow import keras
import numpy as np
import matplotlib.pyplot as plt

die Daten laden 

wir verwenden die keras.datasets.fashion_mnist, weil es bereits in Keras vorhanden ist 

fashion_mnist = keras.datasets.fashion_mnist

Beim Laden der Daten werden vier Numpy-Arrays zurückgegeben, und diese sind die Daten, die das Modell zum Lernen verwendet  

(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()

Laden der Etiketten

jedes Bild wird einem einzelnen Label zugeordnet, da die Klasse nicht im Datensatz enthalten ist, müssen wir sie hier speichern 

class_names = ['T-shirt/top', 'Sneaker', 'Pullover', 'Ankle boot', 'Coat', 'Sandal', 'Shirt', 'Trouser', 'Bag', 'Dress']

Erkundung der Daten: (Formatierung des Datensatzes) 

Train_images.shape

Ausgabe:

(60000, 28, 28)

Wie Sie aus der Ausgabe ersehen können, haben wir 60000 Bilder im Trainingssatz 

len(train_labels)

Ausgabe:

60000

Wir haben auch 60000 Etiketten in den Datensätzen

Für die Bildklassifizierung mit TensorFlow müssen die Daten einen Prozess durchlaufen, der Vorverarbeitung genannt wird, um die Bilder so zu konditionieren, dass sie den ImageNet 1k Kategorien entsprechen. Wenn Sie das erste Bild Ihres Datensatzes untersuchen, werden Sie sehen, dass es Pixelwerte im Bereich von 0 – 255 hat: 

plt.figure()
plt.imshow(train_images[0])
plt.colorbar()
plt.grid(False)
plt.show()

Output:

Wir haben die Trainingsbilder und die Testbilder durch 255 geteilt, da die Trainings- und die Testmenge auf die gleiche Weise vorverarbeitet werden müssen.  

train_images = train_images / 255.0

test_images = test_images / 255.0

Jetzt werden wir die ersten 25 Bilder aus dem Trainingssatz anzeigen und den Namen der Klasse in jedem Bild darunter anzeigen. 

plt.figure(figsize=(10,10))
for i in range(25):
    plt.subplot(5,5,i+1)
    plt.xticks([])
    plt.yticks([])
    plt.grid(False)
    plt.imshow(train_images[i], cmap=plt.cm.binary)
    plt.xlabel(class_names[train_labels[i]])
plt.show()

Ausgabe:

Jetzt sind wir bereit, das Netzwerk aufzubauen und zu trainieren

Aufbau des Netzes:

Der Aufbau des neuronalen Netzes erfordert die Konfiguration der Schichten des Modells und die anschließende Kompilierung des Modells 

# setup the layer
model = keras.Sequential([
    keras.layers.Flatten(input_shape=(28, 28)),
    keras.layers.Dense(128, activation='relu'),
    keras.layers.Dense(10)
])
#Fitting the Model
model.fit(train_images, train_labels, epochs=10)
#Evaluating Accuracy
test_loss, test_acc = model.evaluate(test_images,  test_labels, verbose=2)
print('\nTest accuracy:', test_acc)

Ausbildungsmodell

#Fitting the Model
model.fit(train_images, train_labels, epochs=10)
#Evaluating Accuracy
test_loss, test_acc = model.evaluate(test_images,  test_labels, verbose=2)
print('\nTest accuracy:', test_acc)

Ausgabe:

Ausgabe:

Vorhersage treffen:

probability_model = tf.keras.Sequential([model,
                                        tf.keras.layers.Softmax()])
predictions = probability_model.predict(test_images)
predictions[0]

Ausgabe:

Erstellen eines Diagramms zur Betrachtung der Vorhersage 

# defined the plot image
def plot_image(i, predictions_array, true_label, img):
  true_label, img = true_label[i], img[i]
  plt.grid(False)
  plt.xticks([])
  plt.yticks([])

  plt.imshow(img, cmap=plt.cm.binary)

  # defining the plot value array
  predicted_label = np.argmax(predictions_array)
  if predicted_label == true_label:
    color = 'blue'
  else:
    color = 'red'

  plt.xlabel("{} {:2.0f}% ({})".format(class_names[predicted_label],
                                100*np.max(predictions_array),
                                class_names[true_label]),
                                color=color)

def plot_value_array(i, predictions_array, true_label):
  true_label = true_label[i]
  plt.grid(False)
  plt.xticks(range(10))
  plt.yticks([])
  thisplot = plt.bar(range(10), predictions_array, color="#777777")
  plt.ylim([0, 1])
  predicted_label = np.argmax(predictions_array)

  thisplot[predicted_label].set_color('red')
  thisplot[true_label].set_color('blue')

Schauen wir uns nun die 1. Anzahl von Bildern an, um die Vorhersage zu überprüfen 

i = 1
plt.figure(figsize=(6,3))
plt.subplot(1,2,1)
plot_image(i, predictions[i], test_labels, test_images)
plt.subplot(1,2,2)
plot_value_array(i, predictions[i],  test_labels)
plt.show()

Ausgabe:

Mehrere Bilder zusammen klassifizieren: 

num_rows = 5
num_cols = 3
num_images = num_rows*num_cols
plt.figure(figsize=(2*2*num_cols, 2*num_rows))
for i in range(num_images):
  plt.subplot(num_rows, 2*num_cols, 2*i+1)
  plot_image(i, predictions[i], test_labels, test_images)
  plt.subplot(num_rows, 2*num_cols, 2*i+2)
  plot_value_array(i, predictions[i], test_labels)
plt.tight_layout()
plt.show()

Ausgabe

Hier ist die Vorhersage des Bildes mit Blau richtig und die Vorhersage mit Rot falsch.

Letzte Worte

Dieser Blog-Beitrag bietet ein Beispiel für die Verwendung von TensorFlow, der Python-Bibliothek für maschinelles Lernen, die von Google als Open Source zur Verfügung gestellt wurde, um ein Modell zu trainieren, das zwischen verschiedenen Arten von Bildern unterscheiden kann. Wir haben einen bestehenden Datensatz namens fashion_mnist verwendet, und zwar den von Google trainierten Datensatz, dessen Ziel es ist, zu erkennen, welches Kleidungsstück auf einem bestimmten Bild zu sehen ist. Ich hoffe, das Tutorial hat euch gefallen und wenn ihr Fragen habt, könnt ihr sie gerne unten stellen, ich werde mein Bestes tun, um sie zu beantworten!