Generare immagini con Imagen

Imagen è un modello di generazione di immagini. Può essere utilizzato per generare avatar personalizzati per i profili utente o per integrare asset visivi personalizzati nei flussi di schermata esistenti per aumentare il coinvolgimento degli utenti.

Puoi accedere ai modelli Imagen dalla tua app per Android utilizzando l'SDK Firebase AI Logic. I modelli Imagen sono disponibili utilizzando entrambi i provider di API Firebase AI Logic: l'API Gemini Developer (consigliata per la maggior parte degli sviluppatori) e Vertex AI.

Un diagramma che illustra un'architettura di integrazione di Firebase AI Logic per accedere all'API Gemini Developer. Un'app per Android utilizza l'SDK Firebase per Android per connettersi a Firebase. Firebase interagisce quindi con l'API Gemini Developer, che accede a Gemini Pro e Flash nel cloud.
Figura 1. Accedi ai modelli Imagen utilizzando Firebase AI Logic.

Sperimentare con i prompt

La creazione dei prompt ideali spesso richiede più tentativi. Puoi sperimentare con i prompt di immagini in Vertex AI Studio, un IDE per la progettazione e la prototipazione dei prompt. Per suggerimenti su come migliorare i prompt, consulta la guida agli attributi di prompt e immagine.

Screenshot dell'interfaccia di Google Cloud Vertex AI Studio, che mostra quattro immagini generate di un T-Rex con uno zaino blu in una foresta preistorica. La barra laterale a sinistra mostra le opzioni di navigazione come Dashboard, Model Garden e Vision, mentre il riquadro a destra contiene i parametri per le impostazioni di generazione delle immagini.
Figura 2. Vertex AI Studio può aiutarti a perfezionare i prompt per la generazione di immagini.

Configura un progetto Firebase e connetti la tua app

Segui i passaggi descritti nella documentazione di Firebase per aggiungere Firebase al tuo progetto Android.

Aggiungi la dipendenza Gradle

Aggiungi le seguenti dipendenze al file build.gradle:

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")
}

Genera un'immagine

Per generare un'immagine nella tua app per Android, inizia istanziando un ImagenModel con una configurazione facoltativa.

Puoi utilizzare il parametro generationConfig per definire un prompt negativo, il numero di immagini, le proporzioni dell'immagine di output, il formato dell'immagine e aggiungere una filigrana. Puoi utilizzare il parametro safetySettings per configurare i filtri sicurezza e persone.

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-3.0-generate-002",
    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-3.0-generate-002",
       config,
       ImagenSafetySettings.builder()
          .setSafetyFilterLevel(ImagenSafetyFilterLevel.BLOCK_LOW_AND_ABOVE)
          .setPersonFilterLevel(ImagenPersonFilterLevel.BLOCK_ALL)
          .build())
);

Una volta creata un'istanza di ImagenModel, puoi generare immagini chiamando generateImages:

Kotlin

val imageResponse = model.generateImages(
  prompt = "An astronaut riding a horse",
)
val image = imageResponse.images.first
val bitmapImage = image.asBitmap()

Java

CompletableFuture<GenerateContentResponse> futureResponse =
    model.generateContent(
        Content.newBuilder()
            .addParts(
                Part.newBuilder()
                    .setText("An astronaut riding a horse")
                    .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();
}