Guide sur la détection de la langue pour Android

La tâche "Détecteur de langue" MediaPipe vous permet d'identifier la langue d'un texte. Ces instructions vous expliquent comment utiliser le détecteur de langue avec les applications Android. L'exemple de code décrit dans ces instructions est disponible sur GitHub.

Pour voir cette tâche en action, regardez la démonstration. Pour en savoir plus sur les fonctionnalités, les modèles et les options de configuration de cette tâche, consultez la présentation.

Exemple de code

L'exemple de code pour le détecteur de langue fournit une implémentation simple de cette tâche à titre de référence. Ce code vous aide à tester cette tâche et à créer votre propre fonctionnalité de détection de la langue. Vous pouvez parcourir l'exemple de code du détecteur de langue sur GitHub.

Télécharger le code

Les instructions suivantes vous expliquent comment créer une copie locale de l'exemple de code à l'aide de l'outil de ligne de commande du contrôle des versions git.

Pour télécharger l'exemple de code, procédez comme suit:

Clonez le dépôt git à l'aide de la commande suivante :

git clone https://github.com/google-ai-edge/mediapipe-samples

Vous pouvez éventuellement configurer votre instance Git pour utiliser le paiement creux afin de n'avoir que les fichiers de l'application exemple de détecteur de langue :
```
cd mediapipe
git sparse-checkout init --cone
git sparse-checkout set examples/languagedetector/android
```

Pour savoir comment configurer et exécuter un exemple avec Android Studio, consultez les instructions de configuration d'exemple de code dans le guide de configuration pour Android.

Composants clés

Les fichiers suivants contiennent le code crucial de l'exemple d'application de classification de texte:

LanguageDetectorHelper.kt : initialise le détecteur de langue et gère la sélection du modèle.
ResultsAdapter.kt : gère et met en forme les résultats de la détection.
MainActivity.kt : met en œuvre l'application, y compris en appelant LanguageDetectorHelper et ResultsAdapter.

Préparation

Cette section décrit les étapes clés de la configuration de votre environnement de développement et de vos projets de code spécifiquement pour l'utilisation du détecteur de langage. Pour obtenir des informations générales sur la configuration de votre environnement de développement pour l'utilisation des tâches MediaPipe, y compris sur les exigences de version de la plate-forme, consultez le guide de configuration pour Android.

Dépendances

L'outil de détection de langue utilise les bibliothèques com.google.mediapipe:tasks-text. Ajoutez cette dépendance au fichier build.gradle de votre projet de développement d'application Android. Vous pouvez importer les dépendances requises à l'aide du code suivant:

dependencies {
    implementation 'com.google.mediapipe:tasks-text:latest.release'
}

Modèle

La tâche de détecteur de langue MediaPipe nécessite un modèle entraîné compatible avec cette tâche. Pour en savoir plus sur les modèles entraînés disponibles pour le détecteur de langue, consultez la section Modèles de la présentation des tâches.

Sélectionnez et téléchargez le modèle, puis stockez-le dans le répertoire de votre projet:

<dev-project-root>/src/main/assets

Spécifiez le chemin d'accès du modèle dans le paramètre ModelName.

Créer la tâche

Vous pouvez utiliser l'une des fonctions createFrom...() pour créer la tâche. La fonction createFromOptions() accepte les options de configuration pour le détecteur de langue. Vous pouvez également initialiser la tâche à l'aide de la fonction de fabrique createFromFile(). La fonction createFromFile() accepte un chemin d'accès relatif ou absolu au fichier du modèle entraîné. Pour en savoir plus sur la configuration des tâches, consultez la page Options de configuration.

Le code suivant montre comment créer et configurer cette tâche.

// For creating a language detector instance:
LanguageDetectorOptions options =
       LanguageDetectorOptions.builder()
       .setBaseOptions(
          BaseOptions.builder()
            .setModelAssetPath(modelPath)
            .build()
          )
       .build();
LanguageDetector languageDetector = LanguageDetector.createFromOptions(context, options);

Vous pouvez voir comment créer une tâche dans l'exemple de code de la fonction initDetector() de la classe LanguageDetectorHelper.

Options de configuration

Cette tâche dispose des options de configuration suivantes pour les applications Android:

Nom de l'option	Description	Plage de valeurs	Valeur par défaut
`maxResults`	Définit le nombre maximal (facultatif) de prédictions linguistiques mieux notées à renvoyer. Si cette valeur est inférieure à zéro, tous les résultats disponibles sont renvoyés.	Tout nombre positif	`-1`
`scoreThreshold`	Définit le seuil de score de prédiction qui remplace celui fourni dans les métadonnées du modèle (le cas échéant). Les résultats inférieurs à cette valeur sont refusés.	N'importe quelle valeur flottante	Non définie
`categoryAllowlist`	Définit la liste facultative des codes de langue autorisés. Si ce champ n'est pas vide, les prédictions de langue dont le code de langue ne figure pas dans cet ensemble seront filtrées. Cette option s'exclut mutuellement avec `categoryDenylist` et l'utilisation des deux résultats génère une erreur.	N'importe quelle chaîne	Non définie
`categoryDenylist`	Définit la liste facultative des codes de langue non autorisés. Si ce champ n'est pas vide, les prédictions de langue dont le code de langue fait partie de cet ensemble seront filtrées. Cette option s'exclut mutuellement avec `categoryAllowlist`. L'utilisation des deux résultats génère une erreur.	N'importe quelle chaîne	Non définie

Préparation des données

Le détecteur de langue fonctionne avec les données textuelles (String). Cette tâche gère le prétraitement de l'entrée des données, y compris la tokenisation et le prétraitement du Tensor. L'ensemble du prétraitement est géré dans la fonction detect(). Aucun prétraitement supplémentaire du texte d'entrée n'est nécessaire au préalable.

String inputText = "Some input text for the language detector";

Exécuter la tâche

Le détecteur de langue utilise la méthode LanguageDetector.detect() pour traiter le texte d'entrée et prédire sa langue. Vous devez utiliser un thread d'exécution distinct pour exécuter la détection afin d'éviter de bloquer le thread de l'interface utilisateur Android avec votre application.

Le code suivant montre comment exécuter le traitement avec le modèle de tâche à l'aide d'un thread d'exécution distinct.

// Predict the language of the input text.
fun classify(text: String) {
    executor = ScheduledThreadPoolExecutor(1)

    executor.execute {
        val results = languageDetector.detect(text)
        listener.onResult(results)
    }
}

Vous pouvez voir un exemple d'exécution d'une tâche dans l'exemple de code de la fonction detect() de la classe LanguageDetectorHelper.

Gérer et afficher les résultats

Le détecteur de langue renvoie un LanguageDetectorResult composé d'une liste de prédictions de langues et de leurs probabilités. Les catégories de langage sont définies dans le modèle. Consultez la section Modèles de la présentation des tâches pour en savoir plus sur le modèle que vous utilisez.

Voici un exemple des données de sortie de cette tâche:

LanguageDetectorResult:
  LanguagePrediction #0:
    language_code: "fr"
    probability: 0.999781

Vous avez obtenu ce résultat en exécutant le modèle sur le texte d'entrée : "Il y a beaucoup de bouches qui parlent et fort peu de têtes qui pensent.".

Vous pouvez voir comment afficher les résultats dans l'exemple de code de la classe ResultsAdapter et de la classe interne ViewHolder.