Genera imágenes con Imagen

Imagen es un modelo de generación de imágenes. Se puede usar para generar avatares personalizados para perfiles de usuario o para integrar recursos visuales personalizados en flujos de pantallas existentes para aumentar la participación de los usuarios.

Puedes acceder a los modelos de Imagen desde tu app para Android con el SDK de Firebase AI Logic. Los modelos de Imagen están disponibles a través de los proveedores de la API de Firebase AI Logic: la API de Gemini Developer (recomendada para la mayoría de los desarrolladores) y Vertex AI.

Un diagrama que ilustra una arquitectura de integración de Firebase AI Logic para acceder a la API de Gemini Developer. Una app para Android utiliza el SDK de Firebase para Android para conectarse a Firebase. Luego, Firebase interactúa con la API de Gemini Developer, que accede a Gemini Pro y Flash en la nube.
Figura 1: Accede a los modelos de Imagen con Firebase AI Logic.

Experimenta con instrucciones

Crear las instrucciones ideales suele requerir varios intentos. Puedes experimentar con instrucciones de imágenes en Vertex AI Studio, un IDE para el diseño y la creación de prototipos de instrucciones. Si quieres obtener sugerencias para mejorar tus instrucciones, consulta la guía de atributos de imágenes y mensajes.

Captura de pantalla de la interfaz de Vertex AI Studio de Google Cloud, en la que se muestran cuatro imágenes generadas de un T-Rex con una mochila azul en un bosque prehistórico. En la barra lateral izquierda, se muestran opciones de navegación, como Panel, Model Garden y Vision, mientras que el panel derecho contiene parámetros para la configuración de generación de imágenes.
Figura 2: Vertex AI Studio puede ayudarte a definir mejor tus instrucciones de generación de imágenes.

Configura un proyecto de Firebase y conecta tu app

Sigue los pasos que se indican en la documentación de Firebase para agregar Firebase a tu proyecto de Android.

Agrega la dependencia de Gradle

Agrega las siguientes dependencias a tu archivo build.gradle:

dependencies {
  // Import the BoM for the Firebase platform
  implementation(platform("com.google.firebase:firebase-bom:34.2.0"))

  // Add the dependency for the Firebase AI Logic library. When using the BoM,
  // you don't specify versions in Firebase library dependencies
  implementation("com.google.firebase:firebase-ai")
}

Genera una imagen

Para generar una imagen en tu app para Android, primero crea una instancia de ImagenModel con una configuración opcional.

Puedes usar el parámetro generationConfig para definir una instrucción negativa, la cantidad de imágenes, la relación de aspecto de la imagen de salida, el formato de la imagen y agregar una marca de agua. Puedes usar el parámetro safetySettings para configurar los filtros de seguridad y de personas.

Kotlin

val config = ImagenGenerationConfig {
    numberOfImages = 2,
    aspectRatio = ImagenAspectRatio.LANDSCAPE_16x9,
    imageFormat = ImagenImageFormat.jpeg(compressionQuality = 100),
    addWatermark = false
}

// Initialize the Gemini Developer API backend service
// For Vertex AI use Firebase.ai(backend = GenerativeBackend.vertexAI())
val model = Firebase.ai(backend = GenerativeBackend.googleAI()).imagenModel(
    modelName = "imagen-3.0-generate-002",
    generationConfig = config,
    safetySettings = ImagenSafetySettings(
       safetyFilterLevel = ImagenSafetyFilterLevel.BLOCK_LOW_AND_ABOVE,
       personFilterLevel = ImagenPersonFilterLevel.BLOCK_ALL
    )
)

Java

ImagenGenerationConfig config = new ImagenGenerationConfig.Builder()
    .setNumberOfImages(2)
    .setAspectRatio(ImagenAspectRatio.LANDSCAPE_16x9)
    .setImageFormat(ImagenImageFormat.jpeg(100))
    .setAddWatermark(false)
    .build();

// For Vertex AI use Firebase.ai(backend = GenerativeBackend.vertexAI())
ImagenModelFutures model = ImagenModelFutures.from(
    FirebaseAI.ai(backend = GenerativeBackend.googleAI()).imagenModel(
       "imagen-3.0-generate-002",
       config,
       ImagenSafetySettings.builder()
          .setSafetyFilterLevel(ImagenSafetyFilterLevel.BLOCK_LOW_AND_ABOVE)
          .setPersonFilterLevel(ImagenPersonFilterLevel.BLOCK_ALL)
          .build())
);

Una vez que se crea una instancia de tu ImagenModel, puedes generar imágenes llamando a generateImages:

Kotlin

val imageResponse = model.generateImages(
  prompt = "An astronaut riding a horse",
)
val image = imageResponse.images.first
val bitmapImage = image.asBitmap()

Java

CompletableFuture<GenerateContentResponse> futureResponse =
    model.generateContent(
        Content.newBuilder()
            .addParts(
                Part.newBuilder()
                    .setText("An astronaut riding a horse")
                    .build())
            .build());

try {
  GenerateContentResponse imageResponse = futureResponse.get();
  List<GeneratedImage> images =
      imageResponse
          .getCandidates(0)
          .getContent()
          .getParts(0)
          .getInlineData()
          .getImagesList();

  if (!images.isEmpty()) {
    GeneratedImage image = images.get(0);
    Bitmap bitmapImage = image.asBitmap();
    // Use bitmapImage
  }
} catch (ExecutionException | InterruptedException e) {
  e.printStackTrace();
}