|
| 1 | +<!--Copyright 2024 The HuggingFace Team. All rights reserved. |
| 2 | +
|
| 3 | +Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with |
| 4 | +the License. You may obtain a copy of the License at |
| 5 | +
|
| 6 | +http://www.apache.org/licenses/LICENSE-2.0 |
| 7 | +
|
| 8 | +Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on |
| 9 | +an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the |
| 10 | +specific language governing permissions and limitations under the License. |
| 11 | +--> |
| 12 | + |
| 13 | +# PixArt-Σ |
| 14 | + |
| 15 | + |
| 16 | + |
| 17 | +[PixArt-Σ: Weak-to-Strong Training of Diffusion Transformer for 4K Text-to-Image Generation](https://huggingface.co/papers/2403.04692) is Junsong Chen, Jincheng Yu, Chongjian Ge, Lewei Yao, Enze Xie, Yue Wu, Zhongdao Wang, James Kwok, Ping Luo, Huchuan Lu, and Zhenguo Li. |
| 18 | + |
| 19 | +The abstract from the paper is: |
| 20 | + |
| 21 | +*In this paper, we introduce PixArt-Σ, a Diffusion Transformer model (DiT) capable of directly generating images at 4K resolution. PixArt-Σ represents a significant advancement over its predecessor, PixArt-α, offering images of markedly higher fidelity and improved alignment with text prompts. A key feature of PixArt-Σ is its training efficiency. Leveraging the foundational pre-training of PixArt-α, it evolves from the ‘weaker’ baseline to a ‘stronger’ model via incorporating higher quality data, a process we term “weak-to-strong training”. The advancements in PixArt-Σ are twofold: (1) High-Quality Training Data: PixArt-Σ incorporates superior-quality image data, paired with more precise and detailed image captions. (2) Efficient Token Compression: we propose a novel attention module within the DiT framework that compresses both keys and values, significantly improving efficiency and facilitating ultra-high-resolution image generation. Thanks to these improvements, PixArt-Σ achieves superior image quality and user prompt adherence capabilities with significantly smaller model size (0.6B parameters) than existing text-to-image diffusion models, such as SDXL (2.6B parameters) and SD Cascade (5.1B parameters). Moreover, PixArt-Σ’s capability to generate 4K images supports the creation of high-resolution posters and wallpapers, efficiently bolstering the production of highquality visual content in industries such as film and gaming.* |
| 22 | + |
| 23 | +You can find the original codebase at [PixArt-alpha/PixArt-sigma](https://github.com/PixArt-alpha/PixArt-sigma) and all the available checkpoints at [PixArt-alpha](https://huggingface.co/PixArt-alpha). |
| 24 | + |
| 25 | +Some notes about this pipeline: |
| 26 | + |
| 27 | +* It uses a Transformer backbone (instead of a UNet) for denoising. As such it has a similar architecture as [DiT](https://hf.co/docs/transformers/model_doc/dit). |
| 28 | +* It was trained using text conditions computed from T5. This aspect makes the pipeline better at following complex text prompts with intricate details. |
| 29 | +* It is good at producing high-resolution images at different aspect ratios. To get the best results, the authors recommend some size brackets which can be found [here](https://github.com/PixArt-alpha/PixArt-sigma/blob/master/diffusion/data/datasets/utils.py). |
| 30 | +* It rivals the quality of state-of-the-art text-to-image generation systems (as of this writing) such as PixArt-α, Stable Diffusion XL, Playground V2.0 and DALL-E 3, while being more efficient than them. |
| 31 | +* It shows the ability of generating super high resolution images, such as 2048px or even 4K. |
| 32 | +* It shows that text-to-image models can grow from a weak model to a stronger one through several improvements (VAEs, datasets, and so on.) |
| 33 | + |
| 34 | +<Tip> |
| 35 | + |
| 36 | +Make sure to check out the Schedulers [guide](../../using-diffusers/schedulers) to learn how to explore the tradeoff between scheduler speed and quality, and see the [reuse components across pipelines](../../using-diffusers/loading#reuse-a-pipeline) section to learn how to efficiently load the same components into multiple pipelines. |
| 37 | + |
| 38 | +</Tip> |
| 39 | + |
| 40 | +## Inference with under 8GB GPU VRAM |
| 41 | + |
| 42 | +Run the [`PixArtSigmaPipeline`] with under 8GB GPU VRAM by loading the text encoder in 8-bit precision. Let's walk through a full-fledged example. |
| 43 | + |
| 44 | +First, install the [bitsandbytes](https://github.com/TimDettmers/bitsandbytes) library: |
| 45 | + |
| 46 | +```bash |
| 47 | +pip install -U bitsandbytes |
| 48 | +``` |
| 49 | + |
| 50 | +Then load the text encoder in 8-bit: |
| 51 | + |
| 52 | +```python |
| 53 | +from transformers import T5EncoderModel |
| 54 | +from diffusers import PixArtSigmaPipeline |
| 55 | +import torch |
| 56 | + |
| 57 | +text_encoder = T5EncoderModel.from_pretrained( |
| 58 | + "PixArt-alpha/PixArt-Sigma-XL-2-1024-MS", |
| 59 | + subfolder="text_encoder", |
| 60 | + load_in_8bit=True, |
| 61 | + device_map="auto", |
| 62 | + |
| 63 | +) |
| 64 | +pipe = PixArtSigmaPipeline.from_pretrained( |
| 65 | + "PixArt-alpha/PixArt-Sigma-XL-2-1024-MS", |
| 66 | + text_encoder=text_encoder, |
| 67 | + transformer=None, |
| 68 | + device_map="balanced" |
| 69 | +) |
| 70 | +``` |
| 71 | + |
| 72 | +Now, use the `pipe` to encode a prompt: |
| 73 | + |
| 74 | +```python |
| 75 | +with torch.no_grad(): |
| 76 | + prompt = "cute cat" |
| 77 | + prompt_embeds, prompt_attention_mask, negative_embeds, negative_prompt_attention_mask = pipe.encode_prompt(prompt) |
| 78 | +``` |
| 79 | + |
| 80 | +Since text embeddings have been computed, remove the `text_encoder` and `pipe` from the memory, and free up som GPU VRAM: |
| 81 | + |
| 82 | +```python |
| 83 | +import gc |
| 84 | + |
| 85 | +def flush(): |
| 86 | + gc.collect() |
| 87 | + torch.cuda.empty_cache() |
| 88 | + |
| 89 | +del text_encoder |
| 90 | +del pipe |
| 91 | +flush() |
| 92 | +``` |
| 93 | + |
| 94 | +Then compute the latents with the prompt embeddings as inputs: |
| 95 | + |
| 96 | +```python |
| 97 | +pipe = PixArtSigmaPipeline.from_pretrained( |
| 98 | + "PixArt-alpha/PixArt-Sigma-XL-2-1024-MS", |
| 99 | + text_encoder=None, |
| 100 | + torch_dtype=torch.float16, |
| 101 | +).to("cuda") |
| 102 | + |
| 103 | +latents = pipe( |
| 104 | + negative_prompt=None, |
| 105 | + prompt_embeds=prompt_embeds, |
| 106 | + negative_prompt_embeds=negative_embeds, |
| 107 | + prompt_attention_mask=prompt_attention_mask, |
| 108 | + negative_prompt_attention_mask=negative_prompt_attention_mask, |
| 109 | + num_images_per_prompt=1, |
| 110 | + output_type="latent", |
| 111 | +).images |
| 112 | + |
| 113 | +del pipe.transformer |
| 114 | +flush() |
| 115 | +``` |
| 116 | + |
| 117 | +<Tip> |
| 118 | + |
| 119 | +Notice that while initializing `pipe`, you're setting `text_encoder` to `None` so that it's not loaded. |
| 120 | + |
| 121 | +</Tip> |
| 122 | + |
| 123 | +Once the latents are computed, pass it off to the VAE to decode into a real image: |
| 124 | + |
| 125 | +```python |
| 126 | +with torch.no_grad(): |
| 127 | + image = pipe.vae.decode(latents / pipe.vae.config.scaling_factor, return_dict=False)[0] |
| 128 | +image = pipe.image_processor.postprocess(image, output_type="pil")[0] |
| 129 | +image.save("cat.png") |
| 130 | +``` |
| 131 | + |
| 132 | +By deleting components you aren't using and flushing the GPU VRAM, you should be able to run [`PixArtSigmaPipeline`] with under 8GB GPU VRAM. |
| 133 | + |
| 134 | + |
| 135 | + |
| 136 | +If you want a report of your memory-usage, run this [script](https://gist.github.com/sayakpaul/3ae0f847001d342af27018a96f467e4e). |
| 137 | + |
| 138 | +<Tip warning={true}> |
| 139 | + |
| 140 | +Text embeddings computed in 8-bit can impact the quality of the generated images because of the information loss in the representation space caused by the reduced precision. It's recommended to compare the outputs with and without 8-bit. |
| 141 | + |
| 142 | +</Tip> |
| 143 | + |
| 144 | +While loading the `text_encoder`, you set `load_in_8bit` to `True`. You could also specify `load_in_4bit` to bring your memory requirements down even further to under 7GB. |
| 145 | + |
| 146 | +## PixArtSigmaPipeline |
| 147 | + |
| 148 | +[[autodoc]] PixArtSigmaPipeline |
| 149 | + - all |
| 150 | + - __call__ |
| 151 | + |
0 commit comments