Genera imágenes con Imagen


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

  • Genera imágenes a partir de instrucciones escritas en lenguaje natural
  • Genera imágenes en una amplia variedad de formatos y estilos
  • Renderiza 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 compatibles más adelante en esta página.

Ir al código para la entrada de solo texto

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 función

Los modelos Imagen 3 admiten la generación de imágenes.

Ten en cuenta que Firebase AI Logic también admite la generación de imágenes con modelos Gemini. La documentación estará disponible pronto.

Genera imágenes a partir de una entrada 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 app.
En esa sección, también harás clic en un botón del proveedor de Gemini API que elijas para ver 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.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 apropiado para tu caso de uso y tu app.

Genera varias imágenes 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 app.
En esa sección, también harás clic en un botón del proveedor de Gemini API que elijas para ver contenido específico del proveedor en esta página.

De forma predeterminada, los modelos de Imagen 3 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 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.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 apropiado para tu caso de uso y tu app.


Funciones y requisitos admitidos

Los modelos Imagen 3 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 3.

  • Generar personas y rostros (siempre que tu proyecto de Firebase tenga aprobación de Google Cloud)

  • Generar texto dentro de imágenes generadas

  • Cómo agregar una marca de agua a las imágenes generadas

  • Configura los 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 seguridad

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

Ten en cuenta que la mayoría de estas funciones requieren estar en una lista de usuarios aprobados, incluso cuando se usan modelos Imagen del servidor.

  • Funciones de edición o manipulación de imágenes, lo que incluye el aumento de resolución de imágenes

  • Incluir imágenes en la solicitud al modelo (como en el aprendizaje con varios ejemplos)

  • Cómo verificar las 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)

  • Genera imágenes con un estilo predefinido

  • Cómo configurar el idioma del texto de entrada

  • Habilita includeSafetyAttributes, lo que significa que no se pueden mostrar 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

Límites (por solicitud) Imagen 3 Imagen 3 Fast
Cantidad máxima de tokens de entrada 480 tokens 480 tokens
Cantidad máxima de imágenes de salida 4 imágenes 4 imágenes
Resoluciones de imagen de salida compatibles (en 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)
  • 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?

Aprende a controlar la generación de contenido

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