Di chuyển từ Imagen sang một mô hình tạo ảnh của Gemini ("Nano Banana")


Tất cả các mô hình Imagen đều không được dùng nữa và sẽ ngừng hoạt động sớm nhất là vào ngày 30 tháng 6 năm 2026. Việc ngừng cung cấp và đóng cửa này áp dụng trên toàn Google và cho cả Gemini Developer API và Vertex AI Gemini API.

Trước ngày ngừng hoạt động này, để tránh bị gián đoạn dịch vụ, bạn nên di chuyển các ứng dụng của mình từ việc sử dụng các mô hình Imagen sang sử dụng các mô hình Gemini 3.x Image ("Nano Banana"), như mô tả trong hướng dẫn này.

Nếu bạn gặp vấn đề khẩn cấp liên quan đến việc ngừng cung cấp và ngừng hoạt động này, hãy liên hệ với Nhóm hỗ trợ Firebase.

Mô hình hình ảnh Gemini thay thế

Hãy xem bảng sau đây để chọn một mô hình Gemini 3.x Image thay thế cho ứng dụng của bạn.

Dòng Imagen. Mô hình Gemini 3.x Image ("Nano Banana")
imagen-4.0-fast-generate-001 gemini-3.1-flash-image (với cấp độ tư duy MINIMAL)
imagen-4.0-generate-001 gemini-3.1-flash-image (với cấp độ tư duy HIGH)
imagen-4.0-ultra-generate-001 gemini-3-pro-image
imagen-3.0-capability-001 gemini-3.1-flash-image

Di chuyển ứng dụng

Phần này trình bày các ví dụ trước và sau khi di chuyển từ mô hình Imagen sang mô hình Gemini Image.

Tạo hình ảnh từ văn bản

Nhấp vào nhà cung cấp Gemini API để xem nội dung và mã dành riêng cho nhà cung cấp trên trang này.

Để tạo hình ảnh từ văn bản, hãy di chuyển ứng dụng của bạn:

  • Sử dụng mô hình Hình ảnh Gemini thay thế phù hợp (chẳng hạn như gemini-3.1-flash-image).

  • Tạo một thực thể GenerativeModel (thay vì thực thể ImagenModel).

  • Cập nhật các lựa chọn về cấu hình mô hình để phù hợp với các mô hình GeminiHình ảnh.

    • Trong quá trình thiết lập cấu hình này, hãy đặt phương thức phản hồi là IMAGE.
      Xin lưu ý rằng bạn có thể định cấu hình các mô hình Gemini Hình ảnh để trả về cả hình ảnh và văn bản.

  • (Chỉ Vertex AI Gemini API) Cập nhật vị trí mà bạn truy cập vào mô hình thành một vị trí được hỗ trợ cho các mô hình Hình ảnh Gemini. Bạn nên global.

Swift

Trước


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)

Sau


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

Trước


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

Sau


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

Trước


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

Sau


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

Trước


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];

Sau


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

Trước


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

Sau


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

Trước


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();

Sau


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
  }
}

Các lựa chọn cấu hình thay thế

Phần này mô tả các lựa chọn thay thế cho nhiều lựa chọn cấu hình mô hình để giúp kiểm soát phản hồi của mô hình.

Chế độ cài đặt an toàn

Bạn định cấu hình chế độ cài đặt an toàn cho các mô hình Imagen bằng cách sử dụng ImagenSafetySettings. Tuy nhiên, đối với các mô hình Hình ảnh Gemini, bạn cần di chuyển sang sử dụng SafetySetting.

Tham số cấu hình mô hình

Bạn định cấu hình các mô hình Imagen bằng một ImagenGenerationConfig. Tuy nhiên, đối với các mô hình Hình ảnh Gemini, bạn cần di chuyển sang sử dụng GenerationConfig và có thể là ImageConfig lồng nhau (chế độ này có sẵn từ các phiên bản SDK đầu tháng 5 năm 2026).

Trong GenerationConfig, hãy đặt phương thức phản hồi là IMAGE (như minh hoạ trong các mã mẫu "sau" ở phần đầu hướng dẫn này). Xin lưu ý rằng bạn có thể tuỳ ý định cấu hình các mô hình Gemini Hình ảnh để trả về cả IMAGE và TEXT.

Hãy xem bảng sau để tìm hiểu cách di chuyển các thông số cấu hình mô hình từ Imagen sang Gemini Mô hình hình ảnh:

Mẫu xe Imagen Mô hình Gemini 3.x Image ("Nano Banana")
addWatermark

Không được hỗ trợ

Gemini Các mô hình hình ảnh luôn trả về hình ảnh được tạo có hình mờ SynthID.

aspectRatio

Sử dụng aspectRatio trong ImageConfig

Để xem các mẫu mã và giá trị được hỗ trợ, hãy xem phần Định cấu hình tính năng tạo hình ảnh trong hướng dẫn về Gemini Mô hình hình ảnh.

imageFormat

Không được hỗ trợ

Gemini Các mô hình hình ảnh luôn trả về hình ảnh được tạo ở định dạng PNG.

negativePrompt

Không được hỗ trợ

Xin lưu ý rằng câu lệnh phủ định là một tính năng cũ và không được hỗ trợ kể từ imagen-3.0-generate-002 (hoặc bởi bất kỳ mô hình Imagen 4 nào).

numberOfImages

Không được hỗ trợ

Gemini Các mô hình hình ảnh luôn trả về một hình ảnh duy nhất được tạo.
Để khắc phục vấn đề này, bạn có thể chạy quá trình tạo trong một vòng lặp để đạt được kết quả tương tự. Xin lưu ý rằng số lượng đề xuất không thay thế được số lượng đề xuất.

personGeneration

Không được hỗ trợ

Theo mặc định, Gemini Các mô hình hình ảnh cho phép tạo hình ảnh về con người.