text stringlengths 0 5.54k |
|---|
) |
def conv_filter_fn(mod, *args): |
return ( |
isinstance(mod, torch.nn.Conv2d) and mod.kernel_size == (1, 1) and 128 in [mod.in_channels, mod.out_channels] |
) Finally, apply all the optimizations discussed so far: Copied # SDPA + bfloat16. |
pipe = StableDiffusionXLPipeline.from_pretrained( |
"stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.bfloat16 |
).to("cuda") |
# Combine attention projection matrices. |
pipe.fuse_qkv_projections() |
# Change the memory layout. |
pipe.unet.to(memory_format=torch.channels_last) |
pipe.vae.to(memory_format=torch.channels_last) Since dynamic quantization is only limited to the linear layers, convert the appropriate pointwise convolution layers into linear layers to maximize its benefit. Copied from torchao import swap_conv2d_1x1_to_linear |
swap_conv2d_1x1_to_linear(pipe.unet, conv_filter_fn) |
swap_conv2d_1x1_to_linear(pipe.vae, conv_filter_fn) Apply dynamic quantization: Copied from torchao import apply_dynamic_quant |
apply_dynamic_quant(pipe.unet, dynamic_quant_filter_fn) |
apply_dynamic_quant(pipe.vae, dynamic_quant_filter_fn) Finally, compile and perform inference: Copied pipe.unet = torch.compile(pipe.unet, mode="max-autotune", fullgraph=True) |
pipe.vae.decode = torch.compile(pipe.vae.decode, mode="max-autotune", fullgraph=True) |
prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k" |
image = pipe(prompt, num_inference_steps=30).images[0] Applying dynamic quantization improves the latency from 2.52 seconds to 2.43 seconds. |
Stable Diffusion pipelines Stable Diffusion is a text-to-image latent diffusion model created by the researchers and engineers from CompVis, Stability AI and LAION. Latent diffusion applies the diffusion process over a lower dimensional latent space to reduce memory and compute complexity. This specific type of diffusi... |
pipeline = StableDiffusionPipeline.from_pretrained("CompVis/stable-diffusion-v1-4") |
pipeline.scheduler = EulerDiscreteScheduler.from_config(pipeline.scheduler.config) |
# or |
euler_scheduler = EulerDiscreteScheduler.from_pretrained("CompVis/stable-diffusion-v1-4", subfolder="scheduler") |
pipeline = StableDiffusionPipeline.from_pretrained("CompVis/stable-diffusion-v1-4", scheduler=euler_scheduler) Reuse pipeline components to save memory To save memory and use the same components across multiple pipelines, use the .components method to avoid loading weights into RAM more than once. Copied from diffus... |
StableDiffusionPipeline, |
StableDiffusionImg2ImgPipeline, |
StableDiffusionInpaintPipeline, |
) |
text2img = StableDiffusionPipeline.from_pretrained("CompVis/stable-diffusion-v1-4") |
img2img = StableDiffusionImg2ImgPipeline(**text2img.components) |
inpaint = StableDiffusionInpaintPipeline(**text2img.components) |
# now you can use text2img(...), img2img(...), inpaint(...) just like the call methods of each respective pipeline |
InstructPix2Pix InstructPix2Pix is a Stable Diffusion model trained to edit images from human-provided instructions. For example, your prompt can be “turn the clouds rainy” and the model will edit the input image accordingly. This model is conditioned on the text prompt (or editing instruction) and the input image. Thi... |
cd diffusers |
pip install . Then navigate to the example folder containing the training script and install the required dependencies for the script you’re using: Copied cd examples/instruct_pix2pix |
pip install -r requirements.txt 🤗 Accelerate is a library for helping you train on multiple GPUs/TPUs or with mixed-precision. It’ll automatically configure your training setup based on your hardware and environment. Take a look at the 🤗 Accelerate Quick tour to learn more. Initialize an 🤗 Accelerate environment: ... |
write_basic_config() Lastly, if you want to train a model on your own dataset, take a look at the Create a dataset for training guide to learn how to create a dataset that works with the training script. The following sections highlight parts of the training script that are important for understanding how to modify it,... |
--resolution=512 \ Many of the basic and important parameters are described in the Text-to-image training guide, so this guide just focuses on the relevant parameters for InstructPix2Pix: --original_image_column: the original image before the edits are made --edited_image_column: the image after the edits are made --... |
out_channels = unet.conv_in.out_channels |
unet.register_to_config(in_channels=in_channels) |
with torch.no_grad(): |
new_conv_in = nn.Conv2d( |
in_channels, out_channels, unet.conv_in.kernel_size, unet.conv_in.stride, unet.conv_in.padding |
) |
new_conv_in.weight.zero_() |
new_conv_in.weight[:, :4, :, :].copy_(unet.conv_in.weight) |
unet.conv_in = new_conv_in These UNet parameters are updated by the optimizer: Copied optimizer = optimizer_cls( |
unet.parameters(), |
lr=args.learning_rate, |
betas=(args.adam_beta1, args.adam_beta2), |
weight_decay=args.adam_weight_decay, |
eps=args.adam_epsilon, |
) Next, the edited images and and edit instructions are preprocessed and tokenized. It is important the same image transformations are applied to the original and edited images. Copied def preprocess_train(examples): |
preprocessed_images = preprocess_images(examples) |
original_images, edited_images = preprocessed_images.chunk(2) |
original_images = original_images.reshape(-1, 3, args.resolution, args.resolution) |
edited_images = edited_images.reshape(-1, 3, args.resolution, args.resolution) |
examples["original_pixel_values"] = original_images |
examples["edited_pixel_values"] = edited_images |
captions = list(examples[edit_prompt_column]) |
examples["input_ids"] = tokenize_captions(captions) |
return examples Finally, in the training loop, it starts by encoding the edited images into latent space: Copied latents = vae.encode(batch["edited_pixel_values"].to(weight_dtype)).latent_dist.sample() |
latents = latents * vae.config.scaling_factor Then, the script applies dropout to the original image and edit instruction embeddings to support CFG. This is what enables the model to modulate the influence of the edit instruction and original image on the edited image. Copied encoder_hidden_states = text_encoder(batc... |
original_image_embeds = vae.encode(batch["original_pixel_values"].to(weight_dtype)).latent_dist.mode() |
if args.conditioning_dropout_prob is not None: |
random_p = torch.rand(bsz, device=latents.device, generator=generator) |
prompt_mask = random_p < 2 * args.conditioning_dropout_prob |
prompt_mask = prompt_mask.reshape(bsz, 1, 1) |
null_conditioning = text_encoder(tokenize_captions([""]).to(accelerator.device))[0] |
encoder_hidden_states = torch.where(prompt_mask, null_conditioning, encoder_hidden_states) |
image_mask_dtype = original_image_embeds.dtype |
image_mask = 1 - ( |
(random_p >= args.conditioning_dropout_prob).to(image_mask_dtype) |
* (random_p < 3 * args.conditioning_dropout_prob).to(image_mask_dtype) |
) |
image_mask = image_mask.reshape(bsz, 1, 1, 1) |
original_image_embeds = image_mask * original_image_embeds That’s pretty much it! Aside from the differences described here, the rest of the script is very similar to the Text-to-image training script, so feel free to check it out for more details. If you want to learn more about how the training loop works, check ... |
--pretrained_model_name_or_path=$MODEL_NAME \ |
--dataset_name=$DATASET_ID \ |
--enable_xformers_memory_efficient_attention \ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.