Generare immagini utilizzando Imagen


Gli SDK Firebase AI Logic ti consentono di accedere ai modelli Imagen (tramite Imagen API) per generare immagini da un prompt di testo. Con questa funzionalità puoi:

  • Generare immagini da prompt scritti in linguaggio naturale
  • Generare immagini in un'ampia gamma di formati e stili
  • Visualizzare il testo nelle immagini

Tieni presente che Firebase AI Logic non supporta ancora tutte le funzionalità disponibili per i modelli Imagen. Scopri di più in Funzionalità e capacità supportate più avanti in questa pagina.

Vai al codice per l'input solo testo

Scelta tra i modelli Gemini e Imagen

Gli SDK Firebase AI Logic supportano la generazione di immagini utilizzando un modello Gemini o un modello Imagen. Per la maggior parte dei casi d'uso, inizia con Gemini, quindi scegli Imagen per attività specializzate in cui la qualità dell'immagine è fondamentale.

Tieni presente che gli SDK Firebase AI Logic non supportano ancora l'input di immagini (ad esempio per la modifica) con i modelli Imagen. Pertanto, se vuoi lavorare con immagini di input, puoi utilizzare un modello Gemini.

Scegli Gemini quando vuoi:

  • Utilizzare la conoscenza del mondo e il ragionamento per generare immagini contestualmente pertinenti.
  • Per combinare perfettamente testo e immagini.
  • Per incorporare immagini accurate all'interno di lunghe sequenze di testo.
  • Per modificare le immagini in modo conversazionale mantenendo il contesto.

Scegli Imagen quando vuoi:

  • Per dare la priorità alla qualità dell'immagine, al fotorealismo, ai dettagli artistici o a stili specifici (ad esempio, impressionismo o anime).
  • Per specificare in modo esplicito le proporzioni o il formato delle immagini generate.

Prima di iniziare

Fai clic sul tuo fornitore Gemini API per visualizzare i contenuti e il codice specifici del fornitore in questa pagina.

Se non l'hai ancora fatto, completa la guida introduttiva, che descrive come configurare il progetto Firebase, connettere l'app a Firebase, aggiungere l'SDK, inizializzare il servizio di backend per il provider API scelto e creare un'istanza ImagenModel.

Modelli che supportano questa funzionalità

Gemini Developer API supporta solo la generazione di immagini tramite l'ultimo modello Imagen 3 stabile, ma non gli altri modelli Imagen. Queste limitazioni del modello Imagen sono applicabili indipendentemente da come accedi a Gemini Developer API.

  • imagen-3.0-generate-002

Generare immagini da input solo di testo

Puoi chiedere a un modello Imagen di generare immagini con un prompt di testo. Puoi generare un'immagine o più immagini.

Genera un'immagine da un input di solo testo

Prima di provare questo esempio, completa la sezione Prima di iniziare di questa guida per configurare il progetto e l'app.
In questa sezione, fai clic anche su un pulsante per il provider Gemini API che hai scelto, in modo da visualizzare i contenuti specifici del provider in questa pagina.

Puoi chiedere a un modello Imagen di generare una singola immagine fornendo un prompt di testo.

Assicurati di creare un'istanza ImagenModel e chiamare 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

L'utilizzo di Imagen non è ancora supportato per Unity, ma ricontrolla a breve.

Scopri come scegliere un modello adatta al tuo caso d'uso e alla tua app.

Generare più immagini da input solo di testo

Prima di provare questo esempio, completa la sezione Prima di iniziare di questa guida per configurare il progetto e l'app.
In questa sezione, fai clic anche su un pulsante per il provider Gemini API che hai scelto, in modo da visualizzare i contenuti specifici del provider in questa pagina.

Per impostazione predefinita, i modelli Imagen generano una sola immagine per richiesta. Tuttavia, puoi chiedere a un modello Imagen di generare più immagini per richiesta fornendo un ImagenGenerationConfig quando crei l'istanza ImagenModel.

Assicurati di creare un'istanza ImagenModel e chiamare 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

L'utilizzo di Imagen non è ancora supportato per Unity, ma ricontrolla a breve.

Scopri come scegliere un modello adatta al tuo caso d'uso e alla tua app.


Funzionalità e requisiti supportati

I modelli Imagen offrono molte funzionalità relative alla generazione di immagini. Questa sezione descrive cosa è supportato quando si utilizzano i modelli con Firebase AI Logic.

Funzionalità e capacità supportate

Firebase AI Logic supporta queste funzionalità dei modelli Imagen.

  • Generazione di persone e volti (dato che il tuo progetto Firebase ha ricevuto l'approvazione da Google Cloud)

  • Generare testo all'interno delle immagini generate

  • Aggiungere una filigrana alle immagini generate

  • Configurazione dei parametri di generazione delle immagini, come il numero di immagini generate, le proporzioni e l'applicazione di filigrane

  • Configurazione delle impostazioni di sicurezza

Firebase AI Logic non supporta queste funzionalità avanzate dei modelli Imagen.

Tieni presente che la maggior parte di queste funzionalità richiede l'inserimento in un elenco approvato di utenti anche quando utilizzi i modelli Imagen lato server.

  • Funzionalità di modifica o manipolazione delle immagini, inclusa l'upscaling delle immagini

  • Includere immagini nella richiesta al modello (ad esempio per l'apprendimento few-shot)

  • Verifica delle filigrane digitali utilizzando gli SDK
    Se vuoi verificare che un'immagine abbia una filigrana, puoi caricarla in Vertex AI Studio utilizzando la scheda Media.

  • Generazione di "immagini live" dal testo (generazione di MP4)

  • Generare immagini utilizzando uno stile predefinito

  • Impostare la lingua del testo di input

  • Se attivi includeSafetyAttributes, significa che safetyAttributes.categories e safetyAttributes.scores non possono essere restituiti

  • Disattivazione del miglioramento del prompt (il parametro enhancePrompt), il che significa che uno strumento di riscrittura del prompt basato su LLM aggiungerà sempre automaticamente maggiori dettagli al prompt fornito per fornire immagini di qualità superiore che riflettano meglio il prompt fornito

  • Scrivere un'immagine generata direttamente in Google Cloud Storage come parte della risposta del modello (il parametro storageUri). Le immagini vengono sempre restituite come byte immagine con codifica base64 nella risposta.
    Se vuoi caricare un'immagine generata su Cloud Storage, puoi utilizzare Cloud Storage for Firebase.

Specifiche e limitazioni

Proprietà (per richiesta) Valore
Numero massimo di token di input 480 token
Numero massimo di immagini di output 4 immagini
Risoluzioni delle immagini di output supportate (pixel)
  • 1024 x 1024 pixel (proporzioni 1:1)
  • 896 x 1280 (proporzioni 3:4)
  • 1280 x 896 (proporzioni 4:3)
  • 768 x 1408 (proporzioni 9:16)
  • 1408 x 768 (proporzioni 16:9)


Cos'altro puoi fare?

Scopri come controllare la generazione di contenuti

Scopri di più sui modelli supportati

Scopri di più sui modelli disponibili per vari casi d'uso e sulle relative quote e prezzi.


Fornisci un feedback sulla tua esperienza con Firebase AI Logic