L'IA générative est devenue un outil courant pour améliorer et accélérer le processus créatif dans divers secteurs, notamment le divertissement, la publicité et la conception graphique. Il permet des expériences plus personnalisées pour le public et améliore la qualité globale des produits finaux.

L’un des avantages majeurs de l’IA générative est la création d’expériences uniques et personnalisées pour les utilisateurs. Par exemple, l'IA générative est utilisée par les services de streaming pour générer des titres de films et des visuels personnalisés afin d'augmenter l'engagement du spectateur et de créer des visuels pour les titres en fonction de l'historique de visionnage et des préférences d'un utilisateur. Le système génère ensuite des milliers de variantes de l'illustration d'un titre et les teste pour déterminer quelle version attire le plus l'attention de l'utilisateur. Dans certains cas, les illustrations personnalisées pour les séries télévisées ont considérablement augmenté les taux de clics et les taux de visionnage par rapport aux émissions sans illustrations personnalisées.

Dans cet article, nous montrons comment vous pouvez utiliser des modèles d'IA génératifs tels que Stable Diffusion pour créer une solution d'avatar personnalisée sur Amazon Sage Maker et économisez sur les coûts d'inférence avec des points de terminaison multimodèles (MME) en même temps. La solution montre comment, en téléchargeant 10 à 12 images de vous-même, vous pouvez affiner un modèle personnalisé qui peut ensuite générer des avatars basés sur n'importe quelle invite textuelle, comme le montrent les captures d'écran suivantes. Bien que cet exemple génère des avatars personnalisés, vous pouvez appliquer la technique à n'importe quelle génération d'art créatif en affinant des objets ou des styles spécifiques.

Vue d'ensemble de la solution

Le schéma d'architecture suivant présente la solution de bout en bout pour notre générateur d'avatar.

La portée de cet article et l'exemple Code GitHub nous nous concentrons uniquement sur la formation du modèle et l'orchestration de l'inférence (la section verte dans le diagramme précédent). Vous pouvez référencer l’architecture complète de la solution et vous appuyer sur l’exemple que nous fournissons.

La formation et l'inférence du modèle peuvent être décomposées en quatre étapes :

1. Téléchargez des images sur Service de stockage simple Amazon (Amazon S3). Dans cette étape, nous vous demandons de fournir un minimum de 10 images haute résolution de vous-même. Plus il y a d'images, meilleur est le résultat, mais plus l'entraînement prendra du temps.
2. Affinez un modèle de base Stable Diffusion 2.1 à l’aide de l’inférence asynchrone SageMaker. Nous expliquons la justification de l'utilisation d'un point de terminaison d'inférence pour la formation plus loin dans cet article. Le processus de réglage fin commence par la préparation des images, y compris le recadrage du visage, la variation de l'arrière-plan et le redimensionnement du modèle. Ensuite, nous utilisons l'adaptation de bas rang (LoRA), une technique de réglage fin efficace en termes de paramètres pour les grands modèles de langage (LLM), pour affiner le modèle. Enfin, lors du post-traitement, nous emballons les poids LoRA affinés avec le script d'inférence et les fichiers de configuration (tar.gz) et les téléchargeons vers un emplacement de compartiment S3 pour les MME SageMaker.
3. Hébergez les modèles affinés à l’aide de SageMaker MME avec GPU. SageMaker chargera et mettra en cache dynamiquement le modèle à partir de l'emplacement Amazon S3 en fonction du trafic d'inférence vers chaque modèle.
4. Utilisez le modèle affiné pour l’inférence. Après le Service de notification simple d'Amazon (Amazon SNS) indiquant que le réglage fin est envoyé, vous pouvez immédiatement utiliser ce modèle en fournissant un target_model paramètre lors de l’appel du MME pour créer votre avatar.

Nous expliquons chaque étape plus en détail dans les sections suivantes et passons en revue certains exemples d'extraits de code.

Préparez les images

Pour obtenir les meilleurs résultats en ajustant la diffusion stable afin de générer des images de vous-même, vous devez généralement fournir une grande quantité et une grande variété de photos de vous-même sous différents angles, avec différentes expressions et dans différents arrière-plans. Cependant, grâce à notre implémentation, vous pouvez désormais obtenir un résultat de haute qualité avec seulement 10 images d'entrée. Nous avons également ajouté un prétraitement automatisé pour extraire votre visage de chaque photo. Tout ce dont vous avez besoin est de capturer clairement l’essence de votre apparence sous plusieurs perspectives. Incluez une photo de face, une photo de profil de chaque côté et des photos sous des angles intermédiaires. Vous devez également inclure des photos avec différentes expressions faciales comme un sourire, un froncement de sourcils et une expression neutre. Avoir un mélange d’expressions permettra au modèle de mieux reproduire les traits uniques de votre visage. Les images d'entrée dictent la qualité de l'avatar que vous pouvez générer. Pour nous assurer que cela est fait correctement, nous recommandons une expérience d'interface utilisateur frontale intuitive pour guider l'utilisateur tout au long du processus de capture et de téléchargement d'images.

Voici des exemples d’images de selfie sous différents angles avec différentes expressions faciales.

Affiner un modèle de diffusion stable

Une fois les images téléchargées sur Amazon S3, nous pouvons appeler le Inférence asynchrone SageMaker point final pour démarrer notre processus de formation. Les points de terminaison asynchrones sont destinés aux cas d'utilisation d'inférence avec des charges utiles importantes (jusqu'à 1 Go) et des temps de traitement longs (jusqu'à 1 heure). Il fournit également un mécanisme de mise en file d'attente intégré pour mettre les demandes en file d'attente et un mécanisme de notification d'achèvement des tâches via Amazon SNS, en plus d'autres fonctionnalités natives de l'hébergement SageMaker telles que la mise à l'échelle automatique.

Même si le réglage fin n'est pas un cas d'utilisation d'inférence, nous avons choisi de l'utiliser ici à la place des tâches de formation SageMaker en raison de ses mécanismes de file d'attente et de notification intégrés et mise à l'échelle automatique gérée, y compris la possibilité de réduire à 0 instance lorsque le service n'est pas utilisé. Cela nous permet d'adapter facilement le service de réglage fin à un grand nombre d'utilisateurs simultanés et élimine le besoin de mettre en œuvre et de gérer des composants supplémentaires. Cependant, cela présente l’inconvénient d’une charge utile de 1 Go et d’un temps de traitement maximum d’une heure. Lors de nos tests, nous avons constaté que 1 minutes suffisent pour obtenir des résultats raisonnablement bons avec environ 20 images d’entrée sur une instance ml.g10xlarge. Cependant, la formation SageMaker serait l'approche recommandée pour les travaux de réglage fin à plus grande échelle.

Pour héberger le point de terminaison asynchrone, nous devons effectuer plusieurs étapes. La première consiste à définir notre serveur modèle. Pour cet article, nous utilisons le Conteneur d'inférence de grand modèle (IMT). LMI est alimenté par DJL Serving, qui est une solution de service de modèles hautes performances, indépendante du langage de programmation. Nous avons choisi cette option car le conteneur d'inférence géré par SageMaker contient déjà de nombreuses bibliothèques de formation dont nous avons besoin, telles que Hugging Face. Diffuseurs et les Accélérez. Cela réduit considérablement la quantité de travail nécessaire pour personnaliser le conteneur pour notre travail de mise au point.

L'extrait de code suivant montre la version du conteneur LMI que nous avons utilisé dans notre exemple :

inference_image_uri = ( f"763104351884.dkr.ecr.{region}.amazonaws.com/djl-inference:0.21.0-deepspeed0.8.3-cu117"
)
print(f"Image going to be used is ---- > {inference_image_uri}")

En plus de cela, nous devons avoir un serving.properties qui configure les propriétés de diffusion, y compris le moteur d'inférence à utiliser, l'emplacement de l'artefact de modèle et le traitement par lots dynamique. Enfin, nous devons avoir un model.py fichier qui charge le modèle dans le moteur d'inférence et prépare les données d'entrée et de sortie du modèle. Dans notre exemple, nous utilisons le model.py pour lancer le travail de réglage fin, que nous expliquons plus en détail dans une section ultérieure. Les deux serving.properties et les model.py les fichiers sont fournis dans le training_service dossier.

L'étape suivante après la définition de notre serveur modèle consiste à créer une configuration de point de terminaison qui définit la manière dont notre inférence asynchrone sera servie. Pour notre exemple, nous définissons simplement la limite maximale d'appels simultanés et l'emplacement S3 de sortie. Avec le ml.g5.2xlarge Par exemple, nous avons constaté que nous sommes capables d'affiner jusqu'à deux modèles simultanément sans rencontrer d'exception de manque de mémoire (MOO), et nous avons donc défini max_concurrent_invocations_per_instance à 2. Ce nombre devra peut-être être ajusté si nous utilisons un ensemble différent de paramètres de réglage ou un type d'instance plus petit. Nous vous recommandons de définir cette valeur sur 1 initialement et de surveiller l'utilisation de la mémoire GPU dans Amazon Cloud Watch.

# create async endpoint configuration
async_config = AsyncInferenceConfig( output_path=f"s3://{bucket}/{s3_prefix}/async_inference/output" , # Where our results will be stored max_concurrent_invocations_per_instance=2, notification_config={   "SuccessTopic": "...",   "ErrorTopic": "...", }, #  Notification configuration
)

Enfin, nous créons un modèle SageMaker qui regroupe les informations du conteneur, les fichiers de modèle et Gestion des identités et des accès AWS (IAM) en un seul objet. Le modèle est déployé à l'aide de la configuration du point de terminaison que nous avons définie précédemment :

model = Model( image_uri=image_uri, model_data=model_data, role=role, env=env
) model.deploy( initial_instance_count=1, instance_type=instance_type, endpoint_name=endpoint_name, async_inference_config=async_inference_config
) predictor = sagemaker.Predictor( endpoint_name=endpoint_name, sagemaker_session=sagemaker_session
)

Lorsque le point de terminaison est prêt, nous utilisons l'exemple de code suivant pour appeler le point de terminaison asynchrone et démarrer le processus de réglage fin :

sm_runtime = boto3.client("sagemaker-runtime") input_s3_loc = sess.upload_data("data/jw.tar.gz", bucket, s3_prefix) response = sm_runtime.invoke_endpoint_async( EndpointName=sd_tuning.endpoint_name, InputLocation=input_s3_loc)

Pour plus de détails sur LMI sur SageMaker, reportez-vous à Déployez de grands modèles sur Amazon SageMaker à l'aide de DJLServing et de l'inférence parallèle de modèle DeepSpeed.

Après l'appel, le point de terminaison asynchrone commence à mettre en file d'attente notre tâche de réglage fin. Chaque tâche passe par les étapes suivantes : préparer les images, effectuer les réglages précis de Dreambooth et LoRA et préparer les artefacts du modèle. Approfondissons le processus de réglage fin.

Préparez les images

Comme nous l'avons mentionné précédemment, la qualité des images d'entrée a un impact direct sur la qualité du modèle affiné. Pour le cas d'utilisation de l'avatar, nous souhaitons que le modèle se concentre sur les traits du visage. Au lieu d'exiger des utilisateurs qu'ils fournissent des images soigneusement sélectionnées, de taille et de contenu exacts, nous mettons en œuvre une étape de prétraitement utilisant des techniques de vision par ordinateur pour alléger cette charge. Lors de l'étape de prétraitement, nous utilisons d'abord un modèle de détection de visage pour isoler le plus grand visage de chaque image. Ensuite, nous recadrons et remplissons l'image à la taille requise de 512 x 512 pixels pour notre modèle. Enfin, nous segmentons le visage de l'arrière-plan et ajoutons des variations aléatoires d'arrière-plan. Cela permet de mettre en valeur les traits du visage, permettant à notre modèle d'apprendre du visage lui-même plutôt que de l'arrière-plan. Les images suivantes illustrent les trois étapes de ce processus.

Étape 1: Détection de visage à l'aide de la vision par ordinateur	Étape 2: Recadrez et remplissez l'image à 512 x 512 pixels	Étape 3 (facultatif): Segmenter et ajouter une variation d'arrière-plan

Mise au point de Dreambooth et LoRA

Pour la mise au point, nous avons combiné les techniques de Dreambooth et LoRA. Dreambooth vous permet de personnaliser votre modèle de diffusion stable, en intégrant un sujet dans le domaine de sortie du modèle à l'aide d'un identifiant unique et en élargissant le dictionnaire de vision du langage du modèle. Il utilise une méthode appelée conservation préalable pour préserver la connaissance sémantique du modèle sur la classe du sujet, en l'occurrence une personne, et utiliser d'autres objets de la classe pour améliorer le résultat de l'image finale. C'est ainsi que Dreambooth peut obtenir des résultats de haute qualité avec seulement quelques images d'entrée du sujet.

L'extrait de code suivant montre les entrées de notre trainer.py classe pour notre solution d'avatar. Remarquez que nous avons choisi <<TOK>> comme identifiant unique. Ceci est volontairement fait pour éviter de choisir un nom qui figure déjà dans le dictionnaire du modèle. Si le nom existe déjà, le modèle doit désapprendre puis réapprendre le sujet, ce qui peut conduire à de mauvais résultats de réglage. La classe de matière est définie sur “a photo of person”, qui permet une préservation préalable en générant d'abord des photos de personnes à alimenter en tant qu'entrées supplémentaires lors du processus de réglage fin. Cela contribuera à réduire le surapprentissage car le modèle tente de préserver les connaissances antérieures d'une personne en utilisant la méthode de préservation antérieure.

status = trn.run(base_model="stabilityai/stable-diffusion-2-1-base", resolution=512, n_steps=1000, concept_prompt="photo of <<TOK>>", # << unique identifier of the subject learning_rate=1e-4, gradient_accumulation=1, fp16=True, use_8bit_adam=True, gradient_checkpointing=True, train_text_encoder=True, with_prior_preservation=True, prior_loss_weight=1.0, class_prompt="a photo of person", # << subject class num_class_images=50, class_data_dir=class_data_dir, lora_r=128, lora_alpha=1, lora_bias="none", lora_dropout=0.05, lora_text_encoder_r=64, lora_text_encoder_alpha=1, lora_text_encoder_bias="none", lora_text_encoder_dropout=0.05
)

Un certain nombre d'options d'économie de mémoire ont été activées dans la configuration, notamment fp16, use_8bit_adam, et accumulation de gradient. Cela réduit l'empreinte mémoire à moins de 12 Go, ce qui permet d'affiner jusqu'à deux modèles simultanément sur un ml.g5.2xlarge exemple.

LoRA est une technique de réglage fin efficace pour les LLM qui gèle la plupart des poids et attache un petit réseau d'adaptateurs à des couches spécifiques du LLM pré-entraîné, permettant une formation plus rapide et un stockage optimisé. Pour la diffusion stable, l'adaptateur est attaché à l'encodeur de texte et aux composants U-Net du pipeline d'inférence. L'encodeur de texte convertit l'invite de saisie en un espace latent compris par le modèle U-Net, et le modèle U-Net utilise la signification latente pour générer l'image dans le processus de diffusion ultérieur. Le résultat du réglage fin est juste le text_encoder et poids de l'adaptateur U-Net. Au moment de l'inférence, ces poids peuvent être rattachés au modèle de base de diffusion stable pour reproduire les résultats de réglage fin.

Les figures ci-dessous sont un diagramme détaillé du réglage fin de LoRA fourni par l'auteur original : Cheng-Han Chiang, Yung-Sung Chuang, Hung-yi Lee, « AACL_2022_tutorial_PLMs », 2022

En combinant les deux méthodes, nous avons pu générer un modèle personnalisé tout en ajustant un ordre de grandeur moins de paramètres. Cela a entraîné un temps de formation beaucoup plus rapide et une utilisation réduite du GPU. De plus, le stockage a été optimisé avec un poids de l'adaptateur de seulement 70 Mo, contre 6 Go pour un modèle complet à diffusion stable, ce qui représente une réduction de taille de 99 %.

Préparer les artefacts du modèle

Une fois le réglage fin terminé, l'étape de post-traitement TAR les poids LoRA avec le reste du modèle servant des fichiers pour NVIDIA Triton. Nous utilisons un backend Python, ce qui signifie que le fichier de configuration Triton et le script Python utilisé pour l'inférence sont requis. Notez que le script Python doit être nommé model.py. Le fichier TAR du modèle final doit avoir la structure de fichier suivante :

|--sd_lora |--config.pbtxt |--1 |--model.py |--output #LoRA weights |--text_encoder |--unet |--train.sh

Hébergez les modèles affinés à l'aide de SageMaker MME avec GPU

Une fois les modèles affinés, nous hébergeons les modèles de diffusion stable personnalisés à l'aide d'un SageMaker MME. Un SageMaker MME est une fonctionnalité de déploiement puissante qui permet d'héberger plusieurs modèles dans un seul conteneur derrière un seul point de terminaison. Il gère automatiquement le trafic et le routage vers vos modèles pour optimiser l'utilisation des ressources, réduire les coûts et minimiser la charge opérationnelle liée à la gestion de milliers de points de terminaison. Dans notre exemple, nous exécutons sur des instances GPU et les MME SageMaker prennent en charge le GPU à l'aide de Triton Server. Cela vous permet d'exécuter plusieurs modèles sur un seul périphérique GPU et de profiter d'un calcul accéléré. Pour plus de détails sur la façon d'héberger Stable Diffusion sur les MME SageMaker, reportez-vous à Créez des images de haute qualité avec des modèles de diffusion stable et déployez-les de manière rentable avec Amazon SageMaker.

Pour notre exemple, nous avons effectué une optimisation supplémentaire pour charger plus rapidement les modèles affinés lors de situations de démarrage à froid. Ceci est possible grâce à la conception de l'adaptateur LoRA. Étant donné que les poids du modèle de base et les environnements Conda sont les mêmes pour tous les modèles affinés, nous pouvons partager ces ressources communes en les préchargeant sur le conteneur d'hébergement. Cela ne laisse que le fichier de configuration Triton, le backend Python (model.py), et les poids de l'adaptateur LoRA doivent être chargés dynamiquement à partir d'Amazon S3 après le premier appel. Le diagramme suivant fournit une comparaison côte à côte.

Cela réduit considérablement le fichier TAR du modèle d'environ 6 Go à 70 Mo, et est donc beaucoup plus rapide à charger et à décompresser. Pour effectuer le préchargement dans notre exemple, nous avons créé un modèle backend utilitaire Python dans models/model_setup. Le script copie simplement le modèle de diffusion stable de base et l'environnement Conda d'Amazon S3 vers un emplacement commun pour les partager entre tous les modèles affinés. Voici l'extrait de code qui exécute la tâche :

def initialize(self, args): #conda env setup self.conda_pack_path = Path(args['model_repository']) / "sd_env.tar.gz" self.conda_target_path = Path("/tmp/conda") self.conda_env_path = self.conda_target_path / "sd_env.tar.gz" if not self.conda_env_path.exists(): self.conda_env_path.parent.mkdir(parents=True, exist_ok=True) shutil.copy(self.conda_pack_path, self.conda_env_path) #base diffusion model setup self.base_model_path = Path(args['model_repository']) / "stable_diff.tar.gz" try: with tarfile.open(self.base_model_path) as tar: tar.extractall('/tmp') self.response_message = "Model env setup successful." except Exception as e: # print the exception message print(f"Caught an exception: {e}") self.response_message = f"Caught an exception: {e}"

Ensuite, chaque modèle affiné pointera vers l’emplacement partagé sur le conteneur. L'environnement Conda est référencé dans le config.pbtxt.

name: "pipeline_0"
backend: "python"
max_batch_size: 1 ... parameters: { key: "EXECUTION_ENV_PATH", value: {string_value: "/tmp/conda/sd_env.tar.gz"}
}

Le modèle de base de diffusion stable est chargé à partir du initialize() fonction de chacun model.py déposer. Nous appliquons ensuite les poids LoRA personnalisés à l'unet et text_encoder modèle pour reproduire chaque modèle affiné :

... class TritonPythonModel: def initialize(self, args): self.output_dtype = pb_utils.triton_string_to_numpy( pb_utils.get_output_config_by_name(json.loads(args["model_config"]), "generated_image")["data_type"]) self.model_dir = args['model_repository'] device='cuda' self.pipe = StableDiffusionPipeline.from_pretrained('/tmp/stable_diff', torch_dtype=torch.float16, revision="fp16").to(device) # Load the LoRA weights self.pipe.unet = PeftModel.from_pretrained(self.pipe.unet, unet_sub_dir) if os.path.exists(text_encoder_sub_dir): self.pipe.text_encoder = PeftModel.from_pretrained(self.pipe.text_encoder, text_encoder_sub_dir)

import random prompt = """<<TOK>> epic portrait, zoomed out, blurred background cityscape, bokeh, perfect symmetry, by artgem, artstation ,concept art,cinematic lighting, highly detailed, octane, concept art, sharp focus, rockstar games, post processing, picture of the day, ambient lighting, epic composition""" negative_prompt = """
beard, goatee, ugly, tiling, poorly drawn hands, poorly drawn feet, poorly drawn face, out of frame, extra limbs, disfigured, deformed, body out of frame, blurry, bad anatomy, blurred, watermark, grainy, signature, cut off, draft, amateur, multiple, gross, weird, uneven, furnishing, decorating, decoration, furniture, text, poor, low, basic, worst, juvenile, unprofessional, failure, crayon, oil, label, thousand hands """ seed = random.randint(1, 1000000000) gen_args = json.dumps(dict(num_inference_steps=50, guidance_scale=7, seed=seed)) inputs = dict(prompt = prompt, negative_prompt = negative_prompt, gen_args = gen_args) payload = { "inputs": [{"name": name, "shape": [1,1], "datatype": "BYTES", "data": [data]} for name, data in inputs.items()]
} response = sm_runtime.invoke_endpoint( EndpointName=endpoint_name, ContentType="application/octet-stream", Body=json.dumps(payload), TargetModel="sd_lora.tar.gz",
)
output = json.loads(response["Body"].read().decode("utf8"))["outputs"]
original_image = decode_image(output[0]["data"][0])
original_image

• Contenu propulsé par le référencement et distribution de relations publiques. Soyez amplifié aujourd'hui.
• PlatoData.Network Ai générative verticale. Autonomisez-vous. Accéder ici.
• PlatoAiStream. Intelligence Web3. Connaissance Amplifiée. Accéder ici.
• PlatonESG. Automobile / VE, Carbone, Technologie propre, Énergie, Environnement, Solaire, La gestion des déchets. Accéder ici.
• Décalages de bloc. Modernisation de la propriété des compensations environnementales. Accéder ici.
• La source: https://aws.amazon.com/blogs/machine-learning/build-a-personalized-avatar-with-generative-ai-using-amazon-sagemaker/