text stringlengths 0 5.54k |
|---|
Returns |
SemanticStableDiffusionPipelineOutput or tuple |
SemanticStableDiffusionPipelineOutput if return_dict is True, |
otherwise a tuple. When returning a tuple, the first element is a list with the generated images, and the second element is a list of bools denoting whether the corresponding generated image likely represents "not-safe-for-work" (nsfw) content, according to the safety_checker`. |
Function invoked when calling the pipeline for generation. |
Token merging Token merging (ToMe) merges redundant tokens/patches progressively in the forward pass of a Transformer-based network which can speed-up the inference latency of StableDiffusionPipeline. Install ToMe from pip: Copied pip install tomesd You can use ToMe from the tomesd library with the apply_patch functi... |
import torch |
import tomesd |
pipeline = StableDiffusionPipeline.from_pretrained( |
"runwayml/stable-diffusion-v1-5", torch_dtype=torch.float16, use_safetensors=True, |
).to("cuda") |
+ tomesd.apply_patch(pipeline, ratio=0.5) |
image = pipeline("a photo of an astronaut riding a horse on mars").images[0] The apply_patch function exposes a number of arguments to help strike a balance between pipeline inference speed and the quality of the generated tokens. The most important argument is ratio which controls the number of tokens that are merge... |
- Python version: 3.8.16 |
- PyTorch version (GPU?): 1.13.1+cu116 (True) |
- Huggingface_hub version: 0.13.2 |
- Transformers version: 4.27.2 |
- Accelerate version: 0.18.0 |
- xFormers version: 0.0.16 |
- tomesd version: 0.1.2 To reproduce this benchmark, feel free to use this script. The results are reported in seconds, and where applicable we report the speed-up percentage over the vanilla pipeline when using ToMe and ToMe + xFormers. GPU Resolution Batch size Vanilla ToMe ToMe + xFormers A100 512 10 6.88 5.26 (+23.... |
DiffEdit Image editing typically requires providing a mask of the area to be edited. DiffEdit automatically generates the mask for you based on a text query, making it easier overall to create a mask without image editing software. The DiffEdit algorithm works in three steps: the diffusion model denoises an ... |
#!pip install -q diffusers transformers accelerate The StableDiffusionDiffEditPipeline requires an image mask and a set of partially inverted latents. The image mask is generated from the generate_mask() function, and includes two parameters, source_prompt and target_prompt. These parameters determine what to edit in t... |
target_prompt = "a bowl of pears" The partially inverted latents are generated from the invert() function, and it is generally a good idea to include a prompt or caption describing the image to help guide the inverse latent sampling process. The caption can often be your source_prompt, but feel free to experiment with ... |
from diffusers import DDIMScheduler, DDIMInverseScheduler, StableDiffusionDiffEditPipeline |
pipeline = StableDiffusionDiffEditPipeline.from_pretrained( |
"stabilityai/stable-diffusion-2-1", |
torch_dtype=torch.float16, |
safety_checker=None, |
use_safetensors=True, |
) |
pipeline.scheduler = DDIMScheduler.from_config(pipeline.scheduler.config) |
pipeline.inverse_scheduler = DDIMInverseScheduler.from_config(pipeline.scheduler.config) |
pipeline.enable_model_cpu_offload() |
pipeline.enable_vae_slicing() Load the image to edit: Copied from diffusers.utils import load_image, make_image_grid |
img_url = "https://github.com/Xiang-cd/DiffEdit-stable-diffusion/raw/main/assets/origin.png" |
raw_image = load_image(img_url).resize((768, 768)) |
raw_image Use the generate_mask() function to generate the image mask. You’ll need to pass it the source_prompt and target_prompt to specify what to edit in the image: Copied from PIL import Image |
source_prompt = "a bowl of fruits" |
target_prompt = "a basket of pears" |
mask_image = pipeline.generate_mask( |
image=raw_image, |
source_prompt=source_prompt, |
target_prompt=target_prompt, |
) |
Image.fromarray((mask_image.squeeze()*255).astype("uint8"), "L").resize((768, 768)) Next, create the inverted latents and pass it a caption describing the image: Copied inv_latents = pipeline.invert(prompt=source_prompt, image=raw_image).latents Finally, pass the image mask and inverted latents to the pipeline. The t... |
prompt=target_prompt, |
mask_image=mask_image, |
image_latents=inv_latents, |
negative_prompt=source_prompt, |
).images[0] |
mask_image = Image.fromarray((mask_image.squeeze()*255).astype("uint8"), "L").resize((768, 768)) |
make_image_grid([raw_image, mask_image, output_image], rows=1, cols=3) original image edited image Generate source and target embeddings The source and target embeddings can be automatically generated with the Flan-T5 model instead of creating them manually. Load the Flan-T5 model and tokenizer from the 🤗 Transform... |
from transformers import AutoTokenizer, T5ForConditionalGeneration |
tokenizer = AutoTokenizer.from_pretrained("google/flan-t5-large") |
model = T5ForConditionalGeneration.from_pretrained("google/flan-t5-large", device_map="auto", torch_dtype=torch.float16) Provide some initial text to prompt the model to generate the source and target prompts. Copied source_concept = "bowl" |
target_concept = "basket" |
source_text = f"Provide a caption for images containing a {source_concept}. " |
"The captions should be in English and should be no longer than 150 characters." |
target_text = f"Provide a caption for images containing a {target_concept}. " |
"The captions should be in English and should be no longer than 150 characters." Next, create a utility function to generate the prompts: Copied @torch.no_grad() |
def generate_prompts(input_prompt): |
input_ids = tokenizer(input_prompt, return_tensors="pt").input_ids.to("cuda") |
outputs = model.generate( |
input_ids, temperature=0.8, num_return_sequences=16, do_sample=True, max_new_tokens=128, top_k=10 |
) |
return tokenizer.batch_decode(outputs, skip_special_tokens=True) |
source_prompts = generate_prompts(source_text) |
target_prompts = generate_prompts(target_text) |
print(source_prompts) |
print(target_prompts) Check out the generation strategy guide if you’re interested in learning more about strategies for generating different quality text. Load the text encoder model used by the StableDiffusionDiffEditPipeline to encode the text. You’ll use the text encoder to compute the text embeddings: Copied imp... |
from diffusers import StableDiffusionDiffEditPipeline |
pipeline = StableDiffusionDiffEditPipeline.from_pretrained( |
"stabilityai/stable-diffusion-2-1", torch_dtype=torch.float16, use_safetensors=True |
) |
pipeline.enable_model_cpu_offload() |
pipeline.enable_vae_slicing() |
@torch.no_grad() |
def embed_prompts(sentences, tokenizer, text_encoder, device="cuda"): |
embeddings = [] |
for sent in sentences: |
text_inputs = tokenizer( |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.