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 vice versa).

Cette page explique comment commencer à utiliser le SDK client, ainsi que des options et des fonctionnalités de configuration supplémentaires, 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 des appareils spécifiques et est régie par les conditions d'utilisation de ML Kit, ainsi que par les conditions 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 davantage d'utilisateurs en tenant compte de la disponibilité du modèle sur l'appareil et de la connectivité Internet

Fonctionnalités 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 une sortie en streaming ou non. Elle est compatible avec les fonctionnalités de génération de texte suivantes :

Veillez à consulter la liste des fonctionnalités non encore disponibles pour l'inférence sur l'appareil 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 une liste des appareils compatibles et de leurs modèles sur l'appareil dans la documentation de ML Kit.

Commencer

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

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

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

  2. Dans la console Firebase, accédez à Services d'IA > AI Logic.

  3. Cliquez sur Commencer pour lancer un workflow guidé qui vous aidera à 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 à utiliser le Gemini Developer API. Vous pouvez toujours configurer l'Vertex AI Gemini API (et son exigence de facturation) à tout moment.

    Pour le 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 la base de 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 requis

Le Firebase AI Logic SDK pour Android (firebase-ai) et le Firebase AI Logic On-Device SDK (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) (par exemple, <project>/<app-module>/build.gradle.kts), ajoutez les dépendances pour les Firebase AI Logic bibliothèques 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.11.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.11.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 n'est pas disponible.

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.

Notez les points suivants concernant le téléchargement du modèle sur l'appareil :

  • Le temps nécessaire au téléchargement du 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é au début du 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 requête 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 (consultez les détails 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, en maintenant le modèle à jour, etc. Notez que seul un modèle sera téléchargé sur l'appareil. 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 en 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 spécifique au fournisseur et le code 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 le 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, revient au 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, revient 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 : Envoyez 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 de texte uniquement

Avant d'essayer cet exemple, assurez-vous d'avoir suivi les étapes de la section Commencer 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 de texte et d'image (multimodale)

Avant d'essayer cet exemple, assurez-vous d'avoir suivi les étapes de la section Commencer de ce guide.

Vous pouvez utiliser generateContent() pour générer du texte à partir d'un prompt 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 non encore disponibles pour l'inférence sur l'appareil

En tant que 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 une sortie structurée (comme JSON ou des enums)

  • Générer du texte à partir de types d'entrée 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 des requêtes multimodales. Vous devez fournir des fichiers en tant que données intégrées aux modèles sur l'appareil

  • Envoyer des requêtes dépassant 4 000 jetons (ou 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 une autre inférence via Firebase AI Logic.

Autres limites

En plus de ce qui précède, l'inférence sur l'appareil présente les limites suivantes (pour en savoir plus, consultez la documentation de 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, veillez à configurer un mode d'inférence qui peut 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 sortie longue (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. Un trop grand nombre de requêtes API envoyées sur une courte période entraînera une réponse ErrorCode.BUSY. Si vous recevez cette erreur, envisagez d'utiliser un intervalle exponentiel entre les tentatives pour réessayer 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).


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