Cet article a été publié dans le cadre du Blogathon sur la science des données.

Chers lecteurs,

Dans ce blog, nous discuterons de la façon d'effectuer la classification d'images à l'aide de quatre algorithmes d'apprentissage automatique populaires, à savoir Random Forest Classifier, KNN, Decision Tree Classifier et Naive Bayes classifier. Nous passerons directement à la mise en œuvre étape par étape.

A la fin de l'article, vous comprendrez pourquoi le Deep Learning est privilégié pour la classification des images. Cependant, le travail démontré ici aidera à servir à des fins de recherche si l'on souhaite comparer leur modèle de classificateur d'images CNN avec certains algorithmes d'apprentissage automatique.

Alors, commençons…

Agenda

• Acquisition d'ensembles de données
• Prétraitement des ensembles de données
• Implémentation d'un classificateur de forêt aléatoire
• Implémentation d'un KNN
• Implémentation d'un classificateur d'arbre de décision
• Implémentation d'un classificateur Naive Bayes
• Résultats
• Test de l'entrée personnalisée
• Conclusion

Acquisition d'ensembles de données

Identifier

L'ensemble de données utilisé dans ce blog est l'ensemble de données CIFAR-10. Il s'agit d'un jeu de données Keras et peut donc être directement téléchargé à partir d'ici avec un simple code ! Il se compose de dix classes, à savoir, avion, automobile, oiseau, chat, cerf, chien, grenouille, cheval, bateau et camion. De toute évidence, nous allons travailler sur un problème de classification multi-classes.

Tout d'abord, importons les packages requis comme suit :

de tensorflow importer keras importer matplotlib.pyplot en tant que plt

à partir de sklearn.metrics importer precision_score, confusion_matrix, classification_report importer numpy en tant que np

importer cv2

Le jeu de données peut être chargé à l'aide du code ci-dessous :

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

De plus, nous pouvons obtenir la taille des ensembles de données d'entraînement et de test comme indiqué ci-dessous :

x_train.forme,x_test.forme

Ainsi, il y a un total de 50,000 10,000 images pour la formation et 32 32 images pour les tests. De plus, chacune de ces images est de dimensions XNUMX×XNUMX et en couleur. Les détails ci-dessus peuvent être facilement déduits de la forme renvoyée.

REMARQUE : notez qu'il n'est pas nécessaire d'effectuer un fractionnement de train-test dans ce cas, car les ensembles de train et de test peuvent être obtenus directement auprès de Keras !

Prétraitement des ensembles de données

Cette étape comprend la normalisation des images suivie de leur remise en forme.

La normalisation est une étape courante du prétraitement d'image et est obtenue en divisant simplement x_train par 255.0 pour l'ensemble de données de train et x_test par 255.0 pour l'ensemble de données de test. Ceci est essentiel pour maintenir les pixels de toutes les images dans une plage uniforme.

# Normalisation x_train = x_train/255.0 x_test = x_test/255.0

Vient maintenant l'étape la plus essentielle du prétraitement, qui n'est applicable que dans ce cas car nous visons à utiliser l'apprentissage automatique pour la classification des images. Comme nous utiliserons les algorithmes ML de sklearn, il est nécessaire de remodeler les images de l'ensemble de données en un tableau à deux dimensions. En effet, sklearn attend un tableau 2D en entrée de la fonction fit() qui sera appelée sur le modèle lors de la formation.

Ainsi, les images de l'ensemble de données de test doivent également être redimensionnées en tableaux 2D car le modèle a été formé avec cette forme d'entrée.

REMARQUE : Dans le cas des réseaux de neurones, nous arrivons à spécifier la forme d'entrée du modèle et il est donc plus flexible. Mais, dans le cas de sklearn, il y a quelques restrictions.

Le code requis pour la rame est le suivant :

#sklearn s'attend à ce que i/p soit 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 ))

Le code ci-dessus remodèle les images de trains de (50000,32,32,3) qui est un tableau 4D à (50000,3072), un tableau 2D.3072 est obtenu en multipliant les dimensions de l'image (32x32x3=3072).

Le code requis pour l'ensemble de test est donné ci-dessous :

# donc, éventuellement, model.predict() devrait également être une entrée 2d nsamples, nx, ny, nrgb = x_test.shape x_test2 = x_test.reshape((nsamples,nx*ny*nrgb))

de sklearn.ensemble importer RandomForestClassifier

Créez une instance de la classe RandomForestClassifier :

modèle=RandomForestClassifier()

Enfin, procédons à l'entraînement du modèle :

modèle.fit(x_train2,y_train) REMARQUE : Passez x_train2 à la fonction fit() car il s'agit du tableau 2D remodelé des images et sklearn a besoin d'un tableau 2D en entrée ici. Faites cela tout en convenant à tous les modèles car ils sont tous implémentés à l'aide de sklearn

Maintenant, prédisez pour l'ensemble de test à l'aide du modèle de classificateur de forêt aléatoire ajusté :

y_pred=model.predict(x_test2) y_pred

Le modèle renvoie un nombre compris entre 0 et 9 en sortie. Cela peut être clairement observé à partir des prévisions affichées. Ces réponses peuvent être mappées à leurs classes correspondantes à l'aide du tableau suivant :

Maintenant, évaluez le modèle avec les images de test en obtenant son rapport de classification, sa matrice de confusion et son score de précision.

précision_score(y_pred,y_test) impression(classification_report(y_pred,y_test))

confusion_matrix(y_pred,y_test)

Ainsi, Random Forest Classifier ne montre qu'une précision de 47% sur l'ensemble de test.

Implémentation d'un KNN

KNN signifie K-Nearest Neighbors. C'est aussi un algorithme couramment utilisé pour la classification multi-classes.

Il est implémenté dans sklearn en utilisant la classe KNeighborsClassifier. On commence par l'importer :

à partir de sklearn.neighbors importer KNeighborsClassifier

puis en l'instanciant pour créer un modèle KNN :

knn=KNeighborsClassifier(n_neighbors=7)

J'ai choisi 7 voisins au hasard. N'hésitez pas à jouer avec le nombre de voisins pour arriver à un modèle meilleur et donc optimal.

Enfin, entraînez-le :

knn.fit(x_train2,y_train)

Maintenant, prédisez pour l'ensemble de test en utilisant le modèle KNN ajusté :

y_pred_knn=knn.predict(x_test2) y_pred_knn

Les prédictions sont des sorties représentant les classes comme décrit dans l'algorithme précédent.

Maintenant, continuez à évaluer le modèle KNN exactement comme nous avons évalué notre modèle précédent.

précision_score(y_pred_knn,y_test) impression(classification_report(y_pred_knn,y_test))

confusion_matrix(y_pred_knn,y_test)

Ainsi, le classificateur KNN n'affiche qu'une précision de 34 % sur l'ensemble de test.

Implémentation d'un arbre de décision

Il est implémenté dans sklearn en utilisant la classe DecisionTreeClassifier. On commence par l'importer :

depuis sklearn.tree import DecisionTreeClassifier

puis en l'instanciant pour créer un modèle DecisionTreeClassifier :

dtc=DécisionTreeClassifier()

Enfin, entraînez-le :

dtc.fit(x_train2,y_train)

Maintenant, prédisez pour l'ensemble de test à l'aide du modèle d'arbre de décision ajusté :

y_pred_dtc=dtc.predict(x_test2)

y_pred_dtc

Les prédictions sont des sorties représentant les classes comme décrit dans l'algorithme précédent.

Maintenant, continuez à évaluer le modèle d'arbre de décision exactement comme nous avons évalué notre modèle précédent.

précision_score(y_pred_dtc,y_test) impression(classification_report(y_pred_dtc,y_test))

confusion_matrix(y_pred_dtc,y_test)

Ainsi, le classificateur d'arbre de décision n'affiche qu'une précision de 27 % sur l'ensemble de test.

Implémentation d'un classificateur Naive Bayes

C'est le classificateur d'apprentissage automatique le plus fondamental, également abrégé en NB. Il fonctionne sur la base du théorème de Bayes et possède des fonctionnalités indépendantes.

Il est implémenté dans sklearn en utilisant la classe GaussianNB. On commence par l'importer :

de sklearn.naive_bayes importer GaussianNB

puis en l'instanciant pour créer un modèle NB :

nb=GaussienNB()

Enfin, entraînez-le :

nb.fit(x_train2,y_train)

Maintenant, prédisez pour l'ensemble de test en utilisant le modèle NB ajusté :

y_pred_nb=nb.predict(x_test2)

y_pred_nb

Les prédictions sont des sorties représentant les classes comme décrit dans l'algorithme précédent.

Maintenant, continuez à évaluer le modèle d'arbre de décision exactement comme nous avons évalué notre modèle précédent.

précision_score(y_pred_nb,y_test) impression(classification_report(y_pred_nb,y_test))

confusion_matrix(y_pred_nb,y_test)

Ainsi, le classificateur Naive Bayes ne montre qu'une précision de 30% sur l'ensemble de test.

Résultats

Les précisions des quatre algorithmes ML, que nous venons d'explorer pour notre ensemble de données CIFAR-10, peuvent être résumées à l'aide du graphique ci-dessus.

Le classificateur de forêt aléatoire affiche les meilleures performances avec une précision de 47 %, suivi de KNN avec une précision de 34 %, NB avec une précision de 30 % et un arbre de décision avec une précision de 27 %. Ainsi, Random Forest présente les meilleures performances et Decision Tree les pires.

Cependant, tous les algorithmes d'apprentissage automatique fonctionnent mal, comme l'indiquent les précisions. Le plus élevé n'est que de 47 %, tandis que les algorithmes d'apprentissage en profondeur les surpassent exceptionnellement avec des précisions dépassant généralement 90 % !!!

C'est pourquoi j'ai mentionné au début même que ce travail ne peut être utilisé que pour comparer un modèle de Deep Learning et défendre le modèle DL.

Test d'entrée personnalisée

À partir des résultats ci-dessus, comme RandomForestClassifier affiche les meilleures performances parmi toutes et une précision décente également, choisissons ce modèle.

L'entrée personnalisée fait référence à une seule image que vous souhaitez transmettre au modèle et tester. Le test d'un modèle pour une seule entrée est largement utilisé dans diverses applications en temps réel. Par exemple, la photo d'un individu est entrée dans le système pour la reconnaissance faciale.

J'ai utilisé l'image personnalisée suivante pour tester mon modèle :

                                                                                                       Identifier

Mentionnez le chemin de votre image - l'emplacement où vous avez stocké l'image personnalisée que vous souhaitez tester.

img_path='/content/bird.jfif' REMARQUE : comme j'ai implémenté le travail sur Google Colab, j'y ai téléchargé une image et inclus le chemin de l'image en conséquence. Modifiez la valeur de img_path en fonction de l'emplacement de l'image que vous souhaitez tester.

Tout d'abord, lisez l'image à l'aide d'OpenCV, puis redimensionnez-la à 32 × 32.

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

#ainsi, éventuellement, model.predict() devrait également être une entrée 2d nx, ny, nrgb = img_arr.shape img_arr2 = img_arr.reshape(1,(nx*ny*nrgb))

classes = ["avion","voiture","cheval","cheval","cheval","camion","chat","grenouille","oiseau","navire","]]

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

Conclusion

Ainsi, dans ce blog, nous avons expliqué comment utiliser la classification d'images dans Machine Learning en implémentant quatre algorithmes ML courants, notamment Random Forest, KNN, Decision Tree et Naive Bayes classifier. En raison de leur faible précision, le Deep Learning est préféré pour les tâches de classification d'images.

Vous pouvez approfondir ce travail en essayant d'améliorer la classification de ces images dans les modèles ML à l'aide de réglage hyperparamètre. Vous pouvez arriver à de meilleures précisions dans ce cas ! Allez-y et essayez!

A Propos

Je suis Nithyashree V, étudiante en dernière année de BTech en informatique et en ingénierie. J'aime apprendre des technologies aussi cool et les mettre en pratique, en particulier en observant comment elles nous aident à résoudre les problèmes difficiles de la société. Mes domaines d'intérêt incluent l'intelligence artificielle, la science des données et le traitement du langage naturel.

Vous pouvez lire mes autres articles sur Analytics Vidhya à partir de ici.

Vous pouvez me trouver sur LinkedIn à partir de ici.

Les médias présentés dans cet article n'appartiennent pas à Analytics Vidhya et sont utilisés à la discrétion de l'auteur. 

Services Connexes

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