Image Labeling : définition, méthodes et principe de fonctionnement

Qu'est-ce que Image Labeling : bases de la classification

Image Labeling est un sous-type de classification d'images où le modèle prend une image en entrée et retourne des probabilités pour chaque classe de l'ensemble d'apprentissage. Contrairement à la détection d'objets, Image Labeling ne détermine pas la position des objets dans l'image — seulement leur présence ou absence. Contrairement à la segmentation d'image, il ne délimite pas le contour des objets. Image Labeling répond à la question « qu'y a-t-il sur la photo ? », pas « où et qu'y a-t-il sur la photo ? ».

Architecture du classifieur : un backbone CNN (MobileNet, ResNet, EfficientNet) extrait une carte de caractéristiques de l'image, Global Average Pooling réduit les dimensions spatiales, et une couche entièrement connectée (Dense) avec activation Softmax produit les probabilités des classes. MobileNetV2 est le backbone le plus populaire pour les appareils mobiles : 3,5M de paramètres, inférence de 0,5 à 2 ms sur Pixel 6 via GPU. EfficientNet-Lite est une alternative avec un meilleur rapport précision/paramètres.

Précision Top-1 vs Top-5 : top-1 — le modèle prédit correctement la classe principale (91 % avec ML Kit) ; top-5 — la classe correcte figure parmi les cinq plus probables (98 % avec ML Kit). Pour les applications de production, utilisez top-5 et affichez plusieurs options d'étiquettes à l'utilisateur. Pour la modération de contenu, utilisez top-1 avec un seuil de confiance >= 0,8 (réduit le taux de faux positifs de 40 %).

Sur l'appareil vs Cloud : la classification sur l'appareil (ML Kit, Core ML) offre une latence de 1 à 20 ms avec une confidentialité totale des données. L'API cloud (Google Cloud Vision, AWS Rekognition) a une latence de 500 à 2000 ms plus un coût par requête, mais est plus précise (97–99 %) grâce à des modèles plus grands (ViT, CLIP). Pour les applications en temps réel (caméra, RA), choisissez l'option sur l'appareil. Pour les scénarios complexes (médecine, analyse experte), utilisez le cloud avec repli sur l'appareil.

ML Kit Image Labeling sur Android et iOS

ML Kit Image Labeling est une bibliothèque prête à l'emploi de Google pour la classification d'images sur l'appareil. Disponible en deux modes : sur l'appareil (gratuit, plus de 400 étiquettes, 10–20 ms) et cloud (payant, plus de 10 000 étiquettes, plus de 500 ms). La version sur l'appareil utilise MobileNetV3 avec quantification INT8, occupant 4 Mo d'espace disque. ML Kit détecte automatiquement l'orientation de l'image et optimise la taille avant la classification.

API ML Kit : InputImage (depuis Bitmap, media.Image, filePath) → ImageLabeler → OnSuccessListener avec une liste d'ImageLabel (étiquette, confiance, index). Le seuil de confiance (par défaut 0,5) est la confiance minimale pour retourner une étiquette. Augmenter le seuil à 0,7 réduit le nombre d'étiquettes par image mais augmente la précision de chacune. Pour la modération de contenu, définissez le seuil à 0,8.

val labeler = ImageLabeling.getClient(
    ImageLabelerOptions.DEFAULT_OPTIONS
)

labeler.process(inputImage)
    .addOnSuccessListener { labels ->
        labels
            .filter { it.confidence >= 0.7f }
            .forEach { label ->
                log("Label: ${label.label}")
                log("Confidence: ${label.confidence}")
            }
    }
    .addOnFailureListener { error -> handleError(error) }

ML Kit sur iOS : l'API est similaire à Android, utilisant UIImage ou CMSampleBuffer. ML Kit utilise automatiquement Core ML + ANE sur les appareils A12+. Pour iOS 16+, ML Kit Image Labeling offre une latence de 8 à 15 ms sur iPhone 15 Pro. Pour minimiser la latence, transmettez la plus petite résolution d'image possible (224x224 pour MobileNet) — ML Kit la redimensionne automatiquement, mais la conversion de grandes images ajoute 2 à 5 ms de surcharge.

Core ML et Vision Framework sur iOS

Core ML est le framework d'Apple pour exécuter des modèles de ML sur l'appareil. Associé à Vision Framework (VNCoreMLRequest), Core ML permet la classification d'images avec un minimum de code. Apple fournit des modèles intégrés : SqueezeNet (5 Mo, 80,5 % top-1), ResNet50 (98 Mo, 95,2 %), MobileNetV2 (14 Mo, 90,2 %). Les modèles au format .mlmodel ou .mlpackage sont convertis via coremltools depuis TensorFlow ou PyTorch.

VNCoreMLRequest est une API Vision qui gère le prétraitement de l'image (redimensionnement, crop-to-fill, conversion d'espace colorimétrique) et transmet le résultat au modèle. Vision retourne VNClassificationObservation avec identifier (nom de la classe) et confidence (0..1). MaxCandidates est le nombre maximum d'étiquettes retournées (par défaut 1). Pour la classification avec sélection automatique, utilisez VNCoreMLRequest avec imageCropAndScaleOption = .centerCrop.

guard let model = try? VNCoreMLModel(for: MobileNetV2().model) else { return }
let request = VNCoreMLRequest(model: model) { request, _ in
    guard let results = request.results as? [VNClassificationObservation] else { return }
    results.prefix(5).forEach { obs in
        print("Étiquette : \(obs.identifier), Confiance : \(obs.confidence)")
    }
}
request.imageCropAndScaleOption = .centerCrop

let handler = VNImageRequestHandler(cgImage: cgImage, options: [:])
try handler.perform([request])

Core ML vs ML Kit sur iOS : Core ML est natif, ne nécessite pas de SDK supplémentaires et est mieux optimisé pour ANE (Neural Engine d'Apple). ML Kit est plus précis sur les scènes complexes grâce aux modèles de Google. Core ML prend en charge tout modèle (converti via coremltools), tandis que ML Kit ne prend en charge que les siens. Pour une implémentation rapide, utilisez ML Kit. Pour un contrôle maximal du modèle, utilisez Core ML. Une approche pratique : utilisez les deux frameworks dans une même application — ML Kit pour les étiquettes standard, Core ML pour les personnalisées.

Entraînement et intégration de modèles personnalisés

Modèles personnalisés d'Image Labeling — entraîner votre propre classifieur pour une tâche spécifique : reconnaissance de la qualité des fruits, détection de défauts sur une ligne de production, classification de races de chiens. Le processus comprend la collecte d'un ensemble de données (plus de 1000 images par classe), l'annotation, l'entraînement par transfer learning sur un MobileNetV2 ou EfficientNet pré-entraîné, et la conversion en TFLite / Core ML.

Transfer Learning — la méthode principale pour entraîner les classifieurs mobiles. On prend un modèle pré-entraîné sur ImageNet, on gèle les couches inférieures (backbone CNN) et on réentraîne les couches supérieures (fine-tuning). Cela ne nécessite que 100 à 500 images par classe et prend 1 à 2 heures sur Google Colab (GPU). Bibliothèques : TensorFlow Keras (Android), PyTorch + coremltools (iOS). Résultat : 95 à 98 % de précision sur les classes cibles.

// Inférence de modèle personnalisé TFLite
val interpreter = Interpreter(loadModelFile(context))
val inputImage = TensorImage.fromBitmap(bitmap)
    .apply { load(Bitmap.createScaledBitmap(bitmap, 224, 224, true)) }

val output = Array(1) { FloatArray(NUM_CLASSES) }
interpreter.run(inputImage.tensorBuffer, output)

val probabilities = TensorLabel.mapIndexToLabels(output[0])
val topClass = probabilities.maxByOrNull { it.value }

ML Kit Custom Model API — une alternative : pas besoin d'écrire de code pour TFLite Interpreter — ML Kit charge le modèle et gère le prétraitement automatiquement. L'Image Labeler personnalisé accepte un modèle TFLite avec une taille d'entrée 224x224x3 et une sortie score float[NUM_CLASSES]. Il suffit de fournir le fichier du modèle et d'obtenir des étiquettes standard. ML Kit Custom Model API est recommandé si le modèle correspond au format TFLite. Si un contrôle plus fin de l'inférence est nécessaire (seuils par classe), utilisez directement TFLite Interpreter.

TFLite et Core ML : comparaison des formats

TFLite (TensorFlow Lite) est le format de modèles de Google pour les appareils mobiles et périphériques. Il prend en charge la quantification (FP16, INT8), qui réduit la taille du modèle par 4 et augmente la vitesse par 2 à 3 avec une légère perte de précision (1–2 %). TFLite fonctionne sur Android via GPU Delegate (OpenGL/OpenCL) et sur iOS via Core ML Delegate. TFLite Task API fournit une interface unifiée pour Image Classifier, Object Detector et d'autres tâches.

Core ML est le format d'Apple (.mlpackage — nouveau, .mlmodel — ancien). Il prend en charge la quantification (FP16) et la palettisation des poids (jusqu'à 1/2/4/6/8 bits), atteignant jusqu'à 80 % de compression du modèle. Core ML utilise ANE (Neural Engine), GPU et CPU — le système sélectionne automatiquement le moteur optimal. Conversion depuis PyTorch via torch.onnx.export + coremltools, depuis TensorFlow via tf-keras + coremltools. iOS 18+ prend en charge l'entraînement sur l'appareil via Core ML Training API.

ONNX comme format intermédiaire : convertissez les modèles en ONNX (PyTorch → ONNX, TensorFlow → ONNX) puis en TFLite / Core ML via onnx2tf ou onnx2coreml. ONNX est un format unifié pris en charge par plus de 70 frameworks. Cela simplifie le pipeline : un modèle entraîné → ONNX → formats natifs pour les deux plateformes. L'entraînement en PyTorch + conversion en ONNX → TFLite (Android) / Core ML (iOS) est le pipeline recommandé pour les projets multiplateformes.

Applications d'Image Labeling dans les apps mobiles

Étiquetage automatique de photos — les applications de galerie (Google Photos, Apple Photos) attribuent automatiquement des étiquettes aux images : « plage », « coucher de soleil », « chien », « nourriture ». ML Kit Image Labeling traite chaque photo de la galerie en arrière-plan — 1 à 2 secondes pour 100 photos (lot). L'utilisateur peut rechercher par étiquettes sans tri manuel. Google Photos utilise la classification sur l'appareil avec une vérification ultérieure sur le serveur pour les scènes complexes.

Modération de contenu — détection automatique d'images indésirables dans le contenu généré par l'utilisateur (réseaux sociaux, places de marché, plateformes UGC). ML Kit Custom Model détecte le contenu NSFW, la violence et la propagande avec une précision de 92 à 96 %. Le seuil de déclenchement est une confiance de 0,8. Pour réduire les faux positifs (images médicales légitimes), utilisez un comité de classifieurs : Image Labeling + Object Detection + Blur Detection. La modération sur l'appareil est plus rapide et protège la vie privée des utilisateurs.

Recherche visuelle de produits — un utilisateur photographie un produit (baskets, sac, meuble), l'application détermine l'étiquette et trouve des produits similaires dans le catalogue. Image Labeling réduit la recherche à une catégorie, puis des descripteurs de caractéristiques (vecteurs de caractéristiques) trouvent des articles visuellement similaires. Pinterest Lens, Google Lens et Amazon StyleSnap utilisent cette approche. La classification sur l'appareil donne des résultats en 10 à 30 ms, la recherche cloud en 200 à 500 ms.

// Image Labeling avec Core ML pour la recherche visuelle
let request = VNCoreMLRequest(model: productClassifier) { req, _ in
    guard let result = req.results?.first as? VNClassificationObservation,
          result.confidence > 0.6 else { return }
    SearchService.findSimilarProducts(
        category: result.identifier,
        image: capturedPhoto,
        limit: 10
    ) { products in
        DispatchQueue.main.async {
            self.showResults(products)
        }
    }
}

Applications de RA et éducatives — Image Labeling classifie les objets en temps réel via la caméra. Un utilisateur pointe son téléphone vers une plante — l'application affiche le nom, les instructions d'entretien et le calendrier d'arrosage. Pointe vers une pièce mécanique — elle explique sa fonction. Exigence : latence < 30 ms. EfficientNet-Lite sur les appareils phares offre 15 à 25 ms. En faible luminosité, la précision diminue — utilisez un seuil de confiance adaptatif (abaissez le seuil en conditions de faible luminosité pour compenser la dégradation de la qualité d'entrée).