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

Hey Guys,

Hoffe es geht euch allen gut.

In diesem Artikel erfahren Sie, wie Sie mithilfe von Fläschchen einen Bildklassifizierer entwickeln und bereitstellen können. Wie meine anderen Artikel vermittelt Ihnen dieser Artikel praktische Erfahrungen mit Code und am Ende dieses Artikels können Sie eine einfache und effektive Flask-API erstellen, die das Bild klassifiziert. Dieser Artikel wird zunächst den Theorieteil und dann den Programmierteil enthalten. Ich werde später in diesem Artikel einen Link zu dem Code geben, der Ihnen die Hektik ersparen wird. Konzentrieren wir uns also auf das Lernen. Auch dieser Artikel wird komplett auf PYTHON basieren.

Dieser Artikel ist offen für alle Zuschauerkategorien (Anfänger, Fortgeschrittene, Fortgeschrittene). Nachfolgend finden Sie das Inhaltsverzeichnis dieses Artikels, also können Sie Teile überspringen, mit denen Sie bereits vertraut sind.

Dieser Teil konzentriert sich auf den Bildklassifizierer mit Kolben. Sie finden den zweiten Teil hier wenn Sie nur daran interessiert sind, eine Flaschen-API zu erstellen.

Inhaltsverzeichnis

1. Was ist Bildklassifizierung?
   1. 1. Faltungsneuronales Netzwerk
   1. 2. Lerntransfer
2.  Codierung für Bildklassifizierer
3. Zusammenfassung

Bildklassifizierung

Bildklassifizierung ist der Prozess der Kategorisierung und Kennzeichnung von Gruppen von Pixeln oder Vektoren innerhalb eines Bildes basierend auf bestimmten Regeln. Laienhaft ausgedrückt versuchen wir, verwandte Bilder oder ähnliche Bilder irgendwie zusammenzufassen.
Bildklassifizierungstechniken werden hauptsächlich in zwei Typen unterteilt: Unüberwachte und überwachte Bildklassifizierung. Wir werden hier die überwachten Bildklassifizierungstechniken verwenden. Ich werde nicht tiefer darauf eingehen.

Der Stand der Technik für die Bildklassifizierung basiert auf Deep Learning, bekannt als Convolutional Neural Networks (CNN).

Faltungs-Neuronales Netz

Bevor wir zu CNN übergehen, werfen wir einen Blick auf Neural Network.

Neurales Netzwerk: Hierbei handelt es sich um eine Reihe von Algorithmen, die die zugrunde liegenden Muster/Beziehungen in einer Reihe von Daten durch einen Prozess erkennen, der der Funktionsweise des menschlichen Gehirns ähnlich ist. Deep Learning: Eine Teilmenge von Algorithmen für maschinelles Lernen, die Muster sehr gut erkennen können, aber normalerweise eine große Anzahl von Daten erfordern.

CNN auch als Convnet bekannt, ist eine spezielle Art von neuronalem Netzwerk, das auf die gleiche Weise wie ein normales neuronales Netzwerk funktioniert, außer dass es am Anfang eine Faltungsschicht hat.

Warum verwenden wir CNN?

1. Einfache neuronale Feedforward-Netzwerke sehen keine Reihenfolge in ihren Eingaben. Wenn Sie alle Ihre Bilder auf die gleiche Weise mischen würden, hätte das neuronale Netzwerk genau die gleiche Leistung, die es hatte, als es mit nicht gemischten Bildern trainiert wurde.
2. Nutzen Sie die lokale räumliche Kohärenz von Bildern. Dies bedeutet, dass sie die Anzahl der Operationen, die zum Verarbeiten eines Bildes erforderlich sind, drastisch reduzieren können, indem sie die Faltung auf Patches benachbarter Pixel anwenden, da benachbarte Pixel zusammen sinnvoll sind.
3. Sie verwenden eine sogenannte Pooling-Schicht, um Ihr Bild herunterzurechnen.

Das Bild unten zeigt ein klassisches Beispiel für CNN.

VIP-Begriffe in CNN

Faltung: Es enthält eine Reihe von Filtern/Kernels (Gewichtungsmenge), die die Eingabe als Teilmenge des Eingabebildes aufnimmt. Teilmengen von Bildern werden mit den Filtern multipliziert, die im Allgemeinen eine geringere Größe als das Bild haben. Das folgende Bild hilft Ihnen dabei, Einblicke in die Convolutional-Schicht zu erhalten.

Poolen: Diese Ebene hilft beim Downsampling unserer Bilder. Wir lassen einen Filter über die Matrix laufen und wenden eine Funktion darauf an, um die Ausgabe zu generieren. MAXPOOL ist eine Funktion, die als Maximalwert ausgegeben wird, wie unten im Bild gezeigt.

Das Bild stammt von https://cs231n.github.io/convolutional-networks/

ReLU

Die gleichgerichtete lineare Aktivierungsfunktion oder kurz ReLU ist eine stückweise lineare Funktion, die die Eingabe direkt ausgibt, wenn sie positiv ist, andernfalls wird sie Null ausgeben. Es ist zur Standardaktivierungsfunktion für viele Arten von neuronalen Netzen geworden, da ein Modell, das es verwendet, einfacher zu trainieren ist und häufig eine bessere Leistung erzielt.

Aussteiger

Diese Schicht hilft dabei, die Überanpassung unseres Modells zu vermeiden, indem bestimmte Knoten im neuronalen Netzwerk zufällig gelöscht und Rest für die Vorhersage verwendet werden. Es ist eine Regularisierungstechnik, die CNN zwingt, nicht nur von bestimmten Knoten abhängig zu sein, sondern eine Komponente hat oder von allen Knoten sagt.

Vollständig verbundene Ebene

Neuronen in einer vollständig verbundenen Schicht haben vollständige Verbindungen zu allen Aktivierungen in der vorherigen Schicht. Ihre Aktivierungen können daher mit einer Matrixmultiplikation gefolgt von einem Bias-Offset berechnet werden.

Sie können mehr Details lesen .

Lernen übertragen 

Transfer Learning ist die Wiederverwendung eines zuvor erlernten Modells für ein neues Problem. Dies sind die am häufigsten verwendeten Techniken in der Computer Vision, da sie viel Arbeit ersparen, wenn Sie diese Techniken verwenden, um ein ähnliches neues Problem zu lösen. Zum Beispiel haben wir ein Modell zur Klassifizierung von Katze und Affe erstellt. Können wir es für die Klassifizierung von Tiger und Gorilla verwenden? Mit Transfer Learning können wir das sicher.

Wir werden auch Transfer Learning verwenden, während wir unser Modell erstellen. Beispiele für Transferlernmodelle, die für die Bildklassifizierung verwendet werden, sind Resnet50, MobileNet, VGG16, VGG19, DenseNet.

Lesen Sie mehr über Transfer Learning .

Genug der Theorie. ZEIG MIR DEN CODE!

Codierung für Bildklassifizierer 

Für Bildklassifizierer gibt es viele Module wie TensorFlow, PyTorch, Fastai usw. Für diesen Blog werden wir verwenden TensorFlow. 

Bibliotheken importieren: 

# Hilfsbibliotheken import os import numpy as np import matplotlib.pyplot as plt

# Tensorflow importiert Tensorflow als tf

Erstellen Sie Ihren Datensatz

Sie müssen Variablen entsprechend Ihrer Verwendung deklarieren und ändern.

# Variablen deklarieren train_data_dir = 'v_data/train' validation_data_dir = 'v_data/test' nb_train_samples =400 nb_validation_samples = 100 Epochen = 10 batch_size = 16
img_width, img_height = 224, 224 input_shape = (img_width, img_height, 3)

Epochen: 1 Epoche ist, wenn der komplette Datensatz nur einmal vorwärts und rückwärts durch das neuronale Netz geleitet wird.
Batch_Größe: Da die Vorwärts- und Rückwärtsweiterleitung des vollständigen Datensatzes zu einem Anstieg der Berechnungskosten führt, verwenden wir eine Stapelgröße, die als die Anzahl der Stichproben definiert ist, die durch das Netzwerk weitergegeben werden.

train_datagen = ImageDataGenerator( rescale=1. / 255, sheer_range=0.2, zoom_range=0.2, horizontal_flip=True) test_datagen = ImageDataGenerator(rescale=1. / 255) train_generator = train_datagen.flow_from_directory( train_data_dir, target_size=(img_width, img_height), batch_size=batch_size, class_mode='binary') validation_generator = test_datagen.flow_from_directory( valid_data_dir, target_size=(img_width, img_height), batch_size=batch_size, class_mode='binary')

Modell erstellen

model = Sequential()
model.add(Conv2D(32, (2, 2), input_shape=input_shape))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(32, (2, 2)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(64, (2, 2)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(64))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(1))
model.add(Activation('sigmoid'))

Die Struktur für unser Modell haben wir hier erstellt.

model.compile(loss='binary_crossentropy',
optimizer='adam',metrics=['accuracy'])

aus tensorflow.keras.applications.mobilenet_v2 import MobileNetV2 model = MobileNetV2(weights='imagenet')

Dieser Code erstellt ein Modell mit der Struktur von MobileNetV2, das mit Imagenet-Gewichtungen geladen ist.

Feinabstimmung Transfer-Lernmodell

Um vortrainierte neuronale Netze für unser Problem anzupassen, müssen wir sie auf unserem Datensatz trainieren. Wir können auch einige zusätzliche Ebenen am Ende des Bildklassifizierungsmodells hinzufügen.

from keras.applications import Resnet50 base_model = ResNet50(weights='imagenet', include_top=False, input_shape=(IMG_SIZE, IMG_SIZE, 3))

output_categories = 2 # Anzahl der Kategorien in der letzten Schicht. add_model = Sequential() add_model.add(Flatten(input_shape=base_model.output_shape[1:])) add_model.add(Dropout(0.3)) add_model.add(Dense(128, activation='relu')) add_model.add( Dropout(0.3)) add_model.add(Dense(output_categories, activation='softmax')) model = Model(inputs=base_model.input, output=add_model(base_model.output))

Hier haben wir Resnet50 als vortrainiertes Modell verwendet und dann am Ende unseres Modells einige Schichten hinzugefügt, damit wir es für unseren Fall feinabstimmen können.

Trainingsmodell

model.fit_generator( train_generator, steps_per_epoch=nb_train_samples // batch_size, epochen=epochen, validation_data=validation_generator, validation_steps=nb_validation_samples // batch_size)

Vorhersagen mit Modell 

def model_predict(img, model): img = img.resize((224, 224))

 # Vorverarbeitung des Bildes x = image.img_to_array(img) # x = np.true_divide(x, 255) x = np.expand_dims(x, axis=0)

 # Achten Sie darauf, wie Ihr trainiertes Modell mit der Eingabe umgeht, # andernfalls wird es keine korrekte Vorhersage treffen! x = preprocess_input(x, mode='tf')

 preds = model.predict(x) gibt preds zurück

Modell speichern

model_json = model.to_json() mit open("ImageClassifier.json", "w") als json_file: json_file.write(model_json) # Gewichtungen nach HDF5 serialisieren model.save_weights("ImageClassifier.h5")

Die Standorte ändern sich entsprechend Ihrem System.

Modell laden

model_json = open(path_to_model_json, 'r') load_model_json = model_json.read() model_json.close() model = model_from_json(loaded_model_json) model.load_weights(path_to_model_wieght)

Zusammenfassung

Dies ist das Ende des Bildklassifizierers mit Kolben. Ich hoffe, Sie haben eine Vorstellung davon, wie Sie einen Bildklassifikator erstellen und wie Sie Transfer Learning anwenden und verwenden können, um bessere Ergebnisse für Ihre Computer-Vision-Probleme zu erzielen. Im Folgeartikel werden wir eine API erstellen, um unseren Bildklassifizierer zu speichern und bereitzustellen. Ich habe den vollständigen Code für dieses Tutorial bereits unten in das GitHub-Repository gestellt.

CODE FINDEN . 

ÜBER MICH 

Ich bin ein Student im Abschlussjahr des IIIT und mache meinen Bachelor in Informatik und Ingenieurwesen. Ich liebe es, mehr und mehr über Deep und Machine Learning zu erforschen und auszuprobieren. Wenn Sie zusammenarbeiten möchten, können Sie die folgenden Links verwenden:

Linkedin: Klick mich

Github: Klick mich

Kaggle: Klick mich

Mailen Sie mir: [E-Mail geschützt]

Ich hoffe, Ihnen hat mein Artikel über die Bildklassifizierung mit Flask gefallen. Vielen Dank fürs Lesen!

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/2022/01/develop-and-deploy-image-classifier-using-flask-part-1/