Imagen を使用して画像を生成する

Firebase AI Logic SDK を使用すると、Imagen モデル（Imagen API 経由）にアクセスして、テキスト プロンプトから画像を生成できます。この機能を使用すると、次のようなことができます。

  • 自然言語で記述されたプロンプトから画像を生成する
  • 幅広い形式とスタイルで画像を生成する
  • 画像内のテキストをレンダリングする

このガイドでは、テキスト プロンプトのみを指定して Imagen を使用して画像を生成する方法について説明します。

ただし、Imagen は、カスタマイズ機能（現在は Android と Flutter のみ）を使用して、参照画像に基づいて画像を生成することもできます。リクエストでは、テキスト プロンプトと参照画像を指定します。これにより、モデルは指定されたスタイル、被写体（商品、人物、動物など）、またはコントロールに基づいて新しい画像を生成します。たとえば、猫の写真やロケットと月の絵から新しい画像を生成できます。

テキストのみの入力のコードに移動

Gemini モデルと Imagen モデルの選択

Firebase AI Logic SDK は、Gemini モデルまたは Imagen モデルのいずれかを使用して、画像の生成と編集をサポートしています。

ほとんどのユースケースでは、Gemini から始め、画質が重要な特殊なタスクでのみ Imagen を選択します。

次の場合は Gemini を選択します。

  • 世界に関する知識と推論を使用して、コンテキストに関連性の高い画像を生成します。
  • テキストと画像をシームレスにブレンドしたり、テキストと画像の出力をインターリーブしたりするため。
  • 長いテキスト シーケンス内に正確なビジュアルを埋め込む。
  • コンテキストを維持しながら、会話形式で画像を編集する。

次の場合は Imagen を選択します。

  • 画質、フォトリアリズム、芸術的なディテール、特定のスタイル（印象派やアニメなど）を優先する場合。
  • ブランディング、スタイル、ロゴや商品デザインの生成に活用できます。
  • 生成された画像のアスペクト比または形式を明示的に指定します。

始める前に

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

まだ完了していない場合は、スタートガイドに沿って、記載されている手順（Firebase プロジェクトの設定、アプリと Firebase の連携、SDK の追加、選択した API プロバイダのバックエンド サービスの初期化、ImagenModel インスタンスの作成）を完了します。

この機能をサポートするモデル

Gemini Developer API は、最新の安定版 Imagen モデルによる画像生成をサポートしています。サポートされている Imagen モデルのこの制限は、Gemini Developer API へのアクセス方法に関係なく適用されます。

  • imagen-4.0-generate-001
  • imagen-4.0-fast-generate-001
  • imagen-4.0-ultra-generate-001
  • imagen-3.0-generate-002

テキストのみの入力から画像を生成する

Imagen モデルにテキストのみのプロンプトを指定して、画像を生成するようリクエストできます。1 枚の画像または複数の画像を生成できます。

アスペクト比や画像形式など、画像生成のさまざまな構成オプションを設定することもできます。

テキストのみの入力から画像を 1 つ生成する

このサンプルを試す前に、このガイドの始める前にのセクションを完了して、プロジェクトとアプリを設定してください。
このセクションでは、選択した Gemini API プロバイダのボタンをクリックして、このページにプロバイダ固有のコンテンツを表示します。

Imagen モデルにテキストのみのプロンプトを指定して、単一の画像を生成するようリクエストできます。

ImagenModel インスタンスを作成し、generateImages を呼び出すようにしてください。

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-4.0-generate-001")

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


suspend fun generateImage() {
  // 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-4.0-generate-001")

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

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-4.0-generate-001");

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 model that supports your use case
const model = getImagenModel(ai, { model: "imagen-4.0-generate-001" });

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

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

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

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


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-4.0-generate-001");

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

ユースケースとアプリに適したモデル を選択する方法について説明します。

テキストのみの入力から複数の画像を生成する

このサンプルを試す前に、このガイドの始める前にのセクションを完了して、プロジェクトとアプリを設定してください。
このセクションでは、選択した Gemini API プロバイダのボタンをクリックして、このページにプロバイダ固有のコンテンツを表示します。

デフォルトでは、Imagen モデルはリクエストごとに 1 つの画像のみを生成します。ただし、ImagenModel インスタンスの作成時に ImagenGenerationConfig を指定すると、Imagen モデルにリクエストごとに複数の画像を生成させることができます。

ImagenModel インスタンスを作成し、generateImages を呼び出すようにしてください。

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-4.0-generate-001",
  // 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 


suspend fun generateImage() {
  // 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(
    modelName = "imagen-4.0-generate-001",
    // 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 = model.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-4.0-generate-001",
                /* 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 model that supports your use case
const model = getImagenModel(
  ai,
  {
    model: "imagen-4.0-generate-001",
    // 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 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 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
final ai = FirebaseAI.googleAI();

// Create an `ImagenModel` instance with an Imagen model that supports your use case
final model = ai.imagenModel(
  model: 'imagen-4.0-generate-001',
  // 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 


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-4.0-generate-001",
  // Configure the model to generate multiple images for each request
  // See: https://firebase.google.com/docs/ai-logic/model-parameters
  generationConfig: new ImagenGenerationConfig(numberOfImages: 4)
);

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

// If fewer images were generated than were requested,
// then `filteredReason` will describe the reason they were filtered out
if (!string.IsNullOrEmpty(response.FilteredReason)) {
  UnityEngine.Debug.Log("Filtered reason: " + response.FilteredReason);
}

// Handle the generated images
var images = response.Images.Select(image => image.AsTexture2D());

ユースケースとアプリに適したモデル を選択する方法について説明します。


サポートされている機能と要件

Imagen モデルには、画像生成に関連する多くの機能があります。このセクションでは、Firebase AI Logic でモデルを使用する場合にサポートされている内容について説明します。

サポートされている機能

をご覧ください。

Firebase AI Logic は、Imagen モデルの次の機能をサポートしています。

Firebase AI Logic は、Imagen モデルの次の高度な機能をサポートしていません。

  • 入力テキストの言語を設定する

  • プロンプト書き換えツール（enhancePrompt パラメータ）を無効にします。つまり、LLM ベースのプロンプト書き換えツールは、指定されたプロンプトをより正確に反映した高品質の画像を生成するために、常に指定されたプロンプトに詳細を自動的に追加します。

  • 生成された画像を、モデルからのレスポンスの一部として Google Cloud Storage に直接書き込む（storageUri パラメータ）。代わりに、画像は常に base64 エンコードされた画像バイトとしてレスポンスで返されます。
    生成された画像を Cloud Storage にアップロードする場合は、Cloud Storage for Firebase を使用できます。

仕様と制限事項

プロパティ（リクエストごと） 値
入力トークンの最大数 480 トークン
出力画像の最大数 4 枚
サポートされている出力画像の解像度（ピクセル）
  • 1,024 x 1,024 ピクセル（1:1 のアスペクト比）
  • 896 x 1,280（3:4 のアスペクト比）
  • 1,280 x 896（4:3 のアスペクト比）
  • 768 x 1,408（9:16 のアスペクト比）
  • 1,408 x 768（16:9 のアスペクト比）


Google アシスタントの機能

  • 本番環境の準備（本番環境チェックリストを参照）について検討を開始します。これには、次のものが含まれます。
    • Firebase App Check を設定して、未承認のクライアントによる不正使用から Gemini API を保護します。
    • Firebase Remote Config を統合して、新しいバージョンのアプリをリリースすることなく、アプリ内の値（モデル名など）を更新します。

コンテンツ生成を制御する方法

サポートされているモデルの詳細

さまざまなユースケースで利用可能なモデルとその割り当てと料金について学習します。


Firebase AI Logic の使用感についてフィードバックを送信する