Bilder mit Imagen generieren


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

  • Bilder aus Prompts in natürlicher Sprache generieren
  • Bilder in einer Vielzahl von Formaten und Stilen erstellen
  • Text in Bildern rendern

Firebase AI Logic unterstützt noch nicht alle Funktionen, die für die Imagen-Modelle verfügbar sind. Weitere Informationen finden Sie weiter unten auf dieser Seite unter Unterstützte Funktionen.

 Zum Code für die reine Texteingabe springen

Zwischen Gemini- und Imagen-Modellen wählen

Die Firebase AI Logic-SDKs unterstützen die Bilderstellung mit einem Gemini-Modell oder einem Imagen-Modell. Für die meisten Anwendungsfälle empfiehlt es sich, mit Gemini zu beginnen und dann Imagen für spezielle Aufgaben auszuwählen, bei denen die Bildqualität entscheidend ist.

Die Firebase AI Logic-SDKs unterstützen noch keine Bild-Eingabe (z. B. für die Bearbeitung) mit Imagen-Modellen. Wenn Sie also mit Eingabebildern arbeiten möchten, können Sie stattdessen ein Gemini-Modell verwenden.

Wählen Sie Gemini aus, wenn Sie Folgendes möchten:

  • Weltwissen und logisches Denken nutzen, um kontextbezogene Bilder zu generieren.
  • Text und Bilder nahtlos ineinander übergehen lassen
  • Um präzise Bilder in lange Textsequenzen einzubetten.
  • Bilder im Chat bearbeiten und dabei den Kontext beibehalten

Wählen Sie Imagen aus, wenn Sie Folgendes möchten:

  • Sie können die Bildqualität, den Fotorealismus, die künstlerischen Details oder bestimmte Stile (z. B. Impressionismus oder Anime) priorisieren.
  • Um das Seitenverhältnis oder Format der generierten Bilder explizit anzugeben.

Hinweis

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

Falls noch nicht geschehen, folgen Sie dem Startleitfaden. Darin wird beschrieben, wie Sie Ihr Firebase-Projekt einrichten, Ihre App mit Firebase verbinden, das SDK hinzufügen, den Backend-Dienst für den von Ihnen ausgewählten API-Anbieter initialisieren und eine ImagenModel-Instanz erstellen.

Modelle, die diese Funktion unterstützen

Das Gemini Developer API unterstützt nur die Bildgenerierung durch das aktuelle stabile Imagen 3-Modell, nicht aber die anderen Imagen-Modelle. Diese Einschränkungen für das Imagen-Modell gelten unabhängig davon, wie Sie auf die Gemini Developer API zugreifen.

  • imagen-3.0-generate-002

Bilder aus reinen Texteingaben generieren

Sie können ein Imagen-Modell bitten, Bilder zu generieren, indem Sie einen Text-Prompt eingeben. Sie können ein Bild oder mehrere Bilder generieren.

Ein Bild aus reiner Texteingabe generieren

Bevor Sie dieses Beispiel ausprobieren, müssen Sie den Abschnitt Vorbereitung in diesem Leitfaden durcharbeiten, um Ihr Projekt und Ihre App einzurichten.
In diesem Abschnitt klicken Sie auch auf eine Schaltfläche für den von Ihnen 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 einen Text-Prompt eingeben.

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

Swift 


import FirebaseAI

// 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-3.0-generate-002")

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


// Using this SDK to access Imagen models is a Preview release and requires opt-in
@OptIn(PublicPreviewAPI::class)
suspend fun generateImage() {
  // Initialize the Gemini Developer API backend service
  // Create an `ImagenModel` instance with an Imagen model that supports your use case
  val imagenModel = Firebase.ai(backend = GenerativeBackend.googleAI()).imagenModel("imagen-3.0-generate-002")

  // Provide an image generation prompt
  val prompt = "An astronaut riding a horse"

  // To generate an image, call `generateImages` with the text prompt
  val imageResponse = imagenModel.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-3.0-generate-002");

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

// 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 imagenModel.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
// Create an `ImagenModel` instance with an Imagen model that supports your use case
final model =
  FirebaseAI.googleAI().imagenModel(model: 'imagen-3.0-generate-002');

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

Die Verwendung von Imagen wird für Unity noch nicht unterstützt. Schauen Sie bald wieder vorbei.

Hier erfahren Sie, wie Sie ein Modell auswählen, der für Ihren Anwendungsfall und Ihre App geeignet ist.

Mehrere Bilder aus reinen Texteingaben generieren

Bevor Sie dieses Beispiel ausprobieren, müssen Sie den Abschnitt Vorbereitung in diesem Leitfaden durcharbeiten, um Ihr Projekt und Ihre App einzurichten.
In diesem Abschnitt klicken Sie auch auf eine Schaltfläche für den von Ihnen 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 ein ImagenGenerationConfig angeben.

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

Swift 


import FirebaseAI

// 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-3.0-generate-002",
  // 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 


// Using this SDK to access Imagen models is a Preview release and requires opt-in
@OptIn(PublicPreviewAPI::class)
suspend fun generateImage() {
  // Initialize the Gemini Developer API backend service
  // Create an `ImagenModel` instance with an Imagen model that supports your use case
  val imagenModel = Firebase.ai(backend = GenerativeBackend.googleAI()).imagenModel(
      modelName = "imagen-3.0-generate-002",
      // 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 = imagenModel.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-3.0-generate-002",
        /* 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 3 model that supports your use case
const imagenModel = getImagenModel(
  ai,
  {
    model: "imagen-3.0-generate-002",
    // 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 imagenModel.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
// Create an `ImagenModel` instance with an Imagen model that supports your use case
final model =
  FirebaseAI.googleAI().imagenModel(
    model: 'imagen-3.0-generate-002',
    // 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

Die Verwendung von Imagen wird für Unity noch nicht unterstützt. Schauen Sie bald wieder vorbei.

Hier erfahren Sie, wie Sie ein Modell auswählen, 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 bei der Verwendung der Modelle mit Firebase AI Logic unterstützt wird.

Unterstützte Funktionen

Firebase AI Logic unterstützt diese Funktionen von Imagen-Modellen.

  • Generieren von Personen und Gesichtern (vorausgesetzt, Ihr Firebase-Projekt hat die Genehmigung von Google Cloud)

  • Text in generierten Bildern generieren

  • Generierten Bildern ein Wasserzeichen hinzufügen

  • Parameter für die Bildgenerierung konfigurieren, z. B. Anzahl der generierten Bilder, Seitenverhältnis und Wasserzeichen

  • Sicherheitseinstellungen konfigurieren

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

Beachten Sie, dass für die meisten dieser Funktionen eine genehmigte Nutzerliste erforderlich ist, auch wenn Sie Imagen-Modelle serverseitig verwenden.

  • Funktionen zur Bildbearbeitung oder ‑manipulation, einschließlich der Vergrößerung von Bildern

  • Bilder in die Anfrage an das Modell einfügen (z. B. für Few-Shot-Lernen)

  • Digitale Wasserzeichen mit den SDKs prüfen
    Wenn Sie prüfen möchten, ob ein Bild ein Wasserzeichen hat, können Sie das Bild über den Tab Media in Vertex AI Studio hochladen.

  • Live-Bilder aus Text generieren (MP4-Generierung)

  • Bilder mit einem vordefinierten Stil generieren

  • Sprache des Eingabetexts festlegen

  • Wenn Sie includeSafetyAttributes aktivieren, können safetyAttributes.categories und safetyAttributes.scores nicht zurückgegeben werden.

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

  • Ein generiertes Bild wird direkt in Google Cloud Storage als Teil der Antwort des Modells (dem Parameter storageUri) geschrieben. Stattdessen werden Bilder immer als base64-codierte Bildbyte in der Antwort 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 Ausgabebildauflösungen (Pixel)
  • 1024 × 1024 Pixel (Seitenverhältnis 1:1)
  • 896 × 1280 (Seitenverhältnis 3:4)
  • 1280 × 896 (Seitenverhältnis 4:3)
  • 768x1408 (Seitenverhältnis 9:16)
  • 1408x768 (Seitenverhältnis 16:9)


Was kannst du sonst noch tun?

Informationen zum Steuern der Inhaltserstellung

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 zu Firebase AI Logic geben