Image Labeling: vad det är, metoder och funktionsprincip

Vad är Image Labeling: grunderna i klassificering

Image Labeling — en underkategori av bildklassificering, där modellen tar emot en bild och returnerar sannolikheter för varje klass från träningsuppsättningen. Till skillnad från object detection bestämmer Image Labeling inte objektets position i bilden — endast dess närvaro eller frånvaro. Till skillnad från image segmentation separerar den inte objektets kontur. Image Labeling besvarar frågan “vad finns på bilden?”, inte “var och vad finns på bilden?”.

Klassificerarens arkitektur: CNN backbone (MobileNet, ResNet, EfficientNet) extraherar en egenskapskarta från bilden, Global Average Pooling komprimerar de rumsliga dimensionerna, ett fullt anslutet lager (Dense) med Softmax-aktivering ger klassannolikheterna. MobileNetV2 — den mest populära backbone för mobila enheter: 3,5M parametrar, 0,5–2 ms inferens på Pixel 6 via GPU. EfficientNet-Lite — ett alternativ med bättre förhållande mellan accuracy/parametrar.

Top-1 vs Top-5 accuracy: top-1 — modellen gissade rätt huvudklass (91% för ML Kit); top-5 — rätt klass finns bland de fem mest sannolika (98% för ML Kit). För produktionsapplikationer, använd top-5 och visa flera etikettvarianter för användaren. För innehållsmoderering — top-1 med tröskelvärdet confidence >= 0,8 (minskar falskt positiv frekvens med 40%).

On-device vs Cloud: klassificering på enheten (ML Kit, Core ML) ger latens på 1–20 ms med fullständig datasekretess. Cloud API (Google Cloud Vision, AWS Rekognition) — latens 500–2000 ms + kostnad per begäran, men mer exakt (97–99%) tack vare större modeller (ViT, CLIP). För realtidsapplikationer (kamera, AR) välj on-device. För komplexa scenarier (medicin, expertis) — cloud med fallback till on-device.

ML Kit Image Labeling på Android och iOS

ML Kit Image Labeling — ett färdigt bibliotek från Google för klassificering av bilder på enheten. Tillgängligt i två lägen: on-device (gratis, 400+ etiketter, 10–20 ms) och cloud (betald, 10000+ etiketter, 500+ ms). On-device-versionen använder MobileNetV3 + INT8-kvantisering, upptar 4 MB på disken. ML Kit bestämmer automatiskt bildens orientering och optimerar storleken före klassificering.

ML Kit API: InputImage (från Bitmap, media.Image, filePath) → ImageLabeler → OnSuccessListener med lista av ImageLabel (label, confidence, index). MillisThreshold (standard 0,5) — minsta förtroende för att returnera en etikett. Att höja tröskeln till 0,7 minskar antalet etiketter per bildruta, men ökar noggrannheten för varje etikett. För innehållsmoderering, ställ in tröskeln på 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 på iOS: API liknar Android, använder UIImage eller CMSampleBuffer. ML Kit använder automatiskt Core ML + ANE på A12+-enheter. För iOS 16+ ger ML Kit Image Labeling en latens på 8–15 ms på iPhone 15 Pro. För att minimera latensen, skicka bilden i lägsta möjliga upplösning (224x224 för MobileNet) — ML Kit skalar själv, men konvertering av stora bilder lägger till 2–5 ms overhead.

Core ML och Vision Framework på iOS

Core ML — Apples ramverk för att köra ML-modeller på enheten. Tillsammans med Vision Framework (VNCoreMLRequest) gör Core ML det möjligt att klassificera bilder med minimal kod. Apple tillhandahåller inbyggda modeller: SqueezeNet (5 MB, 80,5% top-1), ResNet50 (98 MB, 95,2%), MobileNetV2 (14 MB, 90,2%). Modeller i .mlmodel- eller .mlpackage-format konverteras via coremltools från TensorFlow, PyTorch.

VNCoreMLRequest — Vision API som tar hand om förbehandling av bilden (skalning, crop-to-fill, konvertering av färgrymd) och skickar resultatet till modellen. Vision returnerar VNClassificationObservation med identifier (klassnamn) och confidence (0..1). MaxCandidates — maximalt antal returnerade etiketter (standard 1). För klassificering med automatiskt urval, använd VNCoreMLRequest med 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("TFLite anpassad modell inferens")
    }
}
request.imageCropAndScaleOption = .centerCrop

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

Core ML vs ML Kit på iOS: Core ML — inbyggd, kräver inga extra SDK:er, bättre optimerad för ANE (Apples neurala motor). ML Kit — mer exakt på komplexa scener tack vare Googles modeller. Core ML stöder alla modeller (konverterade via coremltools), ML Kit — bara sina egna. För snabb implementering — ML Kit. För maximal kontroll över modellen — Core ML. Praktiskt val: båda ramverken i en app — ML Kit för standardetiketter, Core ML för anpassade etiketter.

Träning och integration av anpassade modeller

Anpassade Image Labeling-modeller — träning av en egen klassificerare för en specifik uppgift: igenkänning av fruktkvalitet, detektering av defekter på produktionslinjen, klassificering av hundraser. Processen omfattar insamling av dataset (1000+ bilder per klass), annotering, träning genom transfer learning på förtränad MobileNetV2 eller EfficientNet och konvertering till TFLite / Core ML.

Transfer Learning — den huvudsakliga metoden för träning av mobila klassificerare. En modell förtränad på ImageNet tas, de nedre lagren (CNN backbone) fryses, de övre lagren (Fine-tuning) tränas om. Detta kräver endast 100–500 bilder per klass och tar 1–2 timmar på Google Colab (GPU). Bibliotek: TensorFlow Keras (Android), PyTorch + coremltools (iOS). Resultat: 95–98% accuracy på målklasserna.

// Image Labeling med Core ML för visuell sökning
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 — alternativ: ingen kod behövs för TFLite Interpreter — ML Kit laddar själv modellen och hanterar förbehandlingen. Custom Image Labeler accepterar en TFLite-modell med ingångsstorlek 224x224x3 och utdata score float[NUM_CLASSES]. Det räcker att skicka modellfilen och få standardetiketter. ML Kit Custom Model API rekommenderas om modellen överensstämmer med TFLite-formatet. Om finare kontroll över inferensen krävs (trösklar, threshold per class) — använd TFLite Interpreter direkt.

TFLite och Core ML: jämförelse av format

TFLite (TensorFlow Lite) — Googles modellformat för mobila och edge-enheter. Stöder kvantisering (FP16, INT8), som minskar modellstorleken 4 gånger och ökar hastigheten 2–3x till priset av en liten noggrannhetsförlust (1–2%). TFLite fungerar på Android via GPU Delegate (OpenGL/OpenCL), på iOS — via Core ML Delegate. TFLite Task API tillhandahåller ett enhetligt gränssnitt för Image Classifier, Object Detector och andra uppgifter.

Core ML — Apples format (.mlpackage — nytt, .mlmodel — gammalt). Stöder kvantisering (FP16), viktpalettisering (weight palettization upp till 1/2/4/6/8 bitar), vilket ger modellkomprimering upp till 80%. Core ML använder ANE (Neural Engine), GPU och CPU — systemet väljer automatiskt den optimala motorn. Konvertering från PyTorch via torch.onnx.export + coremltools, från TensorFlow — via tf-keras + coremltools. iOS 18+ stöder träning på enheten via Core ML Training API.

ONNX som mellanformat: konvertera modeller till ONNX (PyTorch → ONNX, TensorFlow → ONNX) och sedan till TFLite / Core ML via onnx2tf eller onnx2coreml. ONNX är ett enhetligt format som stöds av 70+ ramverk. Detta förenklar pipeline: en tränad modell → ONNX → inbyggda format för båda plattformarna. Träning i PyTorch + konvertering till ONNX → TFLite (Android) / Core ML (iOS) — den rekommenderade pipeline för plattformsoberoende projekt.

Tillämpning av Image Labeling i appar

Automatisk taggning av foton — galleriappar (Google Photos, Apple Photos) tilldelar automatiskt etiketter till bilder: “strand”, “solnedgång”, “hund”, “mat”. ML Kit Image Labeling bearbetar varje foto från galleriet i bakgrunden — 1–2 sekunder för 100 foton (batch). Användaren får sökning efter etiketter utan manuell sortering. Google Photos använder klassificering på enheten med efterföljande serververifiering för komplexa scener.

Innehållsmoderering — automatisk detektering av oönskade bilder i användarinnehåll (sociala medier, marknadsplatser, UGC-plattformar). ML Kit Custom Model detekterar NSWF-innehåll, våld, propaganda med en noggrannhet på 92–96%. Aktiveringströskel — confidence 0,8. För att minska falskt positiva (legitima medicinska bilder) använd en kommitté av klassificerare: Image Labeling + Object Detection + Blur Detection. Moderering på enheten är snabbare och skyddar användarnas integritet.

Visuell sökning av produkter — användaren fotograferar en produkt (skor, väska, möbel), appen bestämmer etiketten och hittar liknande produkter i katalogen. Image Labeling begränsar sökningen till en kategori, sedan hittar egenskapsdeskriptorer (feature vectors) visuellt liknande instanser. Pinterest Lens, Google Lens, Amazon StyleSnap använder detta tillvägagångssätt. Klassificering på enheten ger resultat på 10–30 ms, cloud — sökning i produktdatabasen på 200–500 ms.

// Image Labeling with Core ML for visual search
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)
        }
    }
}

AR och utbildningsappar — Image Labeling klassificerar objekt i realtid via kameran. Användaren riktar telefonen mot en växt — appen visar namn, skötsel, vattning. Riktar mot en mekanismdel — förklarar syftet. Krav: latens < 30 ms. EfficientNet-Lite på flaggskeppsenheter ger 15–25 ms. I svagt ljus minskar noggrannheten — använd ett automatiskt confidence-tröskelvärde (sänk tröskeln i svagt ljus för att kompensera för den minskade ingångskvaliteten).