Gerar imagens com o Imagen

O Imagen é um modelo de geração de imagens. Ela pode ser usada para gerar avatares personalizados para perfis de usuários ou integrar recursos visuais personalizados aos fluxos de tela atuais para aumentar o engajamento do usuário.

É possível acessar os modelos Imagen no seu app Android usando o SDK de lógica de IA do Firebase. Os modelos Imagen estão disponíveis usando os provedores de API do Firebase AI Logic: a API Gemini Developer (recomendada para a maioria dos desenvolvedores) e a Vertex AI.

Diagrama que ilustra a arquitetura de integração do Firebase AI Logic para acessar a API Gemini Developer. Um app Android usa o SDK do Firebase para se conectar ao Firebase. Em seguida, o Firebase interage com a API Gemini Developer, que acessa o Gemini Pro e o Flash na nuvem.
Figura 1. Acesse modelos do Imagen usando o Firebase AI Logic.

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.

Uma captura de tela da interface do Vertex AI Studio do Google Cloud, mostrando quatro imagens geradas de um T-Rex com uma mochila azul em uma floresta pré-histórica. A barra lateral esquerda mostra opções de navegação, como Painel, Model Garden e Vision, enquanto o painel direito contém parâmetros para configurações 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 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")
}

Gerar uma imagem

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

Use 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 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())
);

Depois que o ImagenModel for instanciado, você poderá gerar imagens chamando 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();
}