Diffusers documentation
GLM-Image
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, 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
GlmImageForConditionalGenerationde la bibliothèquetransformers. - 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. La base de code peut être trouvée ici.
Exemples d'utilisation
Génération d'images à partir de texte
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
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=Trueet une température de0.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
classe diffusers.GlmImagePipeline
< source >( tokenizer: ByT5Tokenizerprocessor: GlmImageProcessortext_encoder: T5EncoderModelvision_language_encoder: GlmImageForConditionalGenerationvae: AutoencoderKLtransformer: GlmImageTransformer2DModelscheduler: FlowMatchEulerDiscreteScheduler )
Paramètres
- tokenizer (
PreTrainedTokenizer) — Tokeniseur 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) — Modèle de Variational Auto-Encoder (VAE) pour encoder et décoder des images vers et depuis des représentations latentes.
- transformer (GlmImageTransformer2DModel) — Un transformer conditionné par du texte pour débruyer les latents d'image encodés (DiT).
- scheduler (SchedulerMixin) —
Un scheduler à utiliser en combinaison avec
transformerpour 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.
__call__
< source >( prompt: str | list[str] | None = Noneimage: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = Noneheight: int | None = Nonewidth: int | None = Nonenum_inference_steps: int = 50timesteps: list[int] | None = Nonesigmas: list[float] | None = Noneguidance_scale: float = 1.5num_images_per_prompt: int = 1generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = Nonelatents: typing.Optional[torch.Tensor] = Noneprompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Noneprior_token_ids: typing.Optional[torch.Tensor] = Noneprior_token_image_ids: list[torch.Tensor] | None = Nonesource_image_grid_thw: list[torch.Tensor] | None = Nonecrops_coords_top_left: tuple = (0, 0)output_type: str = 'pil'return_dict: bool = Trueattention_kwargs: dict[str, typing.Any] | None = Nonecallback_on_step_end: typing.Union[typing.Callable[[int, int, dict], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = Nonecallback_on_step_end_tensor_inputs: list = ['latents']max_sequence_length: int = 2048 ) → GlmImagePipelineOutput or tuple
Paramètres
- prompt (
stroulist[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 sunset 36 24 ” génère une image de 1152x768. - image — Images de conditionnement optionnelles 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, elle est dérivée des informations de forme du prompt. - num_inference_steps (
int, facultatif, par défaut50) — Le nombre d'étapes de débruitage pour DiT. - timesteps (
list[int], facultatif) — Timesteps personnalisés à utiliser pour le processus de débruitage. S'ils ne sont pas définis, l'agenda par défaut du planificateur pournum_inference_stepsest 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éfaut1.5) — Échelle de guidage pour le guidage sans classifieur. - num_images_per_prompt (
int, facultatif, par défaut1) — 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) — Embeddings de texte pré-générés. S'ils ne sont pas fournis, les embeddings sont générés à partir deprompt. - negative_prompt_embeds (
torch.Tensor, facultatif) — Embeddings de texte négatifs pré-générés. Utilisés lorsque le guidage sans classifieur est activé. - prior_token_ids (
torch.Tensor, facultatif) — Identifiants de jetons antérieurs pré-générés pargenerate_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, par défaut(0, 0)) — Coordonnées du coin supérieur gauche de la recadrage utilisé pour les embeddings de conditionnement. - output_type (
str, facultatif, par défaut"pil") — Format de sortie : « pil », « np » ou « latent ». - return_dict (
bool, facultatif, par défautTrue) — Indique s'il faut retourner unGlmImagePipelineOutputplutô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 tensorielles passées àcallback_on_step_end. - max_sequence_length (
int, facultatif, par défaut2048) — 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 :
>>> 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
< source >( prompt: str | list[str]do_classifier_free_guidance: bool = Truenum_images_per_prompt: int = 1prompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Nonedevice: typing.Optional[torch.device] = Nonedtype: typing.Optional[torch.dtype] = Nonemax_sequence_length: int = 2048 )
Paramètres
- prompt (
stroulist[str], facultatif) — prompt à encoder - do_classifier_free_guidance (
bool, facultatif, valeur par défautTrue) — Indique s'il faut utiliser le classifier free guidance 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) — Embeddings de texte pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, par ex. le pondération des prompts. S'il n'est pas fourni, les embeddings de texte seront générés à partir de l'argument d'entréeprompt. - device — (
torch.device, facultatif) : torch device - dtype — (
torch.dtype, facultatif) : dtype torch - max_sequence_length (
int, par défaut2048) — Longueur maximale de la séquence dans le prompt encodé. Peut être définie à 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
< source >( prompt: str | list[str]height: intwidth: intimage: list[list[PIL.Image.Image]] | None = Nonedevice: typing.Optional[torch.device] = Nonegenerator: typing.Optional[torch.Generator] = None ) → Tuple of
Paramètres
- prompt — Prompt unique ou liste de prompts
- height — Hauteur cible de l'image
- width — Largeur cible de l'image
- 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 de
- 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.
Extrait les textes des glyphes des invites. Renvoie une liste de listes pour le traitement par lots.
GlmImagePipelineOutput
classe diffusers.pipelines.glm_image.pipeline_output.GlmImagePipelineOutput
< source >( images: list[PIL.Image.Image] | numpy.ndarray )
Classe de sortie pour les pipelines CogView3.