Guide de génération d'images pour Android

La tâche MediaPipe Image Generator vous permet de générer des images à partir d'une requête textuelle. Cette tâche utilise un modèle texte vers image pour générer des images à l'aide de techniques de diffusion.

La tâche accepte un prompt textuel en entrée, ainsi qu'une image de condition facultative que le modèle peut augmenter et utiliser comme référence pour la génération. Le générateur d'images peut également générer des images en fonction de concepts spécifiques fournis au modèle lors de l'entraînement ou du réentraînement. Pour en savoir plus, consultez Personnaliser avec LoRA.

L'exemple de code décrit dans ces instructions est disponible sur GitHub. Pour en savoir plus sur les fonctionnalités, les modèles et les options de configuration de cette tâche, consultez la présentation.

Exemple de code

L'exemple de code MediaPipe Tasks est une implémentation de base d'une application Image Generator pour Android. Vous pouvez utiliser l'application comme point de départ pour votre propre application Android ou vous y référer lorsque vous modifiez une application existante. L'exemple de code Image Generator est hébergé sur GitHub.

Télécharger le code

Les instructions suivantes vous montrent comment créer une copie locale de l'exemple de code à l'aide de l'outil de ligne de commande git.

Pour télécharger l'exemple de code :

1. Clonez le dépôt Git à l'aide de la commande suivante :

   git clone https://github.com/google-ai-edge/mediapipe-samples
   

2. Vous pouvez également configurer votre instance Git pour utiliser l'extraction éparse, afin de ne disposer que des fichiers de l'exemple d'application Image Generator :

   cd mediapipe-samples
   git sparse-checkout init --cone
   git sparse-checkout set examples/image_generation/android
   

Après avoir créé une version locale de l'exemple de code, vous pouvez importer le projet dans Android Studio et exécuter l'application. Pour obtenir des instructions, consultez le guide de configuration pour Android.

Composants clés

Les fichiers suivants contiennent le code essentiel pour cet exemple d'application de génération d'images :

• ImageGenerationHelper.kt : initialise la tâche et gère la génération d'images.
• DiffusionActivity.kt : génère des images lorsque les plug-ins ou les pondérations LoRA ne sont pas activés.
• PluginActivity.kt : Implémente les modèles de plug-in, ce qui permet aux utilisateurs de fournir une image de condition comme entrée.
• LoRAWeightActivity.kt : accède aux pondérations LoRA et les gère. Elles sont utilisées pour personnaliser les modèles de fondation et leur permettre de générer des images de concepts spécifiques.

Configuration

Cette section décrit les étapes clés pour configurer votre environnement de développement et vos projets de code afin d'utiliser spécifiquement le générateur d'images. Pour obtenir des informations générales sur la configuration de votre environnement de développement pour l'utilisation des tâches MediaPipe, y compris les exigences concernant la version de la plate-forme, consultez le guide de configuration pour Android.

Dépendances

La tâche Image Generator utilise la bibliothèque com.google.mediapipe:tasks-vision-image-generator. Ajoutez cette dépendance au fichier build.gradle de votre application Android :

dependencies {
    implementation 'com.google.mediapipe:tasks-vision-image-generator:latest.release'
}

Pour les appareils équipés d'Android 12 (API 31) ou version ultérieure, ajoutez la dépendance de la bibliothèque OpenCL native. Pour en savoir plus, consultez la documentation sur la balise uses-native-library.

Ajoutez les balises uses-native-library suivantes au fichier AndroidManifest.xml :

<uses-native-library android:name="libOpenCL.so" android:required="false" />
<uses-native-library android:name="libOpenCL-car.so" android:required="false"/>
<uses-native-library android:name="libOpenCL-pixel.so" android:required="false" />

Modèle

La tâche MediaPipe Image Generator nécessite un modèle de fondation entraîné et compatible avec cette tâche. Après avoir téléchargé un modèle, installez les dépendances requises et convertissez-le dans un format approprié. Transférez ensuite le modèle converti sur l'appareil Android.

Pour en savoir plus sur les modèles entraînés disponibles pour le générateur d'images, consultez la section Modèles de la présentation des tâches.

Télécharger un modèle de fondation

Le générateur d'images nécessite que le modèle de fondation corresponde au format de modèle stable-diffusion-v1-5/stable-diffusion-v1-5 EMA-only, en fonction du modèle suivant : stable-diffusion-v1-5/stable-diffusion-v1-5 EMA-only.

Installer les dépendances et convertir le modèle

$ pip install torch typing_extensions numpy Pillow requests pytorch_lightning absl-py

Exécutez le script convert.py :

$ python3 convert.py --ckpt_path <ckpt_path> --output_path <output_path>

Transférer le modèle converti sur l'appareil

Transférez le contenu du dossier <output_path> vers l'appareil Android.

$ adb shell rm -r /data/local/tmp/image_generator/ # Remove any previously loaded weights
$ adb shell mkdir -p /data/local/tmp/image_generator/
$ adb push <output_path>/. /data/local/tmp/image_generator/bins

Télécharger les modèles de plug-in et ajouter des pondérations LoRA (facultatif)

Si vous prévoyez d'utiliser un modèle de plug-in, vérifiez si le modèle doit être téléchargé. Pour les plug-ins qui nécessitent un modèle supplémentaire, les modèles de plug-in doivent être regroupés dans l'APK ou téléchargés à la demande. Les modèles de plug-in sont légers (~23 Mo) et peuvent être regroupés directement dans l'APK. Toutefois, nous vous recommandons de télécharger les modèles de plug-in à la demande.

Si vous avez personnalisé un modèle avec LoRA, téléchargez-les à la demande. Pour en savoir plus, consultez la section Plugin de modèle sur les pondérations LoRA.

Créer la tâche

La tâche MediaPipe Image Generator utilise la fonction createFromOptions() pour configurer la tâche. La fonction createFromOptions() accepte les valeurs des options de configuration. Pour en savoir plus sur les options de configuration, consultez Options de configuration.

Options de configuration

Cette tâche comporte les options de configuration suivantes pour les applications Android :

La tâche est également compatible avec les modèles de plug-in, ce qui permet aux utilisateurs d'inclure des images de condition dans l'entrée de la tâche. Le modèle de fondation peut alors les augmenter et les utiliser comme référence pour la génération. Ces images de condition peuvent être des points de repère faciaux, des contours et des estimations de profondeur, que le modèle utilise comme contexte et informations supplémentaires pour générer des images.

Lorsque vous ajoutez un modèle de plug-in au modèle de fondation, configurez également les options du plug-in. Le plug-in de repères faciaux utilise faceConditionOptions, le plug-in de détection des contours de Canny utilise edgeConditionOptions et le plug-in de profondeur utilise depthConditionOptions.

Options de contours de Canny

Configurez les options suivantes dans edgeConditionOptions.

Pour en savoir plus sur le fonctionnement de ces options de configuration, consultez Détecteur de contours Canny.

Options de points de repère sur le visage

Configurez les options suivantes dans faceConditionOptions.

Pour en savoir plus sur le fonctionnement de ces options de configuration, consultez la section Tâche de reconnaissance des points de repère du visage.

Options de profondeur

Configurez les options suivantes dans depthConditionOptions.

Créer uniquement avec le modèle de fondation

val options = ImageGeneratorOptions.builder()
    .setImageGeneratorModelDirectory(modelPath)
    .build()

imageGenerator = ImageGenerator.createFromOptions(context, options)

Créer avec des plug-ins

Si vous appliquez un modèle de plug-in facultatif, définissez les options de base pour le modèle de plug-in avec setPluginModelBaseOptions. Si le modèle de plug-in nécessite un modèle téléchargé supplémentaire pour créer l'image de condition, spécifiez le chemin d'accès dans BaseOptions.

val options = ImageGeneratorOptions.builder()
    .setImageGeneratorModelDirectory(modelPath)
    .build()

val faceModelBaseOptions = BaseOptions.builder()
    .setModelAssetPath("face_landmarker.task")
    .build()

val facePluginModelBaseOptions = BaseOptions.builder()
    .setModelAssetPath("face_landmark_plugin.tflite")
    .build()

val faceConditionOptions = FaceConditionOptions.builder()
    .setFaceModelBaseOptions(faceModelBaseOptions)
    .setPluginModelBaseOptions(facePluginModelBaseOptions)
    .setMinFaceDetectionConfidence(0.3f)
    .setMinFacePresenceConfidence(0.3f)
    .build()

val conditionOptions = ConditionOptions.builder()
    .setFaceConditionOptions(faceConditionOptions)
    .build()

imageGenerator =
    ImageGenerator.createFromOptions(context, options, conditionOptions)
    

val options = ImageGeneratorOptions.builder()
    .setImageGeneratorModelDirectory(modelPath)
    .build()

val edgePluginModelBaseOptions = BaseOptions.builder()
    .setModelAssetPath("canny_edge_plugin.tflite")
    .build()

val edgeConditionOptions = EdgeConditionOptions.builder()
    .setThreshold1(100.0f)
    .setThreshold2(100.0f)
    .setApertureSize(3)
    .setL2Gradient(false)
    .setPluginModelBaseOptions(edgePluginModelBaseOptions)
    .build()

val conditionOptions = ConditionOptions.builder()
    .setEdgeConditionOptions(edgeConditionOptions)
    .build()

imageGenerator =
    ImageGenerator.createFromOptions(context, options, conditionOptions)
    

val options = ImageGeneratorOptions.builder()
    .setImageGeneratorModelDirectory(modelPath)
    .build()

val depthModelBaseOptions = BaseOptions.builder()
    .setModelAssetPath("depth_model.tflite")
    .build()

val depthPluginModelBaseOptions = BaseOptions.builder()
    .setModelAssetPath("depth_plugin.tflite")
    .build()

val depthConditionOptions =
    ConditionOptions.DepthConditionOptions.builder()
        .setDepthModelBaseOptions(depthModelBaseOptions)
        .setPluginModelBaseOptions(depthPluginModelBaseOptions)
        .build()

val conditionOptions = ConditionOptions.builder()
    .setDepthConditionOptions(depthConditionOptions)
    .build()

imageGenerator =
    ImageGenerator.createFromOptions(context, options, conditionOptions)
    

Créer avec des pondérations LoRA

Si vous incluez des pondérations LoRA, utilisez le paramètre loraWeightsFilePath pour indiquer le chemin d'accès.

val options = ImageGeneratorOptions.builder()
    .setLoraWeightsFilePath(weightsPath)
    .setImageGeneratorModelDirectory(modelPath)
    .build()

imageGenerator = ImageGenerator.createFromOptions(context, options)

Préparer les données

Le générateur d'images accepte les entrées suivantes :

• prompt (obligatoire) : prompt textuel décrivant l'image à générer.
• iterations (obligatoire) : nombre total d'itérations pour générer l'image. Un bon point de départ est 20.
• seed (obligatoire) : graine aléatoire utilisée lors de la génération d'images.
• condition image (facultatif) : image que le modèle utilise comme référence pour la génération. Ne s'applique que lorsque vous utilisez un modèle de plug-in.
• condition type (facultatif) : type de modèle de plug-in utilisé avec la tâche. Ne s'applique que lorsque vous utilisez un modèle de plug-in.

Entrées avec uniquement le modèle de fondation

fun setInput(prompt: String, iteration: Int, seed: Int) {
    imageGenerator.setInputs(prompt, iteration, seed)
}

Entrées avec plug-ins

Si vous appliquez un modèle de plug-in facultatif, utilisez également le paramètre conditionType pour choisir le modèle de plug-in et le paramètre sourceConditionImage pour générer l'image de condition.

Si vous utilisez un modèle de plug-in, utilisez createConditionImage pour créer l'image de condition :

fun createConditionImage(
    inputImage: MPImage,
    conditionType: ConditionType
): Bitmap {
    val result =
        imageGenerator.createConditionImage(inputImage, conditionType)
    return BitmapExtractor.extract(result)
}

Après avoir créé l'image de condition, incluez-la en tant qu'entrée avec l'invite, la valeur initiale et le nombre d'itérations.

imageGenerator.setInputs(
    prompt,
    conditionalImage,
    conditionType,
    iteration,
    seed
)

Entrées avec pondérations LoRA

Si vous utilisez des pondérations LoRA, assurez-vous que le jeton figure dans la requête textuelle si vous souhaitez générer une image avec le concept spécifique représenté par les pondérations.

fun setInput(prompt: String, iteration: Int, seed: Int) {
    imageGenerator.setInputs(prompt, iteration, seed)
}

Exécuter la tâche

Utilisez la méthode generate() pour générer une image à l'aide des entrées fournies dans la section précédente. Une seule image est générée.

Générer avec le modèle de fondation uniquement

fun generate(prompt: String, iteration: Int, seed: Int): Bitmap {
    val result = imageGenerator.generate(prompt, iteration, seed)
    val bitmap = BitmapExtractor.extract(result?.generatedImage())
    return bitmap
}

Générer avec des plug-ins

fun generate(
    prompt: String,
    inputImage: MPImage,
    conditionType: ConditionType,
    iteration: Int,
    seed: Int
): Bitmap {
    val result = imageGenerator.generate(
        prompt,
        inputImage,
        conditionType,
        iteration,
        seed
    )
    val bitmap = BitmapExtractor.extract(result?.generatedImage())
    return bitmap
}

Générer avec des pondérations LoRA

Le processus de génération d'images avec un modèle personnalisé avec des pondérations LoRA est semblable à celui avec un modèle de base standard. Assurez-vous que le jeton est inclus dans l'invite et exécutez le même code.

fun generate(prompt: String, iteration: Int, seed: Int): Bitmap {
    val result = imageGenerator.generate(prompt, iteration, seed)
    val bitmap = BitmapExtractor.extract(result?.generatedImage())
    return bitmap
}

Génération itérative

Le générateur d'images peut également générer les images intermédiaires à chaque itération, comme défini dans le paramètre d'entrée iterations. Pour afficher ces résultats intermédiaires, appelez la méthode setInputs, puis appelez execute() pour exécuter chaque étape. Définissez le paramètre showResult sur true pour afficher les résultats intermédiaires.

fun execute(showResult: Boolean): Bitmap {
    val result = imageGenerator.execute(showResult)

    val bitmap =
        BitmapExtractor.extract(result.generatedImage())

    return bitmap
}

Gérer et afficher les résultats

Le générateur d'images renvoie un ImageGeneratorResult, qui inclut l'image générée, un code temporel indiquant l'heure de fin et l'image conditionnelle, le cas échéant.

val bitmap = BitmapExtractor.extract(result.generatedImage())

L'image suivante a été générée à partir des entrées suivantes, en utilisant uniquement un modèle de base.

Entrées :

• Prompt : "un raton laveur coloré de dessin animé portant un chapeau à larges bords souples tenant un bâton en marchant dans la forêt, animé, vue de trois quarts, peinture"
• Source : 312687592
• Itérations : 20

Image générée :