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.

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

Um diagrama que ilustra uma arquitetura de integração do Firebase AI Logic para acessar a API Gemini Developer. Um app Android usa o SDK do Firebase para Android 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.

Teste os comandos

Criar os comandos ideais geralmente leva várias tentativas. Você pode testar 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 Google Cloud Vertex AI Studio, 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 seu 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. Use 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();
}