# # Sous licence Apache License, Version 2.0 (la « Licence ») ; # vous ne pouvez utiliser ce fichier que conformément à la Licence. # Vous pouvez obtenir un exemplaire de la Licence à # # http://www.apache.org/licenses/LICENSE-2.0 # # Sauf exigence légale ou accord écrit # distribué sous la Licence est distribué sur une base « EN L'ÉTAT », # SANS AUCUNE GARANTIE NI CONDITION, explicite ou implicite. # Voir la Licence pour le langage spécifique régissant les autorisations et # limitations de la Licence. --> # GLM-Image ## Aperçu GLM-Image est un modèle de génération d'images qui adopte une architecture de décodeur hybride autorégressive + diffusion, repoussant efficacement la limite supérieure de la fidélité visuelle et des détails fins. En termes de qualité générale de génération d'images, il est au niveau des approches basées sur LDM faisant référence dans l'industrie, tout en démontrant des avantages significatifs dans les scénarios de génération d'images intensifs en connaissances. Architecture du modèle : une conception de décodeur hybride autorégressive + diffusion + Générateur autorégressif : un modèle de 9 milliards de paramètres initialisé à partir de [GLM-4-9B-0414](https://huggingface.co/zai-org/GLM-4-9B-0414), avec un vocabulaire élargi pour intégrer des jetons visuels. Le modèle génère d'abord un encodage compact d'environ 256 jetons, puis l'étend à 1K–4K jetons, correspondant à des images de sortie haute résolution de 1K–2K. Vous pouvez consulter le modèle AR dans la classe `GlmImageForConditionalGeneration` de la bibliothèque `transformers`. + Diffusion Decoder : un décodeur de 7 milliards de paramètres basé sur une architecture DiT à flux unique pour le décodage d'images dans l'espace latent. Il est équipé d'un module de texte Glyph Encoder, améliorant considérablement le rendu précis du texte au sein des images. Post-entraînement par apprentissage par renforcement découplé : le modèle introduit une stratégie de rétroaction fine et modulaire utilisant l'algorithme GRPO, améliorant considérablement à la fois la compréhension sémantique et la qualité des détails visuels. + Module autorégressif : fournit des signaux de rétroaction basse fréquence axés sur l'esthétique et l'alignement sémantique, améliorant le respect des instructions et l'expressivité artistique. + Module décodeur : fournit un retour d'information haute fréquence ciblant la fidélité des détails et la précision du texte, ce qui aboutit à des textures, un éclairage et une reproduction des couleurs très réalistes, ainsi qu'à un rendu du texte plus précis. GLM-Image prend en charge à la fois la génération d'images à partir de texte et la génération d'images à partir d'images au sein d'un seul modèle + Texte vers image : génère des images à fort niveau de détail à partir de descriptions textuelles, avec des performances particulièrement solides dans les scénarios denses en informations. + Image vers image : prend en charge une large gamme de tâches, notamment l'édition d'images, le transfert de style, la cohérence multi-sujets et la génération préservant l'identité pour les personnes et les objets. Ce pipeline a été contribué par [zRzRzRzRzRzRzR](https://github.com/zRzRzRzRzRzRzR). La base de code peut être trouvée [ici](https://huggingface.co/zai-org/GLM-Image). ## Exemples d'utilisation ### Génération d'images à partir de texte ```python import torch from diffusers.pipelines.glm_image import GlmImagePipeline pipe = GlmImagePipeline.from_pretrained("zai-org/GLM-Image",dtype=torch.bfloat16,device_map="cuda") prompt = "A beautifully designed modern food magazine style dessert recipe illustration, themed around a raspberry mousse cake. The overall layout is clean and bright, divided into four main areas: the top left features a bold black title 'Raspberry Mousse Cake Recipe Guide', with a soft-lit close-up photo of the finished cake on the right, showcasing a light pink cake adorned with fresh raspberries and mint leaves; the bottom left contains an ingredient list section, titled 'Ingredients' in a simple font, listing 'Flour 150g', 'Eggs 3', 'Sugar 120g', 'Raspberry puree 200g', 'Gelatin sheets 10g', 'Whipping cream 300ml', and 'Fresh raspberries', each accompanied by minimalist line icons (like a flour bag, eggs, sugar jar, etc.); the bottom right displays four equally sized step boxes, each containing high-definition macro photos and corresponding instructions, arranged from top to bottom as follows: Step 1 shows a whisk whipping white foam (with the instruction 'Whip egg whites to stiff peaks'), Step 2 shows a red-and-white mixture being folded with a spatula (with the instruction 'Gently fold in the puree and batter'), Step 3 shows pink liquid being poured into a round mold (with the instruction 'Pour into mold and chill for 4 hours'), Step 4 shows the finished cake decorated with raspberries and mint leaves (with the instruction 'Decorate with raspberries and mint'); a light brown information bar runs along the bottom edge, with icons on the left representing 'Preparation time: 30 minutes', 'Cooking time: 20 minutes', and 'Servings: 8'. The overall color scheme is dominated by creamy white and light pink, with a subtle paper texture in the background, featuring compact and orderly text and image layout with clear information hierarchy." image = pipe( prompt=prompt, height=32 * 32, width=36 * 32, num_inference_steps=30, guidance_scale=1.5, generator=torch.Generator(device="cuda").manual_seed(42), # or "mps", "xpu", "cpu" ).images[0] image.save("output_t2i.png") ``` ### Génération d'image à partir d'image ```python import torch from diffusers.pipelines.glm_image import GlmImagePipeline from PIL import Image pipe = GlmImagePipeline.from_pretrained("zai-org/GLM-Image",dtype=torch.bfloat16,device_map="cuda") image_path = "cond.jpg" prompt = "Replace the background of the snow forest with an underground station featuring an automatic escalator." image = Image.open(image_path).convert("RGB") image = pipe( prompt=prompt, image=[image], # can input multiple images for multi-image-to-image generation such as [image, image1] height=33 * 32, width=32 * 32, num_inference_steps=30, guidance_scale=1.5, generator=torch.Generator(device="cuda").manual_seed(42), # or "mps", "xpu", "cpu" ).images[0] image.save("output_i2i.png") ``` + Étant donné que le modèle AR utilisé dans GLM-Image est configuré par défaut avec `do_sample=True` et une température de `0.95`, les images générées peuvent varier considérablement d'une exécution à l'autre. Nous ne recommandons pas de définir do_sample=False, car cela peut entraîner des sorties incorrectes ou dégénérées du modèle AR. ## GlmImagePipeline[[diffusers.GlmImagePipeline]] #### diffusers.GlmImagePipeline[[diffusers.GlmImagePipeline]] ```python diffusers.GlmImagePipeline(tokenizer: ByT5Tokenizer, processor: GlmImageProcessor, text_encoder: T5EncoderModel, vision_language_encoder: GlmImageForConditionalGeneration, vae: AutoencoderKL, transformer: GlmImageTransformer2DModel, scheduler: FlowMatchEulerDiscreteScheduler) ``` [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/glm_image/pipeline_glm_image.py#L161) **Paramètres :** tokenizer (`PreTrainedTokenizer`) : Tokenizer pour l'encodeur de texte. processor (`AutoProcessor`) : Processeur pour le modèle AR afin de gérer les modèles de discussion et la tokenisation. text_encoder (`T5EncoderModel`) : encodeur de texte figé pour les embeddings de glyphes. vision_language_encoder (`GlmImageForConditionalGeneration`) : Le modèle AR qui génère des jetons d'image à partir de prompts texte. vae ([AutoencoderKL](/docs/diffusers/main/fr/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modèle de Variational Auto-Encoder (VAE) pour encoder et décoder des images vers et depuis des représentations latentes. transformer ([GlmImageTransformer2DModel](/docs/diffusers/main/fr/api/models/glm_image_transformer2d#diffusers.GlmImageTransformer2DModel)) : un transformer conditionné par le texte pour débruyer les latents d'image encodés (DiT). scheduler ([SchedulerMixin](/docs/diffusers/main/fr/api/schedulers/overview#diffusers.SchedulerMixin)) : Un scheduler à utiliser en combinaison avec `transformer` pour débruyer les latents d'image encodés. Pipeline pour la génération d'images à partir de texte utilisant GLM-Image. Ce pipeline intègre à la fois le modèle AR (autoregressive) pour la génération de jetons et le modèle DiT (diffusion transformer) pour le décodage d'images. #### __appel__[[diffusers.GlmImagePipeline.__call__]] ```python __call__(prompt: str | list[str] | None = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 50, timesteps: list[int] | None = None, sigmas: list[float] | None = None, guidance_scale: float = 1.5, num_images_per_prompt: int = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, prior_token_ids: typing.Optional[torch.Tensor] = None, prior_token_image_ids: list[torch.Tensor] | None = None, source_image_grid_thw: list[torch.Tensor] | None = None, crops_coords_top_left: tuple[int, int] = (0, 0), output_type: str = 'pil', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Union[typing.Callable[[int, int, dict], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 2048) ``` [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/glm_image/pipeline_glm_image.py#L719) **Paramètres :** prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts pour guider la génération d'image. Doit contenir les informations de forme au format 'H W' où H et W sont les dimensions des jetons (d32). Exemple : "A beautiful sunset36 24" génère une image de 1152x768. image : Images de conditionnement facultatives pour la génération d'image à partir d'image. height (`int`, *facultatif*) : La hauteur en pixels. Si non fournie, dérivée des informations de forme du prompt. width (`int`, *facultatif*) : La largeur en pixels. Si non fournie, dérivée des informations de forme du prompt. num_inference_steps (`int`, *facultatif*, par défaut `50`) : Le nombre d'étapes de débruitage pour DiT. timesteps (`list[int]`, *facultatif*) : Étapes de temps personnalisées à utiliser pour le processus de débruitage. Si non définies, l'agenda par défaut du planificateur pour `num_inference_steps` est utilisé. sigmas (`list[float]`, *facultatif*) : Sigmas personnalisés à utiliser pour le processus de débruitage. S'ils ne sont pas définis, le planificateur utilise son calendrier par défaut. guidance_scale (`float`, *facultatif*, par défaut `1.5`) : Échelle de guidage pour le guidage sans classifieur. num_images_per_prompt (`int`, *facultatif*, par défaut `1`) : Le nombre d'images à générer par invite. generator (`torch.Generator`, *facultatif*) : Générateur aléatoire pour la reproductibilité. latents (`torch.Tensor`, *facultatif*) : Latents bruités pré-générés à utiliser comme entrées pour la génération d'images. prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte pré-générées. Si non fournies, les incrustations sont générées à partir de `prompt`. negative_prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte négatives pré-générées. Utilisé lorsque le guidage sans classifieur est activé. prior_token_ids (`torch.Tensor`, *facultatif*) : identifiants de jetons antérieurs pré-générés par `generate_prior_tokens`. S'ils sont fournis, la génération antérieure est ignorée. prior_token_image_ids (`list[torch.Tensor]`, *facultatif*) : Identifiants de jetons d'image associés à `prior_token_ids`. source_image_grid_thw (`list[torch.Tensor]`, *facultatif*) : Informations de grille THW par échantillon pour les jetons de l'image source. crops_coords_top_left (`tuple[int, int]`, *facultatif*, valeur par défaut `(0, 0)`) : Les coordonnées du coin supérieur gauche de la zone de recadrage utilisée pour les embeddings de conditionnement. output_type (`str`, *facultatif*, par défaut `"pil"`) : Format de sortie : "pil", "np" ou "latent". return_dict (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut retourner un `GlmImagePipelineOutput` plutôt qu'un simple tuple. attention_kwargs (`dict`, *facultatif*) : Un dictionnaire de kwargs qui, s'il est spécifié, est transmis à l'`AttentionProcessor`. callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *facultatif*) : Une fonction appelée à la fin de chaque étape de débruitage. callback_on_step_end_tensor_inputs (`list[str]`, *facultatif*) : Entrées de tenseurs passées à `callback_on_step_end`. max_sequence_length (`int`, *facultatif*, valeur par défaut `2048`) : Longueur maximale de la séquence pour l'encodeur de texte. **Retourne :** `GlmImagePipelineOutput` ou `tuple` Images générées. Fonction appelée lors de l'appel du pipeline pour la génération. Exemples : ```python >>> import torch >>> from diffusers import GlmImagePipeline >>> pipe = GlmImagePipeline.from_pretrained("zai-org/GLM-Image", torch_dtype=torch.bfloat16) >>> pipe.to("cuda") >>> prompt = "A photo of an astronaut riding a horse on mars" >>> image = pipe(prompt).images[0] >>> image.save("output.png") ``` #### encode_prompt[[diffusers.GlmImagePipeline.encode_prompt]] ```python encode_prompt(prompt: str | list[str], do_classifier_free_guidance: bool = True, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None, max_sequence_length: int = 2048) ``` [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/glm_image/pipeline_glm_image.py#L545) **Paramètres :** prompt (`str` ou `list[str]`, *facultatif*) : invite à encoder do_classifier_free_guidance (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut utiliser le guidage sans classifieur ou non. num_images_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Nombre d'images à générer par invite. Appareil torch sur lequel placer les embeddings résultants prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte, *par ex.* pondération des prompts. Si non fourni, les incrustations de texte seront générées à partir de l'argument d'entrée `prompt`. device : (`torch.device`, *facultatif*) : appareil torch dtype : (`torch.dtype`, *facultatif*) : torch dtype max_sequence_length (`int`, par défaut `2048`) : Longueur maximale de la séquence dans le prompt encodé. Peut être définie sur d'autres valeurs, mais cela peut entraîner des résultats moins bons. Encode le prompt dans les états cachés de l'encodeur de texte. #### generate_prior_tokens[[diffusers.GlmImagePipeline.generate_prior_tokens]] ```python generate_prior_tokens(prompt: str | list[str], height: int, width: int, image: list[list[PIL.Image.Image]] | None = None, device: typing.Optional[torch.device] = None, generator: typing.Optional[torch.Generator] = None) ``` [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/glm_image/pipeline_glm_image.py#L321) **Paramètres :** prompt : Invite unique ou liste d'invites height : Hauteur de l'image cible width : Largeur de l'image cible image : Image d'entrée normalisée sous forme de List[List[PIL.Image]]. Elle doit être pré-validée à l'aide de _validate_and_normalize_images() avant d'appeler cette méthode. device : Appareil cible generator : Générateur aléatoire pour la reproductibilité **Retourne :** `Tuple of` - prior_token_ids : Tensor de forme (batch_size, num_tokens) contenant les jetons antérieurs suréchantillonnés - prior_token_image_ids_per_sample : liste de tenseurs, un par échantillon. Chaque tenseur contient les identifiants de jetons antérieurs agrandis pour toutes les images de condition de cet échantillon. None pour t2i. - source_image_grid_thw_per_sample: Liste de tenseurs, un par échantillon. Chaque tenseur a la forme (num_condition_images, 3) avec les informations de grille upsampled. None pour t2i. Générer les jetons antérieurs pour le modèle DiT à l'aide du modèle AR. #### get_glyph_texts[[diffusers.GlmImagePipeline.get_glyph_texts]] ```python get_glyph_texts(prompt) ``` [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/glm_image/pipeline_glm_image.py#L476) Extrait les textes des glyphes des invites. Renvoie une liste de listes pour le traitement par lots. ## GlmImagePipelineOutput[[diffusers.pipelines.glm_image.pipeline_output.GlmImagePipelineOutput]] #### diffusers.pipelines.glm_image.pipeline_output.GlmImagePipelineOutput[[diffusers.pipelines.glm_image.pipeline_output.GlmImagePipelineOutput]] ```python diffusers.pipelines.glm_image.pipeline_output.GlmImagePipelineOutput(images: list[PIL.Image.Image] | numpy.ndarray) ``` [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/glm_image/pipeline_output.py#L10) **Paramètres :** images (`List[PIL.Image.Image]` ou `np.ndarray`) : Liste d'images PIL débruitées de longueur `batch_size` ou tableau numpy de forme `(batch_size, height, width, num_channels)`. Les images PIL ou le tableau numpy présentent les images débruitées du pipeline de diffusion. Classe de sortie pour les pipelines CogView3.