Reconnaître, identifier la langue et traduire du texte avec ML Kit et CameraX: Android

1. Introduction

ML Kit est un SDK pour mobile qui intègre l'expertise de Google en matière de machine learning dans Android et les applications Android, dans 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. Pour commencer, vous n'avez pas besoin d'avoir des connaissances approfondies sur les réseaux de neurones ni sur l'optimisation des modèles.

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 sur 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 guidera à travers des étapes simples pour ajouter la reconnaissance de texte, l'identification de la langue et la traduction à partir du flux de caméra en temps réel dans votre application Android existante. Il mettra é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 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 ML Kit Language Identification 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 ML Kit Translation.

Au final, vous devriez obtenir un résultat semblable à l'image ci-dessous.

Points abordés

• Découvrez comment utiliser le SDK ML Kit pour ajouter facilement des fonctionnalités de machine learning à n'importe quelle application Android.
• API ML Kit de reconnaissance de texte, d'identification de la langue et de traduction, et leurs fonctionnalités.
• Comment utiliser la bibliothèque CameraX avec les API ML Kit.

Prérequis

• Une version récente d'Android Studio (version 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 consacré à 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 :

Télécharger le code source

Décompressez le fichier ZIP téléchargé. Cela a pour effet de décompresser 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 s'appuie 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 ( Exécuter)  dans la barre d'outils d'Android Studio.

L'application devrait se lancer sur votre appareil. Vous pouvez pointer l'appareil photo sur 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

Au cours de cette étape, nous allons ajouter à votre application la fonctionnalité de reconnaissance du 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. C'est ainsi que vous obtenez 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 à partir de l'appareil photo)

La bibliothèque CameraX fournit un flux d'images de l'appareil photo 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 frame d'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 appeler 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 de l'image terminée. Sinon, le flux vidéo en direct de la caméra 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 ensuite sur Run ( Exécuter)  dans la barre d'outils Android Studio. Une fois l'application chargée, elle devrait commencer à reconnaître le texte de l'appareil photo en temps réel. Dirigez l'appareil photo vers le texte à lire pour confirmer. Si votre application ne reconnaît aucun texte, essayez de "réinitialiser" la détection en pointant la caméra vers un espace vide avant de la pointer 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 à 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() du 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é dans l'image.

Remarque : Le texte détecté est stocké dans un objet appelé sourceText. Il s'agit d'un objet LiveData personnalisé qui n'informe les observateurs que lorsque la nouvelle valeur n'a pas changé pendant une certaine durée. Nous l'utilisons ici pour n'appeler la fonction d'identification de la langue que si le texte détecté est stable depuis 50 ms afin de réduire le scintillement. Pour savoir comment cela a été implémenté, consultez la classe SmoothedMutableLiveData.

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 ensuite sur Run ( Exécuter)  dans la barre d'outils Android Studio. Une fois l'application chargée, elle devrait commencer à reconnaître le texte de l'appareil photo et à identifier la langue du texte en temps réel. Dirigez l'appareil photo vers le texte à lire pour confirmer.

7. Ajouter une traduction

Remplacez la fonction translate() dans le code 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 ensuite sur Run ( Exécuter)  dans la barre d'outils Android Studio. Une fois l'application chargée, elle devrait ressembler à l'image animée ci-dessous, qui montre les résultats de la reconnaissance de texte et de la langue identifiée, 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 du texte et sa langue à partir du flux vidéo en direct de la caméra, puis le traduire en temps réel dans la langue de votre choix.

Points abordés

• Ajouter ML Kit à votre application Android
• Utiliser la reconnaissance de texte sur l'appareil dans ML Kit pour reconnaître du texte dans des images
• Utiliser l'identification de la langue sur l'appareil dans ML Kit pour identifier la langue d'un texte
• Utiliser la traduction sur l'appareil dans ML Kit pour traduire du texte de manière dynamique dans 59 langues
• Utiliser CameraX avec les API ML Kit

Étapes suivantes

• Utilisez ML Kit et CameraX dans votre propre application Android.

En savoir plus

• https://developers.google.com/docs/ml-kit
• https://developer.android.com/training/camerax