Cette page a été traduite par l'API Cloud Translation.

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 revenir de manière transparente à des 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 la 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
Voici les avantages de l'utilisation des fonctionnalités hybrides :
- Touchez 100 % de votre audience, quelle que soit la disponibilité du modèle sur l'appareil

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

Génération de contenu à un seul tour, avec ou sans streaming
Générer du texte à partir d'une entrée textuelle
Génération de texte à partir d'entrées de type texte et image, en particulier les types d'images d'entrée JPEG et PNG
Générer des résultats structurés, y compris JSON et des énumérations

Premiers pas

Ce guide vous explique comment faire vos premiers pas avec 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

Téléchargez la dernière version bêta de Chrome.

L'inférence sur l'appareil est disponible à partir de Chrome 138.
Activez l'API Prompt pour votre instance Chrome en définissant les indicateurs suivants :
- chrome://flags/#optimization-guide-on-device-model : définissez la valeur sur Activé.
- chrome://flags/#prompt-api-for-gemini-nano : définissez la valeur sur Activé.
Pour en savoir plus sur l'utilisation des API sur localhost, consultez la documentation Chrome. Vous pouvez également rejoindre le programme Preview anticipée de Chrome pour nous faire part de vos commentaires.
Activez le modèle multimodal sur l'appareil en définissant l'indicateur suivant :
- chrome://flags/#prompt-api-for-gemini-nano-multimodal-input : Définissez la valeur sur Activé.
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 le résultat est available, downloading ou downloadable. .
5. Si le résultat est downloadable, vous pouvez lancer 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 lancera un téléchargement de modèle en arrière-plan, ce qui peut prendre plusieurs minutes.

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

Connectez-vous à la console Firebase, puis sélectionnez votre projet Firebase.
Vous n'avez pas encore de projet Firebase ?

Si vous n'avez pas encore de projet Firebase, cliquez sur Créer un projet, puis utilisez l'une des options suivantes :
- Option 1 : Créez un projet Firebase entièrement nouveau (et son projet Google Cloud sous-jacent automatiquement) en saisissant un nouveau nom de projet à la première étape du workflow "Create project" (Créer un projet).
- Option 2 : Ajoutez Firebase à un projet Google Cloud existant en sélectionnant le nom de votre projet Google Cloud dans le menu déroulant de la première étape du workflow "Create project" (Créer un projet).
Notez que lorsque vous y êtes invité, vous n'avez pas besoin de configurer Google Analytics pour utiliser les SDK Firebase AI Logic.
Dans la console Firebase, accédez à la page Firebase AI Logic.
Cliquez sur Premiers pas pour lancer un workflow guidé qui vous aide à configurer les API requises et les ressources pour votre projet.
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, vous pourrez passer à un forfait supérieur ultérieurement si vous le souhaitez)
  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
- Vertex AI Gemini API : facturation requise (nécessite le forfait Blaze avec paiement à l'usage)
  La console vous aidera à configurer la facturation et à activer les API requises dans votre projet.
Si vous y êtes invité dans le workflow de la console, suivez les instructions à l'écran pour enregistrer votre application et l'associer à Firebase.
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 Firebase JavaScript pour le Web.

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

La fonctionnalité hybride est publiée sous un tag npm différent. Veillez donc à l'inclure dans votre commande d'installation.
```
npm install firebase@eap-ai-hybridinference
```

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 requête à 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 revienne au 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 remplacer 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 à un modèle

Cette section fournit des exemples de la façon d'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 uniquement
Générer du texte à partir d'une entrée texte et image (multimodale)

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 en fonction d'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 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 des fichiers texte et image, en fournissant le 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 secours 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 utilisaient 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 revienne à un modèle hébergé dans le cloud. Le SDK propose deux modes d'inférence alternatifs : 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 aucun modèle sur l'appareil n'est 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" });
```

Remplacer le modèle de remplacement par défaut

Lorsque vous utilisez le mode prefer_on_device, le SDK utilisera un modèle hébergé dans le cloud si aucun modèle sur l'appareil n'est disponible. Le modèle hébergé dans le cloud par défaut est gemini-2.0-flash-lite. Ce modèle hébergé sur le cloud est également celui 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 par défaut hébergé dans le cloud :

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

Trouvez les noms de modèles 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 inclure une configuration de modèle pour contrôler la manière dont le modèle 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 conservée pendant toute la durée de vie de l'instance. Si vous souhaitez utiliser une autre configuration, 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.5-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 résultats structurés (comme JSON et les é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 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 le responseConstraint que vous souhaitez que le modèle utilise.

Sortie JSON

L'exemple suivant adapte l'exemple général de sortie JSON 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.5-flash"
    generationConfig: {
      responseMimeType: "application/json",
      responseSchema: jsonSchema
    },
  }
  onDeviceParams: {
    promptOptions: {
      responseConstraint: jsonSchema
    }
  }
});

Sortie Enum

Comme ci-dessus, mais en adaptant la documentation sur la sortie enum 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 basée sur le cloud).

Générer du texte à partir de types de fichiers image autres que JPEG et PNG
- Peut revenir au modèle hébergé dans le cloud. Toutefois, le mode only_on_device générera une erreur.
Générer du texte à partir d'entrées audio, vidéo et de documents (comme des PDF)
- Peut revenir au modèle hébergé dans le cloud. Toutefois, le mode only_on_device générera une erreur.
Générer des images à l'aide des modèles Gemini ou Imagen
- Peut revenir au modèle hébergé dans le cloud. Toutefois, le mode only_on_device générera une erreur.
Fournir des fichiers à l'aide d'URL dans les requêtes multimodales. Vous devez fournir les fichiers sous forme de données intégrées aux modèles sur l'appareil.
Chat multitour
- Peut revenir au modèle hébergé dans le cloud. Toutefois, le mode only_on_device générera une erreur.
Streaming bidirectionnel avec Gemini Live API
- Notez que cette fonctionnalité n'est pas compatible avec 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 de résultats sera différent entre les modèles hébergés dans le cloud et ceux sur l'appareil. Il n'y a donc pas de solution de repli 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 utilisant le SDK client Firebase AI Logic pour le Web.

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