Gerar imagens usando o Imagen


Os SDKs do Firebase AI Logic dão acesso aos modelos Imagen (pelo Imagen API) para que você possa gerar imagens com base em um comando de texto. Com esse recurso, é possível:

  • Gerar imagens com base em comandos escritos em linguagem natural
  • Gere imagens em uma ampla variedade de formatos e estilos
  • Renderizar texto em imagens

O Firebase AI Logic ainda não é compatível com todos os recursos disponíveis para os modelos Imagen. Saiba mais em Recursos e funcionalidades compatíveis mais adiante nesta página.

Ir para o código de entrada somente de texto

Como escolher entre os modelos Gemini e Imagen

Os SDKs Firebase AI Logic são compatíveis com a geração de imagens usando um modelo Gemini ou Imagen. Na maioria dos casos de uso, comece com Gemini e escolha Imagen para tarefas especializadas em que a qualidade da imagem é essencial.

Os SDKs do Firebase AI Logic ainda não são compatíveis com entrada de imagem (como para edição) com modelos Imagen. Portanto, se você quiser trabalhar com imagens de entrada, use um modelo Gemini.

Escolha Gemini quando quiser:

  • Usar conhecimento de mundo e raciocínio para gerar imagens contextualmente relevantes.
  • Para combinar texto e imagens de forma integrada.
  • Para incorporar recursos visuais precisos em longas sequências de texto.
  • Para editar imagens de forma conversacional, mantendo o contexto.

Escolha Imagen quando quiser:

  • Para priorizar a qualidade da imagem, o fotorrealismo, os detalhes artísticos ou estilos específicos (por exemplo, impressionismo ou anime).
  • Para especificar explicitamente a proporção ou o formato das imagens geradas.

Antes de começar

Clique no seu provedor de Gemini API para conferir o conteúdo e o código específicos do provedor nesta página.

Se ainda não tiver feito isso, conclua o guia de primeiros passos, que descreve como configurar seu projeto do Firebase, conectar seu app ao Firebase, adicionar o SDK, inicializar o serviço de back-end para o provedor de API escolhido e criar uma instância ImagenModel.

Modelos compatíveis com esse recurso

O Gemini Developer API só é compatível com a geração de imagens pelo modelo Imagen 3 estável mais recente, mas não com os outros modelos Imagen. Essas limitações do modelo Imagen se aplicam independente de como você acessa o Gemini Developer API.

  • imagen-3.0-generate-002

Gerar imagens com base em entradas somente de texto

Você pode pedir a um modelo Imagen para gerar imagens usando comandos de texto. É possível gerar uma imagem ou várias imagens.

Gerar uma imagem com base em uma entrada somente de texto

Antes de testar esta amostra, conclua a seção Antes de começar deste guia para configurar seu projeto e app.
Nessa seção, clique também em um botão do provedor de Gemini API escolhido para ver o conteúdo específico do provedor nesta página.

Você pode pedir a um modelo Imagen para gerar uma única imagem usando um comando de texto.

Crie uma instância ImagenModel e chame generateImages.

Swift


import FirebaseAI

// Initialize the Gemini Developer API backend service
let ai = FirebaseAI.firebaseAI(backend: .googleAI())


// Create an `ImagenModel` instance with a model that supports your use case
let model = ai.imagenModel(modelName: "imagen-3.0-generate-002")

// Provide an image generation prompt
let prompt = "An astronaut riding a horse"

// To generate an image, call `generateImages` with the text prompt
let response = try await model.generateImages(prompt: prompt)

// Handle the generated image
guard let image = response.images.first else {
  fatalError("No image in the response.")
}
let uiImage = UIImage(data: image.data)

Kotlin


// Using this SDK to access Imagen models is a Preview release and requires opt-in
@OptIn(PublicPreviewAPI::class)
suspend fun generateImage() {
  // Initialize the Gemini Developer API backend service
  // Create an `ImagenModel` instance with an Imagen model that supports your use case
  val imagenModel = Firebase.ai(backend = GenerativeBackend.googleAI()).imagenModel("imagen-3.0-generate-002")

  // Provide an image generation prompt
  val prompt = "An astronaut riding a horse"

  // To generate an image, call `generateImages` with the text prompt
  val imageResponse = imagenModel.generateImages(prompt)

  // Handle the generated image
  val image = imageResponse.images.first()

  val bitmapImage = image.asBitmap()
}

Java


// Initialize the Gemini Developer API backend service
// Create an `ImagenModel` instance with an Imagen model that supports your use case
ImagenModel imagenModel = FirebaseAI.getInstance(GenerativeBackend.googleAI()).imagenModel(
        /* modelName */ "imagen-3.0-generate-002");

ImagenModelFutures model = ImagenModelFutures.from(imagenModel);

// Provide an image generation prompt
String prompt = "An astronaut riding a horse";

// To generate an image, call `generateImages` with the text prompt
Futures.addCallback(model.generateImages(prompt), new FutureCallback<ImagenGenerationResponse<ImagenInlineImage>>() {
    @Override
    public void onSuccess(ImagenGenerationResponse<ImagenInlineImage> result) {
        if (result.getImages().isEmpty()) {
            Log.d("TAG", "No images generated");
        }
        Bitmap bitmap = result.getImages().get(0).asBitmap();
        // Use the bitmap to display the image in your UI
    }

    @Override
    public void onFailure(Throwable t) {
        // ...
    }
}, Executors.newSingleThreadExecutor());

Web


import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend } from "firebase/ai";

// TODO(developer) Replace the following with your app's Firebase configuration
// See: https://firebase.google.com/docs/web/learn-more#config-object
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });


// Create an `ImagenModel` instance with an Imagen 3 model that supports your use case
const imagenModel = getImagenModel(ai, { model: "imagen-3.0-generate-002" });

// Provide an image generation prompt
const prompt = "An astronaut riding a horse.";

// To generate an image, call `generateImages` with the text prompt
const response = await imagenModel.generateImages(prompt)

// If fewer images were generated than were requested,
// then `filteredReason` will describe the reason they were filtered out
if (response.filteredReason) {
  console.log(response.filteredReason);
}

if (response.images.length == 0) {
  throw new Error("No images in the response.")
}

const image = response.images[0];

Dart

import 'package:firebase_ai/firebase_ai.dart';
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart';

// Initialize FirebaseApp
await Firebase.initializeApp(
  options: DefaultFirebaseOptions.currentPlatform,
);


// Initialize the Gemini Developer API backend service
// Create an `ImagenModel` instance with an Imagen model that supports your use case
final model =
  FirebaseAI.googleAI().imagenModel(model: 'imagen-3.0-generate-002');

// Provide an image generation prompt
const prompt = 'An astronaut riding a horse.';

// To generate an image, call `generateImages` with the text prompt
final response = await model.generateImages(prompt);

if (response.images.isNotEmpty) {
  final image = response.images[0];
  // Process the image
} else {
  // Handle the case where no images were generated
  print('Error: No images were generated.');
}

Unity

O uso do Imagen ainda não é compatível com o Unity. Confira de novo em breve!

Saiba como escolher um modelo adequado para seu caso de uso e app.

Gerar várias imagens com base em entradas somente de texto

Antes de testar esta amostra, conclua a seção Antes de começar deste guia para configurar seu projeto e app.
Nessa seção, clique também em um botão do provedor de Gemini API escolhido para ver o conteúdo específico do provedor nesta página.

Por padrão, os modelos Imagen geram apenas uma imagem por solicitação. No entanto, é possível pedir a um modelo Imagen para gerar várias imagens por solicitação fornecendo um ImagenGenerationConfig ao criar a instância ImagenModel.

Crie uma instância ImagenModel e chame generateImages.

Swift


import FirebaseAI

// Initialize the Gemini Developer API backend service
let ai = FirebaseAI.firebaseAI(backend: .googleAI())


// Create an `ImagenModel` instance with a model that supports your use case
let model = ai.imagenModel(
  modelName: "imagen-3.0-generate-002",
  // Configure the model to generate multiple images for each request
  // See: https://firebase.google.com/docs/ai-logic/model-parameters
  generationConfig: ImagenGenerationConfig(numberOfImages: 4)
)

// Provide an image generation prompt
let prompt = "An astronaut riding a horse"

// To generate images, call `generateImages` with the text prompt
let response = try await model.generateImages(prompt: prompt)

// If fewer images were generated than were requested,
// then `filteredReason` will describe the reason they were filtered out
if let filteredReason = response.filteredReason {
  print(filteredReason)
}

// Handle the generated images
let uiImages =  response.images.compactMap { UIImage(data: $0.data) }

Kotlin


// Using this SDK to access Imagen models is a Preview release and requires opt-in
@OptIn(PublicPreviewAPI::class)
suspend fun generateImage() {
  // Initialize the Gemini Developer API backend service
  // Create an `ImagenModel` instance with an Imagen model that supports your use case
  val imagenModel = Firebase.ai(backend = GenerativeBackend.googleAI()).imagenModel(
      modelName = "imagen-3.0-generate-002",
      // Configure the model to generate multiple images for each request
      // See: https://firebase.google.com/docs/ai-logic/model-parameters
      generationConfig = ImagenGenerationConfig(numberOfImages = 4)
  )

  // Provide an image generation prompt
  val prompt = "An astronaut riding a horse"

  // To generate images, call `generateImages` with the text prompt
  val imageResponse = imagenModel.generateImages(prompt)

  // If fewer images were generated than were requested,
  // then `filteredReason` will describe the reason they were filtered out
  if (imageResponse.filteredReason != null) {
    Log.d(TAG, "FilteredReason: ${imageResponse.filteredReason}")
  }

  for (image in imageResponse.images) {
    val bitmap = image.asBitmap()
    // Use the bitmap to display the image in your UI
  }
}

Java


// Configure the model to generate multiple images for each request
// See: https://firebase.google.com/docs/ai-logic/model-parameters
ImagenGenerationConfig imagenGenerationConfig = new ImagenGenerationConfig.Builder()
        .setNumberOfImages(4)
        .build();

// Initialize the Gemini Developer API backend service
// Create an `ImagenModel` instance with an Imagen model that supports your use case
ImagenModel imagenModel = FirebaseAI.getInstance(GenerativeBackend.googleAI()).imagenModel(
        /* modelName */ "imagen-3.0-generate-002",
        /* imageGenerationConfig */ imagenGenerationConfig);

ImagenModelFutures model = ImagenModelFutures.from(imagenModel);

// Provide an image generation prompt
String prompt = "An astronaut riding a horse";

// To generate images, call `generateImages` with the text prompt
Futures.addCallback(model.generateImages(prompt), new FutureCallback<ImagenGenerationResponse<ImagenInlineImage>>() {
    @Override
    public void onSuccess(ImagenGenerationResponse<ImagenInlineImage> result) {
        // If fewer images were generated than were requested,
        // then `filteredReason` will describe the reason they were filtered out
        if (result.getFilteredReason() != null){
            Log.d("TAG", "FilteredReason: " + result.getFilteredReason());
        }

        // Handle the generated images
        List<ImagenInlineImage> images = result.getImages();
        for (ImagenInlineImage image : images) {
            Bitmap bitmap = image.asBitmap();
            // Use the bitmap to display the image in your UI
        }
    }

    @Override
    public void onFailure(Throwable t) {
        // ...
    }
}, Executors.newSingleThreadExecutor());

Web


import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend } from "firebase/ai";

// TODO(developer) Replace the following with your app's Firebase configuration
// See: https://firebase.google.com/docs/web/learn-more#config-object
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });


// Create an `ImagenModel` instance with an Imagen 3 model that supports your use case
const imagenModel = getImagenModel(
  ai,
  {
    model: "imagen-3.0-generate-002",
    // Configure the model to generate multiple images for each request
    // See: https://firebase.google.com/docs/ai-logic/model-parameters
    generationConfig: {
      numberOfImages: 4
    }
  }
);

// Provide an image generation prompt
const prompt = "An astronaut riding a horse.";

// To generate images, call `generateImages` with the text prompt
const response = await imagenModel.generateImages(prompt)

// If fewer images were generated than were requested,
// then `filteredReason` will describe the reason they were filtered out
if (response.filteredReason) {
  console.log(response.filteredReason);
}

if (response.images.length == 0) {
  throw new Error("No images in the response.")
}

const images = response.images[0];

Dart

import 'package:firebase_ai/firebase_ai.dart';
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart';

// Initialize FirebaseApp
await Firebase.initializeApp(
  options: DefaultFirebaseOptions.currentPlatform,
);


// Initialize the Gemini Developer API backend service
// Create an `ImagenModel` instance with an Imagen model that supports your use case
final model =
  FirebaseAI.googleAI().imagenModel(
    model: 'imagen-3.0-generate-002',
    // Configure the model to generate multiple images for each request
    // See: https://firebase.google.com/docs/ai-logic/model-parameters
    generationConfig: ImagenGenerationConfig(numberOfImages: 4),
);

// Provide an image generation prompt
const prompt = 'An astronaut riding a horse.';

// To generate images, call `generateImages` with the text prompt
final response = await model.generateImages(prompt);

// If fewer images were generated than were requested,
// then `filteredReason` will describe the reason they were filtered out
if (response.filteredReason != null) {
  print(response.filteredReason);
}

if (response.images.isNotEmpty) {
  final images = response.images;
  for(var image in images) {
  // Process the image
  }
} else {
  // Handle the case where no images were generated
  print('Error: No images were generated.');
}

Unity

O uso do Imagen ainda não é compatível com o Unity. Confira de novo em breve!

Saiba como escolher um modelo adequado para seu caso de uso e app.



Recursos e requisitos compatíveis

Os modelos Imagen oferecem muitos recursos relacionados à geração de imagens. Esta seção descreve o que é compatível ao usar os modelos com Firebase AI Logic.

Recursos e funcionalidades compatíveis

Firebase AI Logic é compatível com estes recursos dos modelos Imagen.

Firebase AI Logic não é compatível com esses recursos avançados dos modelos Imagen.

A maioria desses recursos exige que você esteja em uma lista aprovada de usuários, mesmo ao usar modelos Imagen no lado do servidor.

  • Recursos de edição ou manipulação de imagens, incluindo o dimensionamento de imagens

  • Incluir imagens na solicitação ao modelo (como no aprendizado few-shot)

  • Verificar marcas-d'água digitais usando os SDKs
    Se você quiser verificar se uma imagem tem uma marca-d'água, faça upload dela no Vertex AI Studio usando a guia Mídia.

  • Gerar "imagens dinâmicas" com base em texto (geração de MP4)

  • Gerar imagens usando um estilo predefinido

  • Definir o idioma do texto de entrada

  • Ativar includeSafetyAttributes, o que significa que safetyAttributes.categories e safetyAttributes.scores não podem ser retornados

  • Desativar o aprimoramento de comandos (o parâmetro enhancePrompt), o que significa que uma ferramenta de alteração de comando baseada em LLM sempre adicionará mais detalhes ao comando fornecido para gerar imagens de melhor qualidade que reflitam melhor o comando fornecido.

  • Escrever uma imagem gerada diretamente em Google Cloud Storage como parte da resposta do modelo (o parâmetro storageUri). Em vez disso, as imagens são sempre retornadas como bytes de imagem codificados em base64 na resposta.
    Se você quiser fazer upload de uma imagem gerada para Cloud Storage, use Cloud Storage for Firebase.

Especificações e limitações

Propriedade (por solicitação) Valor
Número máximo de tokens de entrada 480 tokens
Número máximo de imagens de saída 4 imagens
Resoluções de imagem de saída compatíveis (pixels)
  • 1024x1024 pixels (proporção de 1:1)
  • 896x1280 (proporção de 3:4)
  • 1280x896 (proporção de 4:3)
  • 768x1408 (proporção de 9:16)
  • 1408x768 (proporção de 16:9)



O que mais você sabe fazer?

Saiba como controlar a geração de conteúdo

Saiba mais sobre os modelos compatíveis

Saiba mais sobre os modelos disponíveis para vários casos de uso e as respectivas cotas e preços.


Enviar feedback sobre sua experiência com Firebase AI Logic