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


Les SDK Firebase AI Logic vous permettent d'accéder aux modèles Imagen 3 (via Imagen API) afin de générer des images à partir d'une requête textuelle. Grâce à cette fonctionnalité, vous pouvez par exemple:

  • 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 la section Fonctionnalités et fonctionnalités compatibles plus loin sur cette page.

Accéder au code pour la saisie de texte uniquement

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, consultez le guide de démarrage, qui explique comment configurer votre projet Firebase, connecter votre application à Firebase, ajouter le SDK, initialiser le service backend pour le fournisseur d'API de votre choix et créer une instance ImagenModel.

Modèles compatibles avec cette fonctionnalité

La génération d'images est compatible avec les modèles Imagen 3.

Notez que Firebase AI Logic est également compatible avec la génération d'images par les modèles Gemini. La documentation sera bientôt disponible.

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

Vous pouvez demander à un modèle Imagen de générer des images en lui fournissant du texte. Vous pouvez générer une image ou plusieurs.

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

Avant d'essayer cet exemple, consultez la section Avant de commencer de ce guide pour configurer votre projet et votre application.
Dans cette section, vous devrez également cliquer sur un bouton pour le fournisseurGemini 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 en lui fournissant une requête textuelle.

Assurez-vous de créer une instance ImagenModel et d'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.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 compatible avec 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, consultez la section Avant de commencer de ce guide pour configurer votre projet et votre application.
Dans cette section, vous devrez également cliquer sur un bouton pour le fournisseurGemini API de votre choix afin d'afficher le contenu spécifique à ce fournisseur sur cette page.

Par défaut, les modèles Imagen 3 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.

Assurez-vous de créer une instance ImagenModel et d'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.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 compatible avec Unity, mais revenez bientôt.

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


Fonctionnalités compatibles et exigences

Les modèles Imagen 3 offrent de nombreuses fonctionnalités liées à la génération d'images. Cette section décrit ce qui est accepté lorsque vous utilisez les modèles avec Firebase AI Logic.

Fonctionnalités et fonctionnalités compatibles

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

  • Générer des personnes et des visages (étant donné que votre projet Firebase a é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 n'est pas compatible avec ces fonctionnalités avancées des modèles Imagen 3.

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

  • Fonctionnalités de modification ou de manipulation d'images, y compris de redimensionnement

  • Inclure des images dans la requête adressé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 Multimédia.

  • Générer des images en direct à partir de texte (génération de fichiers MP4)

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

  • Définir la langue du texte saisi

  • Activation de includeSafetyAttributes, ce qui signifie que safetyAttributes.categories et safetyAttributes.scores ne peuvent pas être renvoyés

  • Désactivation de l'amélioration de la requête (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). Au lieu de cela, 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

Limites (par requête) Imagen 3 Imagen 3 Fast
Nombre maximal de jetons d'entrée 480 jetons 480 jetons
Nombre maximal d'images de sortie 4 images 4 images
Résolutions d'image de sortie compatibles (pixels)
  • 1024x1024 pixels (format 1:1)
  • 896x1280 (format 3:4)
  • 1280x896 (format 4:3)
  • 768x1408 (format 9:16)
  • 1408x768 (format 16:9)
  • 1024x1024 pixels (format 1:1)
  • 896x1280 (format 3:4)
  • 1280x896 (format 4:3)
  • 768x1408 (format 9:16)
  • 1408x768 (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