Generare immagini utilizzando Imagen

Anteprima: l'utilizzo degli SDK Firebase AI Logic per accedere ai modelli Imagen è una funzionalità in anteprima, il che significa che non è soggetta a SLA (accordo sul livello del servizio) o norme sul ritiro e potrebbe cambiare in modi non retrocompatibili.

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

• Generare immagini da prompt scritti in linguaggio naturale
• Genera immagini in una vasta gamma di formati e stili
• Eseguire il rendering del testo nelle immagini

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

Vai al codice per l'input di solo testo

Scelta tra i modelli Gemini e Imagen

Gli SDK Firebase AI Logic supportano la generazione di immagini utilizzando un modello Gemini o Imagen. Per la maggior parte dei casi d'uso, inizia con Gemini e poi 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 le immagini di input, puoi utilizzare un modello Gemini.

Scegli Gemini quando vuoi:

• Utilizzare le conoscenze e il ragionamento sul mondo per generare immagini contestualmente pertinenti.
• Per fondere perfettamente testo e immagini.
• Per incorporare immagini accurate in sequenze di testo lunghe.
• 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 esplicitamente 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. API Gemini per gli sviluppatori API Vertex AI Gemini

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

Questa guida presuppone che tu stia utilizzando gli SDK Firebase AI Logic più recenti. Se continui a utilizzare gli SDK "Vertex AI in Firebase", consulta la guida alla migrazione.

Modelli che supportano questa funzionalità

Gemini Developer API supporta la generazione di immagini solo con l'ultimo modello Imagen 3 stabile, ma non con gli altri modelli Imagen. Queste limitazioni del modello Imagen sono applicabili indipendentemente dal modo in cui accedi a Gemini Developer API.

• imagen-3.0-generate-002

Generare immagini da input di solo testo

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

Generare 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, dovrai anche fare clic su un pulsante per il fornitore Gemini API scelto per visualizzare i contenuti specifici del fornitore in questa pagina.

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

Assicurati di creare un'istanza ImagenModel e di 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 appropriato per il tuo caso d'uso e la tua app.

Generare più immagini 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, dovrai anche fare clic su un pulsante per il fornitore Gemini API scelto per visualizzare i contenuti specifici del fornitore 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 di 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 appropriato per il tuo caso d'uso e la tua app.

---

Funzionalità e requisiti supportati

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

Funzionalità e capacità supportate

Nota: alcune di queste funzionalità e capacità non sono supportate dai modelliImagen 4. Consulta i dettagli su Imagen 4 e Imagen 4 Ultra nella documentazione di Google Cloud.

Firebase AI Logic supporta queste funzionalità dei modelli Imagen.

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

• Generazione di testo all'interno delle immagini generate

• Aggiunta di una filigrana alle immagini generate

• Configurazione dei parametri di generazione delle immagini, come il numero di immagini generate, le proporzioni e la filigrana.

• 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 di utenti approvati anche quando utilizzi i modelli Imagen lato server.

• Funzionalità di editing o manipolazione delle immagini, tra cui l'upscaling delle immagini

• Inclusione di 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 contenga una filigrana, puoi caricarla in Vertex AI Studio utilizzando la scheda Media.

• Generazione di "immagini in tempo reale" dal testo (generazione di MP4)

• Generazione di immagini utilizzando uno stile predefinito

• Impostare la lingua del testo inserito

• Attivare includeSafetyAttributes, il che significa che safetyAttributes.categories e safetyAttributes.scores non possono essere restituiti

• Disattivazione del miglioramento del prompt (parametro enhancePrompt), il che significa che uno strumento di riscrittura del prompt basato su LLM aggiungerà sempre automaticamente più 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 (parametro storageUri). Le immagini vengono invece sempre restituite come byte di immagini con codifica base64 nella risposta.
  Se vuoi caricare un'immagine creata in 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?

• Inizia a pensare alla preparazione per la produzione (consulta l'elenco di controllo per la produzione), tra cui:
  • Configurazione di Firebase App Check per proteggere Gemini API da abusi da parte di clienti non autorizzati.
  • Integrazione di Firebase Remote Config per aggiornare i valori nell'app (ad esempio il nome del modello) senza rilasciare una nuova versione dell'app.

Scopri come controllare la generazione di contenuti

• Comprendi la progettazione dei prompt, tra cui best practice, strategie e prompt di esempio.
• Configura i parametri del modello Imagen come le proporzioni, la generazione di persone e il watermarking.
• Utilizza le impostazioni di sicurezza per regolare la probabilità di ricevere risposte che potrebbero essere considerate dannose.

Scopri di più sui modelli supportati

Scopri i modelli disponibili per vari casi d'uso e le relative quote e prezzi.

Fornire un feedback sulla tua esperienza con Firebase AI Logic