Eine Anleitung zum Trainieren von Bildklassifizierungsmodellen mit TensorFlow

Übersetzer |. Chen Jun

Rezensent |. Heutzutage sind Computer dank der kontinuierlichen Iteration von maschinellen Lern- und Deep-Learning-Algorithmen in der Lage, aufgenommene Bilder in großem Maßstab mit sehr hoher Genauigkeit zu klassifizieren. Zu den Anwendungsszenarien solcher fortschrittlichen Algorithmen gehören derzeit: die Interpretation von Lungenscanbildern, um festzustellen, ob sie gesund sind, die Durchführung einer Gesichtserkennung über mobile Geräte und die Unterscheidung verschiedener Arten von Konsumgütern für Einzelhändler.

Im Folgenden werde ich mit Ihnen eine Anwendung von Computer Vision (Computer Vision) – Bildklassifizierung – besprechen und nach und nach zeigen, wie Sie TensorFlow verwenden, um ein Modell anhand eines kleinen Bilddatensatzes zu trainieren.

1, Datensatz und Ziel

In diesem Beispiel verwenden wir den MNIST-Datensatz mit Ziffernbildern von 0 bis 9. Seine Form ist wie in der folgenden Abbildung dargestellt:

Der Zweck des Trainings dieses Modells besteht darin, Bilder unter ihren jeweiligen Bezeichnungen zu klassifizieren, das heißt: sie sind auf entsprechende Zahlen in der Abbildung. Typischerweise stellt eine tiefe neuronale Netzwerkarchitektur eine Eingabe, eine Ausgabe, zwei verborgene Schichten (Hidden Layers) und eine Dropout-Schicht zum Trainieren des Modells bereit. CNN oder Convolutional Neural Network ist die erste Wahl zur Identifizierung größerer Bilder. Es kann relevante Informationen erfassen und gleichzeitig die Eingabemenge reduzieren.

2. Vorbereitung

Übergeben wir zunächst TensorFlow, to_categorical (wird zum Konvertieren numerischer Klassenwerte in andere Kategorien verwendet), Sequential, Flatten, Dense und Verwenden Sie Dropout zum Aufbau einer neuronalen Netzwerkarchitektur, um alle relevanten Codebibliotheken zu importieren. Einige der hier genannten Codebibliotheken sind Ihnen möglicherweise etwas unbekannt. Ich erkläre sie weiter unten im Detail.

3. Hyperparameter

Ich werde den richtigen Satz von Hyperparametern anhand der folgenden Aspekte auswählen:

• #🎜 🎜#
• Zuerst definieren wir einige Hyperparameter als Ausgangspunkt. Später können Sie es an unterschiedliche Bedürfnisse anpassen. Hier habe ich 128 als kleinere Losgröße gewählt. Tatsächlich kann die Batch-Größe einen beliebigen Wert annehmen, aber eine Potenz von 2 verbessert oft die Speichereffizienz und sollte daher die erste Wahl sein. Es ist erwähnenswert, dass der Hauptgrund für die Entscheidung über eine geeignete Stapelgröße darin besteht, dass eine zu kleine Stapelgröße die Konvergenz zu umständlich macht, während eine zu große Stapelgröße möglicherweise nicht in den Speicher Ihres Computers passt.
  
Lassen Sie uns die Anzahl der Epochen (jede Probe im Trainingssatz nimmt an einem Training teil) auf 50 belassen, um ein schnelles Training des Modells zu erreichen. Je niedriger der Epochenwert ist, desto besser eignet er sich für kleine und einfache Datensätze.
• Als nächstes müssen Sie eine ausgeblendete Ebene hinzufügen. Hier habe ich 128 Neuronen für jede verborgene Schicht reserviert. Natürlich können Sie auch mit 64 und 32 Neuronen testen. Für dieses Beispiel würde ich nicht empfehlen, höhere Werte für einen einfachen Datensatz wie MINST zu verwenden.
• Sie können verschiedene Lernraten ausprobieren, z. B. 0,01, 0,05 und 0,1. In diesem Fall belasse ich den Wert bei 0,01.
• Für andere Hyperparameter habe ich die Abklingschritte und die Abklingrate auf 2000 bzw. 0,9 gewählt. Und mit fortschreitendem Training können sie dazu genutzt werden, die Lernrate zu reduzieren.
• Hier wähle ich Adamax als Optimierer. Natürlich können Sie auch andere Optimierer wie Adam, RMSProp, SGD usw. wählen.

• import tensorflow as tf
  from tensorflow.keras.utils import to_categorical
  from tensorflow.keras.models import Sequential
  from tensorflow.keras.layers import Flatten, Dense, Dropout
  params = {
  'dropout': 0.25,
  'batch-size': 128,
  'epochs': 50,
  'layer-1-size': 128,
  'layer-2-size': 128,
  'initial-lr': 0.01,
  'decay-steps': 2000,
  'decay-rate': 0.9,
  'optimizer': 'adamax'
  }
  mnist = tf.keras.datasets.mnist
  num_class = 10
  # split between train and test sets
  (x_train, y_train), (x_test, y_test) = mnist.load_data()
  # reshape and normalize the data
  x_train = x_train.reshape(60000, 784).astype("float32")/255
  x_test = x_test.reshape(10000, 784).astype("float32")/255
  # convert class vectors to binary class matrices
  y_train = to_categorical(y_train, num_class)
  y_test = to_categorical(y_test, num_class)

• 4. Erstellen Sie Trainings- und Testsätze

Da die TensorFlow-Bibliothek auch den MNIST-Datensatz enthält, können Sie datasets.mnist für das Objekt aufrufen und dann aufrufen die Methode „load_data()“, um die Trainings- (60.000 Proben) bzw. Testdatensätze (10.000 Proben) zu erhalten.

Als nächstes müssen Sie die Trainings- und Testbilder umformen und normalisieren. Unter anderem begrenzt die Normalisierung die Pixelintensität des Bildes auf 0 bis 1.

Schließlich verwenden wir die to_categorical-Methode, die wir zuvor importiert haben, um die Trainings- und Testetiketten in klassifizierte Etiketten umzuwandeln. Dies ist sehr wichtig, um dem TensorFlow-Framework zu vermitteln, dass die Ausgabebezeichnungen (z. B. 0 bis 9) Klassen und keine numerischen Typen sind.

5. Entwerfen Sie die neuronale Netzwerkarchitektur

Lassen Sie uns als Nächstes verstehen, wie die neuronale Netzwerkarchitektur im Detail entworfen wird.

Wir konvertieren die 2D-Bildmatrix in Vektoren, indem wir Flatten hinzufügen, um die Struktur des DNN (Deep Neural Network) zu definieren. Die Eingabeneuronen entsprechen hier den Zahlen im Vektor.

Als nächstes verwende ich die Methode Dense(), um zwei versteckte dichte Ebenen hinzuzufügen und jeden Hyperparameter aus dem zuvor definierten Wörterbuch „params“ zu extrahieren. Als Aktivierungsfunktion dieser Schichten können wir „relu“ (Rectified Linear Unit) verwenden. Es ist eine der am häufigsten verwendeten Aktivierungsfunktionen in verborgenen Schichten neuronaler Netze.

Dann fügen wir die Dropout-Ebene mit der Dropout-Methode hinzu. Es wird verwendet, um eine Überanpassung beim Training neuronaler Netze zu vermeiden. Schließlich neigen überangepasste Modelle dazu, sich den Trainingssatz genau zu merken und können nicht auf unsichtbare Datensätze verallgemeinern.

输出层是我们网络中的最后一层，它是使用Dense() 方法来定义的。需要注意的是，输出层有10个神经元，这对应于类（数字）的数量。

# Model Definition
# Get parameters from logged hyperparameters
model = Sequential([
Flatten(input_shape=(784, )),
Dense(params('layer-1-size'), activatinotallow='relu'),
Dense(params('layer-2-size'), activatinotallow='relu'),
Dropout(params('dropout')),
Dense(10)
])
lr_schedule =
tf.keras.optimizers.schedules.ExponentialDecay(
initial_learning_rate=experiment.get_parameter('initial-lr'),
decay_steps=experiment.get_parameter('decay-steps'),
decay_rate=experiment.get_parameter('decay-rate')
)
loss_fn = tf.keras.losses.CategoricalCrossentropy(from_logits=True)
model.compile(optimizer='adamax',
loss=loss_fn,
metrics=['accuracy'])
model.fit(x_train, y_train,
batch_size=experiment.get_parameter('batch-size'),
epochs=experiment.get_parameter('epochs'),
validation_data=(x_test, y_test),)
score = model.evaluate(x_test, y_test)
# Log Model
model.save('tf-mnist-comet.h5')

6、训练

至此，我们已经定义好了架构。下面让我们用给定的训练数据，来编译和训练神经网络。

首先，我们以初始学习率、衰减步骤和衰减率作为参数，使用ExponentialDecay（指数衰减学习率）来定义学习率计划。

其次，将损失函数定义为CategoricalCrossentropy（用于多类式分类）。

接着，通过将优化器 (即：adamax)、损失函数、以及各项指标（由于所有类都同等重要、且均匀分布，因此我选择了准确性）作为参数，来编译模型。

然后，我们通过使用x_train、y_train、batch_size、epochs和validation_data去调用一个拟合方法，并拟合出模型。

同时，我们调用模型对象的评估方法，以获得模型在不可见数据集上的表现分数。

最后，您可以使用在模型对象上调用的save方法，保存要在生产环境中部署的模型对象。

7、小结

综上所述，我们讨论了为图像分类任务，训练深度神经网络的一些入门级的知识。您可以将其作为熟悉使用神经网络，进行图像分类的一个起点。据此，您可了解到该如何选择正确的参数集、以及架构背后的思考逻辑。

原文链接：https://www.kdnuggets.com/2022/12/guide-train-image-classification-model-tensorflow.html

Das obige ist der detaillierte Inhalt vonEine Anleitung zum Trainieren von Bildklassifizierungsmodellen mit TensorFlow. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!