Générer des images à l'aide d'Imagen


Les SDK Firebase AI Logic vous donnent accès aux modèles Imagen (via Imagen API) afin que vous puissiez générer des images à partir d'une requête textuelle. Cette fonctionnalité vous permet, entre autres, de :

  • Générer des images à partir de requêtes rédigées en langage naturel
  • Générer des images dans un large éventail de formats et de styles
  • Afficher du texte dans des images

Notez que Firebase AI Logic n'est pas encore compatible avec toutes les fonctionnalités disponibles pour les modèles Imagen. Pour en savoir plus, consultez Fonctionnalités et caractéristiques compatibles plus loin sur cette page.

 Accéder au code pour la saisie de texte uniquement

Choisir entre les modèles Gemini et Imagen

Les SDK Firebase AI Logic permettent de générer des images à l'aide d'un modèle Gemini ou Imagen. Pour la plupart des cas d'utilisation, commencez par Gemini, puis choisissez Imagen pour les tâches spécialisées où la qualité de l'image est essentielle.

Notez que les SDK Firebase AI Logic ne sont pas encore compatibles avec les entrées d'image (comme pour la retouche) avec les modèles Imagen. Par conséquent, si vous souhaitez travailler avec des images d'entrée, vous pouvez utiliser un modèle Gemini à la place.

Choisissez Gemini lorsque vous souhaitez :

  • Utiliser les connaissances du monde et le raisonnement pour générer des images adaptées au contexte.
  • Pour combiner facilement du texte et des images.
  • Pour intégrer des éléments visuels précis dans de longues séquences de texte.
  • Modifier des images de manière conversationnelle tout en conservant le contexte.

Choisissez Imagen lorsque vous souhaitez :

  • Pour privilégier la qualité de l'image, le photoréalisme, les détails artistiques ou des styles spécifiques (par exemple, l'impressionnisme ou l'anime).
  • Pour spécifier explicitement le format ou le format des images générées.

Avant de commencer

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

Si ce n'est pas déjà fait, suivez le guide de démarrage, qui explique comment configurer votre projet Firebase, associer votre application à Firebase, ajouter le SDK, initialiser le service de backend pour le fournisseur d'API de votre choix et créer une instance ImagenModel.

Modèles compatibles avec cette fonctionnalité

Gemini Developer API n'est compatible avec la génération d'images qu'avec le dernier modèle Imagen 3 stable, mais pas avec les autres modèles Imagen. Ces limites du modèle Imagen s'appliquent quelle que soit la façon dont vous accédez à Gemini Developer API.

  • imagen-3.0-generate-002

Générer des images à partir d'entrées textuelles uniquement

Vous pouvez demander à un modèle Imagen de générer des images à partir d'une requête textuelle. Vous pouvez générer une seule image ou plusieurs.

Générer une image à partir d'une entrée textuelle uniquement

Avant d'essayer cet exemple, suivez la section Avant de commencer de ce guide pour configurer votre projet et votre application.
Dans cette section, vous devez également cliquer sur un bouton pour le fournisseur Gemini API de votre choix afin d'afficher le contenu spécifique à ce fournisseur sur cette page.

Vous pouvez demander à un modèle Imagen de générer une seule image à partir d'une requête textuelle.

Veillez à créer une instance ImagenModel et à appeler generateImages.

Swift 


import FirebaseAI

// Initialize the Gemini Developer API backend service
let ai = FirebaseAI.firebaseAI(backend: .googleAI())


// Create an `ImagenModel` instance with a model that supports your use case
let model = ai.imagenModel(modelName: "imagen-3.0-generate-002")

// Provide an image generation prompt
let prompt = "An astronaut riding a horse"

// To generate an image, call `generateImages` with the text prompt
let response = try await model.generateImages(prompt: prompt)

// Handle the generated image
guard let image = response.images.first else {
  fatalError("No image in the response.")
}
let uiImage = UIImage(data: image.data)

Kotlin 


// Using this SDK to access Imagen models is a Preview release and requires opt-in
@OptIn(PublicPreviewAPI::class)
suspend fun generateImage() {
  // Initialize the Gemini Developer API backend service
  // Create an `ImagenModel` instance with an Imagen model that supports your use case
  val imagenModel = Firebase.ai(backend = GenerativeBackend.googleAI()).imagenModel("imagen-3.0-generate-002")

  // Provide an image generation prompt
  val prompt = "An astronaut riding a horse"

  // To generate an image, call `generateImages` with the text prompt
  val imageResponse = imagenModel.generateImages(prompt)

  // Handle the generated image
  val image = imageResponse.images.first()

  val bitmapImage = image.asBitmap()
}

Java 


// Initialize the Gemini Developer API backend service
// Create an `ImagenModel` instance with an Imagen model that supports your use case
ImagenModel imagenModel = FirebaseAI.getInstance(GenerativeBackend.googleAI()).imagenModel(
        /* modelName */ "imagen-3.0-generate-002");

ImagenModelFutures model = ImagenModelFutures.from(imagenModel);

// Provide an image generation prompt
String prompt = "An astronaut riding a horse";

// To generate an image, call `generateImages` with the text prompt
Futures.addCallback(model.generateImages(prompt), new FutureCallback<ImagenGenerationResponse<ImagenInlineImage>>() {
    @Override
    public void onSuccess(ImagenGenerationResponse<ImagenInlineImage> result) {
        if (result.getImages().isEmpty()) {
            Log.d("TAG", "No images generated");
        }
        Bitmap bitmap = result.getImages().get(0).asBitmap();
        // Use the bitmap to display the image in your UI
    }

    @Override
    public void onFailure(Throwable t) {
        // ...
    }
}, Executors.newSingleThreadExecutor());

Web 


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 an `ImagenModel` instance with an Imagen 3 model that supports your use case
const imagenModel = getImagenModel(ai, { model: "imagen-3.0-generate-002" });

// Provide an image generation prompt
const prompt = "An astronaut riding a horse.";

// To generate an image, call `generateImages` with the text prompt
const response = await imagenModel.generateImages(prompt)

// If fewer images were generated than were requested,
// then `filteredReason` will describe the reason they were filtered out
if (response.filteredReason) {
  console.log(response.filteredReason);
}

if (response.images.length == 0) {
  throw new Error("No images in the response.")
}

const image = response.images[0];

Dart 

import 'package:firebase_ai/firebase_ai.dart';
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart';

// Initialize FirebaseApp
await Firebase.initializeApp(
  options: DefaultFirebaseOptions.currentPlatform,
);


// Initialize the Gemini Developer API backend service
// Create an `ImagenModel` instance with an Imagen model that supports your use case
final model =
  FirebaseAI.googleAI().imagenModel(model: 'imagen-3.0-generate-002');

// Provide an image generation prompt
const prompt = 'An astronaut riding a horse.';

// To generate an image, call `generateImages` with the text prompt
final response = await model.generateImages(prompt);

if (response.images.isNotEmpty) {
  final image = response.images[0];
  // Process the image
} else {
  // Handle the case where no images were generated
  print('Error: No images were generated.');
}

Unity

L'utilisation de Imagen n'est pas encore prise en charge pour Unity, mais revenez bientôt !

Découvrez comment choisir un modèle adapté à votre cas d'utilisation et à votre application.

Générer plusieurs images à partir d'une entrée textuelle

Avant d'essayer cet exemple, suivez la section Avant de commencer de ce guide pour configurer votre projet et votre application.
Dans cette section, vous devez également cliquer sur un bouton pour le fournisseur Gemini API de votre choix afin d'afficher le contenu spécifique à ce fournisseur sur cette page.

Par défaut, les modèles Imagen ne génèrent qu'une seule image par requête. Toutefois, vous pouvez demander à un modèle Imagen de générer plusieurs images par requête en fournissant un ImagenGenerationConfig lors de la création de l'instance ImagenModel.

Veillez à créer une instance ImagenModel et à appeler generateImages.

Swift 


import FirebaseAI

// Initialize the Gemini Developer API backend service
let ai = FirebaseAI.firebaseAI(backend: .googleAI())


// Create an `ImagenModel` instance with a model that supports your use case
let model = ai.imagenModel(
  modelName: "imagen-3.0-generate-002",
  // Configure the model to generate multiple images for each request
  // See: https://firebase.google.com/docs/ai-logic/model-parameters
  generationConfig: ImagenGenerationConfig(numberOfImages: 4)
)

// Provide an image generation prompt
let prompt = "An astronaut riding a horse"

// To generate images, call `generateImages` with the text prompt
let response = try await model.generateImages(prompt: prompt)

// If fewer images were generated than were requested,
// then `filteredReason` will describe the reason they were filtered out
if let filteredReason = response.filteredReason {
  print(filteredReason)
}

// Handle the generated images
let uiImages =  response.images.compactMap { UIImage(data: $0.data) }

Kotlin 


// Using this SDK to access Imagen models is a Preview release and requires opt-in
@OptIn(PublicPreviewAPI::class)
suspend fun generateImage() {
  // Initialize the Gemini Developer API backend service
  // Create an `ImagenModel` instance with an Imagen model that supports your use case
  val imagenModel = Firebase.ai(backend = GenerativeBackend.googleAI()).imagenModel(
      modelName = "imagen-3.0-generate-002",
      // Configure the model to generate multiple images for each request
      // See: https://firebase.google.com/docs/ai-logic/model-parameters
      generationConfig = ImagenGenerationConfig(numberOfImages = 4)
  )

  // Provide an image generation prompt
  val prompt = "An astronaut riding a horse"

  // To generate images, call `generateImages` with the text prompt
  val imageResponse = imagenModel.generateImages(prompt)

  // If fewer images were generated than were requested,
  // then `filteredReason` will describe the reason they were filtered out
  if (imageResponse.filteredReason != null) {
    Log.d(TAG, "FilteredReason: ${imageResponse.filteredReason}")
  }

  for (image in imageResponse.images) {
    val bitmap = image.asBitmap()
    // Use the bitmap to display the image in your UI
  }
}

Java 


// Configure the model to generate multiple images for each request
// See: https://firebase.google.com/docs/ai-logic/model-parameters
ImagenGenerationConfig imagenGenerationConfig = new ImagenGenerationConfig.Builder()
        .setNumberOfImages(4)
        .build();

// Initialize the Gemini Developer API backend service
// Create an `ImagenModel` instance with an Imagen model that supports your use case
ImagenModel imagenModel = FirebaseAI.getInstance(GenerativeBackend.googleAI()).imagenModel(
        /* modelName */ "imagen-3.0-generate-002",
        /* imageGenerationConfig */ imagenGenerationConfig);

ImagenModelFutures model = ImagenModelFutures.from(imagenModel);

// Provide an image generation prompt
String prompt = "An astronaut riding a horse";

// To generate images, call `generateImages` with the text prompt
Futures.addCallback(model.generateImages(prompt), new FutureCallback<ImagenGenerationResponse<ImagenInlineImage>>() {
    @Override
    public void onSuccess(ImagenGenerationResponse<ImagenInlineImage> result) {
        // If fewer images were generated than were requested,
        // then `filteredReason` will describe the reason they were filtered out
        if (result.getFilteredReason() != null){
            Log.d("TAG", "FilteredReason: " + result.getFilteredReason());
        }

        // Handle the generated images
        List<ImagenInlineImage> images = result.getImages();
        for (ImagenInlineImage image : images) {
            Bitmap bitmap = image.asBitmap();
            // Use the bitmap to display the image in your UI
        }
    }

    @Override
    public void onFailure(Throwable t) {
        // ...
    }
}, Executors.newSingleThreadExecutor());

Web 


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 an `ImagenModel` instance with an Imagen 3 model that supports your use case
const imagenModel = getImagenModel(
  ai,
  {
    model: "imagen-3.0-generate-002",
    // Configure the model to generate multiple images for each request
    // See: https://firebase.google.com/docs/ai-logic/model-parameters
    generationConfig: {
      numberOfImages: 4
    }
  }
);

// Provide an image generation prompt
const prompt = "An astronaut riding a horse.";

// To generate images, call `generateImages` with the text prompt
const response = await imagenModel.generateImages(prompt)

// If fewer images were generated than were requested,
// then `filteredReason` will describe the reason they were filtered out
if (response.filteredReason) {
  console.log(response.filteredReason);
}

if (response.images.length == 0) {
  throw new Error("No images in the response.")
}

const images = response.images[0];

Dart 

import 'package:firebase_ai/firebase_ai.dart';
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart';

// Initialize FirebaseApp
await Firebase.initializeApp(
  options: DefaultFirebaseOptions.currentPlatform,
);


// Initialize the Gemini Developer API backend service
// Create an `ImagenModel` instance with an Imagen model that supports your use case
final model =
  FirebaseAI.googleAI().imagenModel(
    model: 'imagen-3.0-generate-002',
    // Configure the model to generate multiple images for each request
    // See: https://firebase.google.com/docs/ai-logic/model-parameters
    generationConfig: ImagenGenerationConfig(numberOfImages: 4),
);

// Provide an image generation prompt
const prompt = 'An astronaut riding a horse.';

// To generate images, call `generateImages` with the text prompt
final response = await model.generateImages(prompt);

// If fewer images were generated than were requested,
// then `filteredReason` will describe the reason they were filtered out
if (response.filteredReason != null) {
  print(response.filteredReason);
}

if (response.images.isNotEmpty) {
  final images = response.images;
  for(var image in images) {
  // Process the image
  }
} else {
  // Handle the case where no images were generated
  print('Error: No images were generated.');
}

Unity

L'utilisation de Imagen n'est pas encore prise en charge pour Unity, mais revenez bientôt !

Découvrez comment choisir un modèle adapté à votre cas d'utilisation et à votre application.


Fonctionnalités et exigences compatibles

Les modèles Imagen offrent de nombreuses fonctionnalités liées à la génération d'images. Cette section décrit ce qui est compatible lors de l'utilisation des modèles avec Firebase AI Logic.

Fonctionnalités et caractéristiques compatibles

Firebase AI Logic est compatible avec les fonctionnalités suivantes des modèles Imagen.

  • Générer des personnes et des visages (à condition que votre projet Firebase ait été approuvé par Google Cloud)

  • Générer du texte dans des images générées

  • Ajouter un filigrane aux images générées

  • Configurer les paramètres de génération d'images, comme le nombre d'images générées, le format et le filigrane

  • Configurer les paramètres de sécurité

Firebase AI Logic ne prend pas en charge ces fonctionnalités avancées des modèles Imagen.

Notez que la plupart de ces fonctionnalités nécessitent de figurer sur une liste d'utilisateurs approuvés, même lorsque vous utilisez des modèles Imagen côté serveur.

  • Fonctionnalités de retouche ou de manipulation d'images, y compris l'amélioration de la taille des images

  • Inclure des images dans la requête envoyée au modèle (comme pour l'apprentissage few-shot)

  • Vérifier les filigranes numériques à l'aide des SDK
    Si vous souhaitez vérifier qu'une image comporte un filigrane, vous pouvez l'importer dans Vertex AI Studio à l'aide de l'onglet Média.

  • Génération d'images en direct à partir de texte (génération de MP4)

  • Générer des images à l'aide d'un style prédéfini

  • Définir la langue du texte saisi

  • includeSafetyAttributes activé, ce qui signifie que safetyAttributes.categories et safetyAttributes.scores ne peuvent pas être retournés

  • Désactiver l'amélioration des requêtes (paramètre enhancePrompt), ce qui signifie qu'un outil de reformulation de requête basé sur un LLM ajoutera toujours automatiquement plus de détails à la requête fournie pour générer des images de meilleure qualité qui reflètent mieux la requête fournie

  • Écrire une image générée directement dans Google Cloud Storage dans le cadre de la réponse du modèle (paramètre storageUri). En revanche, les images sont toujours renvoyées sous forme d'octets d'image encodés en base64 dans la réponse.
    Si vous souhaitez importer une image générée dans Cloud Storage, vous pouvez utiliser Cloud Storage for Firebase.

Spécifications et limites

Propriété (par demande) Valeur
Nombre maximal de jetons d'entrée 480 jetons
Nombre maximal d'images de sortie 4 images
Résolutions d'image de sortie compatibles (pixels)
  • 1 024 x 1 024 pixels (format 1:1)
  • 896 x 1 280 (format 3:4)
  • 1 280 x 896 (format 4:3)
  • 768 x 1 408 (format 9:16)
  • 1 408 x 768 (format 16:9)


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

Découvrez comment contrôler la génération de contenu.

En savoir plus sur les modèles compatibles

Découvrez les modèles disponibles pour différents cas d'utilisation, ainsi que leurs quotas et leurs tarifs.


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