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 deux fournisseurs d'API Firebase AI Logic: l'API Gemini Developer (recommandée pour la plupart des développeurs) et Vertex AI.

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

Tester des requêtes

Créer les requêtes idéales nécessite souvent plusieurs tentatives. Vous pouvez tester des requêtes d'image dans Vertex 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 Cloud Vertex AI Studio, affichant quatre images générées d'un T-Rex avec un sac à dos bleu dans une forêt préhistorique. La barre latérale de gauche affiche des options de navigation telles que le tableau de bord, le jardin de modèles et Vision, tandis que le panneau de droite contient les paramètres de génération d'images.
Figure 2. Vertex 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 une ImagenModel avec une configuration facultative.

Vous pouvez utiliser le paramètre generationConfig pour définir une invite négative, 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 personne.

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

Une fois votre ImagenModel instanciée, vous pouvez générer des images en appelant 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();
}