API GenAI Summarization

Cette API est proposée en version bêta et n'est soumise à aucun contrat de niveau de service ni aucun règlement relatif aux abandons. Des modifications peuvent être apportées à cette API, ce qui peut entraîner une rupture de la rétrocompatibilité.

Avec l'API de synthèse d'IA générative de ML Kit, vous pouvez générer automatiquement des résumés d'articles et de conversations sous forme de liste à puces. Cela permet aux utilisateurs de comprendre de grands blocs de texte.

La synthèse bénéficie de l'IA générative sur l'appareil, car elle répond aux préoccupations concernant la confidentialité des données et l'efficacité des coûts. Les applications qui résument les discussions personnelles, les e-mails, les notes et les rappels traitent souvent des informations sensibles. Il est donc important de les traiter sur l'appareil pour protéger la confidentialité des utilisateurs. De plus, les tâches de synthèse, en particulier celles qui comportent des contextes longs ou de nombreux éléments, peuvent nécessiter une puissance de traitement importante. Le traitement de ce contenu sur l'appareil réduit la charge du serveur et les coûts de diffusion, tout en préservant la confidentialité des données utilisateur.

Capacités clés

L'API de synthèse d'IA générative couvre les fonctionnalités suivantes :

• Synthétiser du texte, classé comme article ou conversation.
• Générer un résumé en un, deux ou trois points.

Premiers pas

**Remarque** : Cette API nécessite le niveau d'API Android 26 ou supérieur.

Ajoutez l'API de synthèse ML Kit en tant que dépendance dans votre configuration build.gradle.

implementation("com.google.mlkit:genai-summarization:1.0.0-beta1")

Ensuite, implémentez le code dans votre projet :

1. Créez un Summarizer objet.
2. Téléchargez la fonctionnalité si elle est téléchargeable.
3. Créez une requête de synthèse.
4. Exécutez l'inférence et récupérez le résultat.

Kotlin

val articleToSummarize = "Announcing a set of on-device GenAI APIs..."

// Define task with required input type, output type, and language
val summarizerOptions = SummarizerOptions.builder(context)
    .setInputType(InputType.ARTICLE)
    .setOutputType(OutputType.ONE_BULLET)
    .setLanguage(Language.ENGLISH)
    .build()
val summarizer = Summarization.getClient(summarizerOptions)

suspend fun prepareAndStartSummarization() {
    // Check feature availability. Status will be one of the following:
    // UNAVAILABLE, DOWNLOADABLE, DOWNLOADING, AVAILABLE
    val featureStatus = summarizer.checkFeatureStatus().await()

    if (featureStatus == FeatureStatus.DOWNLOADABLE) {
        // Download feature if necessary. If downloadFeature is not called,
        // the first inference request will also trigger the feature to be
        // downloaded if it's not already downloaded.
        summarizer.downloadFeature(object : DownloadCallback {
            override fun onDownloadStarted(bytesToDownload: Long) { }

            override fun onDownloadFailed(e: GenAiException) { }

            override fun onDownloadProgress(totalBytesDownloaded: Long) {}

            override fun onDownloadCompleted() {
                startSummarizationRequest(articleToSummarize, summarizer)
            }
        })
    } else if (featureStatus == FeatureStatus.DOWNLOADING) {
        // Inference request will automatically run once feature is
        // downloaded. If Gemini Nano is already downloaded on the device,
        // the feature-specific LoRA adapter model will be downloaded
        // quickly. However, if Gemini Nano is not already downloaded, the
        // download process may take longer.
        startSummarizationRequest(articleToSummarize, summarizer)
    } else if (featureStatus == FeatureStatus.AVAILABLE) {
        startSummarizationRequest(articleToSummarize, summarizer)
    }
}

fun startSummarizationRequest(text: String, summarizer: Summarizer) {
    // Create task request
    val summarizationRequest = SummarizationRequest.builder(text).build()

    // Start summarization request with streaming response
    summarizer.runInference(summarizationRequest) { newText ->
        // Show new text in UI
    }

    // You can also get a non-streaming response from the request
    // val summarizationResult = summarizer.runInference(
    //     summarizationRequest).get().summary
}

// Be sure to release the resource when no longer needed
// For example, on viewModel.onCleared() or activity.onDestroy()
summarizer.close()

Java

String articleToSummarize = "Announcing: a set of on-device GenAI AI APIs.";

// Define task with required input type, output type, and language
SummarizerOptions summarizerOptions = 
    SummarizerOptions.builder(context)
        .setInputType(SummarizerOptions.InputType.ARTICLE)
        .setOutputType(SummarizerOptions.OutputType.ONE_BULLET)
        .setLanguage(SummarizerOptions.Language.ENGLISH)
        .build();
Summarizer summarizer = Summarization.getClient(summarizerOptions);

void prepareAndStartSummarization()
        throws ExecutionException, InterruptedException {
    // Check feature availability. Status will be one of the following:
    // UNAVAILABLE, DOWNLOADABLE, DOWNLOADING, AVAILABLE
    try {
        int featureStatus = summarizer.checkFeatureStatus().get();
        if (featureStatus == FeatureStatus.DOWNLOADABLE) {
            // Download feature if necessary.
            // If downloadFeature is not called, the first inference request
            // will also trigger the feature to be downloaded if it's not
            // already downloaded.
            summarizer.downloadFeature(new DownloadCallback() {
                @Override
                public void onDownloadCompleted() {
                    startSummarizationRequest(articleToSummarize, summarizer);
                }

                @Override
                public void onDownloadFailed(GenAiException e) { /* handle error */ }

                @Override
                public void onDownloadProgress(long totalBytesDownloaded) {}

                @Override
                public void onDownloadStarted(long bytesDownloaded) {}
            });
        } else if (featureStatus == FeatureStatus.DOWNLOADING) {
            // Inference request will automatically run once feature is
            // downloaded. If Gemini Nano is already downloaded on the
            // device, the feature-specific LoRA adapter model will be
            // downloaded quickly. However, if Gemini Nano is not already
            // downloaded, the download process may take longer.
            startSummarizationRequest(articleToSummarize, summarizer);
        } else if (featureStatus == FeatureStatus.AVAILABLE) {
            startSummarizationRequest(articleToSummarize, summarizer);
        }
    } catch (ExecutionException | InterruptedException e) {
        e.printStackTrace();
    }
}

void startSummarizationRequest(String text, Summarizer summarizer) {
    // Create task request
    SummarizationRequest summarizationRequest =
        SummarizationRequest.builder(text).build();

    // Start summarization request with streaming response
    summarizer.runInference(summarizationRequest, newText -> {
        // Show new text in UI
    });

    // You can also get a non-streaming response from the request
    // ListenableFuture<SummarizationResult> summarizationResult
    //         = summarizer.runInference(summarizationRequest);
    // String summary = summarizationResult.get().getSummary();
}

// Be sure to release the resource when no longer needed
// For example, on viewModel.onCleared() or activity.onDestroy()
summarizer.close();

Comment le modèle gère différents types d'entrée

Lorsque l'entrée de texte est spécifiée comme InputType.CONVERSATION, le modèle attend une entrée au format suivant :

<name>: <message>
<name2>: <message2>
<name>: <message3>
<name3>: <message4>

Cela permet au modèle de produire un résumé plus précis en offrant une meilleure compréhension de la conversation et des interactions.

Fonctionnalités et limites compatibles

L'entrée doit comporter moins de 4 000 jetons (soit environ 3 000 mots en anglais). Si l'entrée dépasse 4 000 jetons, envisagez les options suivantes :

• Priorisez la synthèse des 4 000 premiers jetons. Les tests indiquent que cela donne généralement de bons résultats pour les entrées plus longues. Envisagez d'activer la troncature automatique en appelant setLongInputAutoTruncationEnabled afin que l'entrée supplémentaire soit automatiquement tronquée.
• Segmentez l'entrée en groupes de 4 000 jetons et résumez-les individuellement.
• Envisagez une solution cloud plus adaptée à l'entrée plus volumineuse.

Pour InputType.ARTICLE, l'entrée doit également comporter plus de 400 caractères. Le modèle fonctionne de manière optimale lorsque l'article comporte au moins 300 mots.

L'API de synthèse d'IA générative est compatible avec l'anglais, le coréen et le japonais, et est définie dans SummarizerOptions.Language.

La disponibilité de la configuration de fonctionnalité spécifique (spécifiée par SummarizerOptions) peut varier en fonction de la configuration de l'appareil et des modèles téléchargés sur l'appareil.

Pour les développeurs, le moyen le plus fiable de s'assurer que la fonctionnalité d'API souhaitée est compatible avec un appareil doté des SummarizerOptions demandées consiste à appeler la checkFeatureStatus() méthode. Cette méthode fournit l'état définitif de la disponibilité des fonctionnalités sur l'appareil au moment de l'exécution.

Remarque : Les variations matérielles entre les différents types d'appareils peuvent entraîner des différences dans les versions du modèle de base Gemini Nano et, par conséquent, dans les sorties de l'API d'IA générative ML Kit. Les adaptateurs LoRA sont appliqués pour atténuer ces différences.

Problèmes de configuration courants

**Remarque** : Cette API n'est pas compatible avec les appareils dont le bootloader est déverrouillé.

Les API d'IA générative ML Kit s'appuient sur l'application Android AICore pour accéder à Gemini Nano. Lorsqu'un appareil vient d'être configuré (y compris réinitialisé) ou que l'application AICore vient d'être réinitialisée (par exemple, effacement des données, désinstallation puis réinstallation), il est possible que l'application AICore n'ait pas suffisamment de temps pour terminer l'initialisation (y compris le téléchargement des dernières configurations à partir du serveur). Par conséquent, les API d'IA générative ML Kit peuvent ne pas fonctionner comme prévu. Voici les messages d'erreur de configuration courants que vous pouvez rencontrer et comment les gérer :

Exemple de message d'erreur	Comment répondre à une telle objection
Échec d'AICore avec le type d'erreur 4-CONNECTION_ERROR et le code d'erreur 601-BINDING_FAILURE : échec de la liaison du service AICore.	Cela peut se produire lorsque vous installez l'application à l'aide des API d'IA générative ML Kit immédiatement après la configuration de l'appareil ou lorsque AICore est désinstallé après l'installation de votre application. La mise à jour de l'application AICore, puis la réinstallation de votre application devraient résoudre le problème.
Échec d'AICore avec le type d'erreur 3-PREPARATION_ERROR et le code d'erreur 606-FEATURE_NOT_FOUND : la fonctionnalité ... n'est pas disponible.	Cela peut se produire lorsque AICore n'a pas terminé de télécharger les dernières configurations. Lorsque l'appareil est connecté à Internet, la mise à jour prend généralement de quelques minutes à quelques heures. Le redémarrage de l'appareil peut accélérer la mise à jour. Notez que si le bootloader de l'appareil est déverrouillé, cette erreur s'affiche également. Cette API n'est pas compatible avec les appareils dont le bootloader est déverrouillé.
Échec d'AICore avec le type d'erreur 1-DOWNLOAD_ERROR et le code d'erreur 0-UNKNOWN : échec de la fonctionnalité ... avec l'état d'échec 0 et l'erreur esz : UNAVAILABLE : impossible de résoudre l'hôte ...	Maintenez la connexion réseau, attendez quelques minutes, puis réessayez.

Remarque : Les réinitialisations sont courantes pour les développeurs, mais beaucoup moins fréquentes pour les utilisateurs. De plus, tous ces cas d'échec de configuration peuvent être détectés par les API checkFeatureStatus() ou checkStatus(). Veillez à appeler checkFeatureStatus() ou checkStatus() avant d'afficher une interface utilisateur associée, afin que les utilisateurs de votre application ne voient jamais ces erreurs.

Exemple de code

• Exemples d'IA générative ML Kit