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

Ten en cuenta que Firebase AI Logic aún no admite todas las funciones disponibles para los modelos Imagen. Obtén más información en Funciones y capacidades admitidas más adelante en esta página.

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 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 para tareas especializadas en las que la calidad de la imagen es fundamental.

Ten en cuenta que los SDKs de Firebase AI Logic aún no admiten la entrada de imágenes (como para la edición) con los modelos de Imagen. Por lo tanto, si deseas trabajar con imágenes de entrada, puedes usar un modelo Gemini en su lugar.

Elige Gemini cuando quieras hacer lo siguiente:

Usar el conocimiento del mundo y el razonamiento para generar imágenes pertinentes según el contexto
Para combinar imágenes y texto sin problemas
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)
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 API que elijas y crear una instancia de ImagenModel.

Modelos que admiten esta capacidad

Gemini Developer API solo admite la generación de imágenes con el modelo Imagen 3 estable más reciente, pero no con los otros modelos Imagen. Estas limitaciones del modelo Imagen se aplican independientemente de cómo accedas a Gemini Developer API.

imagen-3.0-generate-002

Genera imágenes a partir de entradas de solo texto

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

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

El uso de Imagen aún no es compatible con Unity, pero vuelve a consultar pronto.

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 solo generan 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-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

El uso de Imagen aún no es compatible con Unity, pero vuelve a consultar pronto.

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 estas funciones de los modelos Imagen.

Generar personas y rostros (si tu proyecto de Firebase tiene la aprobación de Google Cloud)
Genera texto dentro de las imágenes creadas
Cómo agregar una marca de agua a las imágenes generadas
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.

Ten en cuenta que la mayoría de estas funciones requieren que estés en una lista de usuarios aprobados, incluso cuando uses modelos Imagen del servidor.

Funciones de edición o manipulación de imágenes, lo que incluye agrandar imágenes
Incluir imágenes en la solicitud al modelo (como para el aprendizaje con pocos ejemplos)
Cómo verificar marcas de agua digitales con los SDKs
Si quieres verificar que una imagen tenga una marca de agua, puedes subirla a Vertex AI Studio con la pestaña Media.
Generación de "imágenes en vivo" a partir de texto (generación de MP4)
Generar imágenes con un estilo predefinido
Cómo configurar el idioma del texto de entrada
Habilitar includeSafetyAttributes, lo que significa que no se pueden devolver safetyAttributes.categories ni safetyAttributes.scores
Inhabilitar la mejora de instrucciones (el parámetro enhancePrompt), lo que 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 diversos 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