1. Introduction
ML Kit est un SDK pour mobile qui permet d'appliquer l'expertise en machine learning de Google aux applications Android et Android dans un package à la fois puissant et simple d'utilisation. Que vous débutiez ou que vous ayez de l'expérience 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 de neurones ou de l'optimisation de modèles pour vous lancer.
Comment ça marche ?
ML Kit permet d'appliquer facilement des techniques de ML dans vos applications en rassemblant dans un seul SDK les technologies de ML 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 avec seulement quelques lignes de code.
Cet atelier de programmation vous explique comment ajouter la reconnaissance de texte, l'identification de la langue et la traduction à partir du flux de l'appareil photo en temps réel dans votre application Android existante. Cet atelier de programmation présente également les bonnes pratiques d'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 de ML Kit sur l'appareil pour reconnaître du texte provenant du flux de l'appareil photo en temps réel. Il utilisera l'API d'identification de la langue de ML Kit pour identifier la langue du texte reconnu. Enfin, votre application traduira ce texte dans la langue de votre choix parmi les 59 options disponibles, à l'aide de l'API ML Kit Translation.
Au bout du compte, 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
- ML Kit : reconnaissance de texte, identification de la langue, API Translation et fonctionnalités associées.
- 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
- Vous disposez de connaissances de base en développement Android en Kotlin.
Cet atelier de programmation est consacré à ML Kit. Des concepts et des 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 opération a pour effet de décompresser un dossier racine (mlkit-android) contenant toutes les ressources dont vous avez 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 de ML Kit et de CameraX
Importez le projet de démarrage dans Android Studio. Dans le fichier app/build.gradle, vérifiez que les dépendances de ML Kit et de 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 de 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 et 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
Au cours de cette étape, nous allons ajouter à votre application une fonctionnalité permettant de reconnaître le texte de la caméra.
Instancier le détecteur de texte ML Kit
Remplacez TODO en haut de TextAnalyzer.kt pour instancier TextRecognition. C'est ainsi que vous obtenez un handle vers le programme de reconnaissance de texte que vous utiliserez dans les étapes suivantes. Nous devons également ajouter le détecteur en tant qu'observateur de 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. Remplacez la méthode recognizeText() dans la classe TextAnalyzer pour utiliser la reconnaissance de texte de ML Kit sur chaque cadre 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 une 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 en direct de la caméra ne pourra pas traiter d'autres images à des fins d'analyse.
TextAnalyzer.kt
recognizeText(InputImage.fromBitmap(croppedBitmap, 0)).addOnCompleteListener {
imageProxy.close()
}
Exécuter l'application sur votre appareil
Cliquez à présent sur Run (Exécuter) () dans la barre d'outils d'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 du texte pour confirmer. Si votre application ne reconnaît pas de texte, essayez de la réinitialiser la détection en pointant l'appareil photo vers un espace vide avant d'orienter l'appareil photo vers le texte.
6. Ajouter une identification linguistique
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 obtiendrez ainsi un identifiant pour l'identifiant de langue à utiliser à l'étape suivante.
MainViewModel.kt
private val languageIdentifier = LanguageIdentification.getClient(TextRecognizerOptions.DEFAULT_OPTIONS)
De plus, vous devez également 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 une 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.
Remplacez 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 non défini ("und"). Si la langue n'est pas définie, cela signifie que l'API n'a pas pu identifier la langue à partir de la liste des langues disponibles.
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 à présent sur Run (Exécuter) () dans la barre d'outils d'Android Studio. Une fois chargée, l'application 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 du texte 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, celle 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 poursuivons 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 à présent sur Run (Exécuter) () dans la barre d'outils d'Android Studio. Une fois l'application chargée, elle doit ressembler à l'image en mouvement ci-dessous, qui montre les résultats de reconnaissance de texte et de langues identifiées, 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 à votre application à l'aide de ML Kit. Vous pouvez désormais reconnaître du texte et sa langue à partir du flux en direct de la caméra, 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 du texte dans des 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.