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 d'obsolescence. Des modifications susceptibles d'affecter la rétrocompatibilité peuvent être apportées à cette API.

Avec l'API de synthèse GenAI de ML Kit, vous pouvez générer automatiquement des résumés d'articles et de conversations sous forme de liste à puces. Cela aide les utilisateurs à comprendre de grands volumes 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 chats, les e-mails, les notes et les rappels personnels traitent souvent des informations sensibles, ce qui rend le traitement sur l'appareil important pour la confidentialité des utilisateurs. De plus, les tâches de résumé, en particulier celles avec 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 GenAI Summarization couvre les fonctionnalités suivantes:

• Résumer du texte, classé comme article ou conversation
• Résumer les résultats en une, deux ou trois puces.

Commencer

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

Ajoutez l'API de résumé 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 objet Summarizer.
2. Téléchargez la fonctionnalité si elle est téléchargeable.
3. Créez une requête de résumé.
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-t-il les 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 fournissant une meilleure compréhension de la conversation et des interactions.

Fonctionnalités compatibles et limites

L'entrée ne doit pas dépasser 4 000 jetons (ou 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 cette approche donne généralement de bons résultats pour les entrées plus longues. Envisagez d'activer la coupure automatique en appelant setLongInputAutoTruncationEnabled afin que l'entrée supplémentaire soit automatiquement tronquée.
• Divisez l'entrée en groupes de 4 000 jetons et résumez-les individuellement.
• Envisagez une solution cloud plus adaptée à la saisie de données plus volumineuses.

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

L'API GenAI Summarization est disponible en anglais, en coréen et en japonais. Elle est définie dans SummarizerOptions.Language.

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

Le moyen le plus fiable pour les développeurs de s'assurer que la fonctionnalité d'API prévue est compatible avec un appareil avec le SummarizerOptions demandé consiste à appeler la méthode checkFeatureStatus(). 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 différences matérielles entre les différents types d'appareils peuvent entraîner des différences entre les versions du modèle de base Gemini Nano et, par conséquent, entre les sorties de l'API ML Kit GenAI. Des adaptateurs LoRA sont appliqués pour atténuer les différences.

Problèmes de configuration courants

Remarque :Cette API n'est pas compatible avec les appareils dotés d'un démarreur de système d'exploitation déverrouillé.

Les API GenAI de 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, en effaçant les données, en désinstallant puis en réinstallant l'application), il est possible qu'elle n'ait pas le temps de terminer l'initialisation (y compris de télécharger les dernières configurations à partir du serveur). Par conséquent, les API ML Kit GenAI risquent de ne pas fonctionner comme prévu. Voici les messages d'erreur de configuration courants que vous pouvez rencontrer et les solutions à appliquer:

Exemple de message d'erreur	Comment gérer
É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 ML Kit GenAI immédiatement après la configuration de l'appareil ou lorsque AICore est désinstallé après l'installation de votre application. Mettez à jour l'application AICore, puis réinstallez votre application. Le problème devrait être résolu.
É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. Laissez la connexion réseau active et attendez quelques minutes à quelques heures. 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: la fonctionnalité ... a échoué avec l'état d'échec 0 et l'erreur esz: UNAVAILABLE: Unable to resolve host ...	Laissez la connexion réseau active, patientez quelques minutes, puis réessayez.

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