Die Bildklassifizierung ist ein Bereich der Pc Imaginative and prescient, der Bilder in Kategorien klassifiziert. Bei der Bildklassifizierung kann es Klassifizierungsaufgaben mit einem oder mehreren Etiketten geben. Bei der Einzeletikettenklassifizierung werden Bilder klassifiziert, die nur zu einer Klasse gehören, während bei der Mehrfachetikettenklassifizierung Bilder klassifiziert werden, die zu einer oder mehreren Klassen gehören könnten. In diesem Artikel besprechen wir die Aufgabe der Einzeletiketten-Bildklassifizierung.
Datensatz zur Bildklassifizierung
Für unsere Aufgabe habe ich einen beliebten Cat vs. Canine-Datensatz von Kaggle ausgewählt. Das bedeutet, dass der Datensatz Bilder von Katzen und Hunden enthält und nachdem wir unser Modell mit diesen Daten trainiert haben, sollte es in der Lage sein, Hunde von Katzen zu unterscheiden.
Modellarchitektur
Faltungs-Neuronale Netze sind die beliebteste Lösung für Pc-Imaginative and prescient-Aufgaben. Obwohl für diese Aufgabe Klassifizierungsalgorithmen wie SVMs und vollständig verbundene neuronale Netze verwendet werden können, haben sich CNNs als die effizientesten Ergebnisse erwiesen. Die Faltungs- und Pooling-Schichten in CNN sind angesichts der hochdimensionalen Natur von Bilddaten besonders hilfreich.
Unsere Wahl für diese Aufgabe ist auch ein CNN-Typ, der als Xception-Modell bekannt ist. Diese Modellarchitektur verfügt über parallele Faltungen, die dabei helfen, mehr Informationen aus den Bildern zu extrahieren, ohne mehr Rechenzeit zu verbrauchen. Wenn Sie mit der Funktionsweise von CNNs nicht vertraut sind, empfehle ich Ihnen, sich einen guten Überblick zu verschaffen, bevor Sie fortfahren.
Was ist Transferlernen und warum nutzen wir es?
Wie der Title schon sagt, handelt es sich beim Transferlernen um einen Prozess, bei dem Erkenntnisse aus dem Coaching eines Modells genutzt werden können, um das Coaching für eine ähnliche Aufgabe zu initialisieren. Beispielsweise können Gewichte, die während des Trainings einer Klassifizierungsaufgabe gelernt wurden, als Anfangsgewichte beim Coaching eines anderen neuronalen Netzwerks für die Klassifizierung verwendet werden.
Transferlernen wird meist verwendet, wenn Sie nicht über genügend Trainingsdaten verfügen, um ein Modell zu trainieren, das idealerweise eine große Menge an Trainingsdaten benötigt, um eine gute Leistung zu erzielen. Sie können Transferlernen auch verwenden, um die Trainingszeit zu verkürzen, indem Sie diese Gewichte für einige Schichten im Netzwerk einfrieren. Diese Methode ist besonders nützlich, wenn Sie ein großes Modell haben, das, wenn es von Grund auf trainiert wird, sehr rechenintensiv ist.
In diesem Artikel verwenden wir Transferlernen, indem wir Modellgewichte verwenden, die im ImageNet-Datensatz für die Aufgabe der Bildklassifizierung gelernt wurden. Wir werden auch die Gewichte der unteren Schichten im Netzwerk einfrieren. Dies bedeutet, dass nur die oberen paar Schichten mithilfe des Cat-vs-Canine-Datensatzes neu trainiert werden, während die unteren Schichten dieselben Gewichtungen haben, die aus dem ImageNet-Datensatz gelernt wurden. Dies hilft uns, die Schulungszeit erheblich zu verkürzen.
Implementierung
Lassen Sie uns näher darauf eingehen, wie ein Bildklassifizierungsmodell in Keras entwickelt und zur Vorhersage der Kategorie verwendet werden kann, zu der ein Bild gehört.
Als erstes habe ich eine virtuelle Umgebung erstellt und alle erforderlichen Pakete wie Tensorflow, Pandas, CV2 usw. darin installiert. Dann habe ich unseren Datensatz aus den ZIP-Dateien in den Ordner in meinem WD extrahiert. Wenn Sie den Datensatz heruntergeladen und extrahiert haben, ist Ihnen aufgefallen, dass alle Dateien Namen haben, die auf die Kategorie hinweisen, zu der das Bild gehört. Dies erleichtert die Beschriftung des Bildes. Der Dateiname würde beispielsweise so aussehen: cat.101.jpeg.
Ihr Datensatzordner würde nach dem Entpacken des gesamten Inhalts so aussehen:
Zum Kommentieren der Eingabebilder erstellen wir einen Datenrahmen, der den Namen der Bilddatei der Kategorie zuordnet, zu der sie gehört, die aus dem Dateinamen extrahiert wird.
# getting all picture file names from the listing
training_images = os.listdir(training_data)# extracting the class from every file identify
class = [image.split(".")[0] for picture in training_images]
# making a dataframe with the file identify and class for feeding as enter
train_df = pd.DataFrame({"Picture": training_images,"Class":class})
Um die Trainingszeit zu verkürzen, habe ich nur 500 Bilder aus dem Datensatz ausgewählt, die Katzen- und Hundebilder nahezu gleich darstellen. Unser Datenrahmen mit Trainingsdaten sieht wie im Bild unten aus.
Der nächste Schritt besteht darin, den Datensatz mithilfe von train_test_split von sklearn in Trainings- und Validierungssätze aufzuteilen, indem 20 % der Daten in den Validierungssatz verschoben werden.
practice, val = train_test_split(train_df, test_size=0.2)
Sobald die Daten aufgeteilt sind, müssen wir diese Bilder vorverarbeiten, um sie dem neuronalen Netzwerk zuzuführen. Allerdings verfügt Keras über integrierte Funktionen, die bei der Vorverarbeitung von Eingabebildern basierend auf der Modellarchitektur, die Sie verwenden möchten, helfen. Für unser Modell verwenden wir
keras.functions.xception. preprocess_input
Wir verwenden dies zusammen mit dem ImageDataGenerator von Keras, um Daten in Echtzeit zu erweitern und Bildtensordaten zu generieren. Wir verwenden dies in Verbindung mit der Funktion „flow_from_dataframe“, um den Trainingsdatenrahmen und den Pfad zum Trainingsverzeichnis zu übernehmen und Stapel erweiterter Daten zu generieren, die nun als Eingabe an unser Modell übergeben werden können. Wir befolgen die gleichen Schritte für Trainings- und Validierungssätze.
Argumente für die Funktion flow_from_dataframe() in der Reihenfolge, in der sie in unserem Code übergeben wird:
- der Datenrahmen
- das Verzeichnis, in dem Bilder gespeichert sind
- der Title der Spalte mit Bilddateinamen
- die Zielspalte (die vorherzusagende)
- Neue Größe der Bilder, die bei der Größenänderung beachtet werden soll, damit alle Bilder bei der Übergabe an das Netzwerk eine einheitliche Größe haben
- die Losgröße
- der Datentyp des vorherzusagenden Werts
target_size = 300
batch_size = 32
train_aug_map = picture.ImageDataGenerator(
rotation_range=10,
horizontal_flip = True,
fill_mode = 'nearest',
preprocessing_function = preprocess_input)train_data = train_aug_map.flow_from_dataframe(
practice, training_data,
x_col='Picture',
y_col = 'Class',
target_size = (target_size, target_size),
batch_size= batch_size,
class_mode='categorical')
Auf der folgenden Seite finden Sie eine ausführliche Erläuterung von ImageDataGenerator und flow_from_dataframe.
Nachdem wir nun die Daten vorbereitet haben, bereiten wir das Modell für das Coaching dieser Daten vor. Wie bereits erwähnt, werden wir das Xception-Modell verwenden, das auf dem ImageNet-Datensatz vorab trainiert wurde. Wir verwenden die unteren Ebenen dieses Modells wieder und fügen oben vollständig verbundene dichte Ebenen hinzu, um die Klassifizierung unserer Bilder zu erleichtern. Wir werden auch die Gewichte der Basisschichten einfrieren, damit sie während des Trainings nicht aktualisiert werden. Es werden nur die Gewichte der obersten Schichten aktualisiert.
base_model = Xception(
include_top=False,
weights="imagenet",
input_shape=(300, 300, 3)
)
x = base_model.output
x = GlobalAveragePooling2D()(x)
x = Dense(1024, activation='relu')(x)
output_layer = Dense(2, activation='softmax')(x)mannequin = Mannequin(inputs=base_model.enter, outputs=output_layer)
for layer in base_model.layers:
layer.trainable = False
mannequin.compile(optimizer='adam', loss='categorical_crossentropy',metrics = ['accuracy'])
Wenn Sie alle Ebenen in Ihrem Modell im Element sehen möchten, können Sie die Funktion abstract() für Ihre Modellinstanz aufrufen.
mannequin.abstract()
Um das Modell zu trainieren, müssen wir die Methode match() aufrufen und die Trainingsdaten, Validierungsdaten und die Anzahl der Epochen als Parameter übergeben. Die Epoche gibt an, wie oft die Trainingsdaten das Netzwerk durchlaufen müssen, bevor das Coaching abgeschlossen ist. Sie können das trainierte Modell auch speichern, um es später zur Vorhersage zu laden.
train_images = practice.form[0]
val_images = val.form[0]
mannequin.match(train_data, epochs=2,validation_data = val_data,
validation_steps=val_images//batch_size,
steps_per_epoch=train_images//batch_size)
mannequin.save("img_cls_model.h5")
Um dieses Modell zur Vorhersage zu verwenden, müssen wir das Bild vorverarbeiten, bevor wir es an das Modell übergeben. Unten finden Sie die Funktion, die Sie dafür verwenden können.
def preprocess(image_path):
img = picture.load_img(image_path, target_size=(300,300))
x = picture.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
return x
Wenn Sie Predict() für das Modell aufrufen, erhalten Sie ein Array mit zwei Werten, die beide zwischen 0 und 1 liegen.
img = "./dogs-vs-cats/test1/5.jpg"
input_img = preprocess(img)
mannequin.predict(input_img)
Ausgabe: Array([[1.0000000e+00, 1.5303518e-10]], dtype=float32)
Diese beiden Werte sind Wahrscheinlichkeiten aus der Softmax-Funktion, die wir in der letzten Schicht unseres Netzwerks verwendet haben. Einer gibt die Wahrscheinlichkeit an, dass das Bild zur Kategorie „Katze“ gehört, der andere zur Kategorie „Hund“, aber wir wissen nicht, welcher Wert zu welcher Kategorie gehört.
Wie Sie bereits wissen, funktionieren neuronale Netze nicht mit kategorialen Daten. Die Kategorien „Katze“ und „Hund“ würden additionally in numerische Werte umgewandelt und jetzt müssen wir die Kategorie mit ihrem entsprechenden numerischen Wert abbilden.
Dazu müssen wir auf die Trainingsdaten zurückgreifen.
print(train_data.class_indices.objects())
Die Ausgabe ist ein Wörterbuch: {‚cat‘:0,’canine‘:1}. Das bedeutet, dass die erste Wahrscheinlichkeit zu „Katze“ und die zweite zu „Hund“ gehört.
Die höhere Wahrscheinlichkeit gibt uns die Kategorie an, zu der das Bild gehört.
Sie können die folgenden Schritte ausführen, um die vorhergesagte Kategorie zu erhalten:
label = dict((v,okay) for okay,v in train_data.class_indices.objects())
prediction = np.argmax(mannequin.predict(input_img))
print(label[prediction])
np.argmax gibt Ihnen den Index mit der höchsten Wahrscheinlichkeit und Sie ordnen ihn mithilfe des Wörterbuchs zu, um die Kategorie zu erhalten, die diesem Index entspricht.
Wenn Sie nun das gespeicherte Modell zur Vorhersage verwenden möchten, können Sie die Funktion „load_model()“ verwenden und die gleichen Schritte wie zuvor ausführen.
mannequin = load_model("img_cls_model.h5")
Wenn Sie den vollständigen Code für dieses Projekt benötigen, besuchen Sie bitte mein GitHub-Repository (Hyperlink unten).
