Esta página foi traduzida pela API Cloud Translation.

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

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.

Gerar pessoas e rostos (desde que seu projeto do Firebase tenha aprovação da Google Cloud)
Gerar texto em imagens geradas
Adicionar uma marca-d'água às imagens geradas
Configurar parâmetros de geração de imagens, como número de imagens geradas, proporção e marca d'água
Configurar as configurações de segurança

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?

Comece a pensar em se preparar para a produção (consulte a lista de verificação de produção), incluindo:
- Configurar o Firebase App Check para proteger o Gemini API contra abusos de clientes não autorizados.
- Integrar o Firebase Remote Config para atualizar valores no app (como o nome do modelo) sem lançar uma nova versão do app.

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

Entenda o design de comandos, incluindo práticas recomendadas, estratégias e exemplos de comandos.
Configure os parâmetros do modelo Imagen, como proporção, geração de pessoas e marca d'água.
Use as configurações de segurança para ajustar a probabilidade de receber respostas que possam ser consideradas prejudiciais.

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

Gerar imagens usando o Imagen Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Como escolher entre os modelos Gemini e Imagen

Antes de começar

Modelos compatíveis com esse recurso

Gerar imagens com base em entradas somente de texto

Gerar uma imagem com base em uma entrada somente de texto

Swift

Kotlin

Java

Web

Dart

Unity

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

Swift

Kotlin

Java

Web

Dart

Unity

Recursos e requisitos compatíveis

Recursos e funcionalidades compatíveis

Especificações e limitações

O que mais você sabe fazer?

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

Saiba mais sobre os modelos compatíveis

Gerar imagens usando o Imagen