Bilder mit Imagen generieren


Mit den Firebase AI Logic SDKs haben Sie Zugriff auf die Imagen Modelle (über die Imagen API) sodass Sie Bilder aus einem Text-Prompt generieren können. Mit dieser Funktion können Sie beispielsweise Folgendes tun:

  • Bilder aus Prompts generieren, die in natürlicher Sprache verfasst sind
  • Bilder in einer Vielzahl von Formaten und Stilen generieren
  • Text in Bildern rendern

In dieser Anleitung wird beschrieben, wie Sie mit Imagen Bilder generieren, indem Sie nur einen Text-Prompt angeben.

Beachten Sie jedoch, dass Imagen auch Bilder auf der Grundlage eines Referenz bilds generieren kann. Dazu wird die Anpassungsfunktion verwendet (derzeit nur für Android und Flutter). In der Anfrage geben Sie einen Text-Prompt und ein Referenzbild an, mit dem das Modell ein neues Bild basierend auf dem angegebenen Stil, Motiv (z. B. ein Produkt, eine Person oder ein Tier) oder einer Steuerung generiert. Sie können beispielsweise ein neues Bild aus einem Foto einer Katze oder einer Zeichnung einer Rakete und des Mondes generieren.

Zu Code für reine Texteingabe springen

Hinweis

Klicken Sie auf Ihren Gemini API Anbieter, um anbieterspezifische Inhalte und Code auf dieser Seite aufzurufen.

Wenn Sie es noch nicht getan haben, folgen Sie der Anleitung für den Einstieg. Dort wird beschrieben, wie Sie Ihr Firebase-Projekt einrichten, Ihre App mit Firebase verbinden, das SDK hinzufügen, den Back-End-Dienst für den ausgewählten API-Anbieter initialisieren und eine ImagenModel Instanz erstellen.

Modelle, die diese Funktion unterstützen

Die Gemini Developer API unterstützt die Bildgenerierung durch die neuesten stabilen Imagen Modelle. Diese Einschränkung der unterstützten Imagen Modelle gilt unabhängig davon, wie Sie auf die Gemini Developer API zugreifen.

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

Bilder aus reiner Texteingabe generieren

Sie können ein Imagen Modell bitten, Bilder zu generieren, indem Sie nur Text als Prompt verwenden. Sie können ein Bild oder mehrere Bilder generieren.

Sie können auch viele verschiedene Konfigurationsoptionen für die Bildgenerierung festlegen, z. B. Seitenverhältnis und Bildformat.

Ein Bild aus reiner Texteingabe generieren

Bevor Sie dieses Beispiel ausprobieren, führen Sie die Schritte im Abschnitt Hinweis dieser Anleitung aus, um Ihr Projekt und Ihre App einzurichten.
In diesem Abschnitt klicken Sie auch auf eine Schaltfläche für den ausgewählten Gemini API Anbieter, damit auf dieser Seite anbieterspezifische Inhalte angezeigt werden.

Sie können ein Imagen Modell bitten, ein einzelnes Bild zu generieren, indem Sie nur Text als Prompt verwenden.

Erstellen Sie eine ImagenModel-Instanz und rufen Sie generateImages auf.

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

Einheit 


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

Informationen zum Auswählen eines Modells , der für Ihren Anwendungsfall und Ihre App geeignet ist

Mehrere Bilder aus reiner Texteingabe generieren

Bevor Sie dieses Beispiel ausprobieren, führen Sie die Schritte im Abschnitt Hinweis dieser Anleitung aus, um Ihr Projekt und Ihre App einzurichten.
In diesem Abschnitt klicken Sie auch auf eine Schaltfläche für den ausgewählten Gemini API Anbieter, damit auf dieser Seite anbieterspezifische Inhalte angezeigt werden.

Standardmäßig generieren Imagen Modelle nur ein Bild pro Anfrage. Sie können ein Imagen Modell jedoch bitten, mehrere Bilder pro Anfrage zu generieren, indem Sie beim Erstellen der ImagenModel Instanz eine ImagenGenerationConfig angeben.

Erstellen Sie eine ImagenModel-Instanz und rufen Sie generateImages auf.

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

Einheit 


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

Informationen zum Auswählen eines Modells , der für Ihren Anwendungsfall und Ihre App geeignet ist


Unterstützte Funktionen und Anforderungen

Die Imagen Modelle bieten viele Funktionen im Zusammenhang mit der Bildgenerierung. In diesem Abschnitt wird beschrieben, was unterstützt wird bei der Verwendung der Modelle mit Firebase AI Logic.

Unterstützte Funktionen

Firebase AI Logic unterstützt die folgenden Funktionen von Imagen Modellen:

Firebase AI Logic unterstützt die folgenden erweiterten Funktionen von Imagen Modellen nicht:

  • Festlegen der Sprache des Eingabetexts

  • Deaktivieren des Prompt-Rewriters (Parameter enhancePrompt). Das bedeutet, dass ein LLM-basiertes Tool zum Neuschreiben von Prompts dem angegebenen Prompt immer automatisch weitere Details hinzufügt, um Bilder in höherer Qualität zu liefern, die den angegebenen Prompt besser widerspiegeln.

  • Direktes Schreiben eines generierten Bilds in Google Cloud Storage als Teil der Antwort des Modells (Parameter storageUri). Stattdessen werden Bilder in der Antwort immer als base64-codierte Bildbyte zurückgegeben.
    Wenn Sie ein generiertes Bild in Cloud Storage hochladen möchten, können Sie Cloud Storage for Firebase verwenden.

Spezifikationen und Einschränkungen

Property (pro Anfrage) Wert
Maximale Anzahl von Eingabetokens 480 Tokens
Maximale Anzahl von Ausgabebildern 4 Bilder
Unterstützte Auflösungen für Ausgabebilder (Pixel)
  • 1024 × 1024 Pixel (Seitenverhältnis 1:1)
  • 896 × 1280 (Seitenverhältnis 3:4)
  • 1280 × 896 (Seitenverhältnis 4:3)
  • 768 × 1408 (Seitenverhältnis 9:16)
  • 1408 × 768 (Seitenverhältnis 16:9)


Was kannst du sonst noch alles für mich tun?

Informationen zum Steuern der Content-Generierung

Weitere Informationen zu den unterstützten Modellen

Informationen zu den für verschiedene Anwendungsfälle verfügbaren Modellen sowie zu ihren Kontingenten und Preisen.


Feedback geben zu Ihrer Erfahrung mit Firebase AI Logic