Eseguire la migrazione da Imagen a un modello di immagini Gemini ("Nano Banana")


Tutti i modelli Imagen sono deprecati e verranno disattivati a partire dal 30 giugno 2026. Questo ritiro e chiusura è applicabile in Google e sia per Gemini Developer API che per Vertex AI Gemini API.

Prima di questa data di chiusura, per evitare interruzioni del servizio, devi eseguire la migrazione delle tue app dall'utilizzo dei modelli Imagen all'utilizzo dei modelli Gemini 3.x Image (i modelli "Nano Banana"), come descritto in questa guida.

Se hai un problema urgente che riguarda questo ritiro e spegnimento, contatta l'assistenza Firebase.

Modelli di immagini di sostituzione Gemini

Consulta la seguente tabella per scegliere un modello di sostituzione Gemini 3.x Image per la tua app.

Imagen modello Modelli Gemini 3.x Image ("Nano Banana")
imagen-4.0-fast-generate-001 gemini-3.1-flash-image (con livello di ragionamento MINIMAL)
imagen-4.0-generate-001 gemini-3.1-flash-image (con livello di ragionamento HIGH)
imagen-4.0-ultra-generate-001 gemini-3-pro-image
imagen-3.0-capability-001 gemini-3.1-flash-image

Migrazione dell'app

Questa sezione mostra esempi di prima e dopo la migrazione da un modello Imagen a un modello di immagine Gemini.

Generare un'immagine da testo

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

Per generare un'immagine dal testo, esegui la migrazione dell'app:

  • Utilizza un modello di immagine Gemini di sostituzione appropriato (ad esempio gemini-3.1-flash-image).

  • Crea un'istanza GenerativeModel (anziché un'istanza ImagenModel).

  • Aggiorna le opzioni di configurazione del modello per adattarsi ai modelli di immagini Gemini.

    • Nell'ambito di questa configurazione, imposta una modalità di risposta di IMAGE.
      Tieni presente che i modelli di immagini Gemini possono essere configurati per restituire sia immagini che testo.

  • (solo Vertex AI Gemini API) Aggiorna la posizione da cui accedi al modello a una posizione supportata per i modelli di immagini Gemini. Ti consigliamo di global.

Swift

Prima


import FirebaseAILogic

// 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_MODEL_NAME")

// 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)

Dopo


import FirebaseAILogic

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

// Create a `GenerativeModel` instance with a Gemini model that supports image output
let model = ai.generativeModel(
  modelName: "GEMINI_IMAGE_MODEL_NAME",
  generationConfig: GenerationConfig(
    responseModalities: [.image],
    imageConfig: ImageConfig(aspectRatio: .landscape4x3)
  )
)

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

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

// Handle the case where no images were generated
guard let inlineDataPart = response.inlineDataParts.first else {
  fatalError("No image in the response.")
}

// Process the image
guard let uiImage = UIImage(data: inlineDataPart.data) else {
  fatalError("Failed to convert data to UIImage.")
}

Kotlin

Prima


// Initialize the Gemini Developer API backend service
val ai = Firebase.ai(backend = GenerativeBackend.googleAI())

// Create an `ImagenModel` instance with an Imagen model that supports your use case
val model = ai.imagenModel("IMAGEN_MODEL_NAME")

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

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

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

val bitmapImage = image.asBitmap()

Dopo


// Initialize the Gemini Developer API backend service
val ai = Firebase.ai(backend = GenerativeBackend.googleAI())

// Create a `GenerativeModel` instance with a Gemini model that supports image output
val model = ai.generativeModel(
    modelName = "GEMINI_IMAGE_MODEL_NAME",
    generationConfig = generationConfig {
      responseModalities = listOf(ResponseModality.IMAGE),
      imageConfig = imageConfig {
        aspectRatio = AspectRatio.LANDSCAPE_4x3
      }
    }
)

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

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

if (imageResponse.finishReason == FinishReason.NO_IMAGE) {
  // Handle the case where no images were generated
} else {
  // Handle the generated image
  val bitmapImage = imageResponse.candidates.first().content.parts.filterIsInstance().firstOrNull()?.image
}

Java

Prima


// 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_MODEL_NAME");

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>() {
    @Override
    public void onSuccess(ImagenGenerationResponse 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());

Dopo


// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a Gemini model that supports image output
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI()).generativeModel(
    "GEMINI_IMAGE_MODEL_NAME",
    new GenerationConfig.Builder()
        .setResponseModalities(Arrays.asList(ResponseModality.IMAGE))
        .setImageConfig(new ImageConfig(AspectRatio.LANDSCAPE_4x3, null))
        .build()
);

GenerativeModelFutures model = GenerativeModelFutures.from(ai);

// Provide a text prompt instructing the model to generate an image
Content prompt = new Content.Builder()
        .addText("An astronaut riding a horse")
        .build();

// To generate an image, call `generateContent` with the text input
Executor executor = Executors.newSingleThreadExecutor();
ListenableFuture response = model.generateContent(prompt);
Futures.addCallback(response, new FutureCallback() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        if (result.finishReason == FinishReason.NO_IMAGE) {
            // handle the case where no images were generated
            return;
        }
        // iterate over all the parts in the first candidate in the result object
        for (Part part : result.getCandidates().get(0).getContent().getParts()) {
            if (part instanceof ImagePart) {
                ImagePart imagePart = (ImagePart) part;
                // The returned image as a bitmap
                Bitmap generatedImageAsBitmap = imagePart.getImage();
                break;
            }
        }
    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

Web

Prima


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

// TODO(developer) Replace the following with your app's Firebase configuration
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 model that supports your use case
const model = getImagenModel(ai, { model: "IMAGEN_MODEL_NAME" });

// 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 model.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];

Dopo


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

// TODO(developer) Replace the following with your app's Firebase configuration
const firebaseConfig = {
  // ...
};

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

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

// Create a `GenerativeModel` instance with a model that supports your use case
const model = getGenerativeModel(ai, {
  model: "GEMINI_IMAGE_MODEL_NAME",
  generationConfig: {
    responseModalities: [ResponseModality.IMAGE],
    imageConfig: {
      aspectRatio: ImageConfigAspectRatio.LANDSCAPE_4x3
    }
  },
});

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

// To generate an image, call `generateContent` with the text prompt
const result = await model.generateContent(prompt);

// Handle the generated image
try {
  const response = result.response;
  if (response.candidates?.[0].finishReason == FinishReason.NO_IMAGE) {
    // Handle the case where no images were generated
  }
  const inlineDataParts = response.inlineDataParts();
  if (inlineDataParts?.[0]) {
    const image = inlineDataParts[0].inlineData;
    // Use this mimeType and base64 data to display the image using
    // your preferred tooling
    console.log(image.mimeType, image.data);
  }
} catch (err) {
  console.error('Prompt or candidate was blocked:', err);
}

Dart

Prima


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
final ai = FirebaseAI.googleAI();

// Create an `ImagenModel` instance with an Imagen model that supports your use case
final model = ai.imagenModel(model: 'IMAGEN_MODEL_NAME');

// 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.');
}

Dopo


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
final ai = FirebaseAI.googleAI();

// Create a `GenerativeModel` instance with a Gemini model that supports image output
final model = ai.generativeModel(
  model: 'GEMINI_IMAGE_MODEL_NAME',
  generationConfig: GenerationConfig(
    responseModalities: [ResponseModalities.image],
    imageConfig: ImageConfig(aspectRatio: ImageAspectRatio.landscape4x3)
  ),
);

// Provide a text prompt instructing the model to generate an image
final prompt = [Content.text('An astronaut riding a horse.')];

// To generate an image, call `generateContent` with the text prompt
final response = await model.generateContent(prompt);
if (response.inlineDataParts.isNotEmpty) {
  final imageBytes = response.inlineDataParts.first.bytes;
  // Process the image
} else {
  // Handle the case where no images were generated
  print('Error: No images were generated.');
}

Unity

Prima


using Firebase.AI;

// Initialize the Gemini Developer API backend service
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Create an `ImagenModel` instance with a model that supports your use case
var model = ai.GetImagenModel(modelName: "IMAGEN_MODEL_NAME");

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

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

// Handle the generated image
if (response.Images.Count == 0) {
  throw new Exception("No image in the response.");
}
var image = response.Images[0].AsTexture2D();

Dopo


using Firebase;
using Firebase.AI;

// Initialize the Gemini Developer API backend service
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Create a `GenerativeModel` instance with a Gemini model that supports image output
var model = ai.GetGenerativeModel(
  modelName: "GEMINI_IMAGE_MODEL_NAME",
  generationConfig: new GenerationConfig(
    responseModalities: new[] { ResponseModality.Image },
    imageConfig: new ImageConfig(aspectRatio: ImageConfig.AspectRatio.Landscape4x3)
  )
);

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

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

if (response.Candidates.First().FinishReason == FinishReason.NoImage) {
  // Handle the case where no images were generated
}

// Handle the generated image
var imageParts = response.Candidates.First().Content.Parts
                         .OfType<ModelContent.InlineDataPart>()
                         .Where(part => part.MimeType == "image/png");

foreach (var imagePart in imageParts) {
  // Load the Image into a Unity Texture2D object
  UnityEngine.Texture2D texture2D = new(2, 2);
  if (texture2D.LoadImage(imagePart.Data.ToArray())) {
    // Do something with the image
  }
}

Opzioni di configurazione della sostituzione

Questa sezione descrive le opzioni di sostituzione per varie opzioni di configurazione del modello per controllare la risposta del modello.

Impostazioni di sicurezza

Configura le impostazioni di sicurezza per i modelli Imagen utilizzando ImagenSafetySettings. Tuttavia, per i modelli di immagini Gemini, devi eseguire la migrazione all'utilizzo di SafetySetting.

Parametri di configurazione del modello

Configura i modelli Imagen con un ImagenGenerationConfig. Tuttavia, per i modelli di immagini Gemini, devi eseguire la migrazione all'utilizzo di un GenerationConfig e, facoltativamente, di un ImageConfig (disponibile a partire dalle versioni di inizio maggio 2026 degli SDK).

Nell'ambito di GenerationConfig, imposta una modalità di risposta IMAGE (come mostrato negli esempi di codice "after" all'inizio di questa guida). Tieni presente che, se vuoi, puoi configurare i modelli di immagini Gemini in modo che restituiscano sia IMAGE che TEXT.

Consulta la tabella seguente per capire come eseguire la migrazione dei parametri di configurazione del modello dai modelli di immagini Imagen a Gemini:

Imagen modelli Modelli Gemini 3.x Image ("Nano Banana")
addWatermark

Non supportata

Gemini I modelli di immagini restituiscono sempre immagini generate con una filigrana SynthID.

aspectRatio

Utilizzare aspectRatio in un ImageConfig

Per esempi di codice e valori supportati, consulta Configurare la generazione di immagini nella guida ai modelli di immagini Gemini.

imageFormat

Non supportata

Gemini I modelli di immagini restituiscono sempre le immagini generate in formato PNG.

negativePrompt

Non supportata

Tieni presente che i prompt negativi sono una funzionalità legacy e non sono supportati dal imagen-3.0-generate-002 (o da nessuno dei modelli Imagen 4).

numberOfImages

Non supportata

Gemini I modelli di immagini restituiscono sempre una singola immagine generata.
Come soluzione alternativa, puoi eseguire la generazione in un ciclo per ottenere lo stesso risultato. Tieni presente che il conteggio dei candidati non funziona come sostituzione.

personGeneration

Non supportata

Per impostazione predefinita, i modelli di immagini Gemini consentono di generare immagini di persone.