ML Kit: vad är det, bibliotek och ML för Android och iOS

Vad är ML Kit: funktioner och arkitektur

ML Kit — är ett Firebase-kompatibelt SDK för mobila plattformar som tillhandahåller 14 ML-API för Android och iOS. ML Kit ersatte Firebase ML (gamla namnet) år 2020 och är nu tillgängligt som ett fristående SDK via Google Play Services (Android) eller CocoaPods/SPM (iOS). Den viktigaste fördelen — alla modeller fungerar on-device, vilket garanterar datasekretess och funktion utan internet.

Arkitekturen för ML Kit är uppbyggd kring två lägen: bundled (modellen är inbäddad i APK/IPA) och downloaded (modellen laddas ner via Google Play Services vid första anropet). Bundled-läget ger omedelbar start men ökar appstorleken med 5–20 MB. Downloaded — sparar utrymme men kräver internet vid första start. Google rekommenderar downloaded för API som inte används på varje skärm (Object Detection, Pose Detection).

Anpassning via TFLite — ML Kit tillåter dig att ladda din egen TensorFlow Lite-modell via Custom Model API. Detta ger flexibilitet — använd färdiga API för standarduppgifter och din egen modell för specifika uppgifter. ML Kit tillhandahåller en universell Input/Output-hanterare som arbetar med ByteBuffer och FloatArray. Enligt Google (2025) kombinerar 40% av ML Kit-projekten färdiga API och anpassade modeller.

// ML Kit Text Recognition-inställning (Android)
val recognizer = TextRecognition.getClient(TextRecognizerOptions.DEFAULT_OPTIONS)

val image = InputImage.fromBitmap(bitmap)
recognizer.process(image)
    .addOnSuccessListener { result ->
        for (block in result.textBlocks) {
            Log.d("MLKit", block.text)
        }
    }
    .addOnFailureListener { error ->
        // Bearbetningsfel
    }

Firebase vs standalone — ML Kit kan användas med Firebase (Cloud-funktioner, Analytics, Crashlytics) eller som fristående SDK utan Firebase. Standalone-läget ansluter via Google Play Services (Android) utan konfiguration av Firebase-konto. Cloud-API är tillgängliga via Firebase (Cloud Vision, Natural Language) för uppgifter som kräver neurala nätverk på Googles server — men dessa funktioner är betalda och inte on-device.

ML Kit Text Recognition: textigenkänning

ML Kit Text Recognition — API för optisk teckenigenkänning (OCR) på bilder. Stöder två lägen: Latin-based (latinska alfabetet, kyrilliska, siffror — 45 språk) och Chinese/Japanese/Korean (CJK — hieroglyfspråk). Latin-igenkänning använder modell V2 (snabbare) eller V1 (hög precision). V2 ger hastighet på 10–30 ms per bildruta, V1 — 50–100 ms.

Funktioner för Text Recognition inkluderar igenkänning av tryckt och handskriven text, bestämning av textorientering, detektering av rader, ord och symboler, bestämning av textspråk. API returnerar strukturen: Text → TextBlock → Line → Element (Word/Symbol). Varje element har bounding box, confidence och igenkänd text. Enligt Google (2025) är noggrannheten för ML Kit Text Recognition V2 på latinska alfabetet 96%, på kyrilliska — 91%.

Text Recognition i realtid — användning med CameraX eller Camera2 för videostream. Skapa en ImageAnalysis.Analyzer och överför bildrutor till ML Kit. För prestanda, minska bildupplösningen till 480p (640x480) — detta är den optimala balansen mellan hastighet och noggrannhet. ML Kit hanterar automatiskt bildrotation, men för maximal hastighet, överför bilden i rätt orientering.

// Textigenkänning med CameraX-analysator
class TextAnalyzer : ImageAnalysis.Analyzer {
    private val recognizer = TextRecognition.getClient(
        TextRecognizerOptions.DEFAULT_OPTIONS
    )

    override fun analyze(image: ImageProxy) {
        val inputImage = InputImage.fromMediaImage(
            image.image, image.imageInfo.rotationDegrees
        )
        recognizer.process(inputImage)
            .addOnSuccessListener { /* text found */ }
            .addOnCompleteListener { image.close() }
    }
}

Optimering av Text Recognition: använd ImageDecoder för att förbättra igenkänningen av suddiga eller mörka bilder. För tryckt text — TextRecognizerOptions.DEFAULT_OPTIONS (modell V2). För handskriven — TextRecognizerOptions.SCRIPT_LATIN (noggrannare men långsammare). I IT Sectr-projekt använder vi V2 för dokumentigenkänning och Latin-modellen för checkar och kvitton.

ML Kit Face Detection: ansikts- och konturdetektering

ML Kit Face Detection — API för detektering av ansikten i bilder och video. Bestämmer ansiktets bounding box, koordinater för ögon, näsa, mun, öron (468 konturpunkter) och grundläggande uttryck: leende, öppen mun, slutna ögon. Face Detection är ett av de snabbaste API:en i ML Kit: 5–15 ms per bildruta beroende på antal ansikten och konturpunkter.

Lägen för Face Detection: contour mode (468 konturpunkter av ansiktet för exakt applicering av masker/filter), classification mode (bestämning av leende, öppna ögon), landmark mode (nyckelpunkter utan kontur). Lägen kombineras i FaceDetectorOptions. Att aktivera alla lägen saktar ner detekteringen 2–3 gånger — använd den minimalt nödvändiga uppsättningen för din uppgift.

Face Detection i AR-appar — baserat på konturpunkter bygger ML Kit en ansiktsmask för Snapchat-liknande filter. ML Kit returnerar 468 punkter med koordinaterna x, y, z (z = djup). Punkter uppdateras 30–60 gånger per sekund på moderna enheter. För AR-applikation, använd FaceMeshDetector (specialiserad version) — den returnerar även masktrianglarna för texturering.

// Ansiktsdetektering med konturpunkter
val options = FaceDetectorOptions.Builder()
    .setPerformanceMode(FaceDetectorOptions.PerformanceMode.FAST)
    .setContourMode(FaceDetectorOptions.ContourMode.ALL)
    .setClassificationMode(FaceDetectorOptions.ClassificationMode.ALL)
    .build()
val detector = FaceDetection.getClient(options)

detector.process(inputImage)
    .addOnSuccessListener { faces ->
        faces.forEach { face ->
            val bounds = face.boundingBox
            val smileProb = face.smilingProbability
        }
    }

Begränsningar för Face Detection: API:et känner inte igen vem ansiktet tillhör (face recognition) — endast detekterar ansikten. För personidentifiering, använd FaceNet eller ArcFace på en anpassad TFLite-modell. ML Kit fungerar korrekt med ansikten i vinkel upp till 45°, med glasögon och delvis mask. För profilvinklar (90°) sjunker noggrannheten till 40–60%.

ML Kit Barcode Scanning: läsning av alla kodformat

ML Kit Barcode Scanning — API för läsning och avkodning av endimensionella (EAN, UPC, Code 128) och tvådimensionella (QR, Data Matrix, PDF417) streckkoder. Barcode Scanning detekterar koden i bilden — till skillnad från ZXing, som kräver att koden upptar nästan hela bildrutan. ML Kit detekterar koden oavsett storlek och orientering, inklusive flera koder i en bildruta (multi-barcode-läge).

Format som stöds: EAN-8, EAN-13, UPC-A, UPC-E, Code 39, Code 93, Code 128, ITF, Codabar, QR, Data Matrix, PDF417, Aztec. ML Kit bestämmer automatiskt formatet — du behöver inte ange kodtyp. I produktion, använd setBarcodeFormats() för att begränsa formaten som stöds — detta påskyndar skanningen med 30–50% genom att utesluta onödiga avkodningsalgoritmer.

Barcode Scanning i realtid — liknande Text Recognition, integration med CameraX. ML Kit bearbetar bildrutor med en frekvens på upp till 60 FPS. För maximal hastighet, aktivera setPerformanceMode(PerformanceMode.FAST). Barcode Scanning i ML Kit är 2–3 gånger snabbare än ZXing och detekterar suddiga eller delvis täckta koder mer exakt. Enligt Google (2025) har ML Kit Barcode Scanning 98.5% noggrannhet vid standardbelysning.

// Streckkodsskanning med formatfilter
val options = BarcodeScannerOptions.Builder()
    .setBarcodeFormats(Barcode.FORMAT_QR_CODE,
        Barcode.FORMAT_EAN_13)
    .build()
val scanner = BarcodeScanning.getClient(options)

scanner.process(inputImage)
    .addOnSuccessListener { barcodes ->
        barcodes.forEach { barcode ->
            val value = barcode.rawValue
            val type = barcode.format
        }
    }

Jämförelse med ZXing: ML Kit är snabbare, mer exakt och enklare att integrera. ZXing — är öppen källkod, fungerar helt offline, kräver inga Google Play Services. ML Kit kräver Google Play Services (Android) eller CocoaPods (iOS). För appar som körs på enheter utan Google (Huawei, Amazon Fire), använd ZXing som fallback. För resten — ML Kit, eftersom det ger bättre UX tack vare detektering av flera koder.

Object Detection och Pose Detection i ML Kit

ML Kit Object Detection — API för detektering och spårning av objekt i bilder. Detekterar objekt från 1000+ kategorier (ImageNet-klasser) — människor, djur, fordon, hushållsföremål. Object Detection fungerar i två lägen: single-image (enskilt foto) och streaming (videostream med spårning). Streaming-läget spårar objekt mellan bildrutor och tilldelar varje ett unikt track ID.

Pose Detection — API för att bestämma mänsklig posering baserat på 33 nyckelpunkter (skelett): huvud, axlar, armbågar, handleder, höfter, knän, fötter. Bestämmer koordinater (x, y, z) och confidence för varje punkt. Pose Detection tillämpas i fitness-trackers (räkna repetitioner, kontrollera form), AR-appar (avatar som kopierar rörelser) och sportanalys. Hastighet — 10–30 ms per bildruta beroende på antal personer.

Object Tracking — ML Kit Object Detection med spårning mellan bildrutor använder en tracker baserad på Optical Flow. När ett objekt har detekterats, spårar trackern det utan omdetektering, vilket sparar CPU/GPU. Om trackern förlorar objektet (snabb rörelse, blockering), startar ML Kit omdetektering. Enligt Google (2025) behåller trackern objektet i 95% av bildrutorna vid rörelsehastighet upp till 30 km/h.

// Poseringsdetektering (mänskligt skelett)
val poseDetector = PoseDetection.getClient(
    PoseDetectorOptions.Builder()
        .setDetectorMode(PoseDetectorOptions.STREAM_MODE)
        .build()
)

poseDetector.process(inputImage)
    .addOnSuccessListener { pose ->
        pose.allPoseLandmarks.forEach { landmark ->
            val type = landmark.landmarkType // VÄNSTER_AXEL, HÖGER_ARMBÅGE...
            val position = landmark.position3D
        }
    }

Selfie Segmentation — API för segmentering av personen i bilden (separering av personen från bakgrunden). Returnerar en förtroendemask för varje pixel. Selfie Segmentation används för att sudda ut eller byta bakgrund i videosamtal, fotoredigerare och AR-appar. Masken returneras som en UInt8Array i storlek av den ursprungliga bilden — varje pixel innehåller ett värde från 0.0 (bakgrund) till 1.0 (person).

Anpassade TFLite-modeller i ML Kit

Custom Model API — möjlighet att ladda och köra egna TensorFlow Lite-modeller via ML Kit-gränssnittet. ML Kit tillhandahåller ett enhetligt Input/Output API: ByteBuffer på ingången, FloatArray/TensorImage på utgången. Detta gör det möjligt att använda fördelarna med ML Kit (modellhantering, bildbehandling, anslutning till CameraX) med anpassade modeller för face recognition, object classification, NLP och andra.

Ladda modell — placera .tflite-filen i assets/ (Android) eller bundle (iOS) och ladda den via CustomModelDownloadConditions eller Firebase Model Manager. För nedladdning av stora modeller (5+ MB), använd nedladdningsvillkor: Wi-Fi, laddad, i bakgrunden. Google rekommenderar att ladda modellen vid första start av appen, inte vid första användningstillfället.

// Ladda anpassad TFLite-modell
val conditions = CustomModelDownloadConditions.Builder()
    .requireWifi()
    .build()
val remoteModel = CustomRemoteModel.Builder("my_model")
    .setRemoteModelName("my_model_v2")
    .build()

remoteModel.download(conditions)
    .addOnSuccessListener { /* model ready */ }
    .addOnFailureListener {
        // Använd medföljande modell från assets
    }

Optimering av anpassade modeller: använd TFLite Converter med delegate-kompatibilitet. För maximal prestanda, kvantisera modellen (INT8) — detta minskar modellstorleken 4x och snabbar upp inferens 2–3x via XNNPACK Delegate. ML Kit Custom Model API stöder Dynamic Shape (batch = 1), Image Input (UInt8, Float32) och Tensor Output.