Se usó la API de Cloud Translation para traducir esta página.

Genera imágenes con Imagen

Los SDKs de Firebase AI Logic te brindan acceso a los modelos de Imagen (a través de 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
Genera imágenes en una amplia variedad de formatos y estilos
Cómo renderizar texto en imágenes

En esta guía, se describe cómo generar imágenes con Imagen solo con 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 de solo texto

Cómo elegir entre los modelos Gemini y Imagen

Los SDKs de Firebase AI Logic admiten la generación y edición de imágenes con un modelo Gemini o un modelo Imagen.

Para la mayoría de los casos de uso, comienza con Gemini y, luego, elige Imagen solo para tareas especializadas en las que la calidad de la imagen sea fundamental.

Elige Gemini cuando quieras hacer lo siguiente:

Usar el conocimiento del mundo y el razonamiento para generar imágenes pertinentes según el contexto
Combinar texto e imágenes sin problemas o intercalar la salida de texto y la de imágenes
Para incorporar elementos visuales precisos en secuencias de texto largas
Editar imágenes de forma conversacional y mantener el contexto

Elige Imagen cuando quieras hacer lo siguiente:

Priorizar la calidad de la imagen, el fotorrealismo, los detalles artísticos o los estilos específicos (por ejemplo, impresionismo o anime)
Para infundir la marca, el estilo o la generación de logotipos y diseños de productos
Especificar de forma explícita la relación de aspecto o el formato de las imágenes generadas

Antes de comenzar

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

Si aún no lo has hecho, 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

Gemini Developer API admite la generación de imágenes con los modelos Imagen estables más recientes. Esta limitación de los modelos Imagen compatibles se aplica independientemente de cómo accedas a 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 de solo texto

Puedes pedirle a un modelo de Imagen que genere imágenes con instrucciones solo de 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 una entrada de solo texto

Antes de probar esta muestra, 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 proveedor de Gemini API que elijas, de modo que veas contenido específico del proveedor en esta página.

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

Asegúrate de crear una instancia de ImagenModel y llamar a 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-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


// 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
  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();

Aprende a elegir un modelo adecuados para tu caso de uso y tu app.

Genera varias imágenes a partir de una entrada de solo texto

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

Asegúrate de crear una instancia de ImagenModel y llamar a 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-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


// 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
  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());

Aprende a elegir un modelo adecuados para tu caso de uso y tu app.

Funciones y requisitos admitidos

Los modelos 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 admitidas

Firebase AI Logic admite las siguientes 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 Vertex AI Gemini API (actualmente, solo para Android y Flutter)
Cómo agregar una marca de agua a las imágenes generadas
Cómo verificar marcas de agua digitales cuando se usa Vertex AI Gemini API
Si quieres verificar que una imagen tenga una marca de agua, puedes subirla a Vertex AI Studio en la 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
Configuración de la protección

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

Cómo configurar el idioma del texto de entrada
Habilitar includeSafetyAttributes, lo que significa que no se pueden devolver safetyAttributes.categories ni safetyAttributes.scores
Inhabilita la reescritura de instrucciones (el parámetro enhancePrompt). Esto significa que una herramienta de reformulación 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 parámetro storageUri) En cambio, las imágenes siempre se muestran como bytes de imagen codificados en base64 en la respuesta.
Si quieres 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 compatibles (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?

Comienza a pensar en la preparación para la producción (consulta la lista de tareas de producción), que incluye lo siguiente:
- Configura Firebase App Check para proteger Gemini API contra el abuso de clientes no autorizados.
- Integra Firebase Remote Config para actualizar valores en tu app (como el nombre del modelo) sin lanzar una nueva versión de la app.

Más información para controlar la generación de contenido

Comprende el diseño de instrucciones, incluidas las prácticas recomendadas, las estrategias y los ejemplos de instrucciones.
Configura los parámetros del modelo Imagen, como la relación de aspecto, la generación de personas y las marcas de agua.
Usar la configuración de seguridad para ajustar la probabilidad de obtener respuestas que se puedan considerar dañinas

Más información sobre los modelos compatibles

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

Envía comentarios sobre tu experiencia con Firebase AI Logic

Genera imágenes con Imagen Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Cómo elegir entre los modelos Gemini y Imagen

Antes de comenzar

Modelos que admiten esta capacidad

Genera imágenes a partir de entradas de solo texto

Genera una imagen a partir de una entrada de solo texto

Swift

Kotlin

Java

Web

Dart

Unity

Genera varias imágenes a partir de una entrada de solo texto

Swift

Kotlin

Java

Web

Dart

Unity

Funciones y requisitos admitidos

Funciones y capacidades admitidas

Especificaciones y limitaciones

¿Qué más puedes hacer?

Más información para controlar la generación de contenido

Más información sobre los modelos compatibles

Genera imágenes con Imagen