Dit artikel is gepubliceerd als onderdeel van het Data Science-blogathon.

Beste lezers,

In deze blog bespreken we hoe u beeldclassificatie kunt uitvoeren met behulp van vier populaire algoritmen voor machine learning, namelijk Random Forest Classifier, KNN, Decision Tree Classifier en Naive Bayes-classifier. Stap voor stap gaan we direct aan de slag.

Aan het einde van het artikel zult u begrijpen waarom Deep Learning de voorkeur heeft voor beeldclassificatie. Het hier gedemonstreerde werk zal echter helpen bij het dienen van onderzoeksdoeleinden als men hun CNN-beeldclassificatiemodel wil vergelijken met sommige machine learning-algoritmen.

Dus laten we beginnen...

Agenda

• Dataset-acquisitie
• Voorbewerking van dataset
• Een willekeurige bosclassificatie implementeren
• Een KNN . implementeren
• Een beslissingsboomclassificatie implementeren
• Een Naive Bayes-classificatie implementeren
• Resultaten
• Testen voor aangepaste invoer
• Conclusie

Dataset-acquisitie

bron

De dataset die in deze blog wordt gebruikt is de CIFAR-10 dataset. Het is een Keras-dataset en kan dus direct vanaf hier worden gedownload met een eenvoudige code! Het bestaat uit tien klassen, namelijk vliegtuig, auto, vogel, kat, hert, hond, kikker, paard, schip en vrachtwagen. Het is duidelijk dat we werken aan een classificatieprobleem met meerdere klassen.

Laten we eerst de vereiste pakketten als volgt importeren:

van tensorflow import keras import matplotlib.pyplot als plt

van sklearn.metrics import nauwkeurigheid_score,confusion_matrix,classification_report import numpy als np

importeer cv2

De dataset kan worden geladen met onderstaande code:

(x_trein, y_trein), (x_test, y_test) = keras.datasets.cifar10.load_data()

Verder kunnen we de grootte van de trein- en testdatasets verkrijgen, zoals hieronder weergegeven:

x_trein.vorm,x_test.vorm

Zo zijn er in totaal 50,000 afbeeldingen voor training en 10,000 afbeeldingen om te testen. Bovendien heeft elk van deze afbeeldingen de afmetingen 32×32 en kleur. De bovenstaande details kunnen gemakkelijk worden afgeleid uit de geretourneerde vorm.

OPMERKING: Houd er rekening mee dat er in dit geval geen trein-test-splitsing nodig is, aangezien trein- en testsets rechtstreeks bij Keras kunnen worden verkregen!

Voorverwerking van datasets

Deze stap omvat de normalisatie van afbeeldingen, gevolgd door hun omvorming.

Normalisatie is een gebruikelijke stap in de voorbewerking van afbeeldingen en wordt bereikt door x_train eenvoudig te delen door 255.0 voor de treingegevensset en x_test door 255.0 voor de testgegevensset. Dit is essentieel om de pixels van alle afbeeldingen binnen een uniform bereik te houden.

# Normalisatie x_train = x_train/255.0 x_test = x_test/255.0

Nu komt de meest essentiële stap van voorbewerking, die alleen in dit geval van toepassing is omdat we machine learning willen gebruiken voor beeldclassificatie. Omdat we de ML-algoritmen van sklearn zullen gebruiken, is het nodig om de afbeeldingen van de dataset om te vormen tot een tweedimensionale array. Dit komt omdat sklearn een 2D-array verwacht als invoer voor de functie fit() die tijdens de training op het model wordt aangeroepen.

De afbeeldingen van de testgegevensset moeten dus ook worden verkleind tot 2D-arrays, aangezien het model met deze invoervorm is getraind.

OPMERKING: in het geval van neurale netwerken kunnen we de invoervorm voor het model specificeren en is het dus flexibeler. Maar in het geval van sklearn zijn er enkele beperkingen.

De benodigde code voor het treinstel is als volgt:

#sklearn verwacht dat i/p 2d array-model.fit(x_train,y_train)=>hervormt naar 2d array nsamples, nx, ny, nrgb = x_train.shape x_train2 = x_train.reshape((nsamples,nx*ny*nrgb ))

De bovenstaande code hervormt treinsetafbeeldingen van (50000,32,32,3), wat een 4D-array is, tot (50000,3072), een 2D-array.3072 wordt verkregen door de afmetingen van de afbeelding te vermenigvuldigen (32x32x3=3072).

Hieronder vindt u de benodigde code voor de testset:

#so,eventueel,model.predict() moet ook een 2D-invoer zijn nsamples, nx, ny, nrgb = x_test.shape x_test2 = x_test.reshape((nsamples,nx*ny*nrgb))

van sklearn.ensemble import RandomForestClassifier

Maak een instantie van de klasse RandomForestClassifier:

model=RandomForestClassifier()

Laten we ten slotte doorgaan met het trainen van het model:

model.fit(x_train2,y_train) OPMERKING: Geef x_train2 door aan de functie fit() omdat het de hervormde 2D-array van de afbeeldingen is en sklearn heeft hier een 2D-array nodig als invoer. Doe dit tijdens het passen voor alle modellen, omdat ze allemaal zijn geïmplementeerd met sklearn

Voorspel nu voor de testset met behulp van het gemonteerde Random Forest Classifier-model:

y_pred=model.predict(x_test2) y_pred

Het model retourneert een getal van 0 tot 9 als uitvoer. Dit is duidelijk te zien aan de weergegeven voorspellingen. Deze antwoorden kunnen worden toegewezen aan de bijbehorende klassen met behulp van de volgende tabel:

Evalueer nu het model met de testafbeeldingen door het classificatierapport, de verwarringsmatrix en de nauwkeurigheidsscore te verkrijgen.

nauwkeurigheid_score(y_pred,y_test) print(classification_report(y_pred,y_test))

verwarring_matrix(y_pred,y_test)

Random Forest Classifier toont dus slechts 47% nauwkeurigheid op de testset.

Een KNN . implementeren

KNN staat voor K-Dichtbijzijnde buren. Het is ook een algoritme dat in de volksmond wordt gebruikt voor classificatie met meerdere klassen.

Het is geïmplementeerd in sklearn met behulp van de KNeighboursClassifier-klasse. We beginnen met het te importeren:

van sklearn.neighbours importeren KNeighboursClassifier

en vervolgens instantiëren om een ​​KNN-model te maken:

knn=KNeighboursClassifier(n_neighbours=7)

Ik heb willekeurig 7 buren gekozen. Speel gerust met het aantal buren om tot een beter en dus optimaal model te komen.

Train het tot slot:

knn.fit(x_trein2,y_trein)

Voorspel nu voor de testset met behulp van het ingerichte KNN-model:

y_pred_knn=knn.predict(x_test2) y_pred_knn

De voorspellingen zijn outputs die de klassen vertegenwoordigen zoals beschreven in het vorige algoritme.

Ga nu verder met het evalueren van het KNN-model zoals we ons vorige model hebben geëvalueerd.

nauwkeurigheid_score(y_pred_knn,y_test) print(classification_report(y_pred_knn,y_test))

verwarring_matrix(y_pred_knn,y_test)

Zo toont de KNN Classifier slechts 34% nauwkeurigheid op de testset.

Een beslisboom implementeren

Het is geïmplementeerd in sklearn met behulp van de klasse DecisionTreeClassifier. We beginnen met het te importeren:

van sklearn.tree importeren DecisionTreeClassifier

en vervolgens instantiëren om een ​​DecisionTreeClassifier-model te maken:

dtc=DecisionTreeClassifier()

Train het tot slot:

dtc.fit(x_train2,y_train)

Voorspel nu voor de testset met behulp van het aangepaste beslisboommodel:

y_pred_dtc=dtc.predict(x_test2)

y_pred_dtc

De voorspellingen zijn outputs die de klassen vertegenwoordigen zoals beschreven in het vorige algoritme.

Ga nu verder met het evalueren van het beslisboommodel zoals we ons vorige model evalueerden.

nauwkeurigheid_score(y_pred_dtc,y_test) print(classification_report(y_pred_dtc,y_test))

verwarring_matrix(y_pred_dtc,y_test)

De Beslisboom Classifier toont dus slechts 27% nauwkeurigheid op de testset.

Een Naive Bayes-classificatie implementeren

Het is de meest fundamentele classificatie van machine learning, ook wel afgekort als NB. Het werkt op basis van de stelling van Bayes en heeft onafhankelijke functies.

Het wordt geïmplementeerd in sklearn met behulp van de GaussianNB-klasse. We beginnen met het te importeren:

van sklearn.naive_bayes import GaussianNB

en vervolgens instantiëren om een ​​NB-model te maken:

nb=Gaussiaanse NB()

Train het tot slot:

nb.fit(x_trein2,y_trein)

Voorspel nu voor de testset met behulp van het gemonteerde NB-model:

y_pred_nb=nb.predict(x_test2)

y_pred_nb

De voorspellingen zijn outputs die de klassen vertegenwoordigen zoals beschreven in het vorige algoritme.

Ga nu verder met het evalueren van het beslisboommodel zoals we ons vorige model evalueerden.

nauwkeurigheid_score(y_pred_nb,y_test) print(classification_report(y_pred_nb,y_test))

verwarring_matrix(y_pred_nb,y_test)

Zo toont de Naive Bayes Classifier slechts 30% nauwkeurigheid op de testset.

Resultaten

De nauwkeurigheid van de vier ML-algoritmen, die we zojuist hebben onderzocht voor onze CIFAR-10-dataset, kan worden samengevat met behulp van de bovenstaande grafiek.

Random Forest Classifier toont de beste prestaties met een nauwkeurigheid van 47%, gevolgd door KNN met een nauwkeurigheid van 34%, NB met een nauwkeurigheid van 30% en de beslissingsboom met een nauwkeurigheid van 27%. Zo vertoont Random Forest de beste prestaties en de beslissingsboom de slechtste.

Alle machine learning-algoritmen presteren echter slecht, zoals blijkt uit de nauwkeurigheden. Het hoogste is slechts 47%, terwijl Deep Learning-algoritmen ze uitzonderlijk te slim af zijn met een nauwkeurigheid van meestal meer dan 90%!!!

Daarom heb ik in het begin zelf al gezegd dat dit werk alleen kan worden gebruikt om een ​​Deep Learning-model te vergelijken en het DL-model te verdedigen.

Testen voor aangepaste invoer

Uit de bovenstaande resultaten, aangezien RandomForestClassifier de beste prestaties van allemaal laat zien en ook een behoorlijke nauwkeurigheid, laten we dit model kiezen.

Aangepaste invoer verwijst naar een enkele afbeelding die u aan het model wilt doorgeven en testen. Het testen van een model voor een enkele invoer wordt veel gebruikt in verschillende realtime toepassingen. Zo wordt de foto van een persoon ingevoerd in het systeem voor gezichtsherkenning.

Ik heb de volgende aangepaste afbeelding gebruikt om mijn model te testen:

                                                                                                       bron

Vermeld het pad van uw afbeelding - de locatie waar u de aangepaste afbeelding hebt opgeslagen die u wilt testen.

img_path='/content/bird.jfif' OPMERKING: aangezien ik het werk op Google Colab heb geïmplementeerd, heb ik daar een afbeelding geüpload en het pad van de afbeelding dienovereenkomstig toegevoegd. Wijzig de waarde van img_path volgens de locatie van de afbeelding die u wilt testen.

Lees eerst de afbeelding met OpenCV en verklein deze vervolgens naar 32×32.

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

#so,eventueel,model.predict() moet ook een 2d-invoer zijn nx, ny, nrgb = img_arr.shape img_arr2 = img_arr.reshape(1,(nx*ny*nrgb))

klassen = ["vliegtuig", "auto", "vogel", "kat", "hert", "hond", "kikker", "paard", "schip", "vrachtwagen"]

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

Conclusie

Daarom hebben we in deze blog besproken hoe afbeeldingsclassificatie in Machine Learning kan worden gebruikt door vier veelgebruikte ML-algoritmen te implementeren, waaronder Random Forest, KNN, Decision Tree en Naive Bayes-classificatie. Vanwege hun slechte nauwkeurigheid heeft Deep Learning de voorkeur voor beeldclassificatietaken.

U kunt dit werk verder onderzoeken door te proberen deze afbeeldingsclassificatie in ML-modellen te verbeteren met behulp van afstemming van hyperparameters. Wellicht kom je dan tot betere nauwkeurigheid! Ga je gang en probeer!

Over Mij

Ik ben Nithyashree V, een laatstejaars student BTech Computer Science and Engineering. Ik hou ervan om zulke coole technologieën te leren en ze in de praktijk te brengen, vooral door te observeren hoe ze ons helpen de uitdagende problemen van de samenleving op te lossen. Mijn interessegebieden zijn kunstmatige intelligentie, datawetenschap en natuurlijke taalverwerking.

U kunt mijn andere artikelen over Analytics Vidhya lezen van hier..

Je kunt me vinden op LinkedIn van hier..

De in dit artikel getoonde media zijn geen eigendom van Analytics Vidhya en worden naar goeddunken van de auteur gebruikt. 

Verwant

Bron: https://www.analyticsvidhya.com/blog/2022/01/image-classification-using-machine-learning/