Gerar imagens com o Imagen 3

O Imagen 3 é um modelo de geração de imagens. Ele pode ser usado para gerar avatars personalizados para perfis de usuários ou integrar recursos visuais personalizados a fluxos de tela existentes para aumentar o engajamento do usuário.

É possível acessar os modelos do Imagen no seu app Android usando a Vertex AI no SDK do Firebase.

Acessar modelos do Imagen 3 usando a Vertex AI no Firebase
Figura 1. Acesse os modelos do Imagen 3 usando a Vertex AI no Firebase.

Testar comandos

A criação das instruções ideais geralmente exige várias tentativas. Você pode testar com comandos de imagem no Vertex AI Studio, um ambiente de desenvolvimento integrado para design e prototipagem de comandos. Para dicas sobre como melhorar seus comandos, consulte o guia de comandos e atributos de imagem.

O Vertex AI Studio pode ajudar você a refinar seus comandos de geração de imagens
Figura 2. O Vertex AI Studio pode ajudar você a refinar seus comandos de geração de imagens.

Configurar um projeto do Firebase e conectar seu app

Siga as etapas na documentação do Firebase para adicionar o Firebase ao seu projeto Android.

Adicionar a dependência do Gradle

Adicione as seguintes dependências ao arquivo do app build.gradle:

dependencies {
    implementation(platform("com.google.firebase:firebase-bom:33.9.0"))

    implementation("com.google.firebase:firebase-vertexai")
}

O Imagen 3 na Vertex AI no Firebase requer a BOM do Firebase 33.10.0 ou mais recente.

Gerar uma imagem

Para gerar uma imagem no app Android, comece instanciando um ImagenModel com uma configuração opcional.

É possível usar o parâmetro generationConfig para definir um comando negativo, o número de imagens, a proporção da imagem de saída, o formato da imagem e adicionar uma marca d'água. É possível usar o parâmetro safetySettings para configurar os filtros de segurança e de pessoas.

Kotlin

val imagenModel = Firebase.vertexAI.imagenModel(
  modelName = "imagen-3.0-generate-001",
  generationConfig = ImagenGenerationConfig(
    negativePrompt = "frogs",
    numberOfImages = 2,
    aspectRatio = ImagenAspectRatio.LANDSCAPE_16x9,
    imageFormat = ImagenImageFormat.jpeg(compressionQuality = 100),
    addWatermark = false
  ),
  safetySettings = ImagenSafetySettings(
    safetyFilterLevel = ImagenSafetyFilterLevel.BLOCK_LOW_AND_ABOVE,
    personFilterLevel = ImagenPersonFilterLevel.BLOCK_ALL
  )
)

Java

GenerativeModel imagenModel = FirebaseVertexAI.getInstance().imagenModel(
    "imagen-3.0-generate-001",
    ImagenGenerationConfig.builder()
        .setNegativePrompt("frogs")
        .setNumberOfImages(2)
        .setAspectRatio(ImagenAspectRatio.LANDSCAPE_16x9)
        .setImageFormat(ImagenImageFormat.jpeg(100))
        .setAddWatermark(true)
        .build(),
    ImagenSafetySettings.builder()
        .setSafetyFilterLevel(ImagenSafetyFilterLevel.BLOCK_LOW_AND_ABOVE)
        .setPersonFilterLevel(ImagenPersonFilterLevel.BLOCK_ALL)
        .build()
);

Depois que o ImagenModel for instanciado, você poderá gerar imagens chamando generateImages:

Kotlin

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

Java

CompletableFuture<GenerateContentResponse> futureResponse =
    imagenModel.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();
}

Próximas etapas