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


Créez des applications et des fonctionnalités 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 passer sans problème aux modèles hébergés dans le cloud dans le cas contraire.

Avec cette version, l'inférence hybride est disponible à l'aide du SDK client Firebase AI Logic pour le Web, avec prise en charge de l'inférence sur l'appareil pour Chrome sur ordinateur.

Accéder aux exemples de code

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

  • Utiliser les offres de fonctionnalités hybrides:

    • Touchez 100% de votre audience, quelle que soit la disponibilité du modèle sur l'appareil

Fonctionnalités compatibles pour l'inférence sur l'appareil:

  • Génération de contenu à un seul tour, en streaming et hors streaming
  • Générer du texte à partir d'une entrée textuelle
  • Générer du texte à partir d'une entrée de texte et d'image, en particulier des types d'images JPEG et PNG
  • Générer une sortie structurée, y compris JSON et énumérations

Premiers pas

Ce guide vous explique comment commencer à utiliser le SDK Firebase AI Logic pour le Web afin d'effectuer une inférence hybride.

L'inférence à l'aide d'un modèle sur l'appareil utilise l'API Prompt de Chrome, tandis que l'inférence à l'aide d'un modèle hébergé dans le cloud utilise le fournisseur Gemini API de votre choix (Gemini Developer API ou Vertex AI Gemini API).

Étape 1: Configurez Chrome et l'API Prompt pour l'inférence sur l'appareil

  1. Téléchargez le dernier build Chrome Dev.

    L'inférence sur l'appareil est disponible à partir de la version 138 de Chrome.

  2. Activez l'API Prompt pour votre instance Chrome en définissant les indicateurs suivants:

    • chrome://flags/#optimization-guide-on-device-model: définissez cette valeur sur Enabled (Activé).
    • chrome://flags/#prompt-api-for-gemini-nano: définissez cette valeur sur Enabled (Activé).

    Pour en savoir plus sur l'utilisation des API sur localhost, consultez la documentation Chrome. Vous pouvez également rejoindre le programme Preview anticipé (EPP) de Chrome pour nous faire part de vos commentaires.

  3. Activez le modèle multimodal sur l'appareil en définissant l'indicateur suivant:

    • chrome://flags/#prompt-api-for-gemini-nano-multimodal-input : défini sur Enabled (Activé).

  4. Vérifiez l'API en local:

    1. Redémarrez Chrome.

    2. Ouvrez Outils pour les développeurs > Console.

    3. Exécutez la commande suivante :

      await LanguageModel.availability();

    4. Assurez-vous que la sortie est available, downloading ou downloadable. .

    5. Si la sortie est downloadable, vous pouvez démarrer le téléchargement du modèle en exécutant await LanguageModel.create();. Sinon, la première requête d'inférence sur l'appareil démarrera un téléchargement de modèle en arrière-plan, ce qui peut prendre plusieurs minutes.

Étape 2: Configurer un projet Firebase et associer 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 Commencer pour lancer un workflow guidé qui vous aide à configurer les API requises et les ressources de votre projet.

  4. Sélectionnez le fournisseur "Gemini API" que vous souhaitez utiliser avec les SDK Firebase AI Logic. Vous pourrez toujours configurer et utiliser l'autre fournisseur d'API plus tard, si vous le souhaitez.

    • Gemini Developer API : facturation facultative (disponible avec le forfait Spark sans frais)
      La console active les API requises et crée une clé API Gemini dans votre projet.
      N'ajoutez pas cette clé API Gemini au code de votre application. En savoir plus

      Vous pourrez configurer la facturation ultérieurement si vous souhaitez passer à un forfait supérieur.

    • Vertex AI Gemini API : facturation requise (nécessite le forfait Blaze au paiement à l'usage)
      La console vous aidera à configurer la facturation et à activer les API requises dans votre projet.

  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 3: Ajouter le SDK

La bibliothèque Firebase permet d'accéder aux API pour interagir avec les modèles génératifs. La bibliothèque est incluse dans le SDK JavaScript Firebase pour le Web.

  1. Installez le SDK JS Firebase pour le Web à l'aide de npm.

    La fonctionnalité hybride est publiée sous une autre balise npm. Veillez donc à l'inclure dans votre commande d'installation.

    npm install firebase@eap-ai-hybridinference

  2. Initialisez Firebase dans votre application:

    import { initializeApp } from "firebase/app";

// TODO(developer) Replace the following with your app's Firebase configuration
// See: https://firebase.google.com/docs/web/learn-more#config-object
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp
const firebaseApp = initializeApp(firebaseConfig);

É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.

Avant d'envoyer une invite à un modèle Gemini, initialisez le service pour le fournisseur d'API de votre choix et créez une instance GenerativeModel.

Définissez mode sur l'une des valeurs suivantes:

  • prefer_on_device: configure le SDK pour qu'il utilise le modèle sur l'appareil s'il est disponible, ou qu'il utilise le modèle hébergé dans le cloud.

  • only_on_device: configure le SDK pour qu'il utilise le modèle sur l'appareil ou génère une exception.

  • only_in_cloud: configure le SDK pour qu'il n'utilise jamais le modèle sur l'appareil.

Par défaut, lorsque vous utilisez prefer_on_device ou only_in_cloud, le modèle hébergé dans le cloud est gemini-2.0-flash-lite, mais vous pouvez ignorer la valeur par défaut.

import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend } from "firebase/ai";

// TODO(developer) Replace the following with your app's Firebase configuration
// See: https://firebase.google.com/docs/web/learn-more#config-object
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Create a `GenerativeModel` instance
// Set the mode, for example to use on-device model when possible
const model = getGenerativeModel(ai, { mode: "prefer_on_device" });

Envoyer une requête de requête à un modèle

Cette section fournit des exemples sur la façon d'envoyer différents types d'entrées pour générer différents types de sorties, y compris:

Si vous souhaitez générer une sortie structurée (comme JSON ou des énumérations), utilisez l'un des exemples de "génération de texte" suivants et configurez le modèle pour qu'il réponde selon un schéma fourni.

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'une requête contenant du texte:

// Imports + initialization of FirebaseApp and backend service + creation of model instance

// Wrap in an async function so you can use await
async function run() {
  // Provide a prompt that contains text
  const prompt = "Write a story about a magic backpack."

  // To generate text output, call `generateContent` with the text input
  const result = await model.generateContent(prompt);

  const response = result.response;
  const text = response.text();
  console.log(text);
}

run();

Générer du texte à partir d'une entrée texte-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 des fichiers texte et des fichiers image, en fournissant l'mimeType de chaque fichier d'entrée et le fichier lui-même.

Les types d'images d'entrée acceptés pour l'inférence sur l'appareil sont PNG et JPEG.

// Imports + initialization of FirebaseApp and backend service + creation of model instance

// Converts a File object to a Part object.
async function fileToGenerativePart(file) {
  const base64EncodedDataPromise = new Promise((resolve) => {
    const reader = new FileReader();
    reader.onloadend = () => resolve(reader.result.split(',')[1]);
    reader.readAsDataURL(file);
  });
  return {
    inlineData: { data: await base64EncodedDataPromise, mimeType: file.type },
  };
}

async function run() {
  // Provide a text prompt to include with the image
  const prompt = "Write a poem about this picture:";

  const fileInputEl = document.querySelector("input[type=file]");
  const imagePart = await fileToGenerativePart(fileInputEl.files[0]);

  // To generate text output, call `generateContent` with the text and image
  const result = await model.generateContent([prompt, imagePart]);

  const response = result.response;
  const text = response.text();
  console.log(text);
}

run();

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

En plus des exemples ci-dessus, vous pouvez également utiliser d'autres modes d'inférence, remplacer le modèle de remplacement par défaut et utiliser la configuration du modèle pour contrôler les réponses.

Utiliser d'autres modes d'inférence

Les exemples ci-dessus ont utilisé le mode prefer_on_device pour configurer le SDK afin qu'il utilise un modèle sur l'appareil s'il est disponible, ou qu'il utilise un modèle hébergé dans le cloud. Le SDK propose deux modes d'inférence : only_on_device et only_in_cloud.

  • Utilisez le mode only_on_device pour que le SDK ne puisse utiliser qu'un modèle sur l'appareil. Dans cette configuration, l'API génère une erreur si un modèle sur l'appareil n'est pas disponible.

    const model = getGenerativeModel(ai, { mode: "only_on_device" });

  • Utilisez le mode only_in_cloud pour que le SDK ne puisse utiliser qu'un modèle hébergé dans le cloud.

    const model = getGenerativeModel(ai, { mode: "only_in_cloud" });

Ignorer le modèle de remplacement par défaut

Lorsque vous utilisez le mode prefer_on_device, le SDK utilise un modèle hébergé dans le cloud si un modèle sur l'appareil n'est pas disponible. Le modèle par défaut hébergé dans le cloud est gemini-2.0-flash-lite. Ce modèle hébergé dans le cloud est également le modèle par défaut lorsque vous utilisez le mode only_in_cloud.

Vous pouvez utiliser l'option de configuration inCloudParams pour spécifier un autre modèle hébergé dans le cloud par défaut:

const model = getGenerativeModel(ai, {
  mode: 'prefer_on_device',
  inCloudParams: {
    model: "gemini-2.0-flash"
  }
});

Recherchez les noms de modèle pour tous les modèles Gemini compatibles.

Utiliser la configuration du modèle pour contrôler les réponses

Dans chaque requête envoyée à un modèle, vous pouvez envoyer une configuration de modèle pour contrôler la manière dont il génère une réponse. Les modèles hébergés dans le cloud et les modèles sur l'appareil offrent différentes options de configuration.

La configuration est maintenue pendant toute la durée de vie de l'instance. Si vous souhaitez utiliser une configuration différente, créez une instance GenerativeModel avec cette configuration.

Définir la configuration d'un modèle hébergé dans le cloud

Utilisez l'option inCloudParams pour configurer un modèle Gemini hébergé dans le cloud. En savoir plus sur les paramètres disponibles

const model = getGenerativeModel(ai, {
  mode: 'prefer_on_device',
  inCloudParams: {
    model: "gemini-2.0-flash"
    temperature: 0.8,
    topK: 10
  }
});

Définir la configuration d'un modèle sur l'appareil

Notez que l'inférence à l'aide d'un modèle sur l'appareil utilise l'API Prompt de Chrome.

Utilisez l'option onDeviceParams pour configurer un modèle sur l'appareil. En savoir plus sur les paramètres disponibles

const model = getGenerativeModel(ai, {
  mode: 'prefer_on_device',
  onDeviceParams: {
    createOptions: {
      temperature: 0.8,
      topK: 8
    }
  }
});

Définir la configuration pour la sortie structurée

La génération de sortie structurée (comme JSON et énumérations) est compatible avec l'inférence à l'aide de modèles hébergés dans le cloud et sur l'appareil.

Pour l'inférence hybride, utilisez à la fois inCloudParams et onDeviceParams pour configurer le modèle afin qu'il réponde avec une sortie structurée. Pour les autres modes, n'utilisez que la configuration applicable.

  • Pour inCloudParams: spécifiez le responseMimeType approprié (dans cet exemple, application/json) ainsi que le responseSchema que vous souhaitez que le modèle utilise.

  • Pour onDeviceParams: spécifiez l'responseConstraint que vous souhaitez que le modèle utilise.

Sortie JSON

L'exemple suivant adapte l'exemple de sortie JSON général pour l'inférence hybride:

import {
  getAI,
  getGenerativeModel,
  Schema
} from "firebase/ai";

const jsonSchema = Schema.object({
 properties: {
    characters: Schema.array({
      items: Schema.object({
        properties: {
          name: Schema.string(),
          accessory: Schema.string(),
          age: Schema.number(),
          species: Schema.string(),
        },
        optionalProperties: ["accessory"],
      }),
    }),
  }
});

const model = getGenerativeModel(ai, {
  mode: 'prefer_on_device',
  inCloudParams: {
    model: "gemini-2.0-flash"
    generationConfig: {
      responseMimeType: "application/json",
      responseSchema: jsonSchema
    },
  }
  onDeviceParams: {
    promptOptions: {
      responseConstraint: jsonSchema
    }
  }
});
Sortie enum

Comme ci-dessus, mais en adaptant la documentation sur la sortie d'énumération pour l'inférence hybride:

// ...

const enumSchema = Schema.enumString({
  enum: ["drama", "comedy", "documentary"],
});

const model = getGenerativeModel(ai, {

// ...

    generationConfig: {
      responseMimeType: "text/x.enum",
      responseSchema: enumSchema
    },

// ...

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

Comme il s'agit d'une version expérimentale, toutes les fonctionnalités du SDK Web ne sont pas disponibles pour l'inférence sur l'appareil. Les fonctionnalités suivantes ne sont pas encore compatibles avec l'inférence sur l'appareil (mais elles sont généralement disponibles pour l'inférence dans le cloud).

  • Générer du texte à partir d'entrées de type de fichier image autre que JPEG et PNG

    • Peut utiliser le modèle hébergé dans le cloud. Toutefois, le mode only_on_device génère une erreur.

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

    • Peut utiliser le modèle hébergé dans le cloud. Toutefois, le mode only_on_device génère une erreur.

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

    • Peut utiliser le modèle hébergé dans le cloud. Toutefois, le mode only_on_device génère une erreur.

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

  • Chat multitour

    • Peut utiliser le modèle hébergé dans le cloud. Toutefois, le mode only_on_device génère une erreur.

  • Streaming bidirectionnel avec le Gemini Live API

    • Notez que cette fonctionnalité n'est pas prise en charge par le SDK client Firebase AI Logic pour le Web, même pour les modèles hébergés dans le cloud.

  • Appel de fonction

    • Bientôt disponible !

  • Compter les jetons

    • Génère toujours une erreur. Le nombre diffère entre les modèles hébergés dans le cloud et les modèles sur l'appareil. Il n'y a donc pas de solution de remplacement intuitive.

  • Surveillance de l'IA dans la console Firebase pour l'inférence sur l'appareil.

    • Notez que toute inférence utilisant les modèles hébergés dans le cloud peut être surveillée comme toute autre inférence à l'aide du SDK client Firebase AI Logic pour le Web.


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