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개 생성

이 샘플을 사용해 보기 전에 이 가이드의 시작하기 전에 섹션을 완료하여 프로젝트와 앱을 설정하세요.
이 섹션에서는 선택한 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 모델은 요청당 하나의 이미지만 생성합니다. 하지만 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 기반 프롬프트 수정 도구는 제공된 프롬프트에 항상 세부정보를 자동으로 추가하여 제공된 프롬프트를 더 잘 반영하는 고품질 이미지를 제공합니다.

  • 생성된 이미지를 모델의 응답 (storageUri 매개변수)의 일부로 Google Cloud Storage에 직접 작성합니다. 대신 이미지는 항상 base64로 인코딩된 이미지 바이트로 응답에 반환됩니다.
    생성된 이미지를 Cloud Storage에 업로드하려면 Cloud Storage for Firebase를 사용하면 됩니다.

사양 및 제한사항

속성 (요청당) 값
최대 입력 토큰 수 토큰 480개
최대 출력 이미지 수 이미지 4개
지원되는 출력 이미지 해상도 (픽셀)
  • 1024x1024픽셀(가로세로 비율 1:1)
  • 896x1280(가로세로 비율 3:4)
  • 1280x896(가로세로 비율 4:3)
  • 768x1408(가로세로 비율 9:16)
  • 1408x768(가로세로 비율 16:9)


또 뭘 할 수 있어?

콘텐츠 생성 제어 방법 알아보기

지원되는 모델 자세히 알아보기

다양한 사용 사례에 사용할 수 있는 모델과 할당량, 가격에 대해 알아봅니다.


Firebase AI Logic 사용 경험에 관한 의견 보내기