Tensorflow 2.0-Bildklassifizierung: Installieren, Laden von Daten, Erstellen und Trainieren des Modells

Die Bildklassifizierung ist eine Kategorie der Mustererkennung. Es klassifiziert Bilder nach der Beziehung zwischen den benachbarten Pixeln. Mit anderen Worten, es verwendet Kontextinformationen, um Bilder zu organisieren, und ist bei verschiedenen Technologien sehr beliebt. Es ist ein wichtiges Thema in Deep Learning, und wenn Sie sich darüber informieren, wird Ihnen dieser Artikel sicherlich gefallen.

Hier führen wir die TensorFlow-Bildklassifizierung durch. Wir bauen ein Modell, trainieren es und verbessern dann seine Genauigkeit, um Bilder von Kakteen zu klassifizieren. TensorFlow ist eine Open-Source-Plattform für maschinelles Lernen und ein Produkt von Google.

Lass uns anfangen.

Installieren Sie TensorFlow 2.0

Zuerst müssen Sie TensorFlow auf Google Colab installieren. Sie können es über Pip installieren:

!pip installiere tensorflow-gpu==2.0.0-alpha0

Dann überprüfen wir die Installation:

Tensorflow als tf importieren

drucken(tf.__Version)

# Ausgabe: 2.0.0-alpha0

Quelle

Lernen: Die beliebtesten 5 TensorFlow-Projekte für Anfänger

Lade Daten

Nach der Überprüfung können wir die Daten mithilfe des tf.data.dataset laden. Wir bauen einen Klassifikator, der bestimmt, ob ein Bild einen Kaktus enthält oder nicht. Der Kaktus muss säulenförmig sein. Zu diesem Zweck können wir den Datensatz Cactus Aerial Photos verwenden. Jetzt laden wir die Dateipfade zusammen mit ihren Labels:

train_csv = pd.read_csv('data/train.csv')

# Bilddateinamen in train/ mit relativem Pfad voranstellen

filenames = ['train/' + fname for fname in train_csv['id'].tolist()]

label = train_csv['has_cactus'].tolist()

train_filenames, val_filenames, train_labels, val_labels =

train_test_split(Dateinamen,

Etiketten,

train_size=0.9,

random_state=42)

Sobald wir die Labels und Dateinamen haben, können wir die tf.data.Dataset-Objekte erstellen:

train_data = tf.data.Dataset.from_tensor_slices (

(tf.constant(train_filenames), tf.constant(train_labels))

)

val_data = tf.data.Dataset.from_tensor_slices (

(tf.constant(val_filenames), tf.constant(val_labels))

)

Quelle

Im Moment enthält unser Datensatz nicht die tatsächlichen Bilder. Es hat nur ihre Dateinamen. Wir benötigen eine Funktion, um die erforderlichen Bilder zu laden und zu verarbeiten, damit wir die TensorFlow-Bilderkennung an ihnen durchführen können.

IMAGE_SIZE = 96 # Minimale Bildgröße für die Verwendung mit MobileNetV2

BATCH_SIZE = 32

# Funktion zum Laden und Vorverarbeiten jedes Bildes

def _parse_fn(Dateiname, Bezeichnung):

img = tf.io.read_file(img)

img = tf.image.decode_jpeg(img)

img = (tf.cast(img, tf.float32)/127.5) – 1

img = tf.image.resize(img, (IMAGE_SIZE, IMAGE_SIZE))

Rückbild, Etikett

# Führen Sie _parse_fn über jedes Beispiel in train- und val-Datensätzen aus

# Auch mischen und Stapel erstellen

train_data = (train_data.map(_parse_fn)

.shuffle(buffer_size=10000)

.batch(BATCH_SIZE)

)

val_data = (val_data.map(_parse_fn)

.shuffle(buffer_size=10000)

.batch(BATCH_SIZE)

)

Quelle

Erstellen eines Modells

In diesem Beispiel für die TensorFlow-Bildklassifizierung erstellen wir ein Transfer-Lernmodell. Diese Modelle sind schnell, da sie vorhandene Bildklassifizierungsmodelle verwenden können, die zuvor trainiert wurden. Sie müssen nur die obere Schicht ihres Netzwerks neu trainieren, da diese Schicht die Klasse des erforderlichen Bildes angibt.

Wir verwenden die Keras-API von TensorFlow 2.0, um unser Bildklassifizierungsmodell zu erstellen. Und für die Übertragungslernzwecke verwenden wir MobileNetV2 als Attributdetektor. Es ist die zweite Version von MobileNet und ein Produkt von Google. Es ist leichter als andere Modelle wie Inception und ResNet und kann auf Mobilgeräten ausgeführt werden. Wir laden dieses Modell auf ImageNet, frieren die Gewichtungen ein, fügen einen Klassifizierungskopf hinzu und führen es ohne seine oberste Schicht aus.

IMG_SHAPE = (IMAGE_SIZE, BILD_SIZE, 3)

# Vortrainiertes Modell mit MobileNetV2

base_model = tf.keras.applications.MobileNetV2(

input_shape=IMG_SHAPE,

include_top=Falsch,

weights='imagenet'

)

# Frieren Sie die vortrainierten Modellgewichte ein

base_model.trainable = Falsch

# Trainierbarer Klassifikationskopf

maxpool_layer = tf.keras.layers.GlobalMaxPooling2D()

Vorhersage_Schicht = tf.keras.layers.Dense (1, Aktivierung = 'sigmoid')

# Schichtklassifizierungskopf mit Merkmalsdetektor

model = tf.keras.Sequential([

Basismodell,

maxpool_layer,

Vorhersageebene

])

Lernrate = 0,0001

# Kompilieren Sie das Modell

model.compile(optimizer=tf.keras.optimizers.Adam(lr=learning_rate),

loss='binary_crossentropy',

metrics=['Genauigkeit']

)

Quelle

Sie sollten TensorFlow-Optimierer verwenden, wenn Sie tf.keras-Modelle trainieren möchten. Die Optimierer in den tf.keras.optimizers- und tf.train-APIs befinden sich zusammen in den tf.keras.optimizers von TensorFlow 2.0. In TensorFlow 2.0 haben viele der ursprünglichen Optimierer von tf.keras Upgrades und Ersetzungen für eine bessere Leistung erhalten. Sie ermöglichen es uns, Optimierer anzuwenden, ohne die Leistung zu beeinträchtigen, und sparen außerdem Zeit.

Lesen Sie: TensorFlow-Objekterkennungs-Tutorial für Anfänger

Lernen Sie Datenwissenschaftskurse von den besten Universitäten der Welt. Verdienen Sie Executive PG-Programme, Advanced Certificate-Programme oder Master-Programme, um Ihre Karriere zu beschleunigen.

Trainieren des Modells

Nachdem wir das Modell gebaut haben, können wir es unterrichten. Die tf.keras-API von TensorFlow 2.0 unterstützt die tf.data-API, daher müssen Sie für diesen Zweck die tf.data.Dataset-Objekte verwenden. Es kann das Training effizient durchführen und wir müssten keine Kompromisse bei der Leistung eingehen.

Anzahl_Epochen = 30

steps_per_epoch = round(num_train)//BATCH_SIZE

val_steps = 20

model.fit(train_data.repeat(),

Epochen=Anzahl_Epochen,

Schritte_pro_Epoche = Schritte_pro_Epoche,

validation_data=val_data.repeat(),

valid_steps=val_steps)

Quelle

Nach 30 Epochen steigt die Genauigkeit des Modells erheblich, aber wir können es weiter verbessern. Denken Sie daran, dass wir das Einfrieren der Gewichte während des Transferlernens erwähnt haben? Nun, da wir den Klassifikationsleiter trainiert haben, können wir diese Layer entfrieren und unseren Datensatz weiter verfeinern:

# Entsperren Sie alle Schichten von MobileNetV2

base_model.trainable = Wahr

# Ebenen erneut einfrieren, bis die Ebenen erreicht sind, die wir feinabstimmen möchten

für Schicht in base_model.layers[:100]:

layer.trainable = Falsch

# Verwenden Sie eine niedrigere Lernrate

lr_finetune = Lernrate / 10

# Kompilieren Sie das Modell neu

model.compile(loss='binary_crossentropy',

optimizer = tf.keras.optimizers.Adam(lr=lr_finetune),

metrics=['Genauigkeit'])

# Erhöhen Sie die Trainingsepochen für die Feinabstimmung

fine_tune_epochs = 30

total_epochs = num_epochs + fine_tune_epochs

# Feinabstimmung des Modells

# Hinweis: Legen Sie initial_epoch fest, um mit dem Training nach Epoche 30 zu beginnen, da wir

# zuvor für 30 Epochen trainiert.

model.fit(train_data.repeat(),

Schritte_pro_Epoche = Schritte_pro_Epoche,

epochen=total_epochen,

initial_epoch = num_epochs,

validation_data=val_data.repeat(),

valid_steps=val_steps)

Quelle

30 Epochen später verbessert sich die Genauigkeit des Modells weiter. Mit mehr Epochen sahen wir eine weitere Verbesserung der Genauigkeit des Modells. Jetzt haben wir ein geeignetes TensorFlow-Bilderkennungsmodell, das Säulenkakteen in Bildern mit hoher Genauigkeit erkennen kann.

Lesen Sie auch: Tensorflow-Projektideen für Anfänger

Erfahren Sie mehr über die TensorFlow-Bildklassifizierung

Die hochfunktionellen APIs von TensorFlow und seine Fähigkeiten machen es zu einer leistungsstarken Technologie für jeden Programmierer. Seine High-Level-APIs beseitigen auch seine allgemeine Komplexität und machen es einfacher zu verwenden.

Möchten Sie mehr über TensorFlow, Bildklassifizierung und verwandte Themen erfahren? Dann empfehlen wir Ihnen, sich das PG-Diplom in maschinellem Lernen und KI von IIIT-B & upGrad anzusehen, das für Berufstätige konzipiert ist und mehr als 450 Stunden strenges Training, mehr als 30 Fallstudien und Aufgaben, IIIT-B-Alumni-Status und mehr als 5 Praktika bietet Praktische Schlusssteinprojekte und Arbeitsassistenz bei Top-Firmen.