Créer des expériences hybrides dans les applications Android avec des modèles hébergés sur l'appareil et dans le cloud


Vous pouvez créer des applications et des fonctionnalités Android optimisées par l'IA avec l'inférence hybride à l'aide de Firebase AI Logic. L'inférence hybride permet d'exécuter l'inférence à l'aide de modèles sur l'appareil lorsqu'ils sont disponibles et de revenir de manière transparente aux modèles hébergés dans le cloud dans le cas contraire (et inversement).

Cette page explique comment démarrer avec le SDK client et présente d'autres options et fonctionnalités de configuration, comme la température.

Notez que l'inférence sur l'appareil via Firebase AI Logic est compatible avec les applications Android exécutées sur certains appareils et est régie par les Conditions d'utilisation de ML Kit, ainsi que par les Conditions d'utilisation spécifiques aux aspects d'IA générative de ML Kit.

Cas d'utilisation recommandés et fonctionnalités compatibles

Cas d'utilisation recommandés

  • L'utilisation d'un modèle sur l'appareil pour l'inférence offre les avantages suivants :

    • Confidentialité renforcée
    • Contexte local
    • Inférence sans frais
    • Fonctionnalités hors connexion

  • L'utilisation de la fonctionnalité hybride offre les avantages suivants :

    • Toucher une plus grande partie de votre audience en tenant compte de la disponibilité des modèles sur l'appareil et de la connectivité Internet

Fonctionnalités et caractéristiques compatibles pour l'inférence sur l'appareil

L'inférence sur l'appareil n'est compatible qu'avec la génération de texte en un seul tour (pas le chat), avec ou sans flux de sortie. Il est compatible avec les fonctionnalités de génération de texte suivantes :

Veillez à consulter la liste des fonctionnalités d'inférence sur l'appareil qui ne sont pas encore disponibles en bas de cette page.

Avant de commencer

Veuillez noter les points suivants :

Appareils Android compatibles et leurs modèles sur l'appareil

Pour l'inférence sur l'appareil (qui utilise l'API Prompt de ML Kit), vous trouverez la liste des appareils compatibles et de leurs modèles sur l'appareil dans la documentation ML Kit.

Commencer

Ces étapes de démarrage décrivent la configuration générale requise pour toute demande de prompt compatible que vous souhaitez envoyer.

Étape 1 : Configurez un projet Firebase et associez votre application à Firebase

  1. Connectez-vous à la console Firebase, puis sélectionnez votre projet Firebase.

  2. Dans la console Firebase, accédez à la page Firebase AI Logic.

  3. Cliquez sur Premiers pas pour lancer un workflow guidé qui vous aide à configurer les API requises et les ressources pour votre projet.

  4. Configurez votre projet pour utiliser un fournisseur "Gemini API".

    Nous vous recommandons de commencer par utiliser Gemini Developer API. À tout moment, vous pouvez configurer Vertex AI Gemini API (et ses exigences de facturation).

    Pour Gemini Developer API, la console activera les API requises et créera une clé API Gemini dans votre projet.
    N'ajoutez pas cette clé API Gemini dans le code de votre application. En savoir plus

  5. Si vous y êtes invité dans le workflow de la console, suivez les instructions à l'écran pour enregistrer votre application et la connecter à Firebase.

  6. Passez à l'étape suivante de ce guide pour ajouter le SDK à votre application.

Étape 2 : Ajoutez les SDK nécessaires

Le SDK Firebase AI Logic pour Android (firebase-ai) et le SDK Firebase AI Logic On-Device (firebase-ai-ondevice) permettent d'accéder aux API pour interagir avec les modèles génératifs.

Dans le fichier Gradle de votre module (au niveau de l'application) (comme <project>/<app-module>/build.gradle.kts), ajoutez les dépendances pour les bibliothèques Firebase AI Logic pour Android :

Kotlin 

dependencies {
  // ... other androidx dependencies

  // Add the dependencies for the Firebase AI Logic libraries
  // Note that the on-device SDK is not yet included in the Firebase Android BoM
  implementation("com.google.firebase:firebase-ai:17.10.0")
  implementation("com.google.firebase:firebase-ai-ondevice:16.0.0-beta01")
}

Java

Pour Java, vous devez ajouter deux bibliothèques supplémentaires.

dependencies {
  // ... other androidx dependencies

  // Add the dependencies for the Firebase AI Logic libraries
  // Note that the on-device SDK is not yet included in the Firebase Android BoM
  implementation("com.google.firebase:firebase-ai:17.10.0")
  implementation("com.google.firebase:firebase-ai-ondevice:16.0.0-beta01")

  // Required for one-shot operations (to use `ListenableFuture` from Guava Android)
  implementation("com.google.guava:guava:31.0.1-android")

  // Required for streaming operations (to use `Publisher` from Reactive Streams)
  implementation("org.reactivestreams:reactive-streams:1.0.4")
}

Étape 3 : Vérifiez si le modèle sur l'appareil est disponible

À l'aide de FirebaseAIOnDevice, vérifiez si le modèle sur l'appareil est disponible et téléchargez-le s'il ne l'est pas.

Une fois téléchargé, AICore maintiendra automatiquement le modèle à jour. Consultez les notes après l'extrait pour en savoir plus sur AICore et sur la gestion du téléchargement du modèle sur l'appareil.

Kotlin 

val status = FirebaseAIOnDevice.checkStatus()
when (status) {
  OnDeviceModelStatus.UNAVAILABLE -> {
    Log.w(TAG, "On-device model is unavailable")
  }

  OnDeviceModelStatus.DOWNLOADABLE -> {
    FirebaseAIOnDevice.download().collect { status ->
      when (status) {
        is DownloadStatus.DownloadStarted ->
          Log.w(TAG, "Starting download - ${status.bytesToDownload}")

        is DownloadStatus.DownloadInProgress ->
          Log.w(TAG, "Download in progress ${status.totalBytesDownloaded} bytes downloaded")

        is DownloadStatus.DownloadCompleted ->
          Log.w(TAG, "On-device model download complete")

        is DownloadStatus.DownloadFailed ->
          Log.e(TAG, "Download failed ${status}")
      }
    }
  }
  OnDeviceModelStatus.DOWNLOADING -> {
    Log.w(TAG, "On-device model is being downloaded")
  }

  OnDeviceModelStatus.AVAILABLE -> {
    Log.w(TAG, "On-device model is available")
  }
}

Java 

Checking for and downloading the model is not yet available for Java.

However, all other APIs and interactions in this guide are available for Java.

Voici quelques points à noter concernant le téléchargement du modèle sur l'appareil :

  • Le temps nécessaire pour télécharger le modèle sur l'appareil dépend de nombreux facteurs, y compris de votre réseau.

  • Si votre code utilise un modèle sur l'appareil pour son inférence principale ou de secours, assurez-vous que le modèle est téléchargé tôt dans le cycle de vie de votre application afin qu'il soit disponible avant que vos utilisateurs finaux ne rencontrent le code dans votre application.

  • Si le modèle sur l'appareil n'est pas disponible lorsqu'une demande d'inférence sur l'appareil est effectuée, le SDK ne déclenchera pas automatiquement le téléchargement du modèle sur l'appareil. Le SDK reviendra au modèle hébergé dans le cloud ou générera une exception (pour en savoir plus sur le comportement des modes d'inférence).

  • AICore (un service système Android) gère pour vous le modèle et la version téléchargés, la mise à jour du modèle, etc. Notez que l'appareil ne téléchargera qu'un seul modèle. Par conséquent, si une autre application sur l'appareil a déjà téléchargé le modèle sur l'appareil, cette vérification indiquera que le modèle est disponible.

Optimisation de la latence

Pour optimiser le premier appel d'inférence, vous pouvez demander à votre application d'appeler warmup(). Cela charge le modèle sur l'appareil dans la mémoire et initialise les composants d'exécution.

Étape 4 : Initialisez le service et créez une instance de modèle

Cliquez sur votre fournisseur Gemini API pour afficher le contenu et le code spécifiques à ce fournisseur sur cette page.

Configurez les éléments suivants avant d'envoyer une requête de prompt au modèle.

  1. Initialisez le service pour le fournisseur d'API de votre choix.

  2. Créez une instance GenerativeModel et définissez mode sur l'une des valeurs suivantes. Les descriptions fournies ici sont très générales, mais vous pouvez en savoir plus sur le comportement de ces modes dans Définir un mode d'inférence.

    • PREFER_ON_DEVICE : tente d'utiliser le modèle sur l'appareil. Sinon, reprend le modèle hébergé dans le cloud.

    • ONLY_ON_DEVICE : tente d'utiliser le modèle sur l'appareil. Sinon, génère une exception.

    • PREFER_IN_CLOUD : tente d'utiliser le modèle hébergé dans le cloud. Sinon, repasser au modèle sur l'appareil.

    • ONLY_IN_CLOUD : tente d'utiliser le modèle hébergé dans le cloud. Sinon, génère une exception.

Kotlin 

// Using this SDK to access on-device inference is an Experimental release and requires opt-in
@OptIn(PublicPreviewAPI::class)

// ...

// Initialize the Gemini Developer API backend service
// Create a GenerativeModel instance with a model that supports your use case
// Set the inference mode (like PREFER_ON_DEVICE to use the on-device model if available)
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
    .generativeModel(
        modelName = "MODEL_NAME",
        onDeviceConfig = OnDeviceConfig(mode = InferenceMode.PREFER_ON_DEVICE)
    )

Java 

// Initialize the Gemini Developer API backend service
// Create a GenerativeModel instance with a model that supports your use case
// Set the inference mode (like PREFER_ON_DEVICE to use the on-device model if available)
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())
    .generativeModel(
        "MODEL_NAME",
        new OnDeviceConfig(InferenceMode.PREFER_ON_DEVICE)
    );

// Use the GenerativeModelFutures Java compatibility layer which offers
// support for ListenableFuture and Publisher APIs
GenerativeModelFutures model = GenerativeModelFutures.from(ai);

Étape 5 : Envoyer une requête de prompt à un modèle

Cette section vous explique comment envoyer différents types d'entrées pour générer différents types de sorties, y compris :

Générer du texte à partir d'une entrée textuelle

Avant d'essayer cet exemple, assurez-vous d'avoir terminé la section Premiers pas de ce guide.

Vous pouvez utiliser generateContent() pour générer du texte à partir d'un prompt contenant du texte :

Kotlin 

// Imports + initialization of Gemini API backend service + creation of model instance

// Provide a prompt that contains text
val prompt = "Write a story about a magic backpack."

// To generate text output, call generateContent with the text input
val response = model.generateContent(prompt)
print(response.text)

Java 

// Imports + initialization of Gemini API backend service + creation of model instance

// Provide a prompt that contains text
Content prompt = new Content.Builder()
    .addText("Write a story about a magic backpack.")
    .build();

// To generate text output, call generateContent with the text input
ListenableFuture<GenerateContentResponse> response = model.generateContent(prompt);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        String resultText = result.getText();
        System.out.println(resultText);
    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

Notez que Firebase AI Logic est également compatible avec le streaming des réponses textuelles à l'aide de generateContentStream (au lieu de generateContent).

Générer du texte à partir d'une entrée texte et image (multimodale)

Avant d'essayer cet exemple, assurez-vous d'avoir terminé la section Premiers pas de ce guide.

Vous pouvez utiliser generateContent() pour générer du texte à partir d'une requête contenant du texte et jusqu'à un fichier image (bitmap uniquement), en fournissant le mimeType de chaque fichier d'entrée et le fichier lui-même.

Kotlin 

// Imports + initialization of Gemini API backend service + creation of model instance

// Loads an image from the app/res/drawable/ directory
val bitmap: Bitmap = BitmapFactory.decodeResource(resources, R.drawable.sparky)

// Provide a prompt that includes the image specified above and text
val prompt = content {
  image(bitmap)
  text("What developer tool is this mascot from?")
}

// To generate text output, call generateContent with the prompt
val response = model.generateContent(prompt)
print(response.text)

Java 

// Imports + initialization of Gemini API backend service + creation of model instance

Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.sparky);

// Provide a prompt that includes the image specified above and text
Content content = new Content.Builder()
        .addImage(bitmap)
        .addText("What developer tool is this mascot from?")
        .build();

// To generate text output, call generateContent with the prompt
ListenableFuture<GenerateContentResponse> response = model.generateContent(content);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        String resultText = result.getText();
        System.out.println(resultText);
    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

Notez que Firebase AI Logic est également compatible avec le streaming des réponses textuelles à l'aide de generateContentStream (au lieu de generateContent).

Qu'est-ce que tu sais faire d'autre ?

Vous pouvez utiliser différentes options et fonctionnalités de configuration supplémentaires pour vos expériences hybrides :

Fonctionnalités pas encore disponibles pour l'inférence sur l'appareil

Étant donné qu'il s'agit d'une version expérimentale, toutes les fonctionnalités des modèles cloud ne sont pas disponibles pour l'inférence sur l'appareil.

Les fonctionnalités listées dans cette section ne sont pas encore disponibles pour l'inférence sur l'appareil. Si vous souhaitez utiliser l'une de ces fonctionnalités, nous vous recommandons d'utiliser le mode d'inférence ONLY_IN_CLOUD pour une expérience plus cohérente.

  • Générer des résultats structurés (comme JSON ou des énumérations)

  • Génération de texte à partir de types de fichiers image autres que Bitmap (image chargée en mémoire)

  • Générer du texte à partir de plusieurs fichiers image

  • Générer du texte à partir d'entrées audio, vidéo et de documents (comme des PDF)

  • Générer des images à l'aide des modèles Gemini ou Imagen

  • Fournir des fichiers à l'aide d'URL dans les requêtes multimodales. Vous devez fournir des fichiers sous forme de données intégrées aux modèles sur l'appareil.

  • Envoi de requêtes dépassant 4 000 jetons (environ 3 000 mots en anglais).

  • Chat multitour

  • Fournir au modèle des outils pour l'aider à générer sa réponse (comme l'appel de fonction, l'exécution de code, le contexte d'URL et l'ancrage avec la recherche Google)

La surveillance de l'IA dans la console Firebase n'affiche pas de données pour l'inférence sur l'appareil (y compris les journaux sur l'appareil). Toutefois, toute inférence qui utilise un modèle hébergé dans le cloud peut être surveillée comme les autres inférences via Firebase AI Logic.

Autres limites

En plus de ce qui précède, l'inférence sur l'appareil présente leslimitations suivantes (pour en savoir plus, consultez la documentation ML Kit) :

  • L'utilisateur final de votre application doit utiliser un appareil compatible pour l'inférence sur l'appareil.

  • Votre application ne peut exécuter l'inférence sur l'appareil que lorsqu'elle est au premier plan.

  • Seuls l'anglais et le coréen ont été validés pour l'inférence sur l'appareil.

  • La limite maximale de jetons pour l'ensemble de la requête d'inférence sur l'appareil est de 4 000 jetons. Si vos requêtes sont susceptibles de dépasser cette limite, assurez-vous de configurer un mode d'inférence pouvant utiliser un modèle hébergé dans le cloud.

  • Nous vous recommandons d'éviter les cas d'utilisation d'inférence sur l'appareil qui nécessitent une longue sortie (plus de 256 jetons).

  • AICore (un service système Android qui gère les modèles sur l'appareil) applique un quota d'inférence par application. Si vous effectuez trop de requêtes d'API sur une courte période, vous recevrez une réponse ErrorCode.BUSY. Si vous recevez cette erreur, envisagez d'utiliser un intervalle exponentiel entre les tentatives pour relancer la requête. De plus, ErrorCode.PER_APP_BATTERY_USE_QUOTA_EXCEEDED peut être renvoyé si une application dépasse un quota de longue durée (par exemple, un quota quotidien).


Envoyer des commentaires sur votre expérience avec Firebase AI Logic