Genera imágenes con Imagen


Los SDK de Firebase AI Logic te dan acceso a los modelos Imagen (a través de la Imagen API) para que puedas generar imágenes a partir de una instrucción de texto. Con esta capacidad, puedes hacer lo siguiente:

  • Generar imágenes a partir de instrucciones escritas en lenguaje natural
  • Generar imágenes en una amplia variedad de formatos y estilos
  • Renderizar texto en imágenes

En esta guía, se describe cómo generar imágenes con Imagen proporcionando solo una instrucción de texto.

Sin embargo, ten en cuenta que Imagen también puede generar imágenes basadas en una imagen de referencia con su capacidad de personalización (actualmente solo para Android y Flutter). En la solicitud, proporcionas una instrucción de texto y una imagen de referencia que guía al modelo para generar una imagen nueva basada en el estilo, el tema (como un producto, una persona o un animal) o un control especificados. Por ejemplo, puedes generar una imagen nueva a partir de una foto de un gato o un dibujo de un cohete y la luna.

Ir al código para la entrada solo de texto

Antes de comenzar

Haz clic en tu proveedor de Gemini API para ver el contenido específico del proveedor y el código en esta página.

Si aún no lo hiciste, completa la guía de introducción, en la que se describe cómo configurar tu proyecto de Firebase, conectar tu app a Firebase, agregar el SDK, inicializar el servicio de backend para el proveedor de la API que elijas y crear una instancia de ImagenModel.

Modelos que admiten esta capacidad

El Gemini Developer API admite la generación de imágenes con los modelos Imagen estables más recientes. Esta limitación de los modelos compatibles se aplica independientemente de cómo accedas a la Imagen Gemini Developer API.

  • imagen-4.0-generate-001
  • imagen-4.0-fast-generate-001
  • imagen-4.0-ultra-generate-001
  • imagen-3.0-generate-002

Genera imágenes a partir de entradas solo de texto

Puedes pedirle a un Imagen modelo que genere imágenes con solo escribir texto. Puedes generar una imagen o varias imágenes.

También puedes establecer muchas opciones de configuración diferentes para la generación de imágenes, como la relación de aspecto y el formato de imagen.

Genera una imagen a partir de entradas solo de texto

Antes de probar este ejemplo, completa la sección Antes de comenzar de esta guía para configurar tu proyecto y tu app.
En esa sección, también harás clic en un botón para el Gemini API proveedor que elijas, de modo que veas contenido específico del proveedor en esta página.

Puedes pedirle a un modelo de Imagen que genere una sola imagen con solo escribir texto.

Asegúrate de crear una instancia de ImagenModel y llamar a generateImages.

Swift 


import FirebaseAILogic

// 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-4.0-generate-001")

// 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 


suspend fun generateImage() {
  // Initialize the Gemini Developer API backend service
  val ai = Firebase.ai(backend = GenerativeBackend.googleAI())

  // Create an `ImagenModel` instance with an Imagen model that supports your use case
  val model = ai.imagenModel("imagen-4.0-generate-001")

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

  // To generate an image, call `generateImages` with the text prompt
  val imageResponse = model.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-4.0-generate-001");

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 model that supports your use case
const model = getImagenModel(ai, { model: "imagen-4.0-generate-001" });

// 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 model.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
final model = FirebaseAI.googleAI();

// Create an `ImagenModel` instance with an Imagen model that supports your use case
final model = ai.imagenModel(model: 'imagen-4.0-generate-001');

// 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 


using Firebase.AI;

// Initialize the Gemini Developer API backend service
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Create an `ImagenModel` instance with a model that supports your use case
var model = ai.GetImagenModel(modelName: "imagen-4.0-generate-001");

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

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

// Handle the generated image
if (response.Images.Count == 0) {
  throw new Exception("No image in the response.");
}
var image = response.Images[0].AsTexture2D();

Obtén información para elegir un modelo adecuada para tu caso de uso y tu app.

Genera varias imágenes a partir de entradas solo de texto

Antes de probar este ejemplo, completa la sección Antes de comenzar de esta guía para configurar tu proyecto y tu app.
En esa sección, también harás clic en un botón para el Gemini API proveedor que elijas, de modo que veas contenido específico del proveedor en esta página.

De forma predeterminada, los modelos Imagen generan solo una imagen por solicitud. Sin embargo, puedes pedirle a un modelo de Imagen que genere varias imágenes por solicitud proporcionando un ImagenGenerationConfig cuando crees la instancia de ImagenModel.

Asegúrate de crear una instancia de ImagenModel y llamar a generateImages.

Swift 


import FirebaseAILogic

// 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-4.0-generate-001",
  // 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 


suspend fun generateImage() {
  // Initialize the Gemini Developer API backend service
  val ai = Firebase.ai(backend = GenerativeBackend.googleAI())

  // Create an `ImagenModel` instance with an Imagen model that supports your use case
  val model = ai.imagenModel(
    modelName = "imagen-4.0-generate-001",
    // 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 = model.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-4.0-generate-001",
                /* 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 model that supports your use case
const model = getImagenModel(
  ai,
  {
    model: "imagen-4.0-generate-001",
    // 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 model.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
final ai = FirebaseAI.googleAI();

// Create an `ImagenModel` instance with an Imagen model that supports your use case
final model = ai.imagenModel(
  model: 'imagen-4.0-generate-001',
  // 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 


using Firebase.AI;

// Initialize the Gemini Developer API backend service
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

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

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

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

// If fewer images were generated than were requested,
// then `filteredReason` will describe the reason they were filtered out
if (!string.IsNullOrEmpty(response.FilteredReason)) {
  UnityEngine.Debug.Log("Filtered reason: " + response.FilteredReason);
}

// Handle the generated images
var images = response.Images.Select(image => image.AsTexture2D());

Obtén información para elegir un modelo adecuada para tu caso de uso y tu app.


Funciones y requisitos compatibles

Los modelos de Imagen ofrecen muchas funciones relacionadas con la generación de imágenes. En esta sección, se describe lo que se admite cuando se usan los modelos con Firebase AI Logic.

Funciones y capacidades compatibles

Firebase AI Logic admite estas funciones de los modelos Imagen:

  • Generar personas, rostros y texto dentro de las imágenes generadas

  • Editar imágenes o incluirlas en la solicitud cuando se usa la Vertex AI Gemini API (actualmente solo para Android y Flutter)

  • Agregar una marca de agua a las imágenes generadas

  • Verificar marcas de agua digitales cuando se usa la Vertex AI Gemini API
    Si deseas verificar que una imagen tenga una marca de agua, puedes subirla a Vertex AI Studio con su pestaña Media.

  • Configurar parámetros de generación de imágenes, como la cantidad de imágenes generadas, la relación de aspecto y la marca de agua

  • Configurar los parámetros de configuración de seguridad

Firebase AI Logic no admite estas funciones avanzadas de los modelos Imagen:

  • Establecer el idioma del texto de entrada

  • Inhabilitar el reescritor de instrucciones (el parámetro enhancePrompt). Esto significa que una herramienta de reescritura de instrucciones basada en LLM siempre agregará automáticamente más detalles a la instrucción proporcionada para generar imágenes de mayor calidad que reflejen mejor la instrucción proporcionada.

  • Escribir una imagen generada directamente en Google Cloud Storage como parte de la respuesta del modelo (el storageUri parámetro). En cambio, las imágenes siempre se muestran como bytes de imagen codificados en base64 en la respuesta.
    Si deseas subir una imagen generada a Cloud Storage, puedes usar Cloud Storage for Firebase.

Especificaciones y limitaciones

Propiedad (por solicitud) Valor
Cantidad máxima de tokens de entrada 480 tokens
Cantidad máxima de imágenes de salida 4 imágenes
Resoluciones de imagen de salida admitidas (píxeles)
  • 1024x1024 píxeles (relación de aspecto de 1:1)
  • 896x1280 (relación de aspecto de 3:4)
  • 1280x896 (relación de aspecto de 4:3)
  • 768x1408 (relación de aspecto de 9:16)
  • 1408x768 (relación de aspecto de 16:9)


¿Qué más puedes hacer?

Obtén información para controlar la generación de contenido

Obtén más información sobre los modelos compatibles

Obtén información sobre los modelos disponibles para varios casos de uso y sus cuotas y precios.


Envía comentarios sobre tu experiencia con Firebase AI Logic