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 los flujos de pantallas existentes para aumentar la participación de los usuarios.

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

Diagrama que ilustra una arquitectura de integración de Firebase AI Logic para acceder a la API de Gemini Developer Una app para Android usa el SDK de Android de Firebase 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

A menudo, crear las instrucciones ideales requiere varios intentos. Puedes experimentar con instrucciones de imágenes en Vertex AI Studio, un IDE para el diseño y el prototipado 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 tiranosaurio 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 un 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 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 cree una instancia de 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();
}