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.
<ph type="x-smartling-placeholder">Pour télécharger l'exemple de code:
- Clonez le dépôt Git à l'aide de la commande suivante:
git clone https://github.com/google-ai-edge/mediapipe-samples
- 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
<ph type="x-smartling-placeholder">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:
Nom de l'option | Description | Plage de valeurs |
---|---|---|
imageGeneratorModelDirectory |
Répertoire du modèle du générateur d'images qui stocke les pondérations du modèle. | PATH |
loraWeightsFilePath |
Définit le chemin d'accès au fichier de pondérations LoRA. Facultatif et applicable uniquement si le modèle a été personnalisé avec LoRA. | PATH |
errorListener |
Définit un écouteur d'erreurs facultatif. | N/A |
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
.
Nom de l'option | Description | Plage de valeurs | Valeur par défaut |
---|---|---|---|
threshold1 |
Premier seuil pour la procédure d'hystérèse. | Float |
100 |
threshold2 |
Deuxième seuil pour la procédure d'hystérèse. | Float |
200 |
apertureSize |
Taille d'ouverture pour l'opérateur Sobel. La plage standard est comprise entre 3 et 7. | Integer |
3 |
l2Gradient |
Si la norme L2 est utilisée pour calculer la magnitude du gradient de l'image, au lieu de la norme L1 par défaut. | BOOLEAN |
False |
EdgePluginModelBaseOptions |
L'objet BaseOptions qui définit le chemin d'accès
pour le modèle de plug-in. |
Objet BaseOptions |
N/A |
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
.
Nom de l'option | Description | Plage de valeurs | Valeur par défaut |
---|---|---|---|
minFaceDetectionConfidence |
Score de confiance minimal pour la détection de visages considéré comme réussi. | Float [0.0,1.0] |
0.5 |
minFacePresenceConfidence |
Score de confiance minimal de présence du visage dans la détection de points de repère faciales. | Float [0.0,1.0] |
0.5 |
faceModelBaseOptions |
L'objet BaseOptions qui définit le chemin d'accès
pour le modèle qui crée l'image de condition. |
Objet BaseOptions |
N/A |
FacePluginModelBaseOptions |
L'objet BaseOptions qui définit le chemin d'accès
pour le modèle de plug-in. |
Objet BaseOptions |
N/A |
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
.
Nom de l'option | Description | Plage de valeurs | Valeur par défaut |
---|---|---|---|
depthModelBaseOptions |
L'objet BaseOptions qui définit le chemin d'accès
pour le modèle qui crée l'image de condition. |
Objet BaseOptions |
N/A |
depthPluginModelBaseOptions |
L'objet BaseOptions qui définit le chemin d'accès
pour le modèle de plug-in. |
Objet BaseOptions |
N/A |
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
Point de repère du visage
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)
Canny Edge
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)
Profondeur
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.
Nom de l'option | Description | Valeur |
---|---|---|
conditionType |
Modèle de plug-in appliqué au modèle de fondation. | {"FACE", "EDGE", "DEPTH"} |
sourceConditionImage |
Image source utilisée pour créer l'image de condition. | Objet MPImage |
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: