Classification d'images sans réseaux neuronaux : un guide pratique

Introduction

La classification d'images repose principalement sur des algorithmes d'apprentissage profond, en particulier les réseaux de neurones convolutionnels (CNN), comme approche principale. Cependant, de nombreux autres outils existent en dehors de ces architectures de réseaux neuronaux avancées.

La classification d'images sans réseaux de neurones peut être effectuée à l'aide de méthodes traditionnelles d'apprentissage automatique, y compris les machines à vecteurs de support (SVM), les k plus proches voisins (KNN), les arbres de décision et l'ingénierie de caractéristiques personnalisée.

Ce guide décrit les étapes pour construire une pipeline de classification d'images fiable en utilisant des techniques d'extraction de caractéristiques. Il compare les algorithmes classiques d'apprentissage machine et démontre l'implémentation en Python sur un jeu de données réel.

Prérequis

• Une compréhension fondamentale des concepts clés de l'apprentissage automatique, y compris l'apprentissage supervisé, l'entraînement des modèles et les métriques d'évaluation telles que la précision et le score F1.
• Connaissance des représentations numériques d'images telles que les grilles de pixels, les niveaux de gris et les formats RVB.
• À l'aise avec Python et ses bibliothèques NumPy, scikit-learn et OpenCV.
• Comprendre le processus d'extraction de caractéristiques telles que les contours et les formes à partir de données brutes.
• Familiarité avec des algorithmes classiques comme SVM, KNN et les arbres de décision.

Mise en place du problème : Notions de base de la classification supervisée

Fondamentalement, la classification d'images est une tâche de classification supervisée. Habituellement, le jeu de données doit contenir des images assignées individuellement à l'une des k classes différentes. L'objectif est de développer un modèle capable de prédire avec précision l'étiquette des images inédites. Lorsqu'on traite un tel projet, il faut prendre en compte les composants suivants :

• Données : Chaque image dans l'ensemble de données est accompagnée de son étiquette correcte en tant que classe de vérité terrain.
• Caractéristiques : Chaque image doit être convertie en un format numérique que les modèles peuvent traiter pour la classification d'images.
• Algorithme d'apprentissage : L'algorithme d'apprentissage (qui inclut SVM, arbres de décision, KNN, etc.) doit être utilisé pour mapper les caractéristiques extraites à leurs étiquettes correspondantes.
• Évaluation : Vous devez évaluer la capacité du modèle entraîné à se généraliser aux images non vues, en utilisant des métriques telles que la précision, l'exactitude, le rappel et le score F1 (voir notre article sur les métriques de deep learning pour en savoir plus sur les métriques de performance).

La différence essentielle entre l'apprentissage automatique classique et l'apprentissage profond dans ce pipeline découle de qui s'occupe des tâches d'extraction de caractéristiques. Les CNN (dans les systèmes d'apprentissage profond) extraient des caractéristiques à partir des données sans intervention manuelle. L'apprentissage automatique classique nécessite que les utilisateurs conçoivent manuellement les caractéristiques pour le modèle.

Ingénierie des caractéristiques dans les méthodes traditionnelles de classification d'images

La classification d'images sans réseaux neuronaux repose sur l'ingénierie des caractéristiques comme son composant fondamental. Le processus nécessite l'extraction de descripteurs numériques capturant des informations pertinentes sur l'image. Le tableau ci-dessous présente les techniques typiques de classification d'images basées sur les caractéristiques :

Certaines techniques d'extraction de caractéristiques de texture

Explorons quelques techniques populaires d'extraction de caractéristiques et leur fonctionnement :

Histogramme des gradients orientés (HOG)

HOG capture l'apparence et la forme locales des objets à travers les directions de gradient :

Image source

1. Commencez par diviser l'image en petites sections connectées appelées cellules.
2. Ensuite, vous allez créer un histogramme montrant les différentes directions des gradients pour chacune de ces cellules.
3. Une fois que vous avez ces histogrammes, normalisez-les à travers des blocs de cellules.
4. Enfin, tous ces histogrammes sont combinés pour créer un descripteur de caractéristiques.

HOG est particulièrement efficace pour la détection d'objets, en particulier pour les objets rigides ayant des formes bien définies.

Motifs Binaires Locaux (MBL)

Les motifs binaires locaux capturent les descripteurs de texture en comparant chaque pixel avec ses voisins :

Image source

• Dans l'exemple ci-dessus, nous prenons un bloc de 3x3 pixels à partir d'une image en niveaux de gris.
• Ensuite, nous comparons chaque pixel environnant au pixel central (numéro 5). S'il est supérieur ou égal à ce pixel central, nous le notons comme 1 ; sinon, nous le marquons comme 0.
• Ce processus crée un nombre binaire de 8 chiffres positionné autour du pixel central.
• Ensuite, nous multiplions ces nombres binaires par leurs poids respectifs (puissances de 2).
• La somme de ces valeurs nous donne la valeur LBP (dans ce cas, 1 + 4 + 16 + 32 égale 53).

La méthode des motifs binaires locaux s'avère être une approche computationnellement simple mais puissante pour classer les textures.

Transformée de caractéristiques invariantes à l'échelle (SIFT)

SIFT crée des descripteurs de caractéristiques qui sont invariants à l'échelle, à la rotation et aux variations d'éclairage :

Image source

1. Commencez par repérer les points d'intérêt potentiels en utilisant la fonction différence de Gauss.
2. Ensuite, localisez les points clés en éliminant les points à faible contraste et les réponses des contours qui pourraient troubler les résultats.
3. Ensuite, attribuez une orientation à chaque point clé en fonction des gradients locaux dans l'image.
4. Enfin, générez des descripteurs qui capturent les informations de gradient autour de chaque point clé.

La méthode SIFT maintient de bonnes performances tout en nécessitant plus de ressources informatiques que certaines alternatives.

Ces approches établissent la fondation de la reconnaissance d'images sans apprentissage automatique car elles permettent la conception manuelle de caractéristiques. Cependant, vous appliqueriez toujours des techniques classiques d'apprentissage automatique pour classifier les caractéristiques après leur extraction.

Algorithmes d'apprentissage automatique traditionnels pour la classification d'images

Une fois les caractéristiques extraites, divers algorithmes d'apprentissage automatique peuvent être appliqués pour la classification. Explorons-en quelques-uns :

Machines à vecteurs de support (SVM)

SVM pour la classification d'images détermine le meilleur hyperplan qui maximise la marge entre différentes classes.

L'illustration montre des classes de points rouges et bleus séparées par un hyperplan. Les lignes en pointillés indiquent la marge autour de l'hyperplan, tandis que les vecteurs de support apparaissent sous forme de points entourés.
Les tâches de classification d'images sont mieux exécutées avec les SVM lorsqu'ils sont utilisés avec des techniques efficaces d'extraction de caractéristiques.

Avantages du SVM

• Fonctionne bien dans les espaces de haute dimension.
• Bon dans la gestion des frontières non linéaires avec des fonctions noyau.
• Fort contre le surapprentissage si vous ajustez les paramètres avec soin (pensez à C et aux réglages du noyau).

Inconvénients du SVM

• Cela peut être intensif en calcul avec des ensembles de données massifs, en particulier en utilisant des noyaux complexes.
• Obtenir les bons paramètres peut être délicat et chronophage.

K-plus proches voisins (KNN)

La classification d'images par KNN fonctionne en classant les images en fonction de la classe majoritaire parmi ses K voisins les plus proches dans l'espace des caractéristiques :

1. Tout d'abord, calculez la distance (euclidienne, de Manhattan, etc.) entre les caractéristiques de l'image test et celles de toutes les images d'entraînement.
2. Ensuite, sélectionnez les K images les plus proches.
3. Attribuez la classe qui apparaît le plus fréquemment parmi ces voisins.

Avantages de KNN

• C'est simple à mettre en œuvre.
• La mise en œuvre ne nécessite pas de phase d'entraînement.
• Cela fonctionne efficacement si la représentation des caractéristiques est discriminante.

Inconvénients du KNN

• Le processus de prédiction devient lent pour les grands ensembles de données (parce qu'il recherche des voisins au moment de la requête).
• Cet algorithme nécessite une mémoire importante car il stocke toutes les données d'entraînement.
• Le choix de k et la métrique de distance affectent de manière significative la performance.

Arbres de décision

Le processus de classification dans les arbres de décision implique une partition récursive de l'espace des caractéristiques pour parvenir à des décisions :

1. Tout d'abord, sélectionnez la caractéristique qui fait le meilleur travail pour diviser les données.
2. Ensuite, créez des nœuds enfants en fonction de cette division.
3. Continuez à répéter de manière récursive jusqu'à ce que les critères d'arrêt soient atteints.

Avantages des arbres de décision

• Les résultats produits sont très interprétables puisque vous pouvez visualiser la structure de l'arbre.
• Le modèle s'entraîne et prédit rapidement les données lorsqu'il travaille avec des ensembles de données de taille modérée.
• Gérer correctement à la fois les caractéristiques numériques et catégorielles.

Inconvénients des arbres de décision

• Il peut facilement surapprendre s'il n'est pas élagué.
• Les arbres de décision uniques pourraient ne pas atteindre les meilleurs niveaux de précision (mais les méthodes d'ensemble comme les forêts aléatoires produisent généralement des résultats impressionnants).

Ces algorithmes de classification d'images fonctionnent sans apprentissage profond et peuvent atteindre des résultats optimaux lorsqu'ils sont combinés à un ingénierie des caractéristiques robuste.

Mise en œuvre pratique avec Python

Ce tutoriel abordera la classification d'images traditionnelle en démontrant les méthodes d'extraction de caractéristiques et de classification en utilisant scikit-learn et OpenCV. Nous utiliserons le jeu de données Fashion MNIST.

Importer les bibliothèques

Le script commence son exécution en important diverses bibliothèques essentielles :

import numpy as np
from tensorflow.keras.datasets import fashion_mnist
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import classification_report
from sklearn.base import BaseEstimator, TransformerMixin
from skimage.feature import hog, local_binary_pattern

Charge et prétraite le jeu de données Fashion MNIST

# Load and prepare data
(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()
train_images = train_images.astype('float32') / 255.0
test_images = test_images.astype('float32') / 255.0

Après avoir importé les bibliothèques, nous chargeons le jeu de données. Les tableaux d'images et d'étiquettes sont extraits des ensembles d'entraînement et de test. Les valeurs de pixels de ces images, qui vont initialement de 0 à 255, subissent une normalisation par division par 255,0 pour atteindre une plage [0, 1]. Cela améliore les performances et la stabilité de l'entraînement.

Extrait des caractéristiques en utilisant HOG (ou LBP/Histogramme)

class FeatureExtractor(BaseEstimator, TransformerMixin):
    def __init__(self, feature_type='hog'):
        self.feature_type = feature_type

    def fit(self, X, y=None):
        return self

    def transform(self, X, y=None):
        if self.feature_type == 'hog':
            return np.array([hog(img, orientations=8, pixels_per_cell=(4, 4),
                                 cells_per_block=(1, 1), visualize=False) for img in X])
        elif self.feature_type == 'lbp':
            return np.array([local_binary_pattern(img, P=8, R=1, method='uniform').flatten()
                             for img in X])
        elif self.feature_type == 'histogram':
            return np.array([np.histogram(img, bins=32, range=(0, 1))[0] for img in X])
        else:
            raise ValueError("Invalid feature type. Choose 'hog', 'lbp', or 'histogram'.")

La classe FeatureExtractor est l'élément central de ce code. Elle est compatible avec les pipelines scikit-learn, permettant aux développeurs d'utiliser ce transformateur personnalisé. Cette classe permet aux utilisateurs d'obtenir diverses caractéristiques d'image en fonction du paramètre feature_type spécifié lors de l'initialisation.

Si le type de fonctionnalité est défini sur ‘hog’, le système transforme chaque image en un vecteur de fonctionnalités HOG. hog() provient de skimage.feature. Il est utilisé pour calculer les gradients orientés par histogramme. Ses paramètres sont décrits comme suit :

img

L'image d'entrée en niveaux de gris (ou RGB convertie en niveaux de gris)

orientations=8

Nombre de bins d'orientation pour représenter la direction du gradient (par exemple, 0° à 180°)

pixels_per_cell=(4, 4)

Chaque cellule fait 4×4 pixels ; les gradients sont calculés dans chaque cellule

cells_per_block=(1, 1)

Chaque bloc (utilisé pour la normalisation) consiste en une cellule 1×1 ; c'est-à-dire, pas de normalisation par bloc

visualize=False

Si vrai, retourne également une image montrant la visualisation HOG

D'un autre côté, si le feature_type est « lbp », le système calcule le motif binaire local de l'image et le transforme en un tableau unidimensionnel. local_binary_pattern() est utilisé pour calculer les motifs binaires locaux. Les paramètres sont décrits comme suit :

img

L'image en niveaux de gris d'entrée

P=8

Nombre de points d'échantillonnage du voisinage circulairement symétrique

R=1

Le rayon du cercle (distance du pixel central aux voisins)

method='uniform'

Utilisez la variante LBP uniforme (moins de motifs, des caractéristiques plus robustes)

Enfin, l'option « histogramme » sélectionnée calcule les histogrammes en niveaux de gris avec 32 compartiments pour chaque image.

Entraîne plusieurs classificateurs dans un pipeline scikit-learn

def create_pipeline(classifier, feature_type='hog'):
    return Pipeline([
        ('feature_extractor', FeatureExtractor(feature_type=feature_type)),
        ('scaler', StandardScaler()),
        ('pca', PCA(n_components=0.95)),
        ('classifier', classifier)
    ])

# Define classifiers
classifiers = {
    'SVM': SVC(kernel='rbf', C=10, gamma='scale', random_state=42),
    'KNN': KNeighborsClassifier(n_neighbors=5, weights='distance'),
    'Decision Tree': DecisionTreeClassifier(max_depth=10, random_state=42)
}

# Train and evaluate models
results = {}
for name, clf in classifiers.items():
    print(f"\nTraining {name}...")
    pipeline = create_pipeline(clf, feature_type='hog')  # You can change 'hog' to 'lbp' or 'histogram'
    pipeline.fit(train_images, train_labels)

    predictions = pipeline.predict(test_images)
    report = classification_report(test_labels, predictions, output_dict=True)
    results[name] = report

    print(f"{name} Results:")
    print(classification_report(test_labels, predictions))

Le code ci-dessus définit une fonction d'aide create_pipeline. Cette fonction accepte un classificateur et un type de caractéristiques comme paramètres d'entrée pour construire un pipeline scikit-learn. Le pipeline effectue quatre étapes principales :

• Le FeatureExtractor convertit initialement les images brutes en caractéristiques.
• Ces caractéristiques sont ensuite normalisées en utilisant une mise à l'échelle standard.
• Cela est suivi par l'ACP, qui réduit la dimensionnalité et conserve 95 % de la variance des données.
• Enfin, le classificateur sélectionné peut fonctionner sur les données transformées.

Les modèles de classification incluent SVM avec noyau RBF, un classificateur KNN qui utilise un vote basé sur la distance, et un arbre de décision avec une limite de profondeur fixée à 10. Un dictionnaire stocke ces modèles pour simplifier l'itération. Le processus d'entraînement et d'évaluation consiste à parcourir chaque classificateur. Le script affiche le nom de chaque modèle avant de construire un pipeline avec la caractéristique HOG. Ensuite, il entraîne le modèle et génère des prédictions sur les données de test.

Évaluer et comparer les modèles en utilisant la précision et le score F1

# Compare model performance
print("\nModel Comparison:")
for model, metrics in results.items():
    print(f"{model}:")
    print(f"Accuracy: {metrics['accuracy']:.3f}")
    print(f"Macro Avg F1: {metrics['macro avg']['f1-score']:.3f}\n")

La précision et le score F1 macro-moyenné sont affichés pour chaque modèle. Cette étape finale permet une comparaison rapide des performances de chaque classificateur. La performance peut être résumée dans le tableau suivant :

Dominance des SVM

La tâche de classification SVM a donné des résultats optimaux avec une précision de 89,1 %/F, ce qui montre son efficacité élevée. Cela s'aligne avec les forces connues des SVM :

• Gérer correctement les données de haute dimension (après avoir appliqué l'ACP).

  • Le noyau RBF produit des résultats efficaces lorsqu'il travaille avec des frontières de décision non linéaires.
  • Avantages des caractéristiques HOG capturant les informations de texture/forme.

Performance de KNN

Les scores de 84,5 % suggèrent :

• Les approches basées sur la distance donnent des résultats satisfaisants lorsqu'elles sont appliquées à des caractéristiques normalisées.

  • Pourrait potentiellement s'améliorer avec l'ajustement de la valeur k

Limitations des arbres de décision

Les scores de 77,5-77,6 % indiquent :

• Faible compatibilité avec les caractéristiques HOG basées sur le gradient.

  • Simplification excessive due à la contrainte max_depth=10.

Comparaison : Apprentissage automatique vs Apprentissage profond pour la classification d'images

Le choix entre l'apprentissage machine traditionnel et l'apprentissage profond pour la classification d'images nécessite une considération attentive de vos contraintes et objectifs.

Cas d'utilisation et scénarios pratiques

Dans quelles conditions devriez-vous choisir des méthodes de classification d'images sans réseaux neuronaux ? Voici quelques scénarios courants :

Cela dit, les modèles d'apprentissage profond atteignent des performances à la pointe de la technologie si vous disposez d'un grand ensemble de données diversifié et de ressources informatiques suffisantes.

SECTION FAQ

Quelle méthode est la meilleure pour la classification d'images ?
Il n'existe pas de méthode « meilleure » universelle. Cela dépend de la taille des données, de la complexité des caractéristiques, des ressources matérielles et des exigences en matière d'interprétabilité. L'apprentissage profond produit des résultats très précis lorsqu'il est appliqué à de grands ensembles de données étiquetées avec suffisamment de puissance de calcul. Les techniques classiques de classification d'images telles que SVM ou les Forêts Aléatoires peuvent être plus pratiques lorsqu'on travaille avec des ensembles de données plus petits ou lorsque l'interprétabilité est requise.

Qu'est-ce que la classification d'images utilisant l'apprentissage non supervisé ?
L'apprentissage non supervisé vise à trouver des structures cachées dans des données non étiquetées en regroupant les images en clusters sans étiquettes de classe connues. Une application pratique des algorithmes de regroupement (comme K-Means) est de regrouper des images en fonction de leurs similitudes. Cependant, cette tâche ne peut pas être considérée strictement comme une « classification » puisque la classification nécessite des données étiquetées. L'apprentissage non supervisé peut aider au pré-regroupement, à la détection d'anomalies, etc., en préparant les données pour des tâches de classification supervisée ultérieures.

Quelles sont les alternatives aux CNN pour la classification d'images ?
Les alternatives incluent :

• SVM, KNN, et Arbres de décision.
• Forêts aléatoires ou d'autres techniques d'ensemble peuvent également être d'excellentes options.
• Machines à Gradient Boosting (XGBoost, LightGBM) avec des caractéristiques d'image personnalisées.

Bien que ces méthodes servent d'alternatives, leur performance dépend des exigences spécifiques de chaque tâche de classification d'images.

Les images peuvent-elles être classées sans apprentissage profond ?
Absolument. Avant l'adoption rapide des CNN, les algorithmes de classification d'images sans techniques d'apprentissage profond étaient la norme industrielle dominante. Ils restent pertinents pour gérer des ensembles de données plus petits et des scénarios à ressources limitées.

Les algorithmes classiques nécessitent moins de puissance de calcul et peuvent être plus faciles à interpréter. Ils donnent de bons résultats lorsque les caractéristiques sont correctement conçues. Ces algorithmes sont souvent utilisés dans des domaines spécialisés, des systèmes de niche et des environnements académiques, où ils servent à enseigner les concepts fondamentaux de la vision par ordinateur et de l'apprentissage automatique.

Conclusion

Une technique de classification d'images sans réseaux neuronaux semble dépassée dans notre ère actuelle centrée sur l'IA. Cependant, cette approche conserve une importance significative dans de nombreuses applications pratiques, en particulier lorsque la disponibilité des données ou la puissance de calcul est limitée ou lorsque la transparence du modèle est essentielle. En combinant des caractéristiques conçues telles que les contours, les textures et les histogrammes de couleurs avec des méthodes classiques d'apprentissage automatique, vous pouvez construire des modèles robustes, efficaces et interprétables. Il est généralement conseillé d'évaluer à la fois les méthodes d'apprentissage automatique traditionnelles et les approches modernes d'apprentissage profond pour déterminer laquelle répond le mieux à vos besoins. Vous pouvez explorer des sujets avancés tels que l'apprentissage par peu d'exemples pour des scénarios avec des données très limitées.

Références et ressources

• Classification d'images utilisant l'apprentissage automatique
• Extraction de caractéristiques en apprentissage automatique : un guide complet
• SVM contre KNN en apprentissage automatique
• TransformerMixin

Merci d'apprendre avec la communauté Linux-Console.net.