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

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

La tâche accepte une requête textuelle en entrée, ainsi qu'une image de condition facultative que le modèle peut enrichir et utiliser comme référence pour la génération. Générateur d'images peut également générer des images à partir de concepts spécifiques fournis au modèle d'entraînement ou de réentraînement. Pour en savoir plus, consultez la section 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 section Présentation.

Exemple de code

L'exemple de code MediaPipe Tasks est une implémentation de base d'un générateur d'images pour Android. Vous pouvez utiliser l'application comme point de départ pour votre propre application application, ou s'y référer lors de la modification d'une application existante. Exemple de générateur d'images le code est hébergé sur GitHub

Télécharger le code

Les instructions suivantes vous expliquent comment créer une copie locale de l'exemple à 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. Si vous le souhaitez, vous pouvez configurer votre instance Git pour utiliser le paiement creuse. Seuls les fichiers de l'exemple d'application de générateur d'images sont les suivants:

   cd mediapipe
   git sparse-checkout init --cone
   git sparse-checkout set examples/image_generator/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 Android

Composants clés

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

• 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 condition comme entrée.
• LoRAWeightActivity.kt: Accède aux pondérations LoRA et les gère pour personnaliser les éléments de base et leur permettre de générer des images de concepts spécifiques.

Configuration

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

Dépendances

La tâche de génération d'images utilise la bibliothèque com.google.mediapipe:tasks-vision-image-generator. Ajouter 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 bibliothèque OpenCL native la dépendance à AndroidManifest.xml. Pour en savoir plus, consultez la documentation uses-native-library .

Certains appareils Android peuvent également nécessiter des bibliothèques supplémentaires:

<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 de génération d'images MediaPipe nécessite un modèle de fondation entraîné et compatible pour cette tâche. Après avoir téléchargé un modèle, installez les dépendances requises et convertir son modèle dans un format approprié et adapté. Ensuite, transférez les conversions 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 tâche consultez la section Modèles.

Télécharger le modèle de fondation

Pour utiliser le générateur d'images, le modèle de fondation doit correspondre Format de modèle runwayml/stable-diffusion-v1-5 EMA-only, d'après ce qui suit modèle: runwayml/stable-diffusion-v1-5.

Installer des dépendances et convertir le modèle

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

Exécutez la convert.py script:

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

Transmettre le modèle converti à l'appareil

Transférez le contenu du dossier <output_path> sur 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 des modèles de plug-in et ajouter des pondérations LoRA (facultatif)

Si vous comptez utiliser un modèle de plug-in, vérifiez si le modèle doit être téléchargée. Pour les plug-ins nécessitant un modèle supplémentaire, le plug-in les modèles doivent être regroupés dans l'APK ou téléchargés à la demande. Modèles de plug-in sont légères (environ 23 Mo) et peuvent être regroupées directement dans l'APK. Cependant, nous de télécharger des modèles de plug-ins à la demande.

Si vous avez personnalisé un modèle avec LoRA et les télécharger à la demande. Pour plus consultez la section sur les pondérations LoRA concernant le modèle de plug-in.

Créer la tâche

La tâche de génération d'images MediaPipe utilise la fonction createFromOptions() pour configurer le tâche. La fonction createFromOptions() accepte les valeurs pour la configuration options. Pour plus d'informations sur les options de configuration, consultez la section Configuration options.

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, qui permettent aux utilisateurs d'inclure des images de conditions dans l'entrée de la tâche, que le modèle de fondation peut enrichir et utiliser comme référence. depuis plusieurs générations. Il peut s'agir de repères de visages, de contours de la profondeur estimée, 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 le plug-in options. Le plug-in de point de repère "Face" utilise faceConditionOptions, le bord Canny et le plug-in Depth utilise edgeConditionOptions, tandis que le plug-in Depth depthConditionOptions

Options de Canny Edge

Configurez les options suivantes dans edgeConditionOptions.

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

Options des points de repère du visage

Configurez les options suivantes dans faceConditionOptions.

Pour en savoir plus sur le fonctionnement de ces options de configuration, consultez la Tâche de création de repère de 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 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 les pondérations LoRA, utilisez le paramètre loraWeightsFilePath pour à l'emplacement du 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): invite textuelle décrivant l'image à générer.
• iterations (obligatoire): nombre total d'itérations nécessaires pour générer l'image. A un bon point de départ est de 20.
• seed (obligatoire): valeur aléatoire utilisée lors de la génération de l'image.
• condition image (facultatif): image utilisée comme référence par le modèle génération. Uniquement applicable lors de l'utilisation d'un modèle de plug-in.
• condition type (facultatif): type de modèle de plug-in utilisé avec la tâche. Uniquement applicable lors de l'utilisation d'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 conditionType pour choisir le modèle de plug-in et le paramètre sourceConditionImage à utiliser générer l'image de condition.

Si vous utilisez un modèle de plug-in, utilisez createConditionImage pour créer le 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 la la requête, la graine 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 l'invite textuelle si vous voulez 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 alors générée.

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

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 au processus avec un modèle de fondation standard. Assurez-vous que le jeton est inclus dans l'invite et exécute 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 générées lors de chaque d'itération, comme défini dans le paramètre d'entrée iterations. Pour les afficher des résultats intermédiaires, appelez la méthode setInputs, puis execute() pour exécuter chaque étape. Définissez le paramètre showResult sur true pour afficher le niveau intermédiaire résultats.

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 code ImageGeneratorResult qui inclut l'élément un code temporel de l'heure d'exécution et l'image conditionnelle, si elle est disponible a été fournie en entrée.

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

L'image ci-dessous a été générée à partir des entrées ci-dessous, en utilisant uniquement un de fondation.

Entrées:

• Requête : "un raton laveur dessiné coloré portant un chapeau souple à large bord tenant un bâton marchant dans la forêt, vue animée à trois quarts, peinture"
• Graine: 312687592
• Itération: 20

Image générée: