Générer des images avec Imagen

Imagen est un modèle de génération d'images. Il peut être utilisé pour générer des avatars personnalisés pour les profils utilisateur ou pour intégrer des composants visuels personnalisés dans des flux d'écran existants afin d'accroître l'engagement des utilisateurs.

Vous pouvez accéder aux modèles Imagen depuis votre application Android à l'aide du SDK Firebase AI Logic. Les modèles Imagen sont disponibles avec les fournisseurs d'API Firebase AI Logic : l'API Gemini Developer (recommandée pour la plupart des développeurs) et Vertex AI.

Diagramme illustrant une architecture d'intégration Firebase AI Logic pour accéder à l'API Gemini Developer. Une application Android utilise le SDK Firebase pour Android pour se connecter à Firebase. Firebase interagit ensuite avec l'API Gemini Developer, qui accède à Gemini Pro et Gemini Flash dans le cloud.
Figure 1. Accédez aux modèles Imagen à l'aide de Firebase AI Logic.

Tester des requêtes

Il faut souvent plusieurs tentatives pour créer les requêtes idéales. Vous pouvez tester les requêtes d'image dans Google AI Studio, un IDE pour la conception et le prototypage de requêtes. Pour obtenir des conseils sur l'amélioration de vos requêtes, consultez le guide des attributs de requête et d'image.

Capture d'écran de l'interface Google AI Studio affichant quatre images générées d'un T-Rex avec un sac à dos bleu dans une forêt préhistorique.
Figure 2. Google AI Studio peut vous aider à affiner vos requêtes de génération d'images.

Configurer un projet Firebase et associer votre application

Suivez les étapes de la documentation Firebase pour ajouter Firebase à votre projet Android.

Ajouter la dépendance Gradle

Ajoutez les dépendances suivantes à votre fichier 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")
}

Générer une image

Pour générer une image dans votre application Android, commencez par instancier un ImagenModel avec une configuration facultative.

Vous pouvez utiliser le paramètre generationConfig pour définir un prompt négatif, le nombre d'images, le format d'image de sortie, le format d'image et ajouter un filigrane. Vous pouvez utiliser le paramètre safetySettings pour configurer les filtres de sécurité et de personnes.

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())
);

Une fois votre ImagenModel instancié, vous pouvez générer des images en appelant generateImages :

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();
}