Personaliza imágenes según un tema específico con Imagen

En esta página, se describe cómo usar la capacidad de personalización de Imagen para editar o generar imágenes basadas en un sujeto específico con los SDKs de Firebase AI Logic.

Cómo funciona: Proporcionas una instrucción de texto y, al menos, una imagen de referencia que muestre un tema específico (como un producto, una persona o un animal de compañía). El modelo usa estas entradas para generar una imagen nueva basada en el tema especificado en las imágenes de referencia.

Por ejemplo, puedes pedirle al modelo que aplique un estilo de dibujos animados a una foto de un niño o niña, o que cambie el color de una bicicleta en una imagen.

arrow_downward Ir al código

Antes de comenzar

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

Imagen ofrece edición de imágenes a través de su modelo capability:

• imagen-3.0-capability-001

Ten en cuenta que, para los modelos Imagen, no se admite la ubicación global.

Envía una solicitud de personalización del asunto

En el siguiente ejemplo, se muestra una solicitud de personalización del tema que le pide al modelo que genere una imagen nueva basada en la imagen de referencia proporcionada (en este ejemplo, un gato). Como un gato es un animal, usa el tipo de sujeto ImagenSubjectReferenceType.ANIMAL.

Si el tema es una persona o un producto, también puedes usar este ejemplo, pero con los siguientes cambios:

• Si el asunto es una persona, usa el tipo de asunto ImagenSubjectReferenceType.PERSON. Puedes enviar este tipo de solicitud con o sin una imagen de control de malla facial para guiar aún más la generación de imágenes.

• Si el tema es un producto, usa el tipo de tema ImagenSubjectReferenceType.PRODUCT.

Revisa las plantillas de instrucciones más adelante en esta página para obtener información sobre cómo escribir instrucciones y usar imágenes de referencia en ellas.

// Using this SDK to access Imagen models is a Preview release and requires opt-in
@OptIn(PublicPreviewAPI::class)
suspend fun customizeImage() {
    // Initialize the Vertex AI Gemini API backend service
    // Optionally specify the location to access the model (for example, `us-central1`)
    val ai = Firebase.ai(backend = GenerativeBackend.vertexAI(location = "us-central1"))

    // Create an `ImagenModel` instance with an Imagen "capability" model
    val model = ai.imagenModel("imagen-3.0-capability-001")

    // This example assumes 'referenceImage' is a pre-loaded Bitmap.
    // In a real app, this might come from the user's device or a URL.
    val referenceImage: Bitmap = TODO("Load your reference image Bitmap here")

    // Define the subject reference using the reference image.
    val subjectReference = ImagenSubjectReference(
        image = referenceImage,
        referenceID = 1,
        description = "cat",
        subjectType = ImagenSubjectReferenceType.ANIMAL
    )

    // Provide a prompt that describes the final image.
    // The "[1]" links the prompt to the subject reference with ID 1.
    val prompt = "A cat[1] flying through outer space"

    // Use the editImage API to perform the subject customization.
    // Pass the list of references, the prompt, and an editing configuration.
    val editedImage = model.editImage(
        references = listOf(subjectReference),
        prompt = prompt,
        config = ImagenEditingConfig(
            editSteps = 50 // Number of editing steps, a higher value can improve quality
        )
    )

    // Process the result
}

// Initialize the Vertex AI Gemini API backend service
// Optionally specify the location to access the model (for example, `us-central1`)
// Create an `ImagenModel` instance with an Imagen "capability" model
ImagenModel imagenModel = FirebaseAI.getInstance(GenerativeBackend.vertexAI("us-central1"))
        .imagenModel(
                /* modelName */ "imagen-3.0-capability-001");

ImagenModelFutures model = ImagenModelFutures.from(imagenModel);

// This example assumes 'referenceImage' is a pre-loaded Bitmap.
// In a real app, this might come from the user's device or a URL.
Bitmap referenceImage = null; // TODO("Load your image Bitmap here");

// Define the subject reference using the reference image.
ImagenSubjectReference subjectReference = new ImagenSubjectReference.Builder()
        .setImage(referenceImage)
        .setReferenceID(1)
        .setDescription("cat")
        .setSubjectType(ImagenSubjectReferenceType.ANIMAL)
        .build();

// Provide a prompt that describes the final image.
// The "[1]" links the prompt to the subject reference with ID 1.
String prompt = "A cat[1] flying through outer space";

// Define the editing configuration.
ImagenEditingConfig imagenEditingConfig = new ImagenEditingConfig.Builder()
        .setEditSteps(50) // Number of editing steps, a higher value can improve quality
        .build();

// Use the editImage API to perform the subject customization.
// Pass the list of references, the prompt, and an editing configuration.
Futures.addCallback(model.editImage(Collections.singletonList(subjectReference), prompt, imagenEditingConfig), new FutureCallback<ImagenGenerationResponse>() {
    @Override
    public void onSuccess(ImagenGenerationResponse 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());

import 'dart:typed_data';
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 Vertex AI Gemini API backend service
// Optionally specify a location to access the model (for example, `us-central1`)
final ai = FirebaseAI.vertexAI(location: 'us-central1');

// Create an `ImagenModel` instance with an Imagen "capability" model
final model = ai.imagenModel(model: 'imagen-3.0-capability-001');

// This example assumes 'referenceImage' is a pre-loaded Uint8List.
// In a real app, this might come from the user's device or a URL.
final Uint8List referenceImage = Uint8List(0); // TODO: Load your reference image data here

// Define the subject reference using the reference image.
final subjectReference = ImagenSubjectReference(
  image: referenceImage,
  referenceId: 1,
  description: 'cat',
  subjectType: ImagenSubjectReferenceType.animal,
);

// Provide a prompt that describes the final image.
// The "[1]" links the prompt to the subject reference with ID 1.
final prompt = "A cat[1] flying through outer space.";

try {
  // Use the editImage API to perform the subject customization.
  // Pass the list of references, the prompt, and an editing configuration.
  final response = await model.editImage(
    [subjectReference],
    prompt,
    config: ImagenEditingConfig(
      editSteps: 50, // Number of editing steps, a higher value can improve quality
    ),
  );

  // Process the result.
  if (response.images.isNotEmpty) {
    final editedImage = response.images.first.bytes;
    // Use the editedImage (a Uint8List) to display the image, save it, etc.
    print('Image successfully generated!');
  } else {
    // Handle the case where no images were generated.
    print('Error: No images were generated.');
  }
} catch (e) {
  // Handle any potential errors during the API call.
  print('An error occurred: $e');
}

Plantillas de instrucciones

En la solicitud, proporcionas imágenes de referencia (hasta 4 imágenes) definiendo un ImagenSubjectReference en el que especificas un ID de referencia para una imagen (y, de manera opcional, una descripción del sujeto). Ten en cuenta que varias imágenes pueden tener el mismo ID de referencia (por ejemplo, varias fotos del mismo gato).

Luego, cuando escribas la instrucción, haz referencia a estos IDs. Por ejemplo, usas [1] en la instrucción para hacer referencia a imágenes con el ID de referencia 1. Si proporcionas una descripción del tema, también puedes incluirla en la instrucción para que sea más fácil de leer.

En la siguiente tabla, se describen las plantillas de instrucciones que pueden ser un punto de partida para escribir instrucciones de personalización basadas en un tema (como un producto, una persona o un animal de compañía).

Prácticas recomendadas y limitaciones

Si usas una persona como sujeto, te recomendamos que el rostro de la imagen de referencia tenga las siguientes propiedades:

• Está centrada y ocupa al menos la mitad de la imagen completa.
• Se rota en la vista frontal en todas las direcciones (alabeo, cabeceo y guiñada)
• No está obstruido por objetos, como anteojos de sol o mascarillas

Casos de uso

La capacidad de personalización ofrece instrucciones de formato libre, lo que puede dar la impresión de que el modelo puede hacer más de lo que está entrenado para hacer. En las siguientes secciones, se describen los casos de uso previstos para la personalización y ejemplos de casos de uso no previstos (no exhaustivos).

Te recomendamos que uses esta capacidad para los casos de uso previstos, ya que entrenamos el modelo en esos casos de uso y esperamos obtener buenos resultados. Por el contrario, si le pides al modelo que haga cosas fuera de los casos de uso previstos, debes esperar resultados deficientes.

Casos de uso previstos

A continuación, se indican los casos de uso previstos para la personalización basada en un tema:

• Estilizar una foto de una persona

• Estilizar una foto de una persona y conservar sus expresiones faciales

• (Bajo nivel de éxito) Coloca un producto, como un sofá o una galleta, en diferentes escenas con diferentes ángulos del producto.

• Generar variaciones de un producto que no conserva los detalles exactos

• Estilizar una foto de una persona y conservar su expresión facial

Ejemplos de casos de uso no previstos

A continuación, se incluye una lista no exhaustiva de casos de uso no previstos para la personalización basada en un sujeto. El modelo no está entrenado para estos casos de uso y es probable que produzca resultados deficientes.

• Coloca a dos o más personas en diferentes escenas y conserva sus identidades.

• Coloca a dos o más personas en diferentes escenas y conserva sus identidades, además de especificar el estilo de la imagen de salida con una imagen de ejemplo como entrada para el estilo.

• Estiliza una foto de dos o más personas y conserva sus identidades.

• Coloca a una mascota en diferentes escenas y conserva su identidad.

• Estiliza una foto de una mascota y conviértela en un dibujo.

• Estiliza una foto de una mascota y conviértela en un dibujo, a la vez que conservas o especificas el estilo de la imagen (como acuarela).

• Coloca una mascota y una persona en una escena diferente, conservando la identidad de ambas.

• Estiliza una foto de una mascota y una o más personas, y conviértela en un dibujo.

• Coloca dos productos en diferentes escenas con diferentes ángulos de los productos.

• Coloca un producto, como una galleta o un sofá, en diferentes escenas con ángulos distintos y siguiendo un estilo de imagen específico (como fotorrealista con colores, estilos de iluminación o animación específicos).

• Coloca un producto en una escena diferente y conserva la composición específica de la escena según lo especifica una imagen de control.

• Coloca dos productos en diferentes escenas con diferentes ángulos de productos, usando una imagen específica como entrada (por ejemplo, fotorrealista con colores, estilos de iluminación o animación específicos).

• Coloca dos productos en diferentes escenas y conserva la composición específica de la escena, tal como se especifica en una imagen de control.