Inpaint des images avec Stable Diffusion à l'aide d'Amazon SageMaker JumpStart

En novembre 2022, nous annoncé que les clients AWS peuvent générer des images à partir de texte avec Diffusion stable modèles utilisant Amazon SageMaker JumpStart. Aujourd'hui, nous sommes ravis de présenter une nouvelle fonctionnalité qui permet aux utilisateurs de peindre des images avec des modèles de diffusion stable. L'inpainting fait référence au processus de remplacement d'une partie d'une image par une autre image basée sur une invite textuelle. En fournissant l'image d'origine, une image de masque qui décrit la partie à remplacer et une invite textuelle, le modèle de diffusion stable peut produire une nouvelle image qui remplace la zone masquée par l'objet, le sujet ou l'environnement décrit dans l'invite textuelle.

Vous pouvez utiliser l'inpainting pour restaurer des images dégradées ou créer de nouvelles images avec de nouveaux sujets ou styles dans certaines sections. Dans le domaine de la conception architecturale, la peinture à diffusion stable peut être appliquée pour réparer les zones incomplètes ou endommagées des plans de construction, fournissant des informations précises aux équipes de construction. Dans le cas de l'imagerie IRM clinique, la tête du patient doit être retenue, ce qui peut conduire à des résultats médiocres en raison de l'artefact de recadrage entraînant une perte de données ou une réduction de la précision du diagnostic. L'inpainting d'image peut aider efficacement à atténuer ces résultats sous-optimaux.

Dans cet article, nous présentons un guide complet sur le déploiement et l'exécution de l'inférence à l'aide du modèle d'inpainting Stable Diffusion selon deux méthodes : via l'interface utilisateur (UI) de JumpStart dans Amazon SageMakerStudio, et par programmation via API JumpStart disponible dans le Kit de développement logiciel (SDK) SageMaker Python.

Vue d'ensemble de la solution

Les images suivantes sont des exemples d'inpainting. Les images d'origine sont à gauche, l'image du masque est au centre et l'image peinte générée par le modèle est à droite. Pour le premier exemple, le modèle a reçu l'image originale, une image de masque et l'invite textuelle "un chat blanc, yeux bleus, portant un pull, allongé dans un parc", ainsi que l'invite négative "pieds mal dessinés". ” Pour le deuxième exemple, l'invite textuelle était "Un modèle féminin présente gracieusement une robe longue décontractée avec un mélange de teintes roses et bleues".

L'exécution de grands modèles comme Stable Diffusion nécessite des scripts d'inférence personnalisés. Vous devez exécuter des tests de bout en bout pour vous assurer que le script, le modèle et l'instance souhaitée fonctionnent ensemble efficacement. JumpStart simplifie ce processus en fournissant des scripts prêts à l'emploi qui ont été rigoureusement testés. Vous pouvez accéder à ces scripts en un clic via l'interface utilisateur de Studio ou avec très peu de lignes de code via le API JumpStart.

Les sections suivantes vous guident tout au long du déploiement du modèle et de l'exécution de l'inférence à l'aide de l'interface utilisateur de Studio ou des API JumpStart.

Notez qu'en utilisant ce modèle, vous acceptez les Licence CreativeML Open RAIL++-M.

Accéder à JumpStart via l'interface utilisateur de Studio

Dans cette section, nous illustrons le déploiement de modèles JumpStart à l'aide de l'interface utilisateur de Studio. La vidéo ci-jointe montre comment localiser le modèle d'inpainting Stable Diffusion pré-entraîné sur JumpStart et comment le déployer. La page du modèle offre des détails essentiels sur le modèle et son utilisation. Pour effectuer l'inférence, nous utilisons le type d'instance ml.p3.2xlarge, qui fournit l'accélération GPU requise pour une inférence à faible latence à un prix abordable. Une fois l'instance d'hébergement SageMaker configurée, choisissez Déployer. Le point de terminaison sera opérationnel et prêt à traiter les demandes d'inférence dans un délai d'environ 10 minutes.

JumpStart fournit un exemple de bloc-notes qui peut aider à accélérer le temps nécessaire à l'exécution de l'inférence sur le point de terminaison nouvellement créé. Pour accéder au bloc-notes dans Studio, choisissez Cahier ouvert dans le Utiliser Endpoint depuis Studio section de la page de point de terminaison du modèle.

Utiliser JumpStart par programmation avec le SDK SageMaker

L'utilisation de l'interface utilisateur JumpStart vous permet de déployer un modèle pré-formé de manière interactive en quelques clics seulement. Vous pouvez également utiliser des modèles JumpStart par programmation en utilisant des API intégrées dans le SDK SageMaker Python.

Dans cette section, nous choisissons un modèle pré-formé approprié dans JumpStart, déployons ce modèle sur un point de terminaison SageMaker et effectuons une inférence sur le point de terminaison déployé, le tout à l'aide du SDK SageMaker Python. Les exemples suivants contiennent des extraits de code. Pour accéder au code complet avec toutes les étapes incluses dans cette démonstration, reportez-vous au Introduction à l'édition d'images JumpStart - Stable Diffusion Inpainting exemple de cahier.

Déployer le modèle pré-entraîné

SageMaker utilise des conteneurs Docker pour diverses tâches de construction et d'exécution. JumpStart utilise le Conteneurs d'apprentissage en profondeur SageMaker (DLC) qui sont spécifiques au framework. Nous récupérons d'abord tous les packages supplémentaires, ainsi que les scripts pour gérer la formation et l'inférence pour la tâche sélectionnée. Ensuite, les artefacts de modèle pré-formés sont récupérés séparément avec model_uris, qui offre de la flexibilité à la plate-forme. Cela permet d'utiliser plusieurs modèles pré-formés avec un seul script d'inférence. Le code suivant illustre ce processus :

model_id, model_version = "model-inpainting-stabilityai-stable-diffusion-2-inpainting-fp16", "*"
# Retrieve the inference docker container uri
deploy_image_uri = image_uris.retrieve( region=None, framework=None, # automatically inferred from model_id image_scope="inference", model_id=model_id, model_version=model_version, instance_type=inference_instance_type,
)
# Retrieve the inference script uri
deploy_source_uri = script_uris.retrieve(model_id=model_id, model_version=model_version, script_scope="inference") base_model_uri = model_uris.retrieve(model_id=model_id, model_version=model_version, model_scope="inference")

Ensuite, nous fournissons ces ressources à un Modèle SageMaker instance et déployer un point de terminaison :

# Create the SageMaker model instance
# Create the SageMaker model instance
model = Model( image_uri=deploy_image_uri, source_dir=deploy_source_uri, model_data=base_model_uri, entry_point="inference.py", # entry point file in source_dir and present in deploy_source_uri role=aws_role, predictor_cls=Predictor, name=endpoint_name,
) # deploy the Model - note that we need to pass the Predictor class when we deploy the model through the Model class,
# in order to run inference through the SageMaker API
base_model_predictor = model.deploy( initial_instance_count=1, instance_type=inference_instance_type, predictor_cls=Predictor, endpoint_name=endpoint_name,
)

Une fois le modèle déployé, nous pouvons en tirer des prédictions en temps réel !

Entrée

L'entrée est l'image de base, une image de masque et l'invite décrivant le sujet, l'objet ou l'environnement à remplacer dans la partie masquée. La création de l'image de masque parfaite pour les effets de peinture implique plusieurs bonnes pratiques. Commencez par une invite spécifique et n'hésitez pas à expérimenter divers paramètres de diffusion stable pour obtenir les résultats souhaités. Utilisez une image de masque qui ressemble étroitement à l'image que vous souhaitez peindre. Cette approche aide l'algorithme d'inpainting à compléter les sections manquantes de l'image, ce qui donne une apparence plus naturelle. Les images de haute qualité donnent généralement de meilleurs résultats, alors assurez-vous que vos images de base et de masque sont de bonne qualité et se ressemblent. De plus, optez pour une image de masque grande et lisse pour préserver les détails et minimiser les artefacts.

Le point de terminaison accepte l'image de base et le masque sous forme de valeurs RVB brutes ou d'une image encodée en base64. Le gestionnaire d'inférence décode l'image en fonction de content_type:

• Pour content_type = “application/json”, la charge utile d'entrée doit être un dictionnaire JSON avec les valeurs RVB brutes, l'invite textuelle et d'autres paramètres facultatifs
• Pour content_type = “application/json;jpeg”, la charge utile d'entrée doit être un dictionnaire JSON avec l'image encodée en base64, une invite textuelle et d'autres paramètres facultatifs

Sortie

Le point de terminaison peut générer deux types de sortie : une image RVB encodée en Base64 ou un dictionnaire JSON des images générées. Vous pouvez spécifier le format de sortie souhaité en définissant le accept en-tête à "application/json" or "application/json;jpeg" pour une image JPEG ou base64, respectivement.

• Pour accept = “application/json”, le point de terminaison renvoie un dictionnaire JSON avec des valeurs RVB pour l'image
• Pour accept = “application/json;jpeg”, le point de terminaison renvoie un dictionnaire JSON avec l'image JPEG sous forme d'octets encodés avec l'encodage base64.b64

Notez que l'envoi ou la réception de la charge utile avec les valeurs RVB brutes peut atteindre les limites par défaut pour la charge utile d'entrée et la taille de la réponse. Par conséquent, nous vous recommandons d'utiliser l'image encodée en base64 en définissant content_type = “application/json;jpeg” et acceptez = "application/json;jpeg".

Le code suivant est un exemple de demande d'inférence :

content_type = "application/json;jpeg" with open(input_img_file_name, "rb") as f: input_img_image_bytes = f.read()
with open(input_img_mask_file_name, "rb") as f: input_img_mask_image_bytes = f.read() encoded_input_image = base64.b64encode(bytearray(input_img_image_bytes)).decode()
encoded_mask = base64.b64encode(bytearray(input_img_mask_image_bytes)).decode() payload = { "prompt": "a white cat, blue eyes, wearing a sweater, lying in park", "image": encoded_input_image, "mask_image": encoded_mask, "num_inference_steps": 50, "guidance_scale": 7.5, "seed": 0, "negative_prompt": "poorly drawn feet",
} accept = "application/json;jpeg" def query(model_predictor, payload, content_type, accept): """Query the model predictor.""" query_response = model_predictor.predict( payload, { "ContentType": content_type, "Accept": accept, }, ) return query_response query_response = query(model_predictor, json.dumps(payload).encode("utf-8"), content_type, accept)
generated_images = parse_response(query_response)

Paramètres pris en charge

Les modèles d'inpainting à diffusion stable prennent en charge de nombreux paramètres pour la génération d'images :

• image – L'image d'origine.
• masque – Une image où la partie noircie reste inchangée pendant la génération de l'image et la partie blanche est remplacée.
• rapide – Une invite pour guider la génération d'image. Il peut s'agir d'une chaîne ou d'une liste de chaînes.
• num_inference_steps (facultatif) – Le nombre d'étapes de débruitage lors de la génération de l'image. Plus d'étapes conduisent à une image de meilleure qualité. S'il est spécifié, il doit s'agir d'un entier positif. Notez que plus d'étapes d'inférence entraîneront un temps de réponse plus long.
• guidance_scale (facultatif) – Une échelle de guidage plus élevée donne une image plus étroitement liée à l'invite, au détriment de la qualité de l'image. S'il est spécifié, il doit s'agir d'un flottant. guidance_scale<=1 est ignoré.
• negative_prompt (optionnel) – Cela guide la génération d'image par rapport à cette invite. Si spécifié, il doit s'agir d'une chaîne ou d'une liste de chaînes et utilisé avec guidance_scale. Si guidance_scale est désactivé, ceci est également désactivé. De plus, si l'invite est une liste de chaînes, alors le negative_prompt doit également être une liste de chaînes.
• graine (facultatif) – Cela corrige l'état aléatoire pour la reproductibilité. S'il est spécifié, il doit s'agir d'un nombre entier. Chaque fois que vous utilisez la même invite avec la même graine, l'image résultante sera toujours la même.
• batch_size (facultatif) – Le nombre d'images à générer en une seule passe avant. Si vous utilisez une instance plus petite ou si vous générez de nombreuses images, réduisez batch_size être un petit nombre (1-2). Le nombre d'images = nombre d'invites*num_images_per_prompt.

Limites et biais

Même si Stable Diffusion a des performances impressionnantes en inpainting, il souffre de plusieurs limitations et biais. Ceux-ci incluent, mais ne sont pas limités à :

• Le modèle peut ne pas générer des visages ou des membres précis car les données d'entraînement n'incluent pas suffisamment d'images avec ces caractéristiques.
• Le modèle a été entraîné sur le Jeu de données LAION-5B, qui a un contenu réservé aux adultes et peut ne pas être adapté à l'utilisation du produit sans autre considération.
• Le modèle peut ne pas fonctionner correctement avec des langues autres que l'anglais, car le modèle a été formé sur du texte en anglais.
• Le modèle ne peut pas générer un bon texte dans les images.
• La peinture par diffusion stable fonctionne généralement mieux avec des images de résolution inférieure, telles que 256 × 256 ou 512 × 512 pixels. Lorsque vous travaillez avec des images haute résolution (768 × 768 ou plus), la méthode peut avoir du mal à maintenir le niveau de qualité et de détail souhaité.
• Bien que l'utilisation d'une graine puisse aider à contrôler la reproductibilité, la peinture à diffusion stable peut toujours produire des résultats variés avec de légères modifications de l'entrée ou des paramètres. Cela peut rendre difficile le réglage fin de la sortie pour des besoins spécifiques.
• La méthode peut avoir du mal à générer des textures et des motifs complexes, en particulier lorsqu'ils s'étendent sur de grandes zones de l'image ou sont essentiels pour maintenir la cohérence et la qualité globales de la région peinte.

Pour plus d'informations sur les limites et les biais, reportez-vous au Fiche modèle Stable Diffusion Inpainting.

Solution de peinture avec masque généré via une invite

CLIPSeq est une technique avancée d'apprentissage en profondeur qui utilise la puissance des modèles CLIP (Contrastive Language-Image Pretraining) pré-formés pour générer des masques à partir d'images d'entrée. Cette approche offre un moyen efficace de créer des masques pour des tâches telles que la segmentation d'images, l'inpainting et la manipulation. CLIPSeq utilise CLIP pour générer une description textuelle de l'image d'entrée. La description textuelle est ensuite utilisée pour générer un masque qui identifie les pixels de l'image qui sont pertinents pour la description textuelle. Le masque peut ensuite être utilisé pour isoler les parties pertinentes de l'image pour un traitement ultérieur.

CLIPSeq présente plusieurs avantages par rapport aux autres méthodes de génération de masques à partir d'images d'entrée. Premièrement, c'est une méthode plus efficace, car elle ne nécessite pas que l'image soit traitée par un algorithme de segmentation d'image séparé. Deuxièmement, il est plus précis, car il peut générer des masques plus étroitement alignés sur la description textuelle de l'image. Troisièmement, il est plus polyvalent, car vous pouvez l'utiliser pour générer des masques à partir d'une grande variété d'images.

Cependant, CLIPSeq présente également certains inconvénients. Premièrement, la technique peut avoir des limites en termes de sujet, car elle repose sur des modèles CLIP pré-formés qui peuvent ne pas englober des domaines ou des domaines d'expertise spécifiques. Deuxièmement, il peut s'agir d'une méthode sensible, car elle est susceptible d'erreurs dans la description textuelle de l'image.

Pour plus d'informations, reportez-vous à Style de mode virtuel avec IA générative utilisant Amazon SageMaker.

Nettoyer

Une fois que vous avez terminé d'exécuter le bloc-notes, assurez-vous de supprimer toutes les ressources créées au cours du processus pour vous assurer que la facturation est arrêtée. Le code pour nettoyer le point de terminaison est disponible dans le fichier associé cahier.

Conclusion

Dans cet article, nous avons montré comment déployer un modèle d'inpainting Stable Diffusion pré-entraîné à l'aide de JumpStart. Nous avons montré des extraits de code dans ce post - le code complet avec toutes les étapes de cette démo est disponible dans le Introduction à JumpStart - Améliorez la qualité de l'image guidée par l'invite exemple de cahier. Essayez la solution par vous-même et envoyez-nous vos commentaires.

Pour en savoir plus sur le modèle et son fonctionnement, consultez les ressources suivantes :

Pour en savoir plus sur JumpStart, consultez les articles suivants :

À propos des auteurs

Dr Vivek Madan est un scientifique appliqué au sein de l'équipe Amazon SageMaker JumpStart. Il a obtenu son doctorat à l'Université de l'Illinois à Urbana-Champaign et a été chercheur postdoctoral à Georgia Tech. Il est un chercheur actif en apprentissage automatique et en conception d'algorithmes et a publié des articles dans les conférences EMNLP, ICLR, COLT, FOCS et SODA.

Alfred Shen est spécialiste senior IA/ML chez AWS. Il a travaillé dans la Silicon Valley, occupant des postes techniques et de direction dans divers secteurs, notamment la santé, la finance et la haute technologie. Il est un chercheur appliqué dédié à l'IA/ML, se concentrant sur le CV, la PNL et la multimodalité. Son travail a été présenté dans des publications telles que EMNLP, ICLR et Public Health.

• Contenu propulsé par le référencement et distribution de relations publiques. Soyez amplifié aujourd'hui.
• Platoblockchain. Intelligence métaverse Web3. Connaissance Amplifiée. Accéder ici.
• La source: https://aws.amazon.com/blogs/machine-learning/inpaint-images-with-stable-diffusion-using-amazon-sagemaker-jumpstart/