Imagen から Gemini 画像モデル（「Nano Banana」）に移行する


すべての Imagen モデルは非推奨となり、2026 年 6 月 24 日にシャットダウンされます。この非推奨と廃止は、Google 全体で適用され、Gemini Developer API と Vertex AI Gemini API の両方に適用されます。

サービスの中断を避けるため、この廃止日までに、このガイドの説明に沿って、 Imagen モデルを使用するアプリを Gemini 画像モデル （「Nano Banana」モデル）を使用するように移行する必要があります。

この非推奨と廃止に関する緊急の問題がある場合は、 Firebase サポートまでお問い合わせください。

代替の Gemini 画像モデル

次の表を確認して、アプリの代替 Gemini 画像モデル を選択してください。

Imagen モデル Gemini 画像モデル（「Nano Banana」）
imagen-4.0-fast-generate-001 gemini-2.5-flash-image（GA）
gemini-3.1-flash-image-preview（思考レベル MINIMAL）
imagen-4.0-generate-001 gemini-2.5-flash-image（GA）
gemini-3.1-flash-image-preview（思考レベル HIGH）
imagen-4.0-ultra-generate-001 gemini-2.5-flash-image （GA）
gemini-3-pro-image-preview
imagen-3.0-capability-001 gemini-2.5-flash-image （GA）
gemini-3.1-flash-image-preview

アプリを移行する

このセクションでは、 Imagen モデルから Gemini 画像モデルに移行する前後の例を示します。

テキストから画像を生成する

Gemini API プロバイダをクリックして、このページでプロバイダ固有のコンテンツとコードを表示します。

テキストから画像を生成するには、アプリを移行します。

  • 適切な代替画像モデル Gemini （gemini-2.5-flash-image など）を使用します。

  • ImagenModel インスタンスではなく、GenerativeModel インスタンスを作成します。

  • モデル構成オプションを更新して、 Gemini画像モデルに対応します。

    • この構成の一環として、レスポンス モダリティを IMAGE に設定します。
      Gemini 画像モデルは、画像とテキストの両方を返すように構成できます。Gemini

  • （Vertex AI Gemini API のみ） モデルにアクセスする ロケーション を、Gemini 画像モデルでサポートされているロケーションに更新します。global をおすすめします。

Swift

変更前


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)

変更後


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

変更前


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

変更後


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

変更前


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

変更後


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

変更前


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

変更後


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

変更前


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

変更後


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

変更前


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

変更後


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

代替の構成オプション

このセクションでは、モデルのレスポンスを制御するための、さまざまなモデル構成オプションの代替オプションについて説明します。

安全性設定

モデルの安全性設定はImagen を使用して構成します ImagenSafetySettings。ただし、Gemini 画像モデルの場合は、 SafetySetting を使用するように移行する必要があります。

モデル構成パラメータ

Imagen モデルは ImagenGenerationConfig で構成します。ただし、 Gemini 画像モデルの場合は、 GenerationConfig と、必要に応じてネストされた ImageConfig を使用するように移行する必要があります（これは、2026 年 5 月上旬の SDK バージョンから使用できます）。

GenerationConfig の一部として、レスポンス モダリティを IMAGE に設定します（このガイドの「変更後」のコードサンプルを参照）。Gemini 画像モデルは、 Gemini と IMAGE と TEXT の両方を返すように構成することもできます。

次の表で、モデル 構成パラメータを Imagen から Gemini 画像モデルに移行する方法を確認してください。

Imagen モデル Gemini 画像モデル（「Nano Banana」）
addWatermark

対象外

Gemini 画像モデルは、生成された画像を常に SynthID 透かし入りで返します。

aspectRatio

ImageConfig で aspectRatio を使用する

コードサンプルとサポートされている値については、 画像生成を構成する Gemini 画像モデル ガイドをご覧ください。

imageFormat

対象外

Gemini 画像モデルは、生成された画像を常に PNG 形式で返します。

negativePrompt

対象外

否定的なプロンプトはレガシー機能であり、サポートされていません imagen-3.0-generate-002 以降（または Imagen 4 モデル）では。

numberOfImages

対象外

Gemini 画像モデルは、生成された画像を常に 1 つ返します。
回避策として、ループで生成を実行して同じ結果を得ることができます。 候補数は代替として機能しません。

personGeneration

対象外

デフォルトでは、Gemini 画像モデルで人物の画像を生成できます。