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.
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
Ativar
includeSafetyAttributes
, o que significa quesafetyAttributes.categories
esafetyAttributes.scores
não podem ser retornadosDesativar 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) |
|
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