1. Introduction
ML Kit est un SDK mobile qui intègre l'expertise de Google en matière de machine learning dans les applications Android par le biais d'un package puissant et simple d'utilisation. Que vous soyez débutant ou expérimenté en machine learning, vous pouvez facilement implémenter la fonctionnalité dont vous avez besoin en quelques lignes de code. Il n'est pas nécessaire d'avoir une connaissance approfondie des réseaux neuronaux ni de l'optimisation des modèles pour commencer.
Comment ça marche ?
ML Kit permet d'appliquer facilement des techniques de machine learning à vos applications en rassemblant dans un seul SDK les technologies de machine learning de Google, telles que Mobile Vision et TensorFlow Lite. Que vous ayez besoin de la puissance des fonctionnalités en temps réel des modèles intégrés à l'appareil de Mobile Vision ou de la flexibilité des modèles TensorFlow Lite personnalisés, ML Kit vous permet de le faire en quelques lignes de code.
Cet atelier de programmation vous explique comment ajouter des fonctionnalités de reconnaissance de texte, d'identification de la langue et de traduction à partir d'un flux de caméra en temps réel dans votre application Android existante. Il met également en évidence les bonnes pratiques concernant l'utilisation de CameraX avec les API ML Kit.
Objectif de cet atelier
Dans cet atelier de programmation, vous allez créer une application Android avec ML Kit. Votre application utilisera l'API de reconnaissance de texte du ML Kit sur l'appareil pour reconnaître le texte provenant d'un flux de caméra en temps réel. Elle utilisera l'API d'identification de la langue du ML Kit pour identifier la langue du texte reconnu. Enfin, votre application traduira ce texte dans la langue de votre choix parmi 59 options à l'aide de l'API de traduction du ML Kit.
À la fin, vous devriez obtenir un résultat semblable à l'image ci-dessous.
Points abordés
- Utiliser le SDK ML Kit pour ajouter facilement des fonctionnalités de machine learning à n'importe quelle application Android
- API de reconnaissance de texte, d'identification de la langue et de traduction du ML Kit, et leurs fonctionnalités
- Utiliser la bibliothèque CameraX avec les API ML Kit
Prérequis
- Une version récente d'Android Studio (4.0 ou ultérieure)
- Un appareil Android physique
- L'exemple de code
- Connaissances de base du développement Android en Kotlin
Cet atelier de programmation est axé sur ML Kit. Les concepts et les blocs de code non pertinents sont déjà fournis et implémentés pour vous.
2. Configuration
Télécharger le code
Cliquez sur le lien ci-dessous pour télécharger l'ensemble du code de cet atelier de programmation :
Décompressez le fichier ZIP téléchargé. Cette action décompresse un dossier racine (mlkit-android) contenant toutes les ressources dont vous aurez besoin. Pour cet atelier de programmation, vous n'aurez besoin que des ressources du sous-répertoire translate.
Le sous-répertoire translate du dépôt mlkit-android contient le répertoire suivant :
starter : code de démarrage sur lequel vous vous appuierez dans cet atelier de programmation.
3. Importer le projet et vérifier les dépendances ML Kit et CameraX
Importez le projet de démarrage dans Android Studio. Dans le fichier app/build.gradle, vérifiez que les dépendances ML Kit et CameraX nécessaires sont incluses :
// CameraX dependencies
def camerax_version = "1.0.0-beta05"
implementation "androidx.camera:camera-core:${camerax_version}"
implementation "androidx.camera:camera-camera2:${camerax_version}"
implementation "androidx.camera:camera-lifecycle:${camerax_version}"
implementation "androidx.camera:camera-view:1.0.0-alpha12"
// ML Kit dependencies
implementation 'com.google.android.gms:play-services-mlkit-text-recognition:16.0.0'
implementation 'com.google.mlkit:language-id:16.0.0'
implementation 'com.google.mlkit:translate:16.0.0'
4. Exécuter l'application de démarrage
Maintenant que vous avez importé le projet dans Android Studio et vérifié les dépendances ML Kit, vous êtes prêt à exécuter l'application pour la première fois. Cliquez sur Run ( 
) dans la barre d'outils d'Android Studio.
L'application devrait se lancer sur votre appareil. Vous pouvez diriger l'appareil photo vers différents textes pour voir un flux en direct, mais la fonctionnalité de reconnaissance de texte n'a pas encore été implémentée.
5. Ajouter la reconnaissance de texte
Dans cette étape, nous allons ajouter une fonctionnalité à votre application pour reconnaître le texte de la caméra vidéo.
Instancier le détecteur de texte ML Kit
Remplacez le TODO en haut de TextAnalyzer.kt pour instancier TextRecognition. Vous obtenez ainsi un handle pour le module de reconnaissance de texte à utiliser lors des étapes ultérieures. Nous devons également ajouter le détecteur en tant qu'observateur du cycle de vie afin de le fermer correctement lorsqu'il n'est plus nécessaire.
TextAnalyzer.kt
private val detector = TextRecognition.getClient(TextRecognizerOptions.DEFAULT_OPTIONS)
init {
lifecycle.addObserver(detector)
}
Exécuter la reconnaissance de texte sur une image d'entrée (créée avec un tampon de la caméra)
La bibliothèque CameraX fournit un flux d'images de la caméra prêt pour l'analyse d'images. Remplacez la méthode recognizeText() dans la classe TextAnalyzer pour utiliser la reconnaissance de texte ML Kit sur chaque image.
TextAnalyzer.kt
private fun recognizeText(
image: InputImage
): Task<Text> {
// Pass image to an ML Kit Vision API
return detector.process(image)
.addOnSuccessListener { text ->
// Task completed successfully
result.value = text.text
}
.addOnFailureListener { exception ->
// Task failed with an exception
Log.e(TAG, "Text recognition error", exception)
val message = getErrorMessage(exception)
message?.let {
Toast.makeText(context, message, Toast.LENGTH_SHORT).show()
}
}
}
La ligne suivante montre comment nous appelons la méthode ci-dessus pour commencer à effectuer la reconnaissance de texte. Ajoutez la ligne suivante à la fin de la méthode analyze(). Notez que vous devez appeler imageProxy.close une fois l'analyse terminée sur l'image. Sinon, le flux de caméra en direct ne pourra pas traiter d'autres images pour l'analyse.
TextAnalyzer.kt
recognizeText(InputImage.fromBitmap(croppedBitmap, 0)).addOnCompleteListener {
imageProxy.close()
}
Exécuter l'application sur votre appareil
Cliquez maintenant sur Run ( ) dans la barre d'outils d'Android Studio. Une fois l'application chargée, elle devrait commencer à reconnaître le texte de la caméra en temps réel. Dirigez votre appareil photo vers n'importe quel texte pour confirmer. Si votre application ne reconnaît aucun texte, essayez de "réinitialiser" la détection en dirigeant l'appareil photo vers un espace vide avant de le diriger vers le texte.
6. Ajouter l'identification de la langue
Instancier l'identifiant de langue ML Kit
MainViewModel.kt se trouve dans le dossier principal. Accédez au fichier et ajoutez le champ suivant à MainViewModel.kt. Vous obtenez ainsi un handle pour l'identifiant de langue à utiliser lors de l'étape suivante.
MainViewModel.kt
private val languageIdentifier = LanguageIdentification.getClient(TextRecognizerOptions.DEFAULT_OPTIONS)
De plus, vous devez vous assurer que les clients sont correctement arrêtés lorsqu'ils ne sont plus nécessaires. Pour ce faire, remplacez la méthode onCleared() de ViewModel.
MainViewModel.kt
override fun onCleared() {
languageIdentifier.close()
translators.evictAll()
}
Exécuter l'identification de la langue sur l'appareil sur le texte détecté
Utilisez l'identifiant de langue ML Kit pour obtenir la langue du texte détecté à partir de l'image.
Remplacez le TODO dans la définition du champ sourceLang dans MainViewModel.kt par le code suivant. Cet extrait appelle la méthode d'identification de la langue et attribue le résultat s'il n'est pas indéfini ("und"). Une langue non définie signifie que l'API n'a pas pu identifier la langue en fonction de la liste des langues acceptées.
MainViewModel.kt
val sourceLang = Transformations.switchMap(sourceText) { text ->
val result = MutableLiveData<Language>()
languageIdentifier.identifyLanguage(text)
.addOnSuccessListener { languageCode ->
if (languageCode != "und")
result.value = Language(languageCode)
}
result
}
Exécuter l'application sur votre appareil
Cliquez maintenant sur Run ( ) dans la barre d'outils d'Android Studio. Une fois l'application chargée, elle devrait commencer à reconnaître le texte de la caméra et à identifier la langue du texte en temps réel. Dirigez votre appareil photo vers n'importe quel texte pour confirmer.
7. Ajouter une traduction
Remplacez la fonction translate() dans MainViewModel.kt par le code suivant. Cette fonction prend la valeur de la langue source, la valeur de la langue cible et le texte source, puis effectue la traduction. Notez que si le modèle de langue cible choisi n'a pas encore été téléchargé sur l'appareil, nous appelons downloadModelIfNeeded() pour le faire, puis nous procédons à la traduction.
MainViewModel.kt
private fun translate(): Task<String> {
val text = sourceText.value
val source = sourceLang.value
val target = targetLang.value
if (modelDownloading.value != false || translating.value != false) {
return Tasks.forCanceled()
}
if (source == null || target == null || text == null || text.isEmpty()) {
return Tasks.forResult("")
}
val sourceLangCode = TranslateLanguage.fromLanguageTag(source.code)
val targetLangCode = TranslateLanguage.fromLanguageTag(target.code)
if (sourceLangCode == null || targetLangCode == null) {
return Tasks.forCanceled()
}
val options = TranslatorOptions.Builder()
.setSourceLanguage(sourceLangCode)
.setTargetLanguage(targetLangCode)
.build()
val translator = translators[options]
modelDownloading.setValue(true)
// Register watchdog to unblock long running downloads
Handler().postDelayed({ modelDownloading.setValue(false) }, 15000)
modelDownloadTask = translator.downloadModelIfNeeded().addOnCompleteListener {
modelDownloading.setValue(false)
}
translating.value = true
return modelDownloadTask.onSuccessTask {
translator.translate(text)
}.addOnCompleteListener {
translating.value = false
}
}
Exécuter l'application sur le simulateur
Cliquez maintenant sur Run ( ) dans la barre d'outils d'Android Studio. Une fois l'application chargée, elle devrait ressembler à l'image animée ci-dessous, affichant la reconnaissance de texte et les résultats d'identification de la langue, ainsi que le texte traduit dans la langue choisie. Vous pouvez choisir l'une des 59 langues.
8. Félicitations !
Félicitations ! Vous venez d'ajouter la reconnaissance de texte, l'identification de la langue et la traduction sur l'appareil à votre application à l'aide de ML Kit. Vous pouvez désormais reconnaître le texte et sa langue à partir du flux de caméra en direct, et traduire ce texte dans la langue de votre choix en temps réel.
Points abordés
- Ajouter ML Kit à votre application Android
- Utiliser la reconnaissance de texte sur l'appareil dans ML Kit pour reconnaître le texte dans les images
- Utiliser l'identification de la langue sur l'appareil dans ML Kit pour identifier la langue du texte
- Utiliser la traduction sur l'appareil dans ML Kit pour traduire du texte de manière dynamique dans 59 langues
- Utiliser CameraX en association avec les API ML Kit
Étapes suivantes
- Utilisez ML Kit et CameraX dans votre propre application Android.