Hugging Face's logo

Diffusers documentation

PRX Pixel

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v0.42.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

PRX Pixel

PRXPixel est un modèle de génération d'images à partir de texte dans l'espace des pixels, développé par Photoroom. Un PRXTransformer2DModel d'environ 7B débruite directement des images RGB brutes — aucun VAE n'est nécessaire. Le modèle est conditionné par un encodeur de texte Qwen3-VL et utilise le flow matching, où le transformer prédit l'image propre à chaque étape (x-prediction). La résolution de génération est intégrée à la modulation du timestep, ce qui permet au modèle de connaître la taille cible.

Modèles disponibles

ModèleRésolutionDescriptionParamètres suggérésdtype recommandé
Photoroom/prxpixel-t2i1024Modèle de l'espace des pixels ~7B avec encodeur de texte Qwen3-VL28 étapes, cfg=5.0torch.bfloat16

Chargement du pipeline

PRXPixelPipeline nécessite transformers >= 4.57 (la version qui a introduit Qwen3VLTextModel). Chargez-le avec from_pretrained() :

import torch
from diffusers import PRXPixelPipeline

pipe = PRXPixelPipeline.from_pretrained("Photoroom/prxpixel-t2i", dtype=torch.bfloat16)
pipe.to("cuda")  # or "mps", "xpu", "cpu"

prompt = "A front-facing portrait of a lion in the golden savanna at sunset."
image = pipe(prompt, num_inference_steps=28, guidance_scale=5.0).images[0]
image.save("prxpixel_output.png")

Optimisation de la mémoire

Pour les environnements à mémoire limitée :

import torch
from diffusers import PRXPixelPipeline

pipe = PRXPixelPipeline.from_pretrained("Photoroom/prxpixel-t2i", dtype=torch.bfloat16)
pipe.enable_model_cpu_offload()

# Or use sequential CPU offload for even lower memory
pipe.enable_sequential_cpu_offload()

PRXPixelPipeline

classe diffusers.PRXPixelPipeline

< >

( transformer: PRXTransformer2DModelscheduler: FlowMatchEulerDiscreteSchedulertext_encoder: PreTrainedModeltokenizer: transformers.models.auto.tokenization_auto.AutoTokenizer | transformers.tokenization_utils_base.PreTrainedTokenizerBasedefault_sample_size: int | None = 1024prompt_max_tokens: int = 256noise_scale: float = 2.0 )

Paramètres

  • transformer (PRXTransformer2DModel) — Le débruiteur PRX d’environ 7 Md de paramètres. Pour PRXPixel, il est construit avec in_channels=3, un goulot d’étranglement img_in et resolution_embeds=True, et il est entraîné à prédire l’image propre x0.
  • scheduler (FlowMatchEulerDiscreteScheduler) — Planificateur de flow-matching utilisé pour débruyer les latents (dans l'espace des pixels).
  • text_encoder (PreTrainedModel) — Le backbone texte Qwen3-VL utilisé pour encoder les prompts (la tour visuelle est écartée). Doit retourner un last_hidden_state.
  • tokenizer (PreTrainedTokenizerBase) — Tokenizer pour text_encoder (généralement chargé via AutoTokenizer).
  • default_sample_size (int, facultatif, valeur par défaut 1024) — Hauteur/largeur par défaut utilisée lorsqu’aucune valeur n’est fournie à __call__.
  • prompt_max_tokens (int, facultatif, par défaut 256) — Nombre de jetons de texte auquel le prompt est rembourré/tronqué avant l'encodage.
  • noise_scale (float, facultatif, valeur par défaut 2.0) — Échelle appliquée au bruit gaussien initial. PRXPixel s’entraîne avec une échelle de bruit initial non unitaire, il faut donc que l’échantillonnage démarre depuis randn * noise_scale.

Pipeline pour la génération d'images à partir de texte avec le modèle PRXPixel.

PRXPixel est un pipeline autonome de génération d’images à partir de texte dans l’espace des pixels. Il débruite directement des données RGB brutes à l’aide d’un PRXTransformer2DModel d’environ 7 milliards de paramètres et ne comporte pas de VAE (la génération s’effectue entièrement dans l’espace des pixels, de sorte que la sortie débruitée est l’image). Les prompts sont encodés par un encodeur de texte Qwen3-VL (la tour de vision est écartée). Contrairement à PRXPipeline, le transformeur est entraîné avec une prédiction x : à chaque étape, il prédit l’image propre x0, qui est convertie en vitesse de flow-matching avant l’étape du planificateur. L’échantillonnage démarre à partir de randn * noise_scale (noise_scale=2.0 par défaut) et la résolution par défaut est de 1024 px.

Ce modèle hérite de DiffusionPipeline. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous les pipelines (tels que le téléchargement ou l'enregistrement, l'exécution sur un appareil particulier, etc.)

Exemples :

>>> import torch
>>> from diffusers import PRXPixelPipeline

>>> pipe = PRXPixelPipeline.from_pretrained("Photoroom/prxpixel-t2i", torch_dtype=torch.bfloat16)
>>> pipe.to("cuda")

>>> prompt = "A front-facing portrait of a lion in the golden savanna at sunset."
>>> image = pipe(prompt, num_inference_steps=28, guidance_scale=5.0).images[0]
>>> image.save("prxpixel_output.png")

__call__

< >

( prompt: str | list[str] = Nonenegative_prompt: str = ''height: int | None = Nonewidth: int | None = Nonenum_inference_steps: int = 28timesteps: list = Noneguidance_scale: float = 4.0num_images_per_prompt: int | None = 1generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = Nonelatents: typing.Optional[torch.Tensor] = Noneprompt_embeds: typing.Optional[torch.FloatTensor] = Nonenegative_prompt_embeds: typing.Optional[torch.FloatTensor] = Noneprompt_attention_mask: typing.Optional[torch.BoolTensor] = Nonenegative_prompt_attention_mask: typing.Optional[torch.BoolTensor] = Noneoutput_type: str | None = 'pil'return_dict: bool = Trueuse_resolution_binning: bool = Truecallback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = Nonecallback_on_step_end_tensor_inputs: list = ['latents'] ) → PRXPipelineOutput or tuple

Paramètres

  • prompt (str ou list[str], facultatif) — Le prompt ou les prompts pour guider la génération d’image. S’il n’est pas défini, il faut passer prompt_embeds à la place.
  • negative_prompt (str, facultatif, par défaut "") — Le ou les prompts à ne pas utiliser pour guider la génération d’image. Ignoré lorsque la guidance n’est pas utilisée (c’est-à-dire ignoré si guidance_scale est inférieur à 1).
  • height (int, facultatif, par défaut default_sample_size) — La hauteur en pixels de l'image générée.
  • width (int, facultatif, par défaut default_sample_size) — La largeur en pixels de l'image générée.
  • num_inference_steps (int, facultatif, valeur par défaut 28) — Le nombre d'étapes de débruitage. Un plus grand nombre d'étapes de débruitage conduit généralement à une image de meilleure qualité, au prix d'une inférence plus lente.
  • timesteps (list[int], facultatif) — Timesteps personnalisés à utiliser pour le processus de débruitage avec les planificateurs qui prennent en charge un argument timesteps dans leur méthode set_timesteps. S'il n'est pas défini, le comportement par défaut lorsque num_inference_steps est passé sera utilisé. Doit être dans l'ordre décroissant.
  • guidance_scale (float, facultatif, valeur par défaut 4.0) — Échelle de guidage telle que définie dans Classifier-Free Diffusion Guidance. guidance_scale est défini comme w de l’équation 2 de Imagen Paper. L’échelle de guidage est activée en définissant guidance_scale > 1. Une échelle de guidage plus élevée encourage la génération d’images étroitement liées au prompt texte, généralement au détriment de la qualité de l’image.
  • num_images_per_prompt (int, facultatif, valeur par défaut 1) — Le nombre d'images à générer par invite.
  • generator (torch.Generator ou list[torch.Generator], facultatif) — Un ou une liste de générateurs torch pour rendre la génération déterministe.
  • latents (torch.Tensor, facultatif) — Latents bruités pré-générés, échantillonnés à partir d’une distribution gaussienne, à utiliser comme entrées pour la génération d’images. Peut être utilisé pour ajuster la même génération avec des prompts différents. S’il n’est pas fourni, un tenseur de latents sera généré par échantillonnage à l’aide du generator aléatoire fourni.
  • prompt_embeds (torch.FloatTensor, 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ée prompt.
  • negative_prompt_embeds (torch.FloatTensor, facultatif) — Embeddings de texte négatifs 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 et que guidance_scale > 1, les embeddings négatifs seront générés à partir d'une chaîne vide.
  • prompt_attention_mask (torch.BoolTensor, facultatif) — Masque d'attention pré-généré pour prompt_embeds. S'il n'est pas fourni, le masque d'attention sera généré à partir de l'argument d'entrée prompt.
  • negative_prompt_attention_mask (torch.BoolTensor, facultatif) — Masque d’attention pré-généré pour negative_prompt_embeds. S’il n’est pas fourni et que guidance_scale > 1, le masque d’attention sera généré à partir d’une chaîne vide.
  • output_type (str, facultatif, par défaut "pil") — Le format de sortie de l'image générée. Choisissez entre PIL : PIL.Image.Image ou np.array.
  • return_dict (bool, facultatif, par défaut True) — Indique s'il faut retourner un PRXPipelineOutput plutôt qu'un simple tuple.
  • use_resolution_binning (bool, facultatif, valeur par défaut True) — Si défini sur True, la hauteur et la largeur demandées sont d’abord mappées sur les résolutions les plus proches à l’aide de bins de ratio d’aspect prédéfinis. Après le décodage des latents produits en images, celles-ci sont redimensionnées pour revenir à la résolution demandée. Utile pour générer des images non carrées à des résolutions optimales.
  • callback_on_step_end (Callable, facultatif) — Une fonction appelée à la fin de chaque étape de débruitage pendant l’inférence. La fonction est appelée avec les arguments suivants : callback_on_step_end(self, step, timestep, callback_kwargs). callback_kwargs contiendra une liste de tous les tenseurs, comme spécifié par callback_on_step_end_tensor_inputs.
  • callback_on_step_end_tensor_inputs (list, facultatif) — La liste des entrées tensorielles pour la fonction callback_on_step_end. Les tenseurs spécifiés dans la liste seront passés en tant qu'argument callback_kwargs. Vous ne pourrez inclure que les tenseurs répertoriés dans l'attribut ._callback_tensor_inputs.

Retourne

PRXPipelineOutput ou tuple

PRXPipelineOutput si return_dict est True, sinon un `tuple. En cas de retour d'un tuple, le premier élément est une liste contenant les 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 PRXPixelPipeline

>>> pipe = PRXPixelPipeline.from_pretrained("Photoroom/prxpixel-t2i", torch_dtype=torch.bfloat16)
>>> pipe.to("cuda")

>>> prompt = "A front-facing portrait of a lion in the golden savanna at sunset."
>>> image = pipe(prompt, num_inference_steps=28, guidance_scale=5.0).images[0]
>>> image.save("prxpixel_output.png")

check_inputs

< >

( prompt: str | list[str]height: intwidth: intguidance_scale: floatcallback_on_step_end_tensor_inputs: list[str] | None = Noneprompt_embeds: typing.Optional[torch.FloatTensor] = Nonenegative_prompt_embeds: typing.Optional[torch.FloatTensor] = None )

Vérifiez que toutes les entrées sont au format correct.

encode_prompt

< >

( prompt: str | list[str]device: typing.Optional[torch.device] = Nonedo_classifier_free_guidance: bool = Truenegative_prompt: str = ''num_images_per_prompt: int = 1prompt_embeds: typing.Optional[torch.FloatTensor] = Nonenegative_prompt_embeds: typing.Optional[torch.FloatTensor] = Noneprompt_attention_mask: typing.Optional[torch.BoolTensor] = Nonenegative_prompt_attention_mask: typing.Optional[torch.BoolTensor] = Nonetokenizer_max_length: int | None = Noneskip_text_cleaning: bool = False )

Encodez le prompt de texte à l'aide d'un encodeur et d'un tokeniseur de texte standard, ou utilisez des embeddings précalculés.

prepare_latents

< >

( batch_size: intnum_channels_latents: intheight: intwidth: intdtype: dtypedevice: devicegenerator: typing.Optional[torch.Generator] = Nonelatents: typing.Optional[torch.Tensor] = None )

Préparez les latents initiaux pour le processus de diffusion.

PRXPixel s’entraîne avec une échelle de bruit initial non unitaire, de sorte que le bruit échantillonné est multiplié par self.config.noise_scale.

PRXPipelineOutput

classe diffusers.pipelines.prx.PRXPipelineOutput

< >

( images: list[PIL.Image.Image] | numpy.ndarray )

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 PRX.

Update on GitHub

←PRX Qwen-Image 2.1→