Bilder mit Imagen generieren


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

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

Hinweis: 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 und Features.

 Code für die Eingabe von Nur-Text-Inhalten

Hinweis

Klicke auf deinen Gemini API-Anbieter, um dir anbieterspezifische Inhalte und Code auf dieser Seite anzusehen.

Sehen Sie sich den Einstiegsleitfaden an, in dem beschrieben wird, wie Sie Ihr Firebase-Projekt einrichten, Ihre App mit Firebase verbinden, das SDK hinzufügen, den Backend-Dienst für den ausgewählten API-Anbieter initialisieren und eine ImagenModel-Instanz erstellen.

Modelle, die diese Funktion unterstützen

Die Bildgenerierung wird von den Imagen 3-Modellen unterstützt.

Hinweis: Firebase AI Logic unterstützt auch die Bildgenerierung mit Gemini-Modellen. Eine entsprechende Dokumentation ist in Vorbereitung.

Bilder aus reiner Texteingabe generieren

Sie können ein Imagen-Modell bitten, Bilder zu generieren, indem Sie einen Textprompt 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.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. Schau aber bald noch einmal vorbei.

Weitere Informationen zur Auswahl eines Modells

Mehrere Bilder aus Text 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 3-Modelle nur ein Bild pro Anfrage. Sie können jedoch ein Imagen-Modell bitten, mehrere Bilder pro Anfrage zu generieren. Geben Sie dazu beim Erstellen der ImagenModel-Instanz einen ImagenGenerationConfig an.

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.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. Schau aber bald noch einmal vorbei.

Weitere Informationen zur Auswahl eines Modells


Unterstützte Funktionen und Anforderungen

Die Imagen 3-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 3-Modellen.

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

Für die meisten dieser Funktionen müssen Sie sich auf einer genehmigten Nutzerliste befinden, auch wenn Sie Imagen-Modelle serverseitig verwenden.

  • Bildbearbeitungs- oder -manipulationsfunktionen, einschließlich der Bildvergrößerung

  • Bilder in die Anfrage an das Modell aufnehmen (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 es ü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

  • includeSafetyAttributes aktivieren, was bedeutet, dass safetyAttributes.categories und safetyAttributes.scores nicht zurückgegeben werden können

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

  • Ein generiertes Bild wird als Teil der Antwort des Modells (storageUri-Parameter) direkt in Google Cloud Storage geschrieben. Stattdessen werden Bilder in der Antwort immer als base64-codierte Bildbytes 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

Limits (pro Anfrage) Imagen 3 Imagen 3 Fast
Maximale Anzahl von Eingabetokens 480 Tokens 480 Tokens
Maximale Anzahl von Ausgabebildern 4 Bilder 4 Bilder
Unterstützte Ausgabebildauflösungen (Pixel)
  • 1.024 × 1.024 Pixel (Seitenverhältnis 1:1)
  • 896 × 1280 (Seitenverhältnis 3:4)
  • 1280 x 896 (Seitenverhältnis 4:3)
  • 768 × 1408 (Seitenverhältnis 9:16)
  • 1408 × 768 (Seitenverhältnis 16:9)
  • 1.024 × 1.024 Pixel (Seitenverhältnis 1:1)
  • 896 × 1280 (Seitenverhältnis 3:4)
  • 1280 x 896 (Seitenverhältnis 4:3)
  • 768 × 1408 (Seitenverhältnis 9:16)
  • 1408 × 768 (Seitenverhältnis 16:9)


Was können Sie sonst noch tun?

  • Überlegen Sie, wie Sie sich auf die Produktion vorbereiten können (siehe Checkliste für die Produktion). Dazu gehören:
    • Firebase App Check einrichten, um die Gemini API vor Missbrauch durch nicht autorisierte Clients zu schützen.
    • Firebase Remote Config einbinden, um Werte in Ihrer App (z. B. den Modellnamen) zu aktualisieren, ohne eine neue App-Version zu veröffentlichen.

Inhaltserstellung steuern

Weitere Informationen zu den unterstützten Modellen

Hier finden Sie Informationen zu den Modellen, die für verschiedene Anwendungsfälle verfügbar sind, sowie zu ihren Kontingenten und Preisen.


Feedback zu Firebase AI Logic geben