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 schermate esistenti al fine di 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 fornitori di API di 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 Android di Firebase 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.

Sperimenta con i prompt

Spesso sono necessari più tentativi per creare i prompt ideali. 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.

Uno screenshot dell'interfaccia di Vertex AI Studio di Google Cloud, che mostra quattro immagini generate di un T-Rex con uno zaino blu in una foresta preistorica. La barra laterale sinistra mostra 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 creando un'istanza di ImagenModel con una configurazione facoltativa.

Puoi utilizzare il parametro generationConfig per definire un prompt negativo, il numero di immagini, le proporzioni delle immagini di output, il formato dell'immagine e aggiungere una filigrana. Puoi utilizzare il parametro safetySettings per configurare i filtri di sicurezza e delle 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 creato 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();
}