text stringlengths 0 5.54k |
|---|
image Use a different prompt for each text-encoder SDXL uses two text-encoders, so it is possible to pass a different prompt to each text-encoder, which can improve quality. Pass your original prompt to prompt and the second prompt to prompt_2 (use negative_prompt and negative_prompt_2 if you’re using negative prompts... |
import torch |
pipeline = StableDiffusionXLPipeline.from_pretrained( |
"stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16, variant="fp16", use_safetensors=True |
).to("cuda") |
# prompt is passed to OAI CLIP-ViT/L-14 |
prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k" |
# prompt_2 is passed to OpenCLIP-ViT/bigG-14 |
prompt_2 = "Van Gogh painting" |
image = pipeline(prompt=prompt, prompt_2=prompt_2).images[0] |
image The dual text-encoders also support textual inversion embeddings that need to be loaded separately as explained in the SDXL textual inversion section. Optimizations SDXL is a large model, and you may need to optimize memory to get it to run on your hardware. Here are some tips to save memory and speed up infere... |
- refiner.to("cuda") |
+ base.enable_model_cpu_offload() |
+ refiner.enable_model_cpu_offload() Use torch.compile for ~20% speed-up (you need torch>=2.0): Copied + base.unet = torch.compile(base.unet, mode="reduce-overhead", fullgraph=True) |
+ refiner.unet = torch.compile(refiner.unet, mode="reduce-overhead", fullgraph=True) Enable xFormers to run SDXL if torch<2.0: Copied + base.enable_xformers_memory_efficient_attention() |
+ refiner.enable_xformers_memory_efficient_attention() Other resources If you’re interested in experimenting with a minimal version of the UNet2DConditionModel used in SDXL, take a look at the minSDXL implementation which is written in PyTorch and directly compatible with 🤗 Diffusers. |
Stable Diffusion XL Turbo SDXL Turbo is an adversarial time-distilled Stable Diffusion XL (SDXL) model capable |
of running inference in as little as 1 step. This guide will show you how to use SDXL-Turbo for text-to-image and image-to-image. Before you begin, make sure you have the following libraries installed: Copied # uncomment to install the necessary libraries in Colab |
#!pip install -q diffusers transformers accelerate omegaconf Load model checkpoints Model weights may be stored in separate subfolders on the Hub or locally, in which case, you should use the from_pretrained() method: Copied from diffusers import AutoPipelineForText2Image, AutoPipelineForImage2Image |
import torch |
pipeline = AutoPipelineForText2Image.from_pretrained("stabilityai/sdxl-turbo", torch_dtype=torch.float16, variant="fp16") |
pipeline = pipeline.to("cuda") You can also use the from_single_file() method to load a model checkpoint stored in a single file format (.ckpt or .safetensors) from the Hub or locally: Copied from diffusers import StableDiffusionXLPipeline |
import torch |
pipeline = StableDiffusionXLPipeline.from_single_file( |
"https://huggingface.co/stabilityai/sdxl-turbo/blob/main/sd_xl_turbo_1.0_fp16.safetensors", torch_dtype=torch.float16) |
pipeline = pipeline.to("cuda") Text-to-image For text-to-image, pass a text prompt. By default, SDXL Turbo generates a 512x512 image, and that resolution gives the best results. You can try setting the height and width parameters to 768x768 or 1024x1024, but you should expect quality degradations when doing so. Make s... |
Increasing the number of steps to 2, 3 or 4 should improve image quality. Copied from diffusers import AutoPipelineForText2Image |
import torch |
pipeline_text2image = AutoPipelineForText2Image.from_pretrained("stabilityai/sdxl-turbo", torch_dtype=torch.float16, variant="fp16") |
pipeline_text2image = pipeline_text2image.to("cuda") |
prompt = "A cinematic shot of a baby racoon wearing an intricate italian priest robe." |
image = pipeline_text2image(prompt=prompt, guidance_scale=0.0, num_inference_steps=1).images[0] |
image Image-to-image For image-to-image generation, make sure that num_inference_steps * strength is larger or equal to 1. |
The image-to-image pipeline will run for int(num_inference_steps * strength) steps, e.g. 0.5 * 2.0 = 1 step in |
our example below. Copied from diffusers import AutoPipelineForImage2Image |
from diffusers.utils import load_image, make_image_grid |
# use from_pipe to avoid consuming additional memory when loading a checkpoint |
pipeline = AutoPipelineForImage2Image.from_pipe(pipeline_text2image).to("cuda") |
init_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/cat.png") |
init_image = init_image.resize((512, 512)) |
prompt = "cat wizard, gandalf, lord of the rings, detailed, fantasy, cute, adorable, Pixar, Disney, 8k" |
image = pipeline(prompt, image=init_image, strength=0.5, guidance_scale=0.0, num_inference_steps=2).images[0] |
make_image_grid([init_image, image], rows=1, cols=2) Speed-up SDXL Turbo even more Compile the UNet if you are using PyTorch version 2 or better. The first inference run will be very slow, but subsequent ones will be much faster. Copied pipe.unet = torch.compile(pipe.unet, mode="reduce-overhead", fullgraph=True) Wh... |
Text-to-Image Generation with Adapter Conditioning Overview T2I-Adapter: Learning Adapters to Dig out More Controllable Ability for Text-to-Image Diffusion Models by Chong Mou, Xintao Wang, Liangbin Xie, Jian Zhang, Zhongang Qi, Ying Shan, Xiaohu Qie. Using the pretrained models we can provide control images (for exam... |
All adapters use the same pipeline. Images are first converted into the appropriate control image format. The control image and prompt are passed to the StableDiffusionAdapterPipeline. Let’s have a look at a simple example using the Color Adapter. Copied from diffusers.utils import load_image, make_image_grid |
image = load_image("https://huggingface.co/datasets/diffusers/docs-images/resolve/main/t2i-adapter/color_ref.png") Then we can create our color palette by simply resizing it to 8 by 8 pixels and then scaling it back to original size. Copied from PIL import Image |
color_palette = image.resize((8, 8)) |
color_palette = color_palette.resize((512, 512), resample=Image.Resampling.NEAREST) Let’s take a look at the processed image. Next, create the adapter pipeline Copied import torch |
from diffusers import StableDiffusionAdapterPipeline, T2IAdapter |
adapter = T2IAdapter.from_pretrained("TencentARC/t2iadapter_color_sd14v1", torch_dtype=torch.float16) |
pipe = StableDiffusionAdapterPipeline.from_pretrained( |
"CompVis/stable-diffusion-v1-4", |
adapter=adapter, |
torch_dtype=torch.float16, |
) |
pipe.to("cuda") Finally, pass the prompt and control image to the pipeline Copied # fix the random seed, so you will get the same result as the example |
generator = torch.Generator("cuda").manual_seed(7) |
out_image = pipe( |
"At night, glowing cubes in front of the beach", |
image=color_palette, |
generator=generator, |
).images[0] |
make_image_grid([image, color_palette, out_image], rows=1, cols=3) Usage example with the base model of StableDiffusion-XL In the following we give a simple example of how to use a T2I-Adapter checkpoint with Diffusers for inference based on StableDiffusion-XL. |
All adapters use the same pipeline. Images are first downloaded into the appropriate control image format. The control image and prompt are passed to the StableDiffusionXLAdapterPipeline. Let’s have a look at a simple example using the Sketch Adapter. Copied from diffusers.utils import load_image, make_image_grid |
sketch_image = load_image("https://huggingface.co/Adapter/t2iadapter/resolve/main/sketch.png").convert("L") Then, create the adapter pipeline Copied import torch |
from diffusers import ( |
T2IAdapter, |
StableDiffusionXLAdapterPipeline, |
DDPMScheduler |
) |
model_id = "stabilityai/stable-diffusion-xl-base-1.0" |
adapter = T2IAdapter.from_pretrained("Adapter/t2iadapter", subfolder="sketch_sdxl_1.0", torch_dtype=torch.float16, adapter_type="full_adapter_xl") |
scheduler = DDPMScheduler.from_pretrained(model_id, subfolder="scheduler") |
pipe = StableDiffusionXLAdapterPipeline.from_pretrained( |
model_id, adapter=adapter, safety_checker=None, torch_dtype=torch.float16, variant="fp16", scheduler=scheduler |
) |
pipe.to("cuda") Finally, pass the prompt and control image to the pipeline Copied # fix the random seed, so you will get the same result as the example |
generator = torch.Generator().manual_seed(42) |
sketch_image_out = pipe( |
prompt="a photo of a dog in real world, high quality", |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.