Bilder mit Imagen generieren

Imagen ist ein Modell zur Bildgenerierung. Damit lassen sich benutzerdefinierte Avatare für Nutzerprofile erstellen oder personalisierte visuelle Assets in bestehende Bildschirmabläufe einbinden, um die Nutzerinteraktion zu steigern.

Sie können über das Firebase AI Logic SDK in Ihrer Android-App auf Imagen-Modelle zugreifen. Imagen-Modelle sind über beide API-Anbieter von Firebase AI Logic verfügbar: die Gemini Developer API (für die meisten Entwickler empfohlen) und Vertex AI.

Ein Diagramm zur Veranschaulichung einer Firebase AI Logic-Integrationsarchitektur für den Zugriff auf die Gemini Developer API. Eine Android-App nutzt das Firebase Android SDK, um eine Verbindung zu Firebase herzustellen. Firebase interagiert dann mit der Gemini Developer API, die auf Gemini Pro und Flash in der Cloud zugreift.
Abbildung 1: Mit Firebase AI Logic auf Imagen-Modelle zugreifen

Prompts ausprobieren

Das Erstellen der idealen Prompts erfordert oft mehrere Versuche. Sie können mit Bild-Prompts in Google AI Studio experimentieren, einer IDE für Prompt-Design und Prototyping. Tipps zur Verbesserung Ihrer Prompts finden Sie im Leitfaden zu Prompts und Bildattributen.

Ein Screenshot der Google AI Studio-Benutzeroberfläche mit vier generierten Bildern eines Tyrannosaurus Rex mit einem blauen Rucksack in einem prähistorischen Wald.
Abbildung 2. Google AI Studio kann Ihnen helfen, Ihre Prompts für die Bildgenerierung zu optimieren.

Firebase-Projekt einrichten und App verbinden

Folgen Sie der Anleitung in der Firebase-Dokumentation, um Firebase zu Ihrem Android-Projekt hinzuzufügen.

Gradle-Abhängigkeit hinzufügen

Fügen Sie der Datei build.gradle die folgenden Abhängigkeiten hinzu:

dependencies {
  // Import the BoM for the Firebase platform
  implementation(platform("com.google.firebase:firebase-bom:34.2.0"))

  // Add the dependency for the Firebase AI Logic library. When using the BoM,
  // you don't specify versions in Firebase library dependencies
  implementation("com.google.firebase:firebase-ai")
}

Bild generieren

Wenn Sie ein Bild in Ihrer Android-App generieren möchten, instanziieren Sie zuerst ein ImagenModel mit einer optionalen Konfiguration.

Mit dem Parameter generationConfig können Sie einen negativen Prompt, die Anzahl der Bilder, das Seitenverhältnis des Ausgabebilds, das Bildformat und ein Wasserzeichen definieren. Mit dem Parameter safetySettings können Sie die Filter für Sicherheit und Personen konfigurieren.

Kotlin

val config = ImagenGenerationConfig {
    numberOfImages = 2,
    aspectRatio = ImagenAspectRatio.LANDSCAPE_16x9,
    imageFormat = ImagenImageFormat.jpeg(compressionQuality = 100),
    addWatermark = false
}

// Initialize the Gemini Developer API backend service
// For Vertex AI use Firebase.ai(backend = GenerativeBackend.vertexAI())
val model = Firebase.ai(backend = GenerativeBackend.googleAI()).imagenModel(
    modelName = "imagen-4.0-generate-001",
    generationConfig = config,
    safetySettings = ImagenSafetySettings(
       safetyFilterLevel = ImagenSafetyFilterLevel.BLOCK_LOW_AND_ABOVE,
       personFilterLevel = ImagenPersonFilterLevel.BLOCK_ALL
    )
)

Java

ImagenGenerationConfig config = new ImagenGenerationConfig.Builder()
    .setNumberOfImages(2)
    .setAspectRatio(ImagenAspectRatio.LANDSCAPE_16x9)
    .setImageFormat(ImagenImageFormat.jpeg(100))
    .setAddWatermark(false)
    .build();

// For Vertex AI use Firebase.ai(backend = GenerativeBackend.vertexAI())
ImagenModelFutures model = ImagenModelFutures.from(
    FirebaseAI.ai(backend = GenerativeBackend.googleAI()).imagenModel(
       "imagen-4.0-generate-001",
       config,
       ImagenSafetySettings.builder()
          .setSafetyFilterLevel(ImagenSafetyFilterLevel.BLOCK_LOW_AND_ABOVE)
          .setPersonFilterLevel(ImagenPersonFilterLevel.BLOCK_ALL)
          .build())
);

Sobald Ihre ImagenModel instanziiert ist, können Sie Bilder generieren, indem Sie generateImages aufrufen:

Kotlin

val imageResponse = model.generateImages(
  prompt = "A hyper realistic picture of a t-rex with a blue bagpack in a prehistoric forest",
)
val image = imageResponse.images.first
val bitmapImage = image.asBitmap()

Java

CompletableFuture<GenerateContentResponse> futureResponse =
    model.generateContent(
        Content.newBuilder()
            .addParts(
                Part.newBuilder()
                    .setText("A hyper realistic picture of a t-rex with a blue bagpack in a prehistoric forest")
                    .build())
            .build());

try {
  GenerateContentResponse imageResponse = futureResponse.get();
  List<GeneratedImage> images =
      imageResponse
          .getCandidates(0)
          .getContent()
          .getParts(0)
          .getInlineData()
          .getImagesList();

  if (!images.isEmpty()) {
    GeneratedImage image = images.get(0);
    Bitmap bitmapImage = image.asBitmap();
    // Use bitmapImage
  }
} catch (ExecutionException | InterruptedException e) {
  e.printStackTrace();
}