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

Liebe Leserinnen und Leser,

In diesem Blog werden wir diskutieren, wie eine Bildklassifizierung mit vier beliebten Algorithmen für maschinelles Lernen durchgeführt wird, nämlich Random Forest Classifier, KNN, Decision Tree Classifier und Naive Bayes Classifier. Wir steigen direkt Schritt für Schritt in die Umsetzung ein.

Am Ende des Artikels werden Sie verstehen, warum Deep Learning für die Bildklassifizierung bevorzugt wird. Die hier gezeigte Arbeit wird jedoch Forschungszwecken dienen, wenn man sein CNN-Bildklassifizierungsmodell mit einigen maschinellen Lernalgorithmen vergleichen möchte.

Fangen wir also an…

Veranstaltungs-kalender

• Datensatzerfassung
• Datensatzvorverarbeitung
• Implementieren eines Random-Forest-Klassifikators
• Implementieren eines KNN
• Implementieren eines Entscheidungsbaum-Klassifikators
• Implementieren eines Naive-Bayes-Klassifikators
• Die Ergebnisse
• Testen auf benutzerdefinierte Eingabe
• Zusammenfassung

Datensatzerfassung

Quelle

Der in diesem Blog verwendete Datensatz ist der CIFAR-10-Datensatz. Es ist ein Keras-Datensatz und kann daher mit einem einfachen Code direkt von hier heruntergeladen werden! Es besteht aus zehn Klassen, nämlich Flugzeug, Auto, Vogel, Katze, Hirsch, Hund, Frosch, Pferd, Schiff und Lastwagen. Natürlich werden wir das tun an einem Klassifikationsproblem mit mehreren Klassen arbeiten.

Lassen Sie uns zunächst die erforderlichen Pakete wie folgt importieren:

aus tensorflow import keras import matplotlib.pyplot als plt

aus sklearn.metrics import precision_score,confusion_matrix,classification_report import numpy as np

cv2 importieren

Der Datensatz kann mit dem folgenden Code geladen werden:

(x_train, y_train), (x_test, y_test) = keras.datasets.cifar10.load_data()

Darüber hinaus können wir die Größe der Zug- und Testdatensätze wie unten gezeigt erhalten:

x_train.form,x_test.form

Somit stehen insgesamt 50,000 Bilder zum Training und 10,000 Bilder zum Testen zur Verfügung. Außerdem hat jedes dieser Bilder die Größe 32×32 und ist farbig. Die obigen Details können leicht aus der zurückgegebenen Form abgeleitet werden.

HINWEIS: Beachten Sie, dass in diesem Fall kein Train-Test-Split erforderlich ist, da Train- und Test-Sets direkt bei Keras bezogen werden können!

Datensatzvorverarbeitung

Dieser Schritt beinhaltet die Normalisierung von Bildern, gefolgt von ihrer Umformung.

Die Normalisierung ist ein üblicher Schritt der Bildvorverarbeitung und wird durch einfaches Teilen von x_train durch 255.0 für den Zugdatensatz und x_test durch 255.0 für den Testdatensatz erreicht. Dies ist wesentlich, um die Pixel aller Bilder innerhalb eines einheitlichen Bereichs zu halten.

# Normalisierung x_train = x_train/255.0 x_test = x_test/255.0

Jetzt kommt der wichtigste Schritt der Vorverarbeitung, der nur in diesem Fall anwendbar ist, da wir darauf abzielen, maschinelles Lernen für die Bildklassifizierung zu verwenden. Da wir die ML-Algorithmen von sklearn verwenden werden, müssen die Bilder des Datensatzes in ein zweidimensionales Array umgeformt werden. Dies liegt daran, dass sklearn ein 2D-Array als Eingabe für die Funktion fit() erwartet, die während des Trainings für das Modell aufgerufen wird.

Daher sollten die Bilder des Testdatensatzes auch auf 2D-Arrays skaliert werden, da das Modell mit dieser Eingabeform trainiert wurde.

HINWEIS: Im Fall von neuronalen Netzen können wir die Eingabeform für das Modell angeben und es ist somit flexibler. Aber im Fall von sklearn gibt es einige Einschränkungen.

Der erforderliche Code für das Zugset lautet wie folgt:

#sklearn erwartet i/p als 2d array-model.fit(x_train,y_train)=>reshape to 2d array nsamples, nx, ny, nrgb = x_train.shape x_train2 = x_train.reshape((nsamples,nx*ny*nrgb ))

Der obige Code formt Zugsatzbilder von (50000,32,32,3), was ein 4D-Array ist, in (50000,3072), ein 2D-Array, um. 3072 wird durch Multiplizieren der Abmessungen des Bildes (32x32x3=3072) erhalten.

Der erforderliche Code für das Testset ist unten angegeben:

#also sollte model.predict() auch eine 2D-Eingabe sein nsamples, nx, ny, nrgb = x_test.shape x_test2 = x_test.reshape((nsamples,nx*ny*nrgb))

aus sklearn.ensemble importieren RandomForestClassifier

Erstellen Sie eine Instanz der RandomForestClassifier-Klasse:

model=RandomForestClassifier()

Lassen Sie uns abschließend das Modell trainieren:

model.fit(x_train2,y_train) HINWEIS: Übergeben Sie x_train2 an die Funktion fit (), da es sich um das umgeformte 2D-Array der Bilder handelt und sklearn hier ein 2D-Array als Eingabe benötigt. Tun Sie dies, während Sie alle Modelle anpassen, da sie alle mit sklearn implementiert werden

Sagen Sie nun für den Testsatz mit dem angepassten Random Forest Classifier-Modell voraus:

y_pred=model.predict(x_test2) y_pred

Das Modell gibt als Ausgabe eine Zahl von 0 bis 9 zurück. Dies ist anhand der angezeigten Vorhersagen deutlich zu erkennen. Diese Antworten können mit Hilfe der folgenden Tabelle den entsprechenden Klassen zugeordnet werden:

Bewerten Sie nun das Modell mit den Testbildern, indem Sie den Klassifizierungsbericht, die Konfusionsmatrix und die Genauigkeitsbewertung abrufen.

precision_score(y_pred,y_test) print(classification_report(y_pred,y_test))

Verwirrungsmatrix(y_pred,y_test)

So zeigt Random Forest Classifier auf dem Testset nur eine Genauigkeit von 47 %.

Implementieren eines KNN

KNN steht für K-Nächste Nachbarn. Es ist auch ein Algorithmus, der allgemein für die Mehrklassenklassifizierung verwendet wird.

Es wird in sklearn mit der Klasse KNeighborsClassifier implementiert. Wir beginnen mit dem Importieren:

aus sklearn.neighbors import KNeighborsClassifier

und dann instanziieren, um ein KNN-Modell zu erstellen:

knn=KNeighborsClassifier(n_neighbors=7)

Ich habe zufällig 7 Nachbarn ausgewählt. Spielen Sie ruhig mit der Anzahl der Nachbarn, um zu einem besseren und damit optimalen Modell zu gelangen.

Schließlich trainieren Sie es:

knn.fit(x_train2,y_train)

Sagen Sie nun für den Testsatz mit dem angepassten KNN-Modell voraus:

y_pred_knn=knn.predict(x_test2) y_pred_knn

Die Vorhersagen sind Ausgaben, die die Klassen darstellen, wie im vorherigen Algorithmus beschrieben.

Fahren Sie nun mit der Auswertung des KNN-Modells fort, genauso wie wir unser vorheriges Modell ausgewertet haben.

precision_score(y_pred_knn,y_test) print(classification_report(y_pred_knn,y_test))

verwirrt_matrix(y_pred_knn,y_test)

So zeigt der KNN-Klassifikator auf dem Testset nur eine Genauigkeit von 34 %.

Implementieren eines Entscheidungsbaums

Es wird in sklearn unter Verwendung der DecisionTreeClassifier-Klasse implementiert. Wir beginnen mit dem Importieren:

aus sklearn.tree import DecisionTreeClassifier

und dann instanziieren, um ein DecisionTreeClassifier-Modell zu erstellen:

dtc=DecisionTreeClassifier()

Schließlich trainieren Sie es:

dtc.fit(x_train2,y_train)

Sagen Sie nun für die Testmenge unter Verwendung des angepassten Entscheidungsbaummodells voraus:

y_pred_dtc=dtc.predict(x_test2)

y_pred_dtc

Die Vorhersagen sind Ausgaben, die die Klassen darstellen, wie im vorherigen Algorithmus beschrieben.

Fahren Sie nun damit fort, das Entscheidungsbaummodell auf die gleiche Weise zu evaluieren, wie wir unser vorheriges Modell evaluiert haben.

precision_score(y_pred_dtc,y_test) print(classification_report(y_pred_dtc,y_test))

verwirrt_matrix(y_pred_dtc,y_test)

Somit zeigt der Entscheidungsbaum-Klassifikator nur eine Genauigkeit von 27 % auf dem Testsatz.

Implementieren eines Naive-Bayes-Klassifikators

Es ist der grundlegendste Klassifikator für maschinelles Lernen, auch als NB abgekürzt. Es funktioniert basierend auf dem Bayes-Theorem und hat unabhängige Funktionen.

Es wird in sklearn unter Verwendung der Klasse GaussianNB implementiert. Wir beginnen mit dem Importieren:

aus sklearn.naive_bayes import GaussianNB

und dann instanziieren, um ein NB-Modell zu erstellen:

nb=GaußscheNB()

Schließlich trainieren Sie es:

nb.fit(x_train2,y_train)

Sagen Sie nun für den Testsatz unter Verwendung des angepassten NB-Modells voraus:

y_pred_nb=nb.predict(x_test2)

y_pred_nb

Die Vorhersagen sind Ausgaben, die die Klassen darstellen, wie im vorherigen Algorithmus beschrieben.

Fahren Sie nun damit fort, das Entscheidungsbaummodell auf die gleiche Weise zu evaluieren, wie wir unser vorheriges Modell evaluiert haben.

precision_score(y_pred_nb,y_test) print(classification_report(y_pred_nb,y_test))

Verwirrungsmatrix(y_pred_nb,y_test)

So zeigt der Naive-Bayes-Klassifikator auf dem Testset nur eine Genauigkeit von 30 %.

Die Ergebnisse

Die Genauigkeiten der vier ML-Algorithmen, die wir gerade für unseren CIFAR-10-Datensatz untersucht haben, können mithilfe der oben gezeigten Grafik zusammengefasst werden.

Random Forest Classifier zeigt die beste Leistung mit 47 % Genauigkeit, gefolgt von KNN mit 34 % Genauigkeit, NB mit 30 % Genauigkeit und Decision Tree mit 27 % Genauigkeit. Somit zeigt Random Forest die beste Leistung und Decision Tree die schlechteste.

Alle Algorithmen für maschinelles Lernen sind jedoch schlecht, wie die Genauigkeiten zeigen. Der höchste Wert liegt bei nur 47 %, während Deep-Learning-Algorithmen sie mit Genauigkeiten von meist über 90 % ausnahmsweise überlisten!!!

Deshalb habe ich eingangs selbst erwähnt, dass diese Arbeit nur dazu dienen kann, ein Deep-Learning-Modell zu vergleichen und das DL-Modell zu verteidigen.

Testen auf benutzerdefinierte Eingabe

Da RandomForestClassifier die beste Leistung von allen und auch eine anständige Genauigkeit zeigt, wählen wir dieses Modell aus den obigen Ergebnissen.

Benutzerdefinierte Eingabe bezieht sich auf ein einzelnes Bild, das Sie an das Modell übergeben und testen möchten. Das Testen eines Modells für eine einzelne Eingabe ist in verschiedenen Echtzeitanwendungen weit verbreitet. Beispielsweise wird das Foto einer Person in das System zur Gesichtserkennung eingegeben.

Ich habe das folgende benutzerdefinierte Bild verwendet, um mein Modell zu testen:

                                                                                                       Quelle

Erwähnen Sie den Pfad Ihres Abbilds – den Speicherort, an dem Sie das benutzerdefinierte Abbild gespeichert haben, das Sie testen möchten.

img_path='/content/bird.jfif' HINWEIS: Da ich die Arbeit auf Google Colab implementiert habe, habe ich dort ein Bild hochgeladen und den Pfad des Bildes entsprechend eingefügt. Ändern Sie den Wert von img_path entsprechend dem Speicherort des Bildes, das Sie testen möchten.

Lesen Sie zuerst das Bild mit OpenCV und ändern Sie dann die Größe auf 32 × 32.

img_arr=cv2.imread(img_path) img_arr=cv2.resize(img_arr,(32,32))

#also sollte model.predict() auch eine 2D-Eingabe sein nx, ny, nrgb = img_arr.shape img_arr2 = img_arr.reshape(1,(nx*ny*nrgb))

Klassen = ["Flugzeug","Automobil","Vogel","Katze","Hirsch","Hund","Frosch","Pferd","Schiff","LKW"]

ans=model.predict(img_arr2) print(classes[ans[0]]) #RandomForestClassifier

Zusammenfassung

Daher haben wir in diesem Blog diskutiert, wie die Bildklassifizierung beim maschinellen Lernen verwendet werden kann, indem vier gängige ML-Algorithmen implementiert werden, darunter Random Forest, KNN, Decision Tree und Naive Bayes-Klassifikator. Aufgrund ihrer geringen Genauigkeit wird Deep Learning für Bildklassifizierungsaufgaben bevorzugt.

Sie können diese Arbeit weiter untersuchen, indem Sie versuchen, diese Bildklassifizierung in ML-Modellen zu verbessern Hyperparameter-Tuning. In diesem Fall können Sie bessere Genauigkeiten erzielen! Gehen Sie voran und versuchen Sie es!

Über mich

Ich bin Nithyashree V, ein BTech Informatik- und Ingenieurstudent im letzten Jahr. Ich liebe es, solche coolen Technologien zu lernen und in die Praxis umzusetzen, insbesondere zu beobachten, wie sie uns helfen, die herausfordernden Probleme der Gesellschaft zu lösen. Meine Interessengebiete sind Künstliche Intelligenz, Data Science und Natural Language Processing.

Sie können meine anderen Artikel zu Analytics Vidhya von lesen hier.

Sie finden mich auf LinkedIn von hier.

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/image-classification-using-machine-learning/