text stringlengths 0 5.54k |
|---|
... response = requests.get(url) |
... return PIL.Image.open(BytesIO(response.content)).convert("RGB") |
>>> img_url = "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/repaint/celeba_hq_256.png" |
>>> mask_url = "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/repaint/mask_256.png" |
>>> # Load the original image and the mask as PIL images |
>>> original_image = download_image(img_url).resize((256, 256)) |
>>> mask_image = download_image(mask_url).resize((256, 256)) |
>>> # Load the RePaint scheduler and pipeline based on a pretrained DDPM model |
>>> scheduler = RePaintScheduler.from_pretrained("google/ddpm-ema-celebahq-256") |
>>> pipe = RePaintPipeline.from_pretrained("google/ddpm-ema-celebahq-256", scheduler=scheduler) |
>>> pipe = pipe.to("cuda") |
>>> generator = torch.Generator(device="cuda").manual_seed(0) |
>>> output = pipe( |
... image=original_image, |
... mask_image=mask_image, |
... num_inference_steps=250, |
... eta=0.0, |
... jump_length=10, |
... jump_n_sample=10, |
... generator=generator, |
... ) |
>>> inpainted_image = output.images[0] ImagePipelineOutput class diffusers.ImagePipelineOutput < source > ( images: typing.Union[typing.List[PIL.Image.Image], numpy.ndarray] ) Parameters images (List[PIL.Image.Image] or np.ndarray) — |
List of denoised PIL images of length batch_size or NumPy array of shape (batch_size, height, width, num_channels). Output class for image pipelines. |
Load LoRAs for inference There are many adapters (with LoRAs being the most common type) trained in different styles to achieve different effects. You can even combine multiple adapters to create new and unique images. With the 🤗 PEFT integration in 🤗 Diffusers, it is really easy to load and manage adapters for inference. In this guide, you’ll learn how to use different adapters with Stable Diffusion XL (SDXL) for inference. Throughout this guide, you’ll use LoRA as the main adapter technique, so we’ll use the terms LoRA and adapter interchangeably. You should have some familiarity with LoRA, and if you don’t, we welcome you to check out the LoRA guide. Let’s first install all the required libraries. Copied !pip install -q transformers accelerate |
!pip install peft |
!pip install diffusers Now, let’s load a pipeline with a SDXL checkpoint: Copied from diffusers import DiffusionPipeline |
import torch |
pipe_id = "stabilityai/stable-diffusion-xl-base-1.0" |
pipe = DiffusionPipeline.from_pretrained(pipe_id, torch_dtype=torch.float16).to("cuda") Next, load a LoRA checkpoint with the load_lora_weights() method. With the 🤗 PEFT integration, you can assign a specific adapter_name to the checkpoint, which let’s you easily switch between different LoRA checkpoints. Let’s call this adapter "toy". Copied pipe.load_lora_weights("CiroN2022/toy-face", weight_name="toy_face_sdxl.safetensors", adapter_name="toy") And then perform inference: Copied prompt = "toy_face of a hacker with a hoodie" |
lora_scale= 0.9 |
image = pipe( |
prompt, num_inference_steps=30, cross_attention_kwargs={"scale": lora_scale}, generator=torch.manual_seed(0) |
).images[0] |
image With the adapter_name parameter, it is really easy to use another adapter for inference! Load the nerijs/pixel-art-xl adapter that has been fine-tuned to generate pixel art images, and let’s call it "pixel". The pipeline automatically sets the first loaded adapter ("toy") as the active adapter. But you can activate the "pixel" adapter with the set_adapters() method as shown below: Copied pipe.load_lora_weights("nerijs/pixel-art-xl", weight_name="pixel-art-xl.safetensors", adapter_name="pixel") |
pipe.set_adapters("pixel") Let’s now generate an image with the second adapter and check the result: Copied prompt = "a hacker with a hoodie, pixel art" |
image = pipe( |
prompt, num_inference_steps=30, cross_attention_kwargs={"scale": lora_scale}, generator=torch.manual_seed(0) |
).images[0] |
image Combine multiple adapters You can also perform multi-adapter inference where you combine different adapter checkpoints for inference. Once again, use the set_adapters() method to activate two LoRA checkpoints and specify the weight for how the checkpoints should be combined. Copied pipe.set_adapters(["pixel", "toy"], adapter_weights=[0.5, 1.0]) Now that we have set these two adapters, let’s generate an image from the combined adapters! LoRA checkpoints in the diffusion community are almost always obtained with DreamBooth. DreamBooth training often relies on “trigger” words in the input text prompts in order for the generation results to look as expected. When you combine multiple LoRA checkpoints, it’s important to ensure the trigger words for the corresponding LoRA checkpoints are present in the input text prompts. The trigger words for CiroN2022/toy-face and nerijs/pixel-art-xl are found in their repositories. Copied # Notice how the prompt is constructed. |
prompt = "toy_face of a hacker with a hoodie, pixel art" |
image = pipe( |
prompt, num_inference_steps=30, cross_attention_kwargs={"scale": 1.0}, generator=torch.manual_seed(0) |
).images[0] |
image Impressive! As you can see, the model was able to generate an image that mixes the characteristics of both adapters. If you want to go back to using only one adapter, use the set_adapters() method to activate the "toy" adapter: Copied # First, set the adapter. |
pipe.set_adapters("toy") |
# Then, run inference. |
prompt = "toy_face of a hacker with a hoodie" |
lora_scale= 0.9 |
image = pipe( |
prompt, num_inference_steps=30, cross_attention_kwargs={"scale": lora_scale}, generator=torch.manual_seed(0) |
).images[0] |
image If you want to switch to only the base model, disable all LoRAs with the disable_lora() method. Copied pipe.disable_lora() |
prompt = "toy_face of a hacker with a hoodie" |
lora_scale= 0.9 |
image = pipe(prompt, num_inference_steps=30, generator=torch.manual_seed(0)).images[0] |
image Monitoring active adapters You have attached multiple adapters in this tutorial, and if you’re feeling a bit lost on what adapters have been attached to the pipeline’s components, you can easily check the list of active adapters using the get_active_adapters() method: Copied active_adapters = pipe.get_active_adapters() |
active_adapters |
["toy", "pixel"] You can also get the active adapters of each pipeline component with get_list_adapters(): Copied list_adapters_component_wise = pipe.get_list_adapters() |
list_adapters_component_wise |
{"text_encoder": ["toy", "pixel"], "unet": ["toy", "pixel"], "text_encoder_2": ["toy", "pixel"]} Fusing adapters into the model You can use PEFT to easily fuse/unfuse multiple adapters directly into the model weights (both UNet and text encoder) using the fuse_lora() method, which can lead to a speed-up in inference and lower VRAM usage. Copied pipe.load_lora_weights("nerijs/pixel-art-xl", weight_name="pixel-art-xl.safetensors", adapter_name="pixel") |
pipe.load_lora_weights("CiroN2022/toy-face", weight_name="toy_face_sdxl.safetensors", adapter_name="toy") |
pipe.set_adapters(["pixel", "toy"], adapter_weights=[0.5, 1.0]) |
# Fuses the LoRAs into the Unet |
pipe.fuse_lora() |
prompt = "toy_face of a hacker with a hoodie, pixel art" |
image = pipe(prompt, num_inference_steps=30, generator=torch.manual_seed(0)).images[0] |
# Gets the Unet back to the original state |
pipe.unfuse_lora() You can also fuse some adapters using adapter_names for faster generation: Copied pipe.load_lora_weights("nerijs/pixel-art-xl", weight_name="pixel-art-xl.safetensors", adapter_name="pixel") |
pipe.load_lora_weights("CiroN2022/toy-face", weight_name="toy_face_sdxl.safetensors", adapter_name="toy") |
pipe.set_adapters(["pixel"], adapter_weights=[0.5, 1.0]) |
# Fuses the LoRAs into the Unet |
pipe.fuse_lora(adapter_names=["pixel"]) |
prompt = "a hacker with a hoodie, pixel art" |
image = pipe(prompt, num_inference_steps=30, generator=torch.manual_seed(0)).images[0] |
# Gets the Unet back to the original state |
pipe.unfuse_lora() |
# Fuse all adapters |
pipe.fuse_lora(adapter_names=["pixel", "toy"]) |
prompt = "toy_face of a hacker with a hoodie, pixel art" |
image = pipe(prompt, num_inference_steps=30, generator=torch.manual_seed(0)).images[0] |
Würstchen Wuerstchen: An Efficient Architecture for Large-Scale Text-to-Image Diffusion Models is by Pablo Pernias, Dominic Rampas, Mats L. Richter and Christopher Pal and Marc Aubreville. The abstract from the paper is: We introduce Würstchen, a novel architecture for text-to-image synthesis that combines competitive performance with unprecedented cost-effectiveness for large-scale text-to-image diffusion models. A key contribution of our work is to develop a latent diffusion technique in which we learn a detailed but extremely compact semantic image representation used to guide the diffusion process. This highly compressed representation of an image provides much more detailed guidance compared to latent representations of language and this significantly reduces the computational requirements to achieve state-of-the-art results. Our approach also improves the quality of text-conditioned image generation based on our user preference study. The training requirements of our approach consists of 24,602 A100-GPU hours - compared to Stable Diffusion 2.1’s 200,000 GPU hours. Our approach also requires less training data to achieve these results. Furthermore, our compact latent representations allows us to perform inference over twice as fast, slashing the usual costs and carbon footprint of a state-of-the-art (SOTA) diffusion model significantly, without compromising the end performance. In a broader comparison against SOTA models our approach is substantially more efficient and compares favorably in terms of image quality. We believe that this work motivates more emphasis on the prioritization of both performance and computational accessibility. Würstchen Overview Würstchen is a diffusion model, whose text-conditional model works in a highly compressed latent space of images. Why is this important? Compressing data can reduce computational costs for both training and inference by magnitudes. Training on 1024x1024 images is way more expensive than training on 32x32. Usually, other works make use of a relatively small compression, in the range of 4x - 8x spatial compression. Würstchen takes this to an extreme. Through its novel design, we achieve a 42x spatial compression. This was unseen before because common methods fail to faithfully reconstruct detailed images after 16x spatial compression. Würstchen employs a two-stage compression, what we call Stage A and Stage B. Stage A is a VQGAN, and Stage B is a Diffusion Autoencoder (more details can be found in the paper). A third model, Stage C, is learned in that highly compressed latent space. This training requires fractions of the compute used for current top-performing models, while also allowing cheaper and faster inference. Würstchen v2 comes to Diffusers After the initial paper release, we have improved numerous things in the architecture, training and sampling, making Würstchen competitive to current state-of-the-art models in many ways. We are excited to release this new version together with Diffusers. Here is a list of the improvements. Higher resolution (1024x1024 up to 2048x2048) Faster inference Multi Aspect Resolution Sampling Better quality We are releasing 3 checkpoints for the text-conditional image generation model (Stage C). Those are: v2-base v2-aesthetic (default) v2-interpolated (50% interpolation between v2-base and v2-aesthetic) We recommend using v2-interpolated, as it has a nice touch of both photorealism and aesthetics. Use v2-base for finetunings as it does not have a style bias and use v2-aesthetic for very artistic generations. |
A comparison can be seen here: Text-to-Image Generation For the sake of usability, Würstchen can be used with a single pipeline. This pipeline can be used as follows: Copied import torch |
from diffusers import AutoPipelineForText2Image |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.