Upload folder using huggingface_hub

scrapped_outputs/0012265cfd9e8129835a009e5814c990.txt

@@ -0,0 +1,96 @@
+I2VGen-XL I2VGen-XL: High-Quality Image-to-Video Synthesis via Cascaded Diffusion Models by Shiwei Zhang, Jiayu Wang, Yingya Zhang, Kang Zhao, Hangjie Yuan, Zhiwu Qin, Xiang Wang, Deli Zhao, and Jingren Zhou. The abstract from the paper is: Video synthesis has recently made remarkable strides benefiting from the rapid development of diffusion models. However, it still encounters challenges in terms of semantic accuracy, clarity and spatio-temporal continuity. They primarily arise from the scarcity of well-aligned text-video data and the complex inherent structure of videos, making it difficult for the model to simultaneously ensure semantic and qualitative excellence. In this report, we propose a cascaded I2VGen-XL approach that enhances model performance by decoupling these two factors and ensures the alignment of the input data by utilizing static images as a form of crucial guidance. I2VGen-XL consists of two stages: i) the base stage guarantees coherent semantics and preserves content from input images by using two hierarchical encoders, and ii) the refinement stage enhances the video’s details by incorporating an additional brief text and improves the resolution to 1280×720. To improve the diversity, we collect around 35 million single-shot text-video pairs and 6 billion text-image pairs to optimize the model. By this means, I2VGen-XL can simultaneously enhance the semantic accuracy, continuity of details and clarity of generated videos. Through extensive experiments, we have investigated the underlying principles of I2VGen-XL and compared it with current top methods, which can demonstrate its effectiveness on diverse data. The source code and models will be publicly available at this https URL. The original codebase can be found here. The model checkpoints can be found here. Make sure to check out the Schedulers guide to learn how to explore the tradeoff between scheduler speed and quality, and see the reuse components across pipelines section to learn how to efficiently load the same components into multiple pipelines. Also, to know more about reducing the memory usage of this pipeline, refer to the [“Reduce memory usage”] section here. Sample output with I2VGenXL: masterpiece, bestquality, sunset.
+           Notes I2VGenXL always uses a clip_skip value of 1. This means it leverages the penultimate layer representations from the text encoder of CLIP. It can generate videos of quality that is often on par with Stable Video Diffusion (SVD). Unlike SVD, it additionally accepts text prompts as inputs. It can generate higher resolution videos. When using the DDIMScheduler (which is default for this pipeline), less than 50 steps for inference leads to bad results.  I2VGenXLPipeline  class diffusers.I2VGenXLPipeline  < source > ( vae: AutoencoderKL text_encoder: CLIPTextModel tokenizer: CLIPTokenizer image_encoder: CLIPVisionModelWithProjection feature_extractor: CLIPImageProcessor unet: I2VGenXLUNet scheduler: DDIMScheduler  )   Parameters   vae (AutoencoderKL) —
+Variational Auto-Encoder (VAE) Model to encode and decode images to and from latent representations.   text_encoder (CLIPTextModel) —
+Frozen text-encoder (clip-vit-large-patch14).   tokenizer (CLIPTokenizer) —
+A CLIPTokenizer to tokenize text.   unet (I2VGenXLUNet) —
+A I2VGenXLUNet to denoise the encoded video latents.   scheduler (DDIMScheduler) —
+A scheduler to be used in combination with unet to denoise the encoded image latents.    Pipeline for image-to-video generation as proposed in I2VGenXL. This model inherits from DiffusionPipeline. Check the superclass documentation for the generic methods
+implemented for all pipelines (downloading, saving, running on a particular device, etc.).  __call__  < source > ( prompt: Union = None image: Union = None height: Optional = 704 width: Optional = 1280 target_fps: Optional = 16 num_frames: int = 16 num_inference_steps: int = 50 guidance_scale: float = 9.0 negative_prompt: Union = None eta: float = 0.0 num_videos_per_prompt: Optional = 1 decode_chunk_size: Optional = 1 generator: Union = None latents: Optional = None prompt_embeds: Optional = None negative_prompt_embeds: Optional = None output_type: Optional = 'pil' return_dict: bool = True cross_attention_kwargs: Optional = None clip_skip: Optional = 1  ) → pipelines.i2vgen_xl.pipeline_i2vgen_xl.I2VGenXLPipelineOutput or tuple  Parameters   prompt (str or List[str], optional) —
+The prompt or prompts to guide image generation. If not defined, you need to pass prompt_embeds.   image (PIL.Image.Image or List[PIL.Image.Image] or torch.FloatTensor) —
+Image or images to guide image generation. If you provide a tensor, it needs to be compatible with
+CLIPImageProcessor.   height (int, optional, defaults to self.unet.config.sample_size * self.vae_scale_factor) —
+The height in pixels of the generated image.   width (int, optional, defaults to self.unet.config.sample_size * self.vae_scale_factor) —
+The width in pixels of the generated image.   target_fps (int, optional) —
+Frames per second. The rate at which the generated images shall be exported to a video after generation. This is also used as a “micro-condition” while generation.   num_frames (int, optional) —
+The number of video frames to generate.   num_inference_steps (int, optional) —
+The number of denoising steps.   guidance_scale (float, optional, defaults to 7.5) —
+A higher guidance scale value encourages the model to generate images closely linked to the text
+prompt at the expense of lower image quality. Guidance scale is enabled when guidance_scale > 1.   negative_prompt (str or List[str], optional) —
+The prompt or prompts to guide what to not include in image generation. If not defined, you need to
+pass negative_prompt_embeds instead. Ignored when not using guidance (guidance_scale < 1).   eta (float, optional) —
+Corresponds to parameter eta (η) from the DDIM paper. Only applies
+to the DDIMScheduler, and is ignored in other schedulers.   num_videos_per_prompt (int, optional) —
+The number of images to generate per prompt.   decode_chunk_size (int, optional) —
+The number of frames to decode at a time. The higher the chunk size, the higher the temporal consistency
+between frames, but also the higher the memory consumption. By default, the decoder will decode all frames at once
+for maximal quality. Reduce decode_chunk_size to reduce memory usage.   generator (torch.Generator or List[torch.Generator], optional) —
+A torch.Generator to make
+generation deterministic.   latents (torch.FloatTensor, optional) —
+Pre-generated noisy latents sampled from a Gaussian distribution, to be used as inputs for image
+generation. Can be used to tweak the same generation with different prompts. If not provided, a latents
+tensor is generated by sampling using the supplied random generator.   prompt_embeds (torch.FloatTensor, optional) —
+Pre-generated text embeddings. Can be used to easily tweak text inputs (prompt weighting). If not
+provided, text embeddings are generated from the prompt input argument.   negative_prompt_embeds (torch.FloatTensor, optional) —
+Pre-generated negative text embeddings. Can be used to easily tweak text inputs (prompt weighting). If
+not provided, negative_prompt_embeds are generated from the negative_prompt input argument.   output_type (str, optional, defaults to "pil") —
+The output format of the generated image. Choose between PIL.Image or np.array.   return_dict (bool, optional, defaults to True) —
+Whether or not to return a StableDiffusionPipelineOutput instead of a
+plain tuple.   cross_attention_kwargs (dict, optional) —
+A kwargs dictionary that if specified is passed along to the AttentionProcessor as defined in
+self.processor.   clip_skip (int, optional) —
+Number of layers to be skipped from CLIP while computing the prompt embeddings. A value of 1 means that
+the output of the pre-final layer will be used for computing the prompt embeddings.   Returns 
+pipelines.i2vgen_xl.pipeline_i2vgen_xl.I2VGenXLPipelineOutput or tuple
+  
+If return_dict is True, pipelines.i2vgen_xl.pipeline_i2vgen_xl.I2VGenXLPipelineOutput is
+returned, otherwise a tuple is returned where the first element is a list with the generated frames.
+  The call function to the pipeline for image-to-video generation with I2VGenXLPipeline.  Examples:   Copied >>> import torch
+>>> from diffusers import I2VGenXLPipeline
+
+>>> pipeline = I2VGenXLPipeline.from_pretrained("ali-vilab/i2vgen-xl", torch_dtype=torch.float16, variant="fp16")
+>>> pipeline.enable_model_cpu_offload()
+
+>>> image_url = "https://github.com/ali-vilab/i2vgen-xl/blob/main/data/test_images/img_0009.png?raw=true"
+>>> image = load_image(image_url).convert("RGB")
+
+>>> prompt = "Papers were floating in the air on a table in the library"
+>>> negative_prompt = "Distorted, discontinuous, Ugly, blurry, low resolution, motionless, static, disfigured, disconnected limbs, Ugly faces, incomplete arms"
+>>> generator = torch.manual_seed(8888)
+
+>>> frames = pipeline(
+...     prompt=prompt,
+...     image=image,
+...     num_inference_steps=50,
+...     negative_prompt=negative_prompt,
+...     guidance_scale=9.0,
+...     generator=generator
+... ).frames[0]
+>>> video_path = export_to_gif(frames, "i2v.gif")  disable_freeu  < source > ( )    Disables the FreeU mechanism if enabled.  disable_vae_slicing  < source > ( )    Disable sliced VAE decoding. If enable_vae_slicing was previously enabled, this method will go back to
+computing decoding in one step.  disable_vae_tiling  < source > ( )    Disable tiled VAE decoding. If enable_vae_tiling was previously enabled, this method will go back to
+computing decoding in one step.  enable_freeu  < source > ( s1: float s2: float b1: float b2: float  )   Parameters   s1 (float) —
+Scaling factor for stage 1 to attenuate the contributions of the skip features. This is done to
+mitigate “oversmoothing effect” in the enhanced denoising process.   s2 (float) —
+Scaling factor for stage 2 to attenuate the contributions of the skip features. This is done to
+mitigate “oversmoothing effect” in the enhanced denoising process.   b1 (float) — Scaling factor for stage 1 to amplify the contributions of backbone features.   b2 (float) — Scaling factor for stage 2 to amplify the contributions of backbone features.    Enables the FreeU mechanism as in https://arxiv.org/abs/2309.11497. The suffixes after the scaling factors represent the stages where they are being applied. Please refer to the official repository for combinations of the values
+that are known to work well for different pipelines such as Stable Diffusion v1, v2, and Stable Diffusion XL.  enable_vae_slicing  < source > ( )    Enable sliced VAE decoding. When this option is enabled, the VAE will split the input tensor in slices to
+compute decoding in several steps. This is useful to save some memory and allow larger batch sizes.  enable_vae_tiling  < source > ( )    Enable tiled VAE decoding. When this option is enabled, the VAE will split the input tensor into tiles to
+compute decoding and encoding in several steps. This is useful for saving a large amount of memory and to allow
+processing larger images.  encode_prompt  < source > ( prompt device num_videos_per_prompt negative_prompt = None prompt_embeds: Optional = None negative_prompt_embeds: Optional = None lora_scale: Optional = None clip_skip: Optional = None  )   Parameters   prompt (str or List[str], optional) —
+prompt to be encoded
+device — (torch.device):
+torch device   num_videos_per_prompt (int) —
+number of images that should be generated per prompt   do_classifier_free_guidance (bool) —
+whether to use classifier free guidance or not   negative_prompt (str or List[str], optional) —
+The prompt or prompts not to guide the image generation. If not defined, one has to pass
+negative_prompt_embeds instead. Ignored when not using guidance (i.e., ignored if guidance_scale is
+less than 1).   prompt_embeds (torch.FloatTensor, optional) —
+Pre-generated text embeddings. Can be used to easily tweak text inputs, e.g. prompt weighting. If not
+provided, text embeddings will be generated from prompt input argument.   negative_prompt_embeds (torch.FloatTensor, optional) —
+Pre-generated negative text embeddings. Can be used to easily tweak text inputs, e.g. prompt
+weighting. If not provided, negative_prompt_embeds will be generated from negative_prompt input
+argument.   lora_scale (float, optional) —
+A LoRA scale that will be applied to all LoRA layers of the text encoder if LoRA layers are loaded.   clip_skip (int, optional) —
+Number of layers to be skipped from CLIP while computing the prompt embeddings. A value of 1 means that
+the output of the pre-final layer will be used for computing the prompt embeddings.    Encodes the prompt into text encoder hidden states.  I2VGenXLPipelineOutput  class diffusers.pipelines.i2vgen_xl.pipeline_i2vgen_xl.I2VGenXLPipelineOutput  < source > ( frames: Union  )   Parameters   frames (List[np.ndarray] or torch.FloatTensor) —
+List of denoised frames (essentially images) as NumPy arrays of shape (height, width, num_channels) or as
+a torch tensor. The length of the list denotes the video length (the number of frames).    Output class for image-to-video pipeline.

scrapped_outputs/002e4f7b8ab52c12963857540b2c6ad7.txt

@@ -0,0 +1,107 @@
+Semantic Guidance Semantic Guidance for Diffusion Models was proposed in SEGA: Instructing Text-to-Image Models using Semantic Guidance and provides strong semantic control over image generation.
+Small changes to the text prompt usually result in entirely different output images. However, with SEGA a variety of changes to the image are enabled that can be controlled easily and intuitively, while staying true to the original image composition. The abstract from the paper is: Text-to-image diffusion models have recently received a lot of interest for their astonishing ability to produce high-fidelity images from text only. However, achieving one-shot generation that aligns with the user’s intent is nearly impossible, yet small changes to the input prompt often result in very different images. This leaves the user with little semantic control. To put the user in control, we show how to interact with the diffusion process to flexibly steer it along semantic directions. This semantic guidance (SEGA) generalizes to any generative architecture using classifier-free guidance. More importantly, it allows for subtle and extensive edits, changes in composition and style, as well as optimizing the overall artistic conception. We demonstrate SEGA’s effectiveness on both latent and pixel-based diffusion models such as Stable Diffusion, Paella, and DeepFloyd-IF using a variety of tasks, thus providing strong evidence for its versatility, flexibility, and improvements over existing methods. Make sure to check out the Schedulers guide to learn how to explore the tradeoff between scheduler speed and quality, and see the reuse components across pipelines section to learn how to efficiently load the same components into multiple pipelines.  SemanticStableDiffusionPipeline  class diffusers.SemanticStableDiffusionPipeline  < source > ( vae: AutoencoderKL text_encoder: CLIPTextModel tokenizer: CLIPTokenizer unet: UNet2DConditionModel scheduler: KarrasDiffusionSchedulers safety_checker: StableDiffusionSafetyChecker feature_extractor: CLIPImageProcessor requires_safety_checker: bool = True  )   Parameters   vae (AutoencoderKL) —
+Variational Auto-Encoder (VAE) model to encode and decode images to and from latent representations.   text_encoder (CLIPTextModel) —
+Frozen text-encoder (clip-vit-large-patch14).   tokenizer (CLIPTokenizer) —
+A CLIPTokenizer to tokenize text.   unet (UNet2DConditionModel) —
+A UNet2DConditionModel to denoise the encoded image latents.   scheduler (SchedulerMixin) —
+A scheduler to be used in combination with unet to denoise the encoded image latents. Can be one of
+DDIMScheduler, LMSDiscreteScheduler, or PNDMScheduler.   safety_checker (Q16SafetyChecker) —
+Classification module that estimates whether generated images could be considered offensive or harmful.
+Please refer to the model card for more details
+about a model’s potential harms.   feature_extractor (CLIPImageProcessor) —
+A CLIPImageProcessor to extract features from generated images; used as inputs to the safety_checker.    Pipeline for text-to-image generation using Stable Diffusion with latent editing. This model inherits from DiffusionPipeline and builds on the StableDiffusionPipeline. Check the superclass
+documentation for the generic methods implemented for all pipelines (downloading, saving, running on a particular
+device, etc.).  __call__  < source > ( prompt: Union height: Optional = None width: Optional = None num_inference_steps: int = 50 guidance_scale: float = 7.5 negative_prompt: Union = None num_images_per_prompt: int = 1 eta: float = 0.0 generator: Union = None latents: Optional = None output_type: Optional = 'pil' return_dict: bool = True callback: Optional = None callback_steps: int = 1 editing_prompt: Union = None editing_prompt_embeddings: Optional = None reverse_editing_direction: Union = False edit_guidance_scale: Union = 5 edit_warmup_steps: Union = 10 edit_cooldown_steps: Union = None edit_threshold: Union = 0.9 edit_momentum_scale: Optional = 0.1 edit_mom_beta: Optional = 0.4 edit_weights: Optional = None sem_guidance: Optional = None  ) → SemanticStableDiffusionPipelineOutput or tuple  Parameters   prompt (str or List[str]) —
+The prompt or prompts to guide image generation.   height (int, optional, defaults to self.unet.config.sample_size * self.vae_scale_factor) —
+The height in pixels of the generated image.   width (int, optional, defaults to self.unet.config.sample_size * self.vae_scale_factor) —
+The width in pixels of the generated image.   num_inference_steps (int, optional, defaults to 50) —
+The number of denoising steps. More denoising steps usually lead to a higher quality image at the
+expense of slower inference.   guidance_scale (float, optional, defaults to 7.5) —
+A higher guidance scale value encourages the model to generate images closely linked to the text
+prompt at the expense of lower image quality. Guidance scale is enabled when guidance_scale > 1.   negative_prompt (str or List[str], optional) —
+The prompt or prompts to guide what to not include in image generation. If not defined, you need to
+pass negative_prompt_embeds instead. Ignored when not using guidance (guidance_scale < 1).   num_images_per_prompt (int, optional, defaults to 1) —
+The number of images to generate per prompt.   eta (float, optional, defaults to 0.0) —
+Corresponds to parameter eta (η) from the DDIM paper. Only applies
+to the DDIMScheduler, and is ignored in other schedulers.   generator (torch.Generator or List[torch.Generator], optional) —
+A torch.Generator to make
+generation deterministic.   latents (torch.FloatTensor, optional) —
+Pre-generated noisy latents sampled from a Gaussian distribution, to be used as inputs for image
+generation. Can be used to tweak the same generation with different prompts. If not provided, a latents
+tensor is generated by sampling using the supplied random generator.   output_type (str, optional, defaults to "pil") —
+The output format of the generated image. Choose between PIL.Image or np.array.   return_dict (bool, optional, defaults to True) —
+Whether or not to return a StableDiffusionPipelineOutput instead of a
+plain tuple.   callback (Callable, optional) —
+A function that calls every callback_steps steps during inference. The function is called with the
+following arguments: callback(step: int, timestep: int, latents: torch.FloatTensor).   callback_steps (int, optional, defaults to 1) —
+The frequency at which the callback function is called. If not specified, the callback is called at
+every step.   editing_prompt (str or List[str], optional) —
+The prompt or prompts to use for semantic guidance. Semantic guidance is disabled by setting
+editing_prompt = None. Guidance direction of prompt should be specified via
+reverse_editing_direction.   editing_prompt_embeddings (torch.Tensor, optional) —
+Pre-computed embeddings to use for semantic guidance. Guidance direction of embedding should be
+specified via reverse_editing_direction.   reverse_editing_direction (bool or List[bool], optional, defaults to False) —
+Whether the corresponding prompt in editing_prompt should be increased or decreased.   edit_guidance_scale (float or List[float], optional, defaults to 5) —
+Guidance scale for semantic guidance. If provided as a list, values should correspond to
+editing_prompt.   edit_warmup_steps (float or List[float], optional, defaults to 10) —
+Number of diffusion steps (for each prompt) for which semantic guidance is not applied. Momentum is
+calculated for those steps and applied once all warmup periods are over.   edit_cooldown_steps (float or List[float], optional, defaults to None) —
+Number of diffusion steps (for each prompt) after which semantic guidance is longer applied.   edit_threshold (float or List[float], optional, defaults to 0.9) —
+Threshold of semantic guidance.   edit_momentum_scale (float, optional, defaults to 0.1) —
+Scale of the momentum to be added to the semantic guidance at each diffusion step. If set to 0.0,
+momentum is disabled. Momentum is already built up during warmup (for diffusion steps smaller than
+sld_warmup_steps). Momentum is only added to latent guidance once all warmup periods are finished.   edit_mom_beta (float, optional, defaults to 0.4) —
+Defines how semantic guidance momentum builds up. edit_mom_beta indicates how much of the previous
+momentum is kept. Momentum is already built up during warmup (for diffusion steps smaller than
+edit_warmup_steps).   edit_weights (List[float], optional, defaults to None) —
+Indicates how much each individual concept should influence the overall guidance. If no weights are
+provided all concepts are applied equally.   sem_guidance (List[torch.Tensor], optional) —
+List of pre-generated guidance vectors to be applied at generation. Length of the list has to
+correspond to num_inference_steps.   Returns 
+SemanticStableDiffusionPipelineOutput or tuple
+  
+If return_dict is True,
+SemanticStableDiffusionPipelineOutput is returned, otherwise a
+tuple is returned where the first element is a list with the generated images and the second element
+is a list of bools indicating whether the corresponding generated image contains “not-safe-for-work”
+(nsfw) content.
+  The call function to the pipeline for generation.  Examples:   Copied >>> import torch
+>>> from diffusers import SemanticStableDiffusionPipeline
+
+>>> pipe = SemanticStableDiffusionPipeline.from_pretrained(
+...     "runwayml/stable-diffusion-v1-5", torch_dtype=torch.float16
+... )
+>>> pipe = pipe.to("cuda")
+
+>>> out = pipe(
+...     prompt="a photo of the face of a woman",
+...     num_images_per_prompt=1,
+...     guidance_scale=7,
+...     editing_prompt=[
+...         "smiling, smile",  # Concepts to apply
+...         "glasses, wearing glasses",
+...         "curls, wavy hair, curly hair",
+...         "beard, full beard, mustache",
+...     ],
+...     reverse_editing_direction=[
+...         False,
+...         False,
+...         False,
+...         False,
+...     ],  # Direction of guidance i.e. increase all concepts
+...     edit_warmup_steps=[10, 10, 10, 10],  # Warmup period for each concept
+...     edit_guidance_scale=[4, 5, 5, 5.4],  # Guidance scale for each concept
+...     edit_threshold=[
+...         0.99,
+...         0.975,
+...         0.925,
+...         0.96,
+...     ],  # Threshold for each concept. Threshold equals the percentile of the latent space that will be discarded. I.e. threshold=0.99 uses 1% of the latent dimensions
+...     edit_momentum_scale=0.3,  # Momentum scale that will be added to the latent guidance
+...     edit_mom_beta=0.6,  # Momentum beta
+...     edit_weights=[1, 1, 1, 1, 1],  # Weights of the individual concepts against each other
+... )
+>>> image = out.images[0]  StableDiffusionSafePipelineOutput  class diffusers.pipelines.semantic_stable_diffusion.SemanticStableDiffusionPipelineOutput  < source > ( images: Union nsfw_content_detected: Optional  )   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).   nsfw_content_detected (List[bool]) —
+List indicating whether the corresponding generated image contains “not-safe-for-work” (nsfw) content or
+None if safety checking could not be performed.    Output class for Stable Diffusion pipelines.

scrapped_outputs/00338ebc720885d1d32274136bd7514e.txt

@@ -0,0 +1,6 @@
+Overview 🤗 Diffusers provides a collection of training scripts for you to train your own diffusion models. You can find all of our training scripts in diffusers/examples. Each training script is: Self-contained: the training script does not depend on any local files, and all packages required to run the script are installed from the requirements.txt file. Easy-to-tweak: the training scripts are an example of how to train a diffusion model for a specific task and won’t work out-of-the-box for every training scenario. You’ll likely need to adapt the training script for your specific use-case. To help you with that, we’ve fully exposed the data preprocessing code and the training loop so you can modify it for your own use. Beginner-friendly: the training scripts are designed to be beginner-friendly and easy to understand, rather than including the latest state-of-the-art methods to get the best and most competitive results. Any training methods we consider too complex are purposefully left out. Single-purpose: each training script is expressly designed for only one task to keep it readable and understandable. Our current collection of training scripts include: Training SDXL-support LoRA-support Flax-support unconditional image generation     text-to-image 👍 👍 👍 textual inversion    👍 DreamBooth  👍 👍 👍 ControlNet 👍  👍 InstructPix2Pix 👍   Custom Diffusion    T2I-Adapters 👍   Kandinsky 2.2  👍  Wuerstchen  👍  These examples are actively maintained, so please feel free to open an issue if they aren’t working as expected. If you feel like another training example should be included, you’re more than welcome to start a Feature Request to discuss your feature idea with us and whether it meets our criteria of being self-contained, easy-to-tweak, beginner-friendly, and single-purpose.  Install Make sure you can successfully run the latest versions of the example scripts by installing the library from source in a new virtual environment:   Copied git clone https://github.com/huggingface/diffusers
+cd diffusers
+pip install . Then navigate to the folder of the training script (for example, DreamBooth) and install the requirements.txt file. Some training scripts have a specific requirement file for SDXL, LoRA or Flax. If you’re using one of these scripts, make sure you install its corresponding requirements file.   Copied cd examples/dreambooth
+pip install -r requirements.txt
+# to train SDXL with DreamBooth
+pip install -r requirements_sdxl.txt To speedup training and reduce memory-usage, we recommend: using PyTorch 2.0 or higher to automatically use scaled dot product attention during training (you don’t need to make any changes to the training code) installing xFormers to enable memory-efficient attention

scrapped_outputs/003990abb5bccb7515ba047c3f63eebe.txt

@@ -0,0 +1,96 @@
+DPMSolverMultistepScheduler DPMSolverMultistep is a multistep scheduler from DPM-Solver: A Fast ODE Solver for Diffusion Probabilistic Model Sampling in Around 10 Steps and DPM-Solver++: Fast Solver for Guided Sampling of Diffusion Probabilistic Models by Cheng Lu, Yuhao Zhou, Fan Bao, Jianfei Chen, Chongxuan Li, and Jun Zhu. DPMSolver (and the improved version DPMSolver++) is a fast dedicated high-order solver for diffusion ODEs with convergence order guarantee. Empirically, DPMSolver sampling with only 20 steps can generate high-quality
+samples, and it can generate quite good samples even in 10 steps.  Tips It is recommended to set solver_order to 2 for guide sampling, and solver_order=3 for unconditional sampling. Dynamic thresholding from Imagen is supported, and for pixel-space
+diffusion models, you can set both algorithm_type="dpmsolver++" and thresholding=True to use the dynamic
+thresholding. This thresholding method is unsuitable for latent-space diffusion models such as
+Stable Diffusion. The SDE variant of DPMSolver and DPM-Solver++ is also supported, but only for the first and second-order solvers. This is a fast SDE solver for the reverse diffusion SDE. It is recommended to use the second-order sde-dpmsolver++.  DPMSolverMultistepScheduler  class diffusers.DPMSolverMultistepScheduler  < source > ( num_train_timesteps: int = 1000 beta_start: float = 0.0001 beta_end: float = 0.02 beta_schedule: str = 'linear' trained_betas: Union = None solver_order: int = 2 prediction_type: str = 'epsilon' thresholding: bool = False dynamic_thresholding_ratio: float = 0.995 sample_max_value: float = 1.0 algorithm_type: str = 'dpmsolver++' solver_type: str = 'midpoint' lower_order_final: bool = True euler_at_final: bool = False use_karras_sigmas: Optional = False use_lu_lambdas: Optional = False lambda_min_clipped: float = -inf variance_type: Optional = None timestep_spacing: str = 'linspace' steps_offset: int = 0  )   Parameters   num_train_timesteps (int, defaults to 1000) —
+The number of diffusion steps to train the model.   beta_start (float, defaults to 0.0001) —
+The starting beta value of inference.   beta_end (float, defaults to 0.02) —
+The final beta value.   beta_schedule (str, defaults to "linear") —
+The beta schedule, a mapping from a beta range to a sequence of betas for stepping the model. Choose from
+linear, scaled_linear, or squaredcos_cap_v2.   trained_betas (np.ndarray, optional) —
+Pass an array of betas directly to the constructor to bypass beta_start and beta_end.   solver_order (int, defaults to 2) —
+The DPMSolver order which can be 1 or 2 or 3. It is recommended to use solver_order=2 for guided
+sampling, and solver_order=3 for unconditional sampling.   prediction_type (str, defaults to epsilon, optional) —
+Prediction type of the scheduler function; can be epsilon (predicts the noise of the diffusion process),
+sample (directly predicts the noisy sample) or v_prediction` (see section 2.4 of Imagen
+Video paper).   thresholding (bool, defaults to False) —
+Whether to use the “dynamic thresholding” method. This is unsuitable for latent-space diffusion models such
+as Stable Diffusion.   dynamic_thresholding_ratio (float, defaults to 0.995) —
+The ratio for the dynamic thresholding method. Valid only when thresholding=True.   sample_max_value (float, defaults to 1.0) —
+The threshold value for dynamic thresholding. Valid only when thresholding=True and
+algorithm_type="dpmsolver++".   algorithm_type (str, defaults to dpmsolver++) —
+Algorithm type for the solver; can be dpmsolver, dpmsolver++, sde-dpmsolver or sde-dpmsolver++. The
+dpmsolver type implements the algorithms in the DPMSolver
+paper, and the dpmsolver++ type implements the algorithms in the
+DPMSolver++ paper. It is recommended to use dpmsolver++ or
+sde-dpmsolver++ with solver_order=2 for guided sampling like in Stable Diffusion.   solver_type (str, defaults to midpoint) —
+Solver type for the second-order solver; can be midpoint or heun. The solver type slightly affects the
+sample quality, especially for a small number of steps. It is recommended to use midpoint solvers.   lower_order_final (bool, defaults to True) —
+Whether to use lower-order solvers in the final steps. Only valid for < 15 inference steps. This can
+stabilize the sampling of DPMSolver for steps < 15, especially for steps <= 10.   euler_at_final (bool, defaults to False) —
+Whether to use Euler’s method in the final step. It is a trade-off between numerical stability and detail
+richness. This can stabilize the sampling of the SDE variant of DPMSolver for small number of inference
+steps, but sometimes may result in blurring.   use_karras_sigmas (bool, optional, defaults to False) —
+Whether to use Karras sigmas for step sizes in the noise schedule during the sampling process. If True,
+the sigmas are determined according to a sequence of noise levels {σi}.   use_lu_lambdas (bool, optional, defaults to False) —
+Whether to use the uniform-logSNR for step sizes proposed by Lu’s DPM-Solver in the noise schedule during
+the sampling process. If True, the sigmas and time steps are determined according to a sequence of
+lambda(t).   lambda_min_clipped (float, defaults to -inf) —
+Clipping threshold for the minimum value of lambda(t) for numerical stability. This is critical for the
+cosine (squaredcos_cap_v2) noise schedule.   variance_type (str, optional) —
+Set to “learned” or “learned_range” for diffusion models that predict variance. If set, the model’s output
+contains the predicted Gaussian variance.   timestep_spacing (str, defaults to "linspace") —
+The way the timesteps should be scaled. Refer to Table 2 of the Common Diffusion Noise Schedules and
+Sample Steps are Flawed for more information.   steps_offset (int, defaults to 0) —
+An offset added to the inference steps. You can use a combination of offset=1 and
+set_alpha_to_one=False to make the last step use step 0 for the previous alpha product like in Stable
+Diffusion.    DPMSolverMultistepScheduler is a fast dedicated high-order solver for diffusion ODEs. This model inherits from SchedulerMixin and ConfigMixin. Check the superclass documentation for the generic
+methods the library implements for all schedulers such as loading and saving.  convert_model_output  < source > ( model_output: FloatTensor *args sample: FloatTensor = None **kwargs  ) → torch.FloatTensor  Parameters   model_output (torch.FloatTensor) —
+The direct output from the learned diffusion model.   sample (torch.FloatTensor) —
+A current instance of a sample created by the diffusion process.   Returns 
+torch.FloatTensor
+  
+The converted model output.
+  Convert the model output to the corresponding type the DPMSolver/DPMSolver++ algorithm needs. DPM-Solver is
+designed to discretize an integral of the noise prediction model, and DPM-Solver++ is designed to discretize an
+integral of the data prediction model. The algorithm and model type are decoupled. You can use either DPMSolver or DPMSolver++ for both noise
+prediction and data prediction models.  dpm_solver_first_order_update  < source > ( model_output: FloatTensor *args sample: FloatTensor = None noise: Optional = None **kwargs  ) → torch.FloatTensor  Parameters   model_output (torch.FloatTensor) —
+The direct output from the learned diffusion model.   sample (torch.FloatTensor) —
+A current instance of a sample created by the diffusion process.   Returns 
+torch.FloatTensor
+  
+The sample tensor at the previous timestep.
+  One step for the first-order DPMSolver (equivalent to DDIM).  multistep_dpm_solver_second_order_update  < source > ( model_output_list: List *args sample: FloatTensor = None noise: Optional = None **kwargs  ) → torch.FloatTensor  Parameters   model_output_list (List[torch.FloatTensor]) —
+The direct outputs from learned diffusion model at current and latter timesteps.   sample (torch.FloatTensor) —
+A current instance of a sample created by the diffusion process.   Returns 
+torch.FloatTensor
+  
+The sample tensor at the previous timestep.
+  One step for the second-order multistep DPMSolver.  multistep_dpm_solver_third_order_update  < source > ( model_output_list: List *args sample: FloatTensor = None **kwargs  ) → torch.FloatTensor  Parameters   model_output_list (List[torch.FloatTensor]) —
+The direct outputs from learned diffusion model at current and latter timesteps.   sample (torch.FloatTensor) —
+A current instance of a sample created by diffusion process.   Returns 
+torch.FloatTensor
+  
+The sample tensor at the previous timestep.
+  One step for the third-order multistep DPMSolver.  scale_model_input  < source > ( sample: FloatTensor *args **kwargs  ) → torch.FloatTensor  Parameters   sample (torch.FloatTensor) —
+The input sample.   Returns 
+torch.FloatTensor
+  
+A scaled input sample.
+  Ensures interchangeability with schedulers that need to scale the denoising model input depending on the
+current timestep.  set_timesteps  < source > ( num_inference_steps: int = None device: Union = None  )   Parameters   num_inference_steps (int) —
+The number of diffusion steps used when generating samples with a pre-trained model.   device (str or torch.device, optional) —
+The device to which the timesteps should be moved to. If None, the timesteps are not moved.    Sets the discrete timesteps used for the diffusion chain (to be run before inference).  step  < source > ( model_output: FloatTensor timestep: int sample: FloatTensor generator = None return_dict: bool = True  ) → SchedulerOutput or tuple  Parameters   model_output (torch.FloatTensor) —
+The direct output from learned diffusion model.   timestep (int) —
+The current discrete timestep in the diffusion chain.   sample (torch.FloatTensor) —
+A current instance of a sample created by the diffusion process.   generator (torch.Generator, optional) —
+A random number generator.   return_dict (bool) —
+Whether or not to return a SchedulerOutput or tuple.   Returns 
+SchedulerOutput or tuple
+  
+If return_dict is True, SchedulerOutput is returned, otherwise a
+tuple is returned where the first element is the sample tensor.
+  Predict the sample from the previous timestep by reversing the SDE. This function propagates the sample with
+the multistep DPMSolver.  SchedulerOutput  class diffusers.schedulers.scheduling_utils.SchedulerOutput  < source > ( prev_sample: FloatTensor  )   Parameters   prev_sample (torch.FloatTensor of shape (batch_size, num_channels, height, width) for images) —
+Computed sample (x_{t-1}) of previous timestep. prev_sample should be used as next model input in the
+denoising loop.    Base class for the output of a scheduler’s step function.

scrapped_outputs/004595462592973e8bbc3c61f477d432.txt

@@ -0,0 +1,74 @@
+DDIMScheduler Denoising Diffusion Implicit Models (DDIM) by Jiaming Song, Chenlin Meng and Stefano Ermon. The abstract from the paper is: Denoising diffusion probabilistic models (DDPMs) have achieved high quality image generation without adversarial training, yet they require simulating a Markov chain for many steps to produce a sample.
+To accelerate sampling, we present denoising diffusion implicit models (DDIMs), a more efficient class of iterative implicit probabilistic models
+with the same training procedure as DDPMs. In DDPMs, the generative process is defined as the reverse of a Markovian diffusion process.
+We construct a class of non-Markovian diffusion processes that lead to the same training objective, but whose reverse process can be much faster to sample from.
+We empirically demonstrate that DDIMs can produce high quality samples 10× to 50× faster in terms of wall-clock time compared to DDPMs, allow us to trade off computation for sample quality, and can perform semantically meaningful image interpolation directly in the latent space. The original codebase of this paper can be found at ermongroup/ddim, and you can contact the author on tsong.me.  Tips The paper Common Diffusion Noise Schedules and Sample Steps are Flawed claims that a mismatch between the training and inference settings leads to suboptimal inference generation results for Stable Diffusion. To fix this, the authors propose: 🧪 This is an experimental feature! rescale the noise schedule to enforce zero terminal signal-to-noise ratio (SNR)   Copied pipe.scheduler = DDIMScheduler.from_config(pipe.scheduler.config, rescale_betas_zero_snr=True) train a model with v_prediction (add the following argument to the train_text_to_image.py or train_text_to_image_lora.py scripts)   Copied --prediction_type="v_prediction" change the sampler to always start from the last timestep   Copied pipe.scheduler = DDIMScheduler.from_config(pipe.scheduler.config, timestep_spacing="trailing") rescale classifier-free guidance to prevent over-exposure   Copied image = pipe(prompt, guidance_rescale=0.7).images[0] For example:   Copied from diffusers import DiffusionPipeline, DDIMScheduler
+import torch
+
+pipe = DiffusionPipeline.from_pretrained("ptx0/pseudo-journey-v2", torch_dtype=torch.float16)
+pipe.scheduler = DDIMScheduler.from_config(
+    pipe.scheduler.config, rescale_betas_zero_snr=True, timestep_spacing="trailing"
+)
+pipe.to("cuda")
+
+prompt = "A lion in galaxies, spirals, nebulae, stars, smoke, iridescent, intricate detail, octane render, 8k"
+image = pipe(prompt, guidance_rescale=0.7).images[0]
+image  DDIMScheduler  class diffusers.DDIMScheduler  < source > ( num_train_timesteps: int = 1000 beta_start: float = 0.0001 beta_end: float = 0.02 beta_schedule: str = 'linear' trained_betas: Union = None clip_sample: bool = True set_alpha_to_one: bool = True steps_offset: int = 0 prediction_type: str = 'epsilon' thresholding: bool = False dynamic_thresholding_ratio: float = 0.995 clip_sample_range: float = 1.0 sample_max_value: float = 1.0 timestep_spacing: str = 'leading' rescale_betas_zero_snr: bool = False  )   Parameters   num_train_timesteps (int, defaults to 1000) —
+The number of diffusion steps to train the model.   beta_start (float, defaults to 0.0001) —
+The starting beta value of inference.   beta_end (float, defaults to 0.02) —
+The final beta value.   beta_schedule (str, defaults to "linear") —
+The beta schedule, a mapping from a beta range to a sequence of betas for stepping the model. Choose from
+linear, scaled_linear, or squaredcos_cap_v2.   trained_betas (np.ndarray, optional) —
+Pass an array of betas directly to the constructor to bypass beta_start and beta_end.   clip_sample (bool, defaults to True) —
+Clip the predicted sample for numerical stability.   clip_sample_range (float, defaults to 1.0) —
+The maximum magnitude for sample clipping. Valid only when clip_sample=True.   set_alpha_to_one (bool, defaults to True) —
+Each diffusion step uses the alphas product value at that step and at the previous one. For the final step
+there is no previous alpha. When this option is True the previous alpha product is fixed to 1,
+otherwise it uses the alpha value at step 0.   steps_offset (int, defaults to 0) —
+An offset added to the inference steps. You can use a combination of offset=1 and
+set_alpha_to_one=False to make the last step use step 0 for the previous alpha product like in Stable
+Diffusion.   prediction_type (str, defaults to epsilon, optional) —
+Prediction type of the scheduler function; can be epsilon (predicts the noise of the diffusion process),
+sample (directly predicts the noisy sample) or v_prediction` (see section 2.4 of Imagen
+Video paper).   thresholding (bool, defaults to False) —
+Whether to use the “dynamic thresholding” method. This is unsuitable for latent-space diffusion models such
+as Stable Diffusion.   dynamic_thresholding_ratio (float, defaults to 0.995) —
+The ratio for the dynamic thresholding method. Valid only when thresholding=True.   sample_max_value (float, defaults to 1.0) —
+The threshold value for dynamic thresholding. Valid only when thresholding=True.   timestep_spacing (str, defaults to "leading") —
+The way the timesteps should be scaled. Refer to Table 2 of the Common Diffusion Noise Schedules and
+Sample Steps are Flawed for more information.   rescale_betas_zero_snr (bool, defaults to False) —
+Whether to rescale the betas to have zero terminal SNR. This enables the model to generate very bright and
+dark samples instead of limiting it to samples with medium brightness. Loosely related to
+--offset_noise.    DDIMScheduler extends the denoising procedure introduced in denoising diffusion probabilistic models (DDPMs) with
+non-Markovian guidance. This model inherits from SchedulerMixin and ConfigMixin. Check the superclass documentation for the generic
+methods the library implements for all schedulers such as loading and saving.  scale_model_input  < source > ( sample: FloatTensor timestep: Optional = None  ) → torch.FloatTensor  Parameters   sample (torch.FloatTensor) —
+The input sample.   timestep (int, optional) —
+The current timestep in the diffusion chain.   Returns 
+torch.FloatTensor
+  
+A scaled input sample.
+  Ensures interchangeability with schedulers that need to scale the denoising model input depending on the
+current timestep.  set_timesteps  < source > ( num_inference_steps: int device: Union = None  )   Parameters   num_inference_steps (int) —
+The number of diffusion steps used when generating samples with a pre-trained model.    Sets the discrete timesteps used for the diffusion chain (to be run before inference).  step  < source > ( model_output: FloatTensor timestep: int sample: FloatTensor eta: float = 0.0 use_clipped_model_output: bool = False generator = None variance_noise: Optional = None return_dict: bool = True  ) → ~schedulers.scheduling_utils.DDIMSchedulerOutput or tuple  Parameters   model_output (torch.FloatTensor) —
+The direct output from learned diffusion model.   timestep (float) —
+The current discrete timestep in the diffusion chain.   sample (torch.FloatTensor) —
+A current instance of a sample created by the diffusion process.   eta (float) —
+The weight of noise for added noise in diffusion step.   use_clipped_model_output (bool, defaults to False) —
+If True, computes “corrected” model_output from the clipped predicted original sample. Necessary
+because predicted original sample is clipped to [-1, 1] when self.config.clip_sample is True. If no
+clipping has happened, “corrected” model_output would coincide with the one provided as input and
+use_clipped_model_output has no effect.   generator (torch.Generator, optional) —
+A random number generator.   variance_noise (torch.FloatTensor) —
+Alternative to generating noise with generator by directly providing the noise for the variance
+itself. Useful for methods such as CycleDiffusion.   return_dict (bool, optional, defaults to True) —
+Whether or not to return a DDIMSchedulerOutput or tuple.   Returns 
+~schedulers.scheduling_utils.DDIMSchedulerOutput or tuple
+  
+If return_dict is True, DDIMSchedulerOutput is returned, otherwise a
+tuple is returned where the first element is the sample tensor.
+  Predict the sample from the previous timestep by reversing the SDE. This function propagates the diffusion
+process from the learned model outputs (most often the predicted noise).  DDIMSchedulerOutput  class diffusers.schedulers.scheduling_ddim.DDIMSchedulerOutput  < source > ( prev_sample: FloatTensor pred_original_sample: Optional = None  )   Parameters   prev_sample (torch.FloatTensor of shape (batch_size, num_channels, height, width) for images) —
+Computed sample (x_{t-1}) of previous timestep. prev_sample should be used as next model input in the
+denoising loop.   pred_original_sample (torch.FloatTensor of shape (batch_size, num_channels, height, width) for images) —
+The predicted denoised sample (x_{0}) based on the model output from the current timestep.
+pred_original_sample can be used to preview progress or for guidance.    Output class for the scheduler’s step function output.

scrapped_outputs/004a80e3475d06e8d1f59f3264b0d35b.txt

@@ -0,0 +1,215 @@
+Text-to-Video Generation with AnimateDiff  Overview AnimateDiff: Animate Your Personalized Text-to-Image Diffusion Models without Specific Tuning by Yuwei Guo, Ceyuan Yang, Anyi Rao, Yaohui Wang, Yu Qiao, Dahua Lin, Bo Dai. The abstract of the paper is the following: With the advance of text-to-image models (e.g., Stable Diffusion) and corresponding personalization techniques such as DreamBooth and LoRA, everyone can manifest their imagination into high-quality images at an affordable cost. Subsequently, there is a great demand for image animation techniques to further combine generated static images with motion dynamics. In this report, we propose a practical framework to animate most of the existing personalized text-to-image models once and for all, saving efforts in model-specific tuning. At the core of the proposed framework is to insert a newly initialized motion modeling module into the frozen text-to-image model and train it on video clips to distill reasonable motion priors. Once trained, by simply injecting this motion modeling module, all personalized versions derived from the same base T2I readily become text-driven models that produce diverse and personalized animated images. We conduct our evaluation on several public representative personalized text-to-image models across anime pictures and realistic photographs, and demonstrate that our proposed framework helps these models generate temporally smooth animation clips while preserving the domain and diversity of their outputs. Code and pre-trained weights will be publicly available at this https URL.  Available Pipelines Pipeline Tasks Demo AnimateDiffPipeline Text-to-Video Generation with AnimateDiff   Available checkpoints Motion Adapter checkpoints can be found under guoyww. These checkpoints are meant to work with any model based on Stable Diffusion 1.4/1.5.  Usage example AnimateDiff works with a MotionAdapter checkpoint and a Stable Diffusion model checkpoint. The MotionAdapter is a collection of Motion Modules that are responsible for adding coherent motion across image frames. These modules are applied after the Resnet and Attention blocks in Stable Diffusion UNet. The following example demonstrates how to use a MotionAdapter checkpoint with Diffusers for inference based on StableDiffusion-1.4/1.5.   Copied import torch
+from diffusers import AnimateDiffPipeline, DDIMScheduler, MotionAdapter
+from diffusers.utils import export_to_gif
+
+# Load the motion adapter
+adapter = MotionAdapter.from_pretrained("guoyww/animatediff-motion-adapter-v1-5-2", torch_dtype=torch.float16)
+# load SD 1.5 based finetuned model
+model_id = "SG161222/Realistic_Vision_V5.1_noVAE"
+pipe = AnimateDiffPipeline.from_pretrained(model_id, motion_adapter=adapter, torch_dtype=torch.float16)
+scheduler = DDIMScheduler.from_pretrained(
+    model_id,
+    subfolder="scheduler",
+    clip_sample=False,
+    timestep_spacing="linspace",
+    beta_schedule="linear",
+    steps_offset=1,
+)
+pipe.scheduler = scheduler
+
+# enable memory savings
+pipe.enable_vae_slicing()
+pipe.enable_model_cpu_offload()
+
+output = pipe(
+    prompt=(
+        "masterpiece, bestquality, highlydetailed, ultradetailed, sunset, "
+        "orange sky, warm lighting, fishing boats, ocean waves seagulls, "
+        "rippling water, wharf, silhouette, serene atmosphere, dusk, evening glow, "
+        "golden hour, coastal landscape, seaside scenery"
+    ),
+    negative_prompt="bad quality, worse quality",
+    num_frames=16,
+    guidance_scale=7.5,
+    num_inference_steps=25,
+    generator=torch.Generator("cpu").manual_seed(42),
+)
+frames = output.frames[0]
+export_to_gif(frames, "animation.gif")
+ Here are some sample outputs: masterpiece, bestquality, sunset.
+          AnimateDiff tends to work better with finetuned Stable Diffusion models. If you plan on using a scheduler that can clip samples, make sure to disable it by setting clip_sample=False in the scheduler as this can also have an adverse effect on generated samples. Additionally, the AnimateDiff checkpoints can be sensitive to the beta schedule of the scheduler. We recommend setting this to linear.  Using Motion LoRAs Motion LoRAs are a collection of LoRAs that work with the guoyww/animatediff-motion-adapter-v1-5-2 checkpoint. These LoRAs are responsible for adding specific types of motion to the animations.   Copied import torch
+from diffusers import AnimateDiffPipeline, DDIMScheduler, MotionAdapter
+from diffusers.utils import export_to_gif
+
+# Load the motion adapter
+adapter = MotionAdapter.from_pretrained("guoyww/animatediff-motion-adapter-v1-5-2", torch_dtype=torch.float16)
+# load SD 1.5 based finetuned model
+model_id = "SG161222/Realistic_Vision_V5.1_noVAE"
+pipe = AnimateDiffPipeline.from_pretrained(model_id, motion_adapter=adapter, torch_dtype=torch.float16)
+pipe.load_lora_weights(
+    "guoyww/animatediff-motion-lora-zoom-out", adapter_name="zoom-out"
+)
+
+scheduler = DDIMScheduler.from_pretrained(
+    model_id,
+    subfolder="scheduler",
+    clip_sample=False,
+    beta_schedule="linear",
+    timestep_spacing="linspace",
+    steps_offset=1,
+)
+pipe.scheduler = scheduler
+
+# enable memory savings
+pipe.enable_vae_slicing()
+pipe.enable_model_cpu_offload()
+
+output = pipe(
+    prompt=(
+        "masterpiece, bestquality, highlydetailed, ultradetailed, sunset, "
+        "orange sky, warm lighting, fishing boats, ocean waves seagulls, "
+        "rippling water, wharf, silhouette, serene atmosphere, dusk, evening glow, "
+        "golden hour, coastal landscape, seaside scenery"
+    ),
+    negative_prompt="bad quality, worse quality",
+    num_frames=16,
+    guidance_scale=7.5,
+    num_inference_steps=25,
+    generator=torch.Generator("cpu").manual_seed(42),
+)
+frames = output.frames[0]
+export_to_gif(frames, "animation.gif")
+ masterpiece, bestquality, sunset.
+           Using Motion LoRAs with PEFT You can also leverage the PEFT backend to combine Motion LoRA’s and create more complex animations. First install PEFT with   Copied pip install peft Then you can use the following code to combine Motion LoRAs.   Copied import torch
+from diffusers import AnimateDiffPipeline, DDIMScheduler, MotionAdapter
+from diffusers.utils import export_to_gif
+
+# Load the motion adapter
+adapter = MotionAdapter.from_pretrained("guoyww/animatediff-motion-adapter-v1-5-2", torch_dtype=torch.float16)
+# load SD 1.5 based finetuned model
+model_id = "SG161222/Realistic_Vision_V5.1_noVAE"
+pipe = AnimateDiffPipeline.from_pretrained(model_id, motion_adapter=adapter, torch_dtype=torch.float16)
+
+pipe.load_lora_weights(
+    "diffusers/animatediff-motion-lora-zoom-out", adapter_name="zoom-out",
+)
+pipe.load_lora_weights(
+    "diffusers/animatediff-motion-lora-pan-left", adapter_name="pan-left",
+)
+pipe.set_adapters(["zoom-out", "pan-left"], adapter_weights=[1.0, 1.0])
+
+scheduler = DDIMScheduler.from_pretrained(
+    model_id,
+    subfolder="scheduler",
+    clip_sample=False,
+    timestep_spacing="linspace",
+    beta_schedule="linear",
+    steps_offset=1,
+)
+pipe.scheduler = scheduler
+
+# enable memory savings
+pipe.enable_vae_slicing()
+pipe.enable_model_cpu_offload()
+
+output = pipe(
+    prompt=(
+        "masterpiece, bestquality, highlydetailed, ultradetailed, sunset, "
+        "orange sky, warm lighting, fishing boats, ocean waves seagulls, "
+        "rippling water, wharf, silhouette, serene atmosphere, dusk, evening glow, "
+        "golden hour, coastal landscape, seaside scenery"
+    ),
+    negative_prompt="bad quality, worse quality",
+    num_frames=16,
+    guidance_scale=7.5,
+    num_inference_steps=25,
+    generator=torch.Generator("cpu").manual_seed(42),
+)
+frames = output.frames[0]
+export_to_gif(frames, "animation.gif")
+ masterpiece, bestquality, sunset.
+          Make sure to check out the Schedulers guide to learn how to explore the tradeoff between scheduler speed and quality, and see the reuse components across pipelines section to learn how to efficiently load the same components into multiple pipelines.  AnimateDiffPipeline  class diffusers.AnimateDiffPipeline  < source > ( vae: AutoencoderKL text_encoder: CLIPTextModel tokenizer: CLIPTokenizer unet: UNet2DConditionModel motion_adapter: MotionAdapter scheduler: Union feature_extractor: CLIPImageProcessor = None image_encoder: CLIPVisionModelWithProjection = None  )   Parameters   vae (AutoencoderKL) —
+Variational Auto-Encoder (VAE) Model to encode and decode images to and from latent representations.   text_encoder (CLIPTextModel) —
+Frozen text-encoder (clip-vit-large-patch14).   tokenizer (CLIPTokenizer) —
+A CLIPTokenizer to tokenize text.   unet (UNet2DConditionModel) —
+A UNet2DConditionModel used to create a UNetMotionModel to denoise the encoded video latents.   motion_adapter (MotionAdapter) —
+A MotionAdapter to be used in combination with unet to denoise the encoded video latents.   scheduler (SchedulerMixin) —
+A scheduler to be used in combination with unet to denoise the encoded image latents. Can be one of
+DDIMScheduler, LMSDiscreteScheduler, or PNDMScheduler.    Pipeline for text-to-video generation. This model inherits from DiffusionPipeline. Check the superclass documentation for the generic methods
+implemented for all pipelines (downloading, saving, running on a particular device, etc.). The pipeline also inherits the following loading methods: load_textual_inversion() for loading textual inversion embeddings load_lora_weights() for loading LoRA weights save_lora_weights() for saving LoRA weights load_ip_adapter() for loading IP Adapters  __call__  < source > ( prompt: Union = None num_frames: Optional = 16 height: Optional = None width: Optional = None num_inference_steps: int = 50 guidance_scale: float = 7.5 negative_prompt: Union = None num_videos_per_prompt: Optional = 1 eta: float = 0.0 generator: Union = None latents: Optional = None prompt_embeds: Optional = None negative_prompt_embeds: Optional = None ip_adapter_image: Union = None output_type: Optional = 'pil' return_dict: bool = True callback: Optional = None callback_steps: Optional = 1 cross_attention_kwargs: Optional = None clip_skip: Optional = None  ) → TextToVideoSDPipelineOutput or tuple  Parameters   prompt (str or List[str], optional) —
+The prompt or prompts to guide image generation. If not defined, you need to pass prompt_embeds.   height (int, optional, defaults to self.unet.config.sample_size * self.vae_scale_factor) —
+The height in pixels of the generated video.   width (int, optional, defaults to self.unet.config.sample_size * self.vae_scale_factor) —
+The width in pixels of the generated video.   num_frames (int, optional, defaults to 16) —
+The number of video frames that are generated. Defaults to 16 frames which at 8 frames per seconds
+amounts to 2 seconds of video.   num_inference_steps (int, optional, defaults to 50) —
+The number of denoising steps. More denoising steps usually lead to a higher quality videos at the
+expense of slower inference.   guidance_scale (float, optional, defaults to 7.5) —
+A higher guidance scale value encourages the model to generate images closely linked to the text
+prompt at the expense of lower image quality. Guidance scale is enabled when guidance_scale > 1.   negative_prompt (str or List[str], optional) —
+The prompt or prompts to guide what to not include in image generation. If not defined, you need to
+pass negative_prompt_embeds instead. Ignored when not using guidance (guidance_scale < 1).   eta (float, optional, defaults to 0.0) —
+Corresponds to parameter eta (η) from the DDIM paper. Only applies
+to the DDIMScheduler, and is ignored in other schedulers.   generator (torch.Generator or List[torch.Generator], optional) —
+A torch.Generator to make
+generation deterministic.   latents (torch.FloatTensor, optional) —
+Pre-generated noisy latents sampled from a Gaussian distribution, to be used as inputs for video
+generation. Can be used to tweak the same generation with different prompts. If not provided, a latents
+tensor is generated by sampling using the supplied random generator. Latents should be of shape
+(batch_size, num_channel, num_frames, height, width).   prompt_embeds (torch.FloatTensor, optional) —
+Pre-generated text embeddings. Can be used to easily tweak text inputs (prompt weighting). If not
+provided, text embeddings are generated from the prompt input argument.   negative_prompt_embeds (torch.FloatTensor, optional) —
+Pre-generated negative text embeddings. Can be used to easily tweak text inputs (prompt weighting). If
+not provided, negative_prompt_embeds are generated from the negative_prompt input argument.
+ip_adapter_image — (PipelineImageInput, optional): Optional image input to work with IP Adapters.   output_type (str, optional, defaults to "pil") —
+The output format of the generated video. Choose between torch.FloatTensor, PIL.Image or
+np.array.   return_dict (bool, optional, defaults to True) —
+Whether or not to return a TextToVideoSDPipelineOutput instead
+of a plain tuple.   callback (Callable, optional) —
+A function that calls every callback_steps steps during inference. The function is called with the
+following arguments: callback(step: int, timestep: int, latents: torch.FloatTensor).   callback_steps (int, optional, defaults to 1) —
+The frequency at which the callback function is called. If not specified, the callback is called at
+every step.   cross_attention_kwargs (dict, optional) —
+A kwargs dictionary that if specified is passed along to the AttentionProcessor as defined in
+self.processor.   clip_skip (int, optional) —
+Number of layers to be skipped from CLIP while computing the prompt embeddings. A value of 1 means that
+the output of the pre-final layer will be used for computing the prompt embeddings.   Returns 
+TextToVideoSDPipelineOutput or tuple
+  
+If return_dict is True, TextToVideoSDPipelineOutput is
+returned, otherwise a tuple is returned where the first element is a list with the generated frames.
+  The call function to the pipeline for generation.  Examples:   Copied >>> import torch
+>>> from diffusers import MotionAdapter, AnimateDiffPipeline, DDIMScheduler
+>>> from diffusers.utils import export_to_gif
+
+>>> adapter = MotionAdapter.from_pretrained("guoyww/animatediff-motion-adapter-v1-5-2")
+>>> pipe = AnimateDiffPipeline.from_pretrained("frankjoshua/toonyou_beta6", motion_adapter=adapter)
+>>> pipe.scheduler = DDIMScheduler(beta_schedule="linear", steps_offset=1, clip_sample=False)
+>>> output = pipe(prompt="A corgi walking in the park")
+>>> frames = output.frames[0]
+>>> export_to_gif(frames, "animation.gif")  disable_freeu  < source > ( )    Disables the FreeU mechanism if enabled.  disable_vae_slicing  < source > ( )    Disable sliced VAE decoding. If enable_vae_slicing was previously enabled, this method will go back to
+computing decoding in one step.  disable_vae_tiling  < source > ( )    Disable tiled VAE decoding. If enable_vae_tiling was previously enabled, this method will go back to
+computing decoding in one step.  enable_freeu  < source > ( s1: float s2: float b1: float b2: float  )   Parameters   s1 (float) —
+Scaling factor for stage 1 to attenuate the contributions of the skip features. This is done to
+mitigate “oversmoothing effect” in the enhanced denoising process.   s2 (float) —
+Scaling factor for stage 2 to attenuate the contributions of the skip features. This is done to
+mitigate “oversmoothing effect” in the enhanced denoising process.   b1 (float) — Scaling factor for stage 1 to amplify the contributions of backbone features.   b2 (float) — Scaling factor for stage 2 to amplify the contributions of backbone features.    Enables the FreeU mechanism as in https://arxiv.org/abs/2309.11497. The suffixes after the scaling factors represent the stages where they are being applied. Please refer to the official repository for combinations of the values
+that are known to work well for different pipelines such as Stable Diffusion v1, v2, and Stable Diffusion XL.  enable_vae_slicing  < source > ( )    Enable sliced VAE decoding. When this option is enabled, the VAE will split the input tensor in slices to
+compute decoding in several steps. This is useful to save some memory and allow larger batch sizes.  enable_vae_tiling  < source > ( )    Enable tiled VAE decoding. When this option is enabled, the VAE will split the input tensor into tiles to
+compute decoding and encoding in several steps. This is useful for saving a large amount of memory and to allow
+processing larger images.  encode_prompt  < source > ( prompt device num_images_per_prompt do_classifier_free_guidance negative_prompt = None prompt_embeds: Optional = None negative_prompt_embeds: Optional = None lora_scale: Optional = None clip_skip: Optional = None  )   Parameters   prompt (str or List[str], optional) —
+prompt to be encoded
+device — (torch.device):
+torch device   num_images_per_prompt (int) —
+number of images that should be generated per prompt   do_classifier_free_guidance (bool) —
+whether to use classifier free guidance or not   negative_prompt (str or List[str], optional) —
+The prompt or prompts not to guide the image generation. If not defined, one has to pass
+negative_prompt_embeds instead. Ignored when not using guidance (i.e., ignored if guidance_scale is
+less than 1).   prompt_embeds (torch.FloatTensor, optional) —
+Pre-generated text embeddings. Can be used to easily tweak text inputs, e.g. prompt weighting. If not
+provided, text embeddings will be generated from prompt input argument.   negative_prompt_embeds (torch.FloatTensor, optional) —
+Pre-generated negative text embeddings. Can be used to easily tweak text inputs, e.g. prompt
+weighting. If not provided, negative_prompt_embeds will be generated from negative_prompt input
+argument.   lora_scale (float, optional) —
+A LoRA scale that will be applied to all LoRA layers of the text encoder if LoRA layers are loaded.   clip_skip (int, optional) —
+Number of layers to be skipped from CLIP while computing the prompt embeddings. A value of 1 means that
+the output of the pre-final layer will be used for computing the prompt embeddings.    Encodes the prompt into text encoder hidden states. enable_freeu disable_freeu enable_vae_slicing disable_vae_slicing enable_vae_tiling disable_vae_tiling  AnimateDiffPipelineOutput  class diffusers.pipelines.animatediff.AnimateDiffPipelineOutput  < source > ( frames: Union  )

scrapped_outputs/007512d8a5a14389eb3f6aa13d0f082f.txt

@@ -0,0 +1,255 @@
+DiffEdit DiffEdit: Diffusion-based semantic image editing with mask guidance is by Guillaume Couairon, Jakob Verbeek, Holger Schwenk, and Matthieu Cord. The abstract from the paper is: Image generation has recently seen tremendous advances, with diffusion models allowing to synthesize convincing images for a large variety of text prompts. In this article, we propose DiffEdit, a method to take advantage of text-conditioned diffusion models for the task of semantic image editing, where the goal is to edit an image based on a text query. Semantic image editing is an extension of image generation, with the additional constraint that the generated image should be as similar as possible to a given input image. Current editing methods based on diffusion models usually require to provide a mask, making the task much easier by treating it as a conditional inpainting task. In contrast, our main contribution is able to automatically generate a mask highlighting regions of the input image that need to be edited, by contrasting predictions of a diffusion model conditioned on different text prompts. Moreover, we rely on latent inference to preserve content in those regions of interest and show excellent synergies with mask-based diffusion. DiffEdit achieves state-of-the-art editing performance on ImageNet. In addition, we evaluate semantic image editing in more challenging settings, using images from the COCO dataset as well as text-based generated images. The original codebase can be found at Xiang-cd/DiffEdit-stable-diffusion, and you can try it out in this demo. This pipeline was contributed by clarencechen. ❤️  Tips The pipeline can generate masks that can be fed into other inpainting pipelines. In order to generate an image using this pipeline, both an image mask (source and target prompts can be manually specified or generated, and passed to generate_mask())
+and a set of partially inverted latents (generated using invert()) must be provided as arguments when calling the pipeline to generate the final edited image. The function generate_mask() exposes two prompt arguments, source_prompt and target_prompt
+that let you control the locations of the semantic edits in the final image to be generated. Let’s say,
+you wanted to translate from “cat” to “dog”. In this case, the edit direction will be “cat -> dog”. To reflect
+this in the generated mask, you simply have to set the embeddings related to the phrases including “cat” to
+source_prompt and “dog” to target_prompt. When generating partially inverted latents using invert, assign a caption or text embedding describing the
+overall image to the prompt argument to help guide the inverse latent sampling process. In most cases, the
+source concept is sufficiently descriptive to yield good results, but feel free to explore alternatives. When calling the pipeline to generate the final edited image, assign the source concept to negative_prompt
+and the target concept to prompt. Taking the above example, you simply have to set the embeddings related to
+the phrases including “cat” to negative_prompt and “dog” to prompt. If you wanted to reverse the direction in the example above, i.e., “dog -> cat”, then it’s recommended to:Swap the source_prompt and target_prompt in the arguments to generate_mask. Change the input prompt in invert() to include “dog”. Swap the prompt and negative_prompt in the arguments to call the pipeline to generate the final edited image. The source and target prompts, or their corresponding embeddings, can also be automatically generated. Please refer to the DiffEdit guide for more details.  StableDiffusionDiffEditPipeline  class diffusers.StableDiffusionDiffEditPipeline  < source > ( vae: AutoencoderKL text_encoder: CLIPTextModel tokenizer: CLIPTokenizer unet: UNet2DConditionModel scheduler: KarrasDiffusionSchedulers safety_checker: StableDiffusionSafetyChecker feature_extractor: CLIPImageProcessor inverse_scheduler: DDIMInverseScheduler requires_safety_checker: bool = True  )   Parameters   vae (AutoencoderKL) —
+Variational Auto-Encoder (VAE) model to encode and decode images to and from latent representations.   text_encoder (CLIPTextModel) —
+Frozen text-encoder (clip-vit-large-patch14).   tokenizer (CLIPTokenizer) —
+A CLIPTokenizer to tokenize text.   unet (UNet2DConditionModel) —
+A UNet2DConditionModel to denoise the encoded image latents.   scheduler (SchedulerMixin) —
+A scheduler to be used in combination with unet to denoise the encoded image latents.   inverse_scheduler (DDIMInverseScheduler) —
+A scheduler to be used in combination with unet to fill in the unmasked part of the input latents.   safety_checker (StableDiffusionSafetyChecker) —
+Classification module that estimates whether generated images could be considered offensive or harmful.
+Please refer to the model card for more details
+about a model’s potential harms.   feature_extractor (CLIPImageProcessor) —
+A CLIPImageProcessor to extract features from generated images; used as inputs to the safety_checker.    This is an experimental feature! Pipeline for text-guided image inpainting using Stable Diffusion and DiffEdit. This model inherits from DiffusionPipeline. Check the superclass documentation for the generic methods
+implemented for all pipelines (downloading, saving, running on a particular device, etc.). The pipeline also inherits the following loading and saving methods: load_textual_inversion() for loading textual inversion embeddings load_lora_weights() for loading LoRA weights save_lora_weights() for saving LoRA weights  generate_mask  < source > ( image: Union = None target_prompt: Union = None target_negative_prompt: Union = None target_prompt_embeds: Optional = None target_negative_prompt_embeds: Optional = None source_prompt: Union = None source_negative_prompt: Union = None source_prompt_embeds: Optional = None source_negative_prompt_embeds: Optional = None num_maps_per_mask: Optional = 10 mask_encode_strength: Optional = 0.5 mask_thresholding_ratio: Optional = 3.0 num_inference_steps: int = 50 guidance_scale: float = 7.5 generator: Union = None output_type: Optional = 'np' cross_attention_kwargs: Optional = None  ) → List[PIL.Image.Image] or np.array  Parameters   image (PIL.Image.Image) —
+Image or tensor representing an image batch to be used for computing the mask.   target_prompt (str or List[str], optional) —
+The prompt or prompts to guide semantic mask generation. If not defined, you need to pass
+prompt_embeds.   target_negative_prompt (str or List[str], optional) —
+The prompt or prompts to guide what to not include in image generation. If not defined, you need to
+pass negative_prompt_embeds instead. Ignored when not using guidance (guidance_scale < 1).   target_prompt_embeds (torch.FloatTensor, optional) —
+Pre-generated text embeddings. Can be used to easily tweak text inputs (prompt weighting). If not
+provided, text embeddings are generated from the prompt input argument.   target_negative_prompt_embeds (torch.FloatTensor, optional) —
+Pre-generated negative text embeddings. Can be used to easily tweak text inputs (prompt weighting). If
+not provided, negative_prompt_embeds are generated from the negative_prompt input argument.   source_prompt (str or List[str], optional) —
+The prompt or prompts to guide semantic mask generation using DiffEdit. If not defined, you need to
+pass source_prompt_embeds or source_image instead.   source_negative_prompt (str or List[str], optional) —
+The prompt or prompts to guide semantic mask generation away from using DiffEdit. If not defined, you
+need to pass source_negative_prompt_embeds or source_image instead.   source_prompt_embeds (torch.FloatTensor, optional) —
+Pre-generated text embeddings to guide the semantic mask generation. Can be used to easily tweak text
+inputs (prompt weighting). If not provided, text embeddings are generated from source_prompt input
+argument.   source_negative_prompt_embeds (torch.FloatTensor, optional) —
+Pre-generated text embeddings to negatively guide the semantic mask generation. Can be used to easily
+tweak text inputs (prompt weighting). If not provided, text embeddings are generated from
+source_negative_prompt input argument.   num_maps_per_mask (int, optional, defaults to 10) —
+The number of noise maps sampled to generate the semantic mask using DiffEdit.   mask_encode_strength (float, optional, defaults to 0.5) —
+The strength of the noise maps sampled to generate the semantic mask using DiffEdit. Must be between 0
+and 1.   mask_thresholding_ratio (float, optional, defaults to 3.0) —
+The maximum multiple of the mean absolute difference used to clamp the semantic guidance map before
+mask binarization.   num_inference_steps (int, optional, defaults to 50) —
+The number of denoising steps. More denoising steps usually lead to a higher quality image at the
+expense of slower inference.   guidance_scale (float, optional, defaults to 7.5) —
+A higher guidance scale value encourages the model to generate images closely linked to the text
+prompt at the expense of lower image quality. Guidance scale is enabled when guidance_scale > 1.   generator (torch.Generator or List[torch.Generator], optional) —
+A torch.Generator to make
+generation deterministic.   output_type (str, optional, defaults to "pil") —
+The output format of the generated image. Choose between PIL.Image or np.array.   cross_attention_kwargs (dict, optional) —
+A kwargs dictionary that if specified is passed along to the
+AttnProcessor as defined in
+self.processor.   Returns 
+List[PIL.Image.Image] or np.array
+  
+When returning a List[PIL.Image.Image], the list consists of a batch of single-channel binary images
+with dimensions (height // self.vae_scale_factor, width // self.vae_scale_factor). If it’s
+np.array, the shape is (batch_size, height // self.vae_scale_factor, width // self.vae_scale_factor).
+  Generate a latent mask given a mask prompt, a target prompt, and an image.    Copied >>> import PIL
+>>> import requests
+>>> import torch
+>>> from io import BytesIO
+
+>>> from diffusers import StableDiffusionDiffEditPipeline
+
+
+>>> def download_image(url):
+...     response = requests.get(url)
+...     return PIL.Image.open(BytesIO(response.content)).convert("RGB")
+
+
+>>> img_url = "https://github.com/Xiang-cd/DiffEdit-stable-diffusion/raw/main/assets/origin.png"
+
+>>> init_image = download_image(img_url).resize((768, 768))
+
+>>> pipe = StableDiffusionDiffEditPipeline.from_pretrained(
+...     "stabilityai/stable-diffusion-2-1", torch_dtype=torch.float16
+... )
+>>> pipe = pipe.to("cuda")
+
+>>> pipeline.scheduler = DDIMScheduler.from_config(pipeline.scheduler.config)
+>>> pipeline.inverse_scheduler = DDIMInverseScheduler.from_config(pipeline.scheduler.config)
+>>> pipeline.enable_model_cpu_offload()
+
+>>> mask_prompt = "A bowl of fruits"
+>>> prompt = "A bowl of pears"
+
+>>> mask_image = pipe.generate_mask(image=init_image, source_prompt=prompt, target_prompt=mask_prompt)
+>>> image_latents = pipe.invert(image=init_image, prompt=mask_prompt).latents
+>>> image = pipe(prompt=prompt, mask_image=mask_image, image_latents=image_latents).images[0]  invert  < source > ( prompt: Union = None image: Union = None num_inference_steps: int = 50 inpaint_strength: float = 0.8 guidance_scale: float = 7.5 negative_prompt: Union = None generator: Union = None prompt_embeds: Optional = None negative_prompt_embeds: Optional = None decode_latents: bool = False output_type: Optional = 'pil' return_dict: bool = True callback: Optional = None callback_steps: Optional = 1 cross_attention_kwargs: Optional = None lambda_auto_corr: float = 20.0 lambda_kl: float = 20.0 num_reg_steps: int = 0 num_auto_corr_rolls: int = 5  )   Parameters   prompt (str or List[str], optional) —
+The prompt or prompts to guide image generation. If not defined, you need to pass prompt_embeds.   image (PIL.Image.Image) —
+Image or tensor representing an image batch to produce the inverted latents guided by prompt.   inpaint_strength (float, optional, defaults to 0.8) —
+Indicates extent of the noising process to run latent inversion. Must be between 0 and 1. When
+inpaint_strength is 1, the inversion process is run for the full number of iterations specified in
+num_inference_steps. image is used as a reference for the inversion process, and adding more noise
+increases inpaint_strength. If inpaint_strength is 0, no inpainting occurs.   num_inference_steps (int, optional, defaults to 50) —
+The number of denoising steps. More denoising steps usually lead to a higher quality image at the
+expense of slower inference.   guidance_scale (float, optional, defaults to 7.5) —
+A higher guidance scale value encourages the model to generate images closely linked to the text
+prompt at the expense of lower image quality. Guidance scale is enabled when guidance_scale > 1.   negative_prompt (str or List[str], optional) —
+The prompt or prompts to guide what to not include in image generation. If not defined, you need to
+pass negative_prompt_embeds instead. Ignored when not using guidance (guidance_scale < 1).   generator (torch.Generator, optional) —
+A torch.Generator to make
+generation deterministic.   prompt_embeds (torch.FloatTensor, optional) —
+Pre-generated text embeddings. Can be used to easily tweak text inputs (prompt weighting). If not
+provided, text embeddings are generated from the prompt input argument.   negative_prompt_embeds (torch.FloatTensor, optional) —
+Pre-generated negative text embeddings. Can be used to easily tweak text inputs (prompt weighting). If
+not provided, negative_prompt_embeds are generated from the negative_prompt input argument.   decode_latents (bool, optional, defaults to False) —
+Whether or not to decode the inverted latents into a generated image. Setting this argument to True
+decodes all inverted latents for each timestep into a list of generated images.   output_type (str, optional, defaults to "pil") —
+The output format of the generated image. Choose between PIL.Image or np.array.   return_dict (bool, optional, defaults to True) —
+Whether or not to return a ~pipelines.stable_diffusion.DiffEditInversionPipelineOutput instead of a
+plain tuple.   callback (Callable, optional) —
+A function that calls every callback_steps steps during inference. The function is called with the
+following arguments: callback(step: int, timestep: int, latents: torch.FloatTensor).   callback_steps (int, optional, defaults to 1) —
+The frequency at which the callback function is called. If not specified, the callback is called at
+every step.   cross_attention_kwargs (dict, optional) —
+A kwargs dictionary that if specified is passed along to the
+AttnProcessor as defined in
+self.processor.   lambda_auto_corr (float, optional, defaults to 20.0) —
+Lambda parameter to control auto correction.   lambda_kl (float, optional, defaults to 20.0) —
+Lambda parameter to control Kullback-Leibler divergence output.   num_reg_steps (int, optional, defaults to 0) —
+Number of regularization loss steps.   num_auto_corr_rolls (int, optional, defaults to 5) —
+Number of auto correction roll steps.    Generate inverted latents given a prompt and image.    Copied >>> import PIL
+>>> import requests
+>>> import torch
+>>> from io import BytesIO
+
+>>> from diffusers import StableDiffusionDiffEditPipeline
+
+
+>>> def download_image(url):
+...     response = requests.get(url)
+...     return PIL.Image.open(BytesIO(response.content)).convert("RGB")
+
+
+>>> img_url = "https://github.com/Xiang-cd/DiffEdit-stable-diffusion/raw/main/assets/origin.png"
+
+>>> init_image = download_image(img_url).resize((768, 768))
+
+>>> pipe = StableDiffusionDiffEditPipeline.from_pretrained(
+...     "stabilityai/stable-diffusion-2-1", torch_dtype=torch.float16
+... )
+>>> pipe = pipe.to("cuda")
+
+>>> pipeline.scheduler = DDIMScheduler.from_config(pipeline.scheduler.config)
+>>> pipeline.inverse_scheduler = DDIMInverseScheduler.from_config(pipeline.scheduler.config)
+>>> pipeline.enable_model_cpu_offload()
+
+>>> prompt = "A bowl of fruits"
+
+>>> inverted_latents = pipe.invert(image=init_image, prompt=prompt).latents  __call__  < source > ( prompt: Union = None mask_image: Union = None image_latents: Union = None inpaint_strength: Optional = 0.8 num_inference_steps: int = 50 guidance_scale: float = 7.5 negative_prompt: Union = None num_images_per_prompt: Optional = 1 eta: float = 0.0 generator: Union = None latents: Optional = None prompt_embeds: Optional = None negative_prompt_embeds: Optional = None output_type: Optional = 'pil' return_dict: bool = True callback: Optional = None callback_steps: int = 1 cross_attention_kwargs: Optional = None clip_ckip: int = None  ) → StableDiffusionPipelineOutput or tuple  Parameters   prompt (str or List[str], optional) —
+The prompt or prompts to guide image generation. If not defined, you need to pass prompt_embeds.   mask_image (PIL.Image.Image) —
+Image or tensor representing an image batch to mask the generated image. White pixels in the mask are
+repainted, while black pixels are preserved. If mask_image is a PIL image, it is converted to a
+single channel (luminance) before use. If it’s a tensor, it should contain one color channel (L)
+instead of 3, so the expected shape would be (B, 1, H, W).   image_latents (PIL.Image.Image or torch.FloatTensor) —
+Partially noised image latents from the inversion process to be used as inputs for image generation.   inpaint_strength (float, optional, defaults to 0.8) —
+Indicates extent to inpaint the masked area. Must be between 0 and 1. When inpaint_strength is 1, the
+denoising process is run on the masked area for the full number of iterations specified in
+num_inference_steps. image_latents is used as a reference for the masked area, and adding more
+noise to a region increases inpaint_strength. If inpaint_strength is 0, no inpainting occurs.   num_inference_steps (int, optional, defaults to 50) —
+The number of denoising steps. More denoising steps usually lead to a higher quality image at the
+expense of slower inference.   guidance_scale (float, optional, defaults to 7.5) —
+A higher guidance scale value encourages the model to generate images closely linked to the text
+prompt at the expense of lower image quality. Guidance scale is enabled when guidance_scale > 1.   negative_prompt (str or List[str], optional) —
+The prompt or prompts to guide what to not include in image generation. If not defined, you need to
+pass negative_prompt_embeds instead. Ignored when not using guidance (guidance_scale < 1).   num_images_per_prompt (int, optional, defaults to 1) —
+The number of images to generate per prompt.   eta (float, optional, defaults to 0.0) —
+Corresponds to parameter eta (η) from the DDIM paper. Only applies
+to the DDIMScheduler, and is ignored in other schedulers.   generator (torch.Generator, optional) —
+A torch.Generator to make
+generation deterministic.   latents (torch.FloatTensor, optional) —
+Pre-generated noisy latents sampled from a Gaussian distribution, to be used as inputs for image
+generation. Can be used to tweak the same generation with different prompts. If not provided, a latents
+tensor is generated by sampling using the supplied random generator.   prompt_embeds (torch.FloatTensor, optional) —
+Pre-generated text embeddings. Can be used to easily tweak text inputs (prompt weighting). If not
+provided, text embeddings are generated from the prompt input argument.   negative_prompt_embeds (torch.FloatTensor, optional) —
+Pre-generated negative text embeddings. Can be used to easily tweak text inputs (prompt weighting). If
+not provided, negative_prompt_embeds are generated from the negative_prompt input argument.   output_type (str, optional, defaults to "pil") —
+The output format of the generated image. Choose between PIL.Image or np.array.   return_dict (bool, optional, defaults to True) —
+Whether or not to return a StableDiffusionPipelineOutput instead of a
+plain tuple.   callback (Callable, optional) —
+A function that calls every callback_steps steps during inference. The function is called with the
+following arguments: callback(step: int, timestep: int, latents: torch.FloatTensor).   callback_steps (int, optional, defaults to 1) —
+The frequency at which the callback function is called. If not specified, the callback is called at
+every step.   cross_attention_kwargs (dict, optional) —
+A kwargs dictionary that if specified is passed along to the AttentionProcessor as defined in
+self.processor.   clip_skip (int, optional) —
+Number of layers to be skipped from CLIP while computing the prompt embeddings. A value of 1 means that
+the output of the pre-final layer will be used for computing the prompt embeddings.   Returns 
+StableDiffusionPipelineOutput or tuple
+  
+If return_dict is True, StableDiffusionPipelineOutput is returned,
+otherwise a tuple is returned where the first element is a list with the generated images and the
+second element is a list of bools indicating whether the corresponding generated image contains
+“not-safe-for-work” (nsfw) content.
+  The call function to the pipeline for generation.    Copied >>> import PIL
+>>> import requests
+>>> import torch
+>>> from io import BytesIO
+
+>>> from diffusers import StableDiffusionDiffEditPipeline
+
+
+>>> def download_image(url):
+...     response = requests.get(url)
+...     return PIL.Image.open(BytesIO(response.content)).convert("RGB")
+
+
+>>> img_url = "https://github.com/Xiang-cd/DiffEdit-stable-diffusion/raw/main/assets/origin.png"
+
+>>> init_image = download_image(img_url).resize((768, 768))
+
+>>> pipe = StableDiffusionDiffEditPipeline.from_pretrained(
+...     "stabilityai/stable-diffusion-2-1", torch_dtype=torch.float16
+... )
+>>> pipe = pipe.to("cuda")
+
+>>> pipeline.scheduler = DDIMScheduler.from_config(pipeline.scheduler.config)
+>>> pipeline.inverse_scheduler = DDIMInverseScheduler.from_config(pipeline.scheduler.config)
+>>> pipeline.enable_model_cpu_offload()
+
+>>> mask_prompt = "A bowl of fruits"
+>>> prompt = "A bowl of pears"
+
+>>> mask_image = pipe.generate_mask(image=init_image, source_prompt=prompt, target_prompt=mask_prompt)
+>>> image_latents = pipe.invert(image=init_image, prompt=mask_prompt).latents
+>>> image = pipe(prompt=prompt, mask_image=mask_image, image_latents=image_latents).images[0]  disable_vae_slicing  < source > ( )    Disable sliced VAE decoding. If enable_vae_slicing was previously enabled, this method will go back to
+computing decoding in one step.  disable_vae_tiling  < source > ( )    Disable tiled VAE decoding. If enable_vae_tiling was previously enabled, this method will go back to
+computing decoding in one step.  enable_vae_slicing  < source > ( )    Enable sliced VAE decoding. When this option is enabled, the VAE will split the input tensor in slices to
+compute decoding in several steps. This is useful to save some memory and allow larger batch sizes.  enable_vae_tiling  < source > ( )    Enable tiled VAE decoding. When this option is enabled, the VAE will split the input tensor into tiles to
+compute decoding and encoding in several steps. This is useful for saving a large amount of memory and to allow
+processing larger images.  encode_prompt  < source > ( prompt device num_images_per_prompt do_classifier_free_guidance negative_prompt = None prompt_embeds: Optional = None negative_prompt_embeds: Optional = None lora_scale: Optional = None clip_skip: Optional = None  )   Parameters   prompt (str or List[str], optional) —
+prompt to be encoded
+device — (torch.device):
+torch device   num_images_per_prompt (int) —
+number of images that should be generated per prompt   do_classifier_free_guidance (bool) —
+whether to use classifier free guidance or not   negative_prompt (str or List[str], optional) —
+The prompt or prompts not to guide the image generation. If not defined, one has to pass
+negative_prompt_embeds instead. Ignored when not using guidance (i.e., ignored if guidance_scale is
+less than 1).   prompt_embeds (torch.FloatTensor, optional) —
+Pre-generated text embeddings. Can be used to easily tweak text inputs, e.g. prompt weighting. If not
+provided, text embeddings will be generated from prompt input argument.   negative_prompt_embeds (torch.FloatTensor, optional) —
+Pre-generated negative text embeddings. Can be used to easily tweak text inputs, e.g. prompt
+weighting. If not provided, negative_prompt_embeds will be generated from negative_prompt input
+argument.   lora_scale (float, optional) —
+A LoRA scale that will be applied to all LoRA layers of the text encoder if LoRA layers are loaded.   clip_skip (int, optional) —
+Number of layers to be skipped from CLIP while computing the prompt embeddings. A value of 1 means that
+the output of the pre-final layer will be used for computing the prompt embeddings.    Encodes the prompt into text encoder hidden states.  StableDiffusionPipelineOutput  class diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput  < source > ( images: Union nsfw_content_detected: Optional  )   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).   nsfw_content_detected (List[bool]) —
+List indicating whether the corresponding generated image contains “not-safe-for-work” (nsfw) content or
+None if safety checking could not be performed.    Output class for Stable Diffusion pipelines.

scrapped_outputs/009a3df3d8ecf57196b920d396c1eb45.txt

@@ -0,0 +1,215 @@
+Text-to-Video Generation with AnimateDiff  Overview AnimateDiff: Animate Your Personalized Text-to-Image Diffusion Models without Specific Tuning by Yuwei Guo, Ceyuan Yang, Anyi Rao, Yaohui Wang, Yu Qiao, Dahua Lin, Bo Dai. The abstract of the paper is the following: With the advance of text-to-image models (e.g., Stable Diffusion) and corresponding personalization techniques such as DreamBooth and LoRA, everyone can manifest their imagination into high-quality images at an affordable cost. Subsequently, there is a great demand for image animation techniques to further combine generated static images with motion dynamics. In this report, we propose a practical framework to animate most of the existing personalized text-to-image models once and for all, saving efforts in model-specific tuning. At the core of the proposed framework is to insert a newly initialized motion modeling module into the frozen text-to-image model and train it on video clips to distill reasonable motion priors. Once trained, by simply injecting this motion modeling module, all personalized versions derived from the same base T2I readily become text-driven models that produce diverse and personalized animated images. We conduct our evaluation on several public representative personalized text-to-image models across anime pictures and realistic photographs, and demonstrate that our proposed framework helps these models generate temporally smooth animation clips while preserving the domain and diversity of their outputs. Code and pre-trained weights will be publicly available at this https URL.  Available Pipelines Pipeline Tasks Demo AnimateDiffPipeline Text-to-Video Generation with AnimateDiff   Available checkpoints Motion Adapter checkpoints can be found under guoyww. These checkpoints are meant to work with any model based on Stable Diffusion 1.4/1.5.  Usage example AnimateDiff works with a MotionAdapter checkpoint and a Stable Diffusion model checkpoint. The MotionAdapter is a collection of Motion Modules that are responsible for adding coherent motion across image frames. These modules are applied after the Resnet and Attention blocks in Stable Diffusion UNet. The following example demonstrates how to use a MotionAdapter checkpoint with Diffusers for inference based on StableDiffusion-1.4/1.5.   Copied import torch
+from diffusers import AnimateDiffPipeline, DDIMScheduler, MotionAdapter
+from diffusers.utils import export_to_gif
+
+# Load the motion adapter
+adapter = MotionAdapter.from_pretrained("guoyww/animatediff-motion-adapter-v1-5-2", torch_dtype=torch.float16)
+# load SD 1.5 based finetuned model
+model_id = "SG161222/Realistic_Vision_V5.1_noVAE"
+pipe = AnimateDiffPipeline.from_pretrained(model_id, motion_adapter=adapter, torch_dtype=torch.float16)
+scheduler = DDIMScheduler.from_pretrained(
+    model_id,
+    subfolder="scheduler",
+    clip_sample=False,
+    timestep_spacing="linspace",
+    beta_schedule="linear",
+    steps_offset=1,
+)
+pipe.scheduler = scheduler
+
+# enable memory savings
+pipe.enable_vae_slicing()
+pipe.enable_model_cpu_offload()
+
+output = pipe(
+    prompt=(
+        "masterpiece, bestquality, highlydetailed, ultradetailed, sunset, "
+        "orange sky, warm lighting, fishing boats, ocean waves seagulls, "
+        "rippling water, wharf, silhouette, serene atmosphere, dusk, evening glow, "
+        "golden hour, coastal landscape, seaside scenery"
+    ),
+    negative_prompt="bad quality, worse quality",
+    num_frames=16,
+    guidance_scale=7.5,
+    num_inference_steps=25,
+    generator=torch.Generator("cpu").manual_seed(42),
+)
+frames = output.frames[0]
+export_to_gif(frames, "animation.gif")
+ Here are some sample outputs: masterpiece, bestquality, sunset.
+          AnimateDiff tends to work better with finetuned Stable Diffusion models. If you plan on using a scheduler that can clip samples, make sure to disable it by setting clip_sample=False in the scheduler as this can also have an adverse effect on generated samples. Additionally, the AnimateDiff checkpoints can be sensitive to the beta schedule of the scheduler. We recommend setting this to linear.  Using Motion LoRAs Motion LoRAs are a collection of LoRAs that work with the guoyww/animatediff-motion-adapter-v1-5-2 checkpoint. These LoRAs are responsible for adding specific types of motion to the animations.   Copied import torch
+from diffusers import AnimateDiffPipeline, DDIMScheduler, MotionAdapter
+from diffusers.utils import export_to_gif
+
+# Load the motion adapter
+adapter = MotionAdapter.from_pretrained("guoyww/animatediff-motion-adapter-v1-5-2", torch_dtype=torch.float16)
+# load SD 1.5 based finetuned model
+model_id = "SG161222/Realistic_Vision_V5.1_noVAE"
+pipe = AnimateDiffPipeline.from_pretrained(model_id, motion_adapter=adapter, torch_dtype=torch.float16)
+pipe.load_lora_weights(
+    "guoyww/animatediff-motion-lora-zoom-out", adapter_name="zoom-out"
+)
+
+scheduler = DDIMScheduler.from_pretrained(
+    model_id,
+    subfolder="scheduler",
+    clip_sample=False,
+    beta_schedule="linear",
+    timestep_spacing="linspace",
+    steps_offset=1,
+)
+pipe.scheduler = scheduler
+
+# enable memory savings
+pipe.enable_vae_slicing()
+pipe.enable_model_cpu_offload()
+
+output = pipe(
+    prompt=(
+        "masterpiece, bestquality, highlydetailed, ultradetailed, sunset, "
+        "orange sky, warm lighting, fishing boats, ocean waves seagulls, "
+        "rippling water, wharf, silhouette, serene atmosphere, dusk, evening glow, "
+        "golden hour, coastal landscape, seaside scenery"
+    ),
+    negative_prompt="bad quality, worse quality",
+    num_frames=16,
+    guidance_scale=7.5,
+    num_inference_steps=25,
+    generator=torch.Generator("cpu").manual_seed(42),
+)
+frames = output.frames[0]
+export_to_gif(frames, "animation.gif")
+ masterpiece, bestquality, sunset.
+           Using Motion LoRAs with PEFT You can also leverage the PEFT backend to combine Motion LoRA’s and create more complex animations. First install PEFT with   Copied pip install peft Then you can use the following code to combine Motion LoRAs.   Copied import torch
+from diffusers import AnimateDiffPipeline, DDIMScheduler, MotionAdapter
+from diffusers.utils import export_to_gif
+
+# Load the motion adapter
+adapter = MotionAdapter.from_pretrained("guoyww/animatediff-motion-adapter-v1-5-2", torch_dtype=torch.float16)
+# load SD 1.5 based finetuned model
+model_id = "SG161222/Realistic_Vision_V5.1_noVAE"
+pipe = AnimateDiffPipeline.from_pretrained(model_id, motion_adapter=adapter, torch_dtype=torch.float16)
+
+pipe.load_lora_weights(
+    "diffusers/animatediff-motion-lora-zoom-out", adapter_name="zoom-out",
+)
+pipe.load_lora_weights(
+    "diffusers/animatediff-motion-lora-pan-left", adapter_name="pan-left",
+)
+pipe.set_adapters(["zoom-out", "pan-left"], adapter_weights=[1.0, 1.0])
+
+scheduler = DDIMScheduler.from_pretrained(
+    model_id,
+    subfolder="scheduler",
+    clip_sample=False,
+    timestep_spacing="linspace",
+    beta_schedule="linear",
+    steps_offset=1,
+)
+pipe.scheduler = scheduler
+
+# enable memory savings
+pipe.enable_vae_slicing()
+pipe.enable_model_cpu_offload()
+
+output = pipe(
+    prompt=(
+        "masterpiece, bestquality, highlydetailed, ultradetailed, sunset, "
+        "orange sky, warm lighting, fishing boats, ocean waves seagulls, "
+        "rippling water, wharf, silhouette, serene atmosphere, dusk, evening glow, "
+        "golden hour, coastal landscape, seaside scenery"
+    ),
+    negative_prompt="bad quality, worse quality",
+    num_frames=16,
+    guidance_scale=7.5,
+    num_inference_steps=25,
+    generator=torch.Generator("cpu").manual_seed(42),
+)
+frames = output.frames[0]
+export_to_gif(frames, "animation.gif")
+ masterpiece, bestquality, sunset.
+          Make sure to check out the Schedulers guide to learn how to explore the tradeoff between scheduler speed and quality, and see the reuse components across pipelines section to learn how to efficiently load the same components into multiple pipelines.  AnimateDiffPipeline  class diffusers.AnimateDiffPipeline  < source > ( vae: AutoencoderKL text_encoder: CLIPTextModel tokenizer: CLIPTokenizer unet: UNet2DConditionModel motion_adapter: MotionAdapter scheduler: Union feature_extractor: CLIPImageProcessor = None image_encoder: CLIPVisionModelWithProjection = None  )   Parameters   vae (AutoencoderKL) —
+Variational Auto-Encoder (VAE) Model to encode and decode images to and from latent representations.   text_encoder (CLIPTextModel) —
+Frozen text-encoder (clip-vit-large-patch14).   tokenizer (CLIPTokenizer) —
+A CLIPTokenizer to tokenize text.   unet (UNet2DConditionModel) —
+A UNet2DConditionModel used to create a UNetMotionModel to denoise the encoded video latents.   motion_adapter (MotionAdapter) —
+A MotionAdapter to be used in combination with unet to denoise the encoded video latents.   scheduler (SchedulerMixin) —
+A scheduler to be used in combination with unet to denoise the encoded image latents. Can be one of
+DDIMScheduler, LMSDiscreteScheduler, or PNDMScheduler.    Pipeline for text-to-video generation. This model inherits from DiffusionPipeline. Check the superclass documentation for the generic methods
+implemented for all pipelines (downloading, saving, running on a particular device, etc.). The pipeline also inherits the following loading methods: load_textual_inversion() for loading textual inversion embeddings load_lora_weights() for loading LoRA weights save_lora_weights() for saving LoRA weights load_ip_adapter() for loading IP Adapters  __call__  < source > ( prompt: Union = None num_frames: Optional = 16 height: Optional = None width: Optional = None num_inference_steps: int = 50 guidance_scale: float = 7.5 negative_prompt: Union = None num_videos_per_prompt: Optional = 1 eta: float = 0.0 generator: Union = None latents: Optional = None prompt_embeds: Optional = None negative_prompt_embeds: Optional = None ip_adapter_image: Union = None output_type: Optional = 'pil' return_dict: bool = True callback: Optional = None callback_steps: Optional = 1 cross_attention_kwargs: Optional = None clip_skip: Optional = None  ) → TextToVideoSDPipelineOutput or tuple  Parameters   prompt (str or List[str], optional) —
+The prompt or prompts to guide image generation. If not defined, you need to pass prompt_embeds.   height (int, optional, defaults to self.unet.config.sample_size * self.vae_scale_factor) —
+The height in pixels of the generated video.   width (int, optional, defaults to self.unet.config.sample_size * self.vae_scale_factor) —
+The width in pixels of the generated video.   num_frames (int, optional, defaults to 16) —
+The number of video frames that are generated. Defaults to 16 frames which at 8 frames per seconds
+amounts to 2 seconds of video.   num_inference_steps (int, optional, defaults to 50) —
+The number of denoising steps. More denoising steps usually lead to a higher quality videos at the
+expense of slower inference.   guidance_scale (float, optional, defaults to 7.5) —
+A higher guidance scale value encourages the model to generate images closely linked to the text
+prompt at the expense of lower image quality. Guidance scale is enabled when guidance_scale > 1.   negative_prompt (str or List[str], optional) —
+The prompt or prompts to guide what to not include in image generation. If not defined, you need to
+pass negative_prompt_embeds instead. Ignored when not using guidance (guidance_scale < 1).   eta (float, optional, defaults to 0.0) —
+Corresponds to parameter eta (η) from the DDIM paper. Only applies
+to the DDIMScheduler, and is ignored in other schedulers.   generator (torch.Generator or List[torch.Generator], optional) —
+A torch.Generator to make
+generation deterministic.   latents (torch.FloatTensor, optional) —
+Pre-generated noisy latents sampled from a Gaussian distribution, to be used as inputs for video
+generation. Can be used to tweak the same generation with different prompts. If not provided, a latents
+tensor is generated by sampling using the supplied random generator. Latents should be of shape
+(batch_size, num_channel, num_frames, height, width).   prompt_embeds (torch.FloatTensor, optional) —
+Pre-generated text embeddings. Can be used to easily tweak text inputs (prompt weighting). If not
+provided, text embeddings are generated from the prompt input argument.   negative_prompt_embeds (torch.FloatTensor, optional) —
+Pre-generated negative text embeddings. Can be used to easily tweak text inputs (prompt weighting). If
+not provided, negative_prompt_embeds are generated from the negative_prompt input argument.
+ip_adapter_image — (PipelineImageInput, optional): Optional image input to work with IP Adapters.   output_type (str, optional, defaults to "pil") —
+The output format of the generated video. Choose between torch.FloatTensor, PIL.Image or
+np.array.   return_dict (bool, optional, defaults to True) —
+Whether or not to return a TextToVideoSDPipelineOutput instead
+of a plain tuple.   callback (Callable, optional) —
+A function that calls every callback_steps steps during inference. The function is called with the
+following arguments: callback(step: int, timestep: int, latents: torch.FloatTensor).   callback_steps (int, optional, defaults to 1) —
+The frequency at which the callback function is called. If not specified, the callback is called at
+every step.   cross_attention_kwargs (dict, optional) —
+A kwargs dictionary that if specified is passed along to the AttentionProcessor as defined in
+self.processor.   clip_skip (int, optional) —
+Number of layers to be skipped from CLIP while computing the prompt embeddings. A value of 1 means that
+the output of the pre-final layer will be used for computing the prompt embeddings.   Returns 
+TextToVideoSDPipelineOutput or tuple
+  
+If return_dict is True, TextToVideoSDPipelineOutput is
+returned, otherwise a tuple is returned where the first element is a list with the generated frames.
+  The call function to the pipeline for generation.  Examples:   Copied >>> import torch
+>>> from diffusers import MotionAdapter, AnimateDiffPipeline, DDIMScheduler
+>>> from diffusers.utils import export_to_gif
+
+>>> adapter = MotionAdapter.from_pretrained("guoyww/animatediff-motion-adapter-v1-5-2")
+>>> pipe = AnimateDiffPipeline.from_pretrained("frankjoshua/toonyou_beta6", motion_adapter=adapter)
+>>> pipe.scheduler = DDIMScheduler(beta_schedule="linear", steps_offset=1, clip_sample=False)
+>>> output = pipe(prompt="A corgi walking in the park")
+>>> frames = output.frames[0]
+>>> export_to_gif(frames, "animation.gif")  disable_freeu  < source > ( )    Disables the FreeU mechanism if enabled.  disable_vae_slicing  < source > ( )    Disable sliced VAE decoding. If enable_vae_slicing was previously enabled, this method will go back to
+computing decoding in one step.  disable_vae_tiling  < source > ( )    Disable tiled VAE decoding. If enable_vae_tiling was previously enabled, this method will go back to
+computing decoding in one step.  enable_freeu  < source > ( s1: float s2: float b1: float b2: float  )   Parameters   s1 (float) —
+Scaling factor for stage 1 to attenuate the contributions of the skip features. This is done to
+mitigate “oversmoothing effect” in the enhanced denoising process.   s2 (float) —
+Scaling factor for stage 2 to attenuate the contributions of the skip features. This is done to
+mitigate “oversmoothing effect” in the enhanced denoising process.   b1 (float) — Scaling factor for stage 1 to amplify the contributions of backbone features.   b2 (float) — Scaling factor for stage 2 to amplify the contributions of backbone features.    Enables the FreeU mechanism as in https://arxiv.org/abs/2309.11497. The suffixes after the scaling factors represent the stages where they are being applied. Please refer to the official repository for combinations of the values
+that are known to work well for different pipelines such as Stable Diffusion v1, v2, and Stable Diffusion XL.  enable_vae_slicing  < source > ( )    Enable sliced VAE decoding. When this option is enabled, the VAE will split the input tensor in slices to
+compute decoding in several steps. This is useful to save some memory and allow larger batch sizes.  enable_vae_tiling  < source > ( )    Enable tiled VAE decoding. When this option is enabled, the VAE will split the input tensor into tiles to
+compute decoding and encoding in several steps. This is useful for saving a large amount of memory and to allow
+processing larger images.  encode_prompt  < source > ( prompt device num_images_per_prompt do_classifier_free_guidance negative_prompt = None prompt_embeds: Optional = None negative_prompt_embeds: Optional = None lora_scale: Optional = None clip_skip: Optional = None  )   Parameters   prompt (str or List[str], optional) —
+prompt to be encoded
+device — (torch.device):
+torch device   num_images_per_prompt (int) —
+number of images that should be generated per prompt   do_classifier_free_guidance (bool) —
+whether to use classifier free guidance or not   negative_prompt (str or List[str], optional) —
+The prompt or prompts not to guide the image generation. If not defined, one has to pass
+negative_prompt_embeds instead. Ignored when not using guidance (i.e., ignored if guidance_scale is
+less than 1).   prompt_embeds (torch.FloatTensor, optional) —
+Pre-generated text embeddings. Can be used to easily tweak text inputs, e.g. prompt weighting. If not
+provided, text embeddings will be generated from prompt input argument.   negative_prompt_embeds (torch.FloatTensor, optional) —
+Pre-generated negative text embeddings. Can be used to easily tweak text inputs, e.g. prompt
+weighting. If not provided, negative_prompt_embeds will be generated from negative_prompt input
+argument.   lora_scale (float, optional) —
+A LoRA scale that will be applied to all LoRA layers of the text encoder if LoRA layers are loaded.   clip_skip (int, optional) —
+Number of layers to be skipped from CLIP while computing the prompt embeddings. A value of 1 means that
+the output of the pre-final layer will be used for computing the prompt embeddings.    Encodes the prompt into text encoder hidden states. enable_freeu disable_freeu enable_vae_slicing disable_vae_slicing enable_vae_tiling disable_vae_tiling  AnimateDiffPipelineOutput  class diffusers.pipelines.animatediff.AnimateDiffPipelineOutput  < source > ( frames: Union  )

scrapped_outputs/00a44ba96e48f08abc944973f3de6edb.txt

@@ -0,0 +1,136 @@
+Cycle Diffusion Cycle Diffusion is a text guided image-to-image generation model proposed in Unifying Diffusion Models’ Latent Space, with Applications to CycleDiffusion and Guidance by Chen Henry Wu, Fernando De la Torre. The abstract from the paper is: Diffusion models have achieved unprecedented performance in generative modeling. The commonly-adopted formulation of the latent code of diffusion models is a sequence of gradually denoised samples, as opposed to the simpler (e.g., Gaussian) latent space of GANs, VAEs, and normalizing flows. This paper provides an alternative, Gaussian formulation of the latent space of various diffusion models, as well as an invertible DPM-Encoder that maps images into the latent space. While our formulation is purely based on the definition of diffusion models, we demonstrate several intriguing consequences. (1) Empirically, we observe that a common latent space emerges from two diffusion models trained independently on related domains. In light of this finding, we propose CycleDiffusion, which uses DPM-Encoder for unpaired image-to-image translation. Furthermore, applying CycleDiffusion to text-to-image diffusion models, we show that large-scale text-to-image diffusion models can be used as zero-shot image-to-image editors. (2) One can guide pre-trained diffusion models and GANs by controlling the latent codes in a unified, plug-and-play formulation based on energy-based models. Using the CLIP model and a face recognition model as guidance, we demonstrate that diffusion models have better coverage of low-density sub-populations and individuals than GANs. The code is publicly available at this https URL. Make sure to check out the Schedulers guide to learn how to explore the tradeoff between scheduler speed and quality, and see the reuse components across pipelines section to learn how to efficiently load the same components into multiple pipelines.  CycleDiffusionPipeline  class diffusers.CycleDiffusionPipeline  < source > ( vae: AutoencoderKL text_encoder: CLIPTextModel tokenizer: CLIPTokenizer unet: UNet2DConditionModel scheduler: DDIMScheduler safety_checker: StableDiffusionSafetyChecker feature_extractor: CLIPImageProcessor requires_safety_checker: bool = True  )   Parameters   vae (AutoencoderKL) —
+Variational Auto-Encoder (VAE) model to encode and decode images to and from latent representations.   text_encoder (CLIPTextModel) —
+Frozen text-encoder (clip-vit-large-patch14).   tokenizer (CLIPTokenizer) —
+A CLIPTokenizer to tokenize text.   unet (UNet2DConditionModel) —
+A UNet2DConditionModel to denoise the encoded image latents.   scheduler (SchedulerMixin) —
+A scheduler to be used in combination with unet to denoise the encoded image latents. Can only be an
+instance of DDIMScheduler.   safety_checker (StableDiffusionSafetyChecker) —
+Classification module that estimates whether generated images could be considered offensive or harmful.
+Please refer to the model card for more details
+about a model’s potential harms.   feature_extractor (CLIPImageProcessor) —
+A CLIPImageProcessor to extract features from generated images; used as inputs to the safety_checker.    Pipeline for text-guided image to image generation using Stable Diffusion. This model inherits from DiffusionPipeline. Check the superclass documentation for the generic methods
+implemented for all pipelines (downloading, saving, running on a particular device, etc.). The pipeline also inherits the following loading methods: load_textual_inversion() for loading textual inversion embeddings load_lora_weights() for loading LoRA weights save_lora_weights() for saving LoRA weights  __call__  < source > ( prompt: typing.Union[str, typing.List[str]] source_prompt: typing.Union[str, typing.List[str]] image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.FloatTensor, typing.List[PIL.Image.Image], typing.List[numpy.ndarray], typing.List[torch.FloatTensor]] = None strength: float = 0.8 num_inference_steps: typing.Optional[int] = 50 guidance_scale: typing.Optional[float] = 7.5 source_guidance_scale: typing.Optional[float] = 1 num_images_per_prompt: typing.Optional[int] = 1 eta: typing.Optional[float] = 0.1 generator: typing.Union[torch._C.Generator, typing.List[torch._C.Generator], NoneType] = None prompt_embeds: typing.Optional[torch.FloatTensor] = None output_type: typing.Optional[str] = 'pil' return_dict: bool = True callback: typing.Union[typing.Callable[[int, int, torch.FloatTensor], NoneType], NoneType] = None callback_steps: int = 1 cross_attention_kwargs: typing.Union[typing.Dict[str, typing.Any], NoneType] = None clip_skip: typing.Optional[int] = None  ) → StableDiffusionPipelineOutput or tuple  Parameters   prompt (str or List[str]) —
+The prompt or prompts to guide the image generation.   image (torch.FloatTensor np.ndarray, PIL.Image.Image, List[torch.FloatTensor], List[PIL.Image.Image], or List[np.ndarray]) —
+Image or tensor representing an image batch to be used as the starting point. Can also accept image
+latents as image, but if passing latents directly it is not encoded again.   strength (float, optional, defaults to 0.8) —
+Indicates extent to transform the reference image. Must be between 0 and 1. image is used as a
+starting point and more noise is added the higher the strength. The number of denoising steps depends
+on the amount of noise initially added. When strength is 1, added noise is maximum and the denoising
+process runs for the full number of iterations specified in num_inference_steps. A value of 1
+essentially ignores image.   num_inference_steps (int, optional, defaults to 50) —
+The number of denoising steps. More denoising steps usually lead to a higher quality image at the
+expense of slower inference. This parameter is modulated by strength.   guidance_scale (float, optional, defaults to 7.5) —
+A higher guidance scale value encourages the model to generate images closely linked to the text
+prompt at the expense of lower image quality. Guidance scale is enabled when guidance_scale > 1.   source_guidance_scale (float, optional, defaults to 1) —
+Guidance scale for the source prompt. This is useful to control the amount of influence the source
+prompt has for encoding.   num_images_per_prompt (int, optional, defaults to 1) —
+The number of images to generate per prompt.   eta (float, optional, defaults to 0.0) —
+Corresponds to parameter eta (η) from the DDIM paper. Only applies
+to the DDIMScheduler, and is ignored in other schedulers.   generator (torch.Generator or List[torch.Generator], optional) —
+A torch.Generator to make
+generation deterministic.   prompt_embeds (torch.FloatTensor, optional) —
+Pre-generated text embeddings. Can be used to easily tweak text inputs (prompt weighting). If not
+provided, text embeddings are generated from the prompt input argument.   negative_prompt_embeds (torch.FloatTensor, optional) —
+Pre-generated negative text embeddings. Can be used to easily tweak text inputs (prompt weighting). If
+not provided, negative_prompt_embeds are generated from the negative_prompt input argument.   output_type (str, optional, defaults to "pil") —
+The output format of the generated image. Choose between PIL.Image or np.array.   return_dict (bool, optional, defaults to True) —
+Whether or not to return a StableDiffusionPipelineOutput instead of a
+plain tuple.   callback (Callable, optional) —
+A function that calls every callback_steps steps during inference. The function is called with the
+following arguments: callback(step: int, timestep: int, latents: torch.FloatTensor).   callback_steps (int, optional, defaults to 1) —
+The frequency at which the callback function is called. If not specified, the callback is called at
+every step.   cross_attention_kwargs (dict, optional) —
+A kwargs dictionary that if specified is passed along to the AttentionProcessor as defined in
+self.processor.   clip_skip (int, optional) —
+Number of layers to be skipped from CLIP while computing the prompt embeddings. A value of 1 means that
+the output of the pre-final layer will be used for computing the prompt embeddings.   Returns 
+StableDiffusionPipelineOutput or tuple
+  
+If return_dict is True, StableDiffusionPipelineOutput is returned,
+otherwise a tuple is returned where the first element is a list with the generated images and the
+second element is a list of bools indicating whether the corresponding generated image contains
+“not-safe-for-work” (nsfw) content.
+  The call function to the pipeline for generation.  Example:   Copied import requests
+import torch
+from PIL import Image
+from io import BytesIO
+
+from diffusers import CycleDiffusionPipeline, DDIMScheduler
+
+# load the pipeline
+# make sure you're logged in with `huggingface-cli login`
+model_id_or_path = "CompVis/stable-diffusion-v1-4"
+scheduler = DDIMScheduler.from_pretrained(model_id_or_path, subfolder="scheduler")
+pipe = CycleDiffusionPipeline.from_pretrained(model_id_or_path, scheduler=scheduler).to("cuda")
+
+# let's download an initial image
+url = "https://raw.githubusercontent.com/ChenWu98/cycle-diffusion/main/data/dalle2/An%20astronaut%20riding%20a%20horse.png"
+response = requests.get(url)
+init_image = Image.open(BytesIO(response.content)).convert("RGB")
+init_image = init_image.resize((512, 512))
+init_image.save("horse.png")
+
+# let's specify a prompt
+source_prompt = "An astronaut riding a horse"
+prompt = "An astronaut riding an elephant"
+
+# call the pipeline
+image = pipe(
+    prompt=prompt,
+    source_prompt=source_prompt,
+    image=init_image,
+    num_inference_steps=100,
+    eta=0.1,
+    strength=0.8,
+    guidance_scale=2,
+    source_guidance_scale=1,
+).images[0]
+
+image.save("horse_to_elephant.png")
+
+# let's try another example
+# See more samples at the original repo: https://github.com/ChenWu98/cycle-diffusion
+url = (
+    "https://raw.githubusercontent.com/ChenWu98/cycle-diffusion/main/data/dalle2/A%20black%20colored%20car.png"
+)
+response = requests.get(url)
+init_image = Image.open(BytesIO(response.content)).convert("RGB")
+init_image = init_image.resize((512, 512))
+init_image.save("black.png")
+
+source_prompt = "A black colored car"
+prompt = "A blue colored car"
+
+# call the pipeline
+torch.manual_seed(0)
+image = pipe(
+    prompt=prompt,
+    source_prompt=source_prompt,
+    image=init_image,
+    num_inference_steps=100,
+    eta=0.1,
+    strength=0.85,
+    guidance_scale=3,
+    source_guidance_scale=1,
+).images[0]
+
+image.save("black_to_blue.png")  encode_prompt  < source > ( prompt device num_images_per_prompt do_classifier_free_guidance negative_prompt = None prompt_embeds: typing.Optional[torch.FloatTensor] = None negative_prompt_embeds: typing.Optional[torch.FloatTensor] = None lora_scale: typing.Optional[float] = None clip_skip: typing.Optional[int] = None  )   Parameters   prompt (str or List[str], optional) —
+prompt to be encoded
+device — (torch.device):
+torch device   num_images_per_prompt (int) —
+number of images that should be generated per prompt   do_classifier_free_guidance (bool) —
+whether to use classifier free guidance or not   negative_prompt (str or List[str], optional) —
+The prompt or prompts not to guide the image generation. If not defined, one has to pass
+negative_prompt_embeds instead. Ignored when not using guidance (i.e., ignored if guidance_scale is
+less than 1).   prompt_embeds (torch.FloatTensor, optional) —
+Pre-generated text embeddings. Can be used to easily tweak text inputs, e.g. prompt weighting. If not
+provided, text embeddings will be generated from prompt input argument.   negative_prompt_embeds (torch.FloatTensor, optional) —
+Pre-generated negative text embeddings. Can be used to easily tweak text inputs, e.g. prompt
+weighting. If not provided, negative_prompt_embeds will be generated from negative_prompt input
+argument.   lora_scale (float, optional) —
+A LoRA scale that will be applied to all LoRA layers of the text encoder if LoRA layers are loaded.   clip_skip (int, optional) —
+Number of layers to be skipped from CLIP while computing the prompt embeddings. A value of 1 means that
+the output of the pre-final layer will be used for computing the prompt embeddings.    Encodes the prompt into text encoder hidden states.  StableDiffusionPiplineOutput  class diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput  < source > ( images: typing.Union[typing.List[PIL.Image.Image], numpy.ndarray] nsfw_content_detected: typing.Optional[typing.List[bool]]  )   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).   nsfw_content_detected (List[bool]) —
+List indicating whether the corresponding generated image contains “not-safe-for-work” (nsfw) content or
+None if safety checking could not be performed.    Output class for Stable Diffusion pipelines.

scrapped_outputs/010878c4f61adff57a313b69bfbf36ee.txt

@@ -0,0 +1,45 @@
+EulerAncestralDiscreteScheduler A scheduler that uses ancestral sampling with Euler method steps. This is a fast scheduler which can often generate good outputs in 20-30 steps. The scheduler is based on the original k-diffusion implementation by Katherine Crowson.  EulerAncestralDiscreteScheduler  class diffusers.EulerAncestralDiscreteScheduler  < source > ( num_train_timesteps: int = 1000 beta_start: float = 0.0001 beta_end: float = 0.02 beta_schedule: str = 'linear' trained_betas: Union = None prediction_type: str = 'epsilon' timestep_spacing: str = 'linspace' steps_offset: int = 0 rescale_betas_zero_snr: bool = False  )   Parameters   num_train_timesteps (int, defaults to 1000) —
+The number of diffusion steps to train the model.   beta_start (float, defaults to 0.0001) —
+The starting beta value of inference.   beta_end (float, defaults to 0.02) —
+The final beta value.   beta_schedule (str, defaults to "linear") —
+The beta schedule, a mapping from a beta range to a sequence of betas for stepping the model. Choose from
+linear or scaled_linear.   trained_betas (np.ndarray, optional) —
+Pass an array of betas directly to the constructor to bypass beta_start and beta_end.   prediction_type (str, defaults to epsilon, optional) —
+Prediction type of the scheduler function; can be epsilon (predicts the noise of the diffusion process),
+sample (directly predicts the noisy sample) or v_prediction` (see section 2.4 of Imagen
+Video paper).   timestep_spacing (str, defaults to "linspace") —
+The way the timesteps should be scaled. Refer to Table 2 of the Common Diffusion Noise Schedules and
+Sample Steps are Flawed for more information.   steps_offset (int, defaults to 0) —
+An offset added to the inference steps. You can use a combination of offset=1 and
+set_alpha_to_one=False to make the last step use step 0 for the previous alpha product like in Stable
+Diffusion.   rescale_betas_zero_snr (bool, defaults to False) —
+Whether to rescale the betas to have zero terminal SNR. This enables the model to generate very bright and
+dark samples instead of limiting it to samples with medium brightness. Loosely related to
+--offset_noise.    Ancestral sampling with Euler method steps. This model inherits from SchedulerMixin and ConfigMixin. Check the superclass documentation for the generic
+methods the library implements for all schedulers such as loading and saving.  scale_model_input  < source > ( sample: FloatTensor timestep: Union  ) → torch.FloatTensor  Parameters   sample (torch.FloatTensor) —
+The input sample.   timestep (int, optional) —
+The current timestep in the diffusion chain.   Returns 
+torch.FloatTensor
+  
+A scaled input sample.
+  Ensures interchangeability with schedulers that need to scale the denoising model input depending on the
+current timestep. Scales the denoising model input by (sigma**2 + 1) ** 0.5 to match the Euler algorithm.  set_timesteps  < source > ( num_inference_steps: int device: Union = None  )   Parameters   num_inference_steps (int) —
+The number of diffusion steps used when generating samples with a pre-trained model.   device (str or torch.device, optional) —
+The device to which the timesteps should be moved to. If None, the timesteps are not moved.    Sets the discrete timesteps used for the diffusion chain (to be run before inference).  step  < source > ( model_output: FloatTensor timestep: Union sample: FloatTensor generator: Optional = None return_dict: bool = True  ) → EulerAncestralDiscreteSchedulerOutput or tuple  Parameters   model_output (torch.FloatTensor) —
+The direct output from learned diffusion model.   timestep (float) —
+The current discrete timestep in the diffusion chain.   sample (torch.FloatTensor) —
+A current instance of a sample created by the diffusion process.   generator (torch.Generator, optional) —
+A random number generator.   return_dict (bool) —
+Whether or not to return a
+EulerAncestralDiscreteSchedulerOutput or tuple.   Returns 
+EulerAncestralDiscreteSchedulerOutput or tuple
+  
+If return_dict is True,
+EulerAncestralDiscreteSchedulerOutput is returned,
+otherwise a tuple is returned where the first element is the sample tensor.
+  Predict the sample from the previous timestep by reversing the SDE. This function propagates the diffusion
+process from the learned model outputs (most often the predicted noise).  EulerAncestralDiscreteSchedulerOutput  class diffusers.schedulers.scheduling_euler_ancestral_discrete.EulerAncestralDiscreteSchedulerOutput  < source > ( prev_sample: FloatTensor pred_original_sample: Optional = None  )   Parameters   prev_sample (torch.FloatTensor of shape (batch_size, num_channels, height, width) for images) —
+Computed sample (x_{t-1}) of previous timestep. prev_sample should be used as next model input in the
+denoising loop.   pred_original_sample (torch.FloatTensor of shape (batch_size, num_channels, height, width) for images) —
+The predicted denoised sample (x_{0}) based on the model output from the current timestep.
+pred_original_sample can be used to preview progress or for guidance.    Output class for the scheduler’s step function output.

scrapped_outputs/010b61c1b09524892e674b81e6a567e2.txt

@@ -0,0 +1,8 @@
+ScoreSdeVpScheduler ScoreSdeVpScheduler is a variance preserving stochastic differential equation (SDE) scheduler.  It was introduced in the Score-Based Generative Modeling through Stochastic Differential Equations paper by Yang Song, Jascha Sohl-Dickstein, Diederik P. Kingma, Abhishek Kumar, Stefano Ermon, Ben Poole. The abstract from the paper is: Creating noise from data is easy; creating data from noise is generative modeling. We present a stochastic differential equation (SDE) that smoothly transforms a complex data distribution to a known prior distribution by slowly injecting noise, and a corresponding reverse-time SDE that transforms the prior distribution back into the data distribution by slowly removing the noise. Crucially, the reverse-time SDE depends only on the time-dependent gradient field (\aka, score) of the perturbed data distribution. By leveraging advances in score-based generative modeling, we can accurately estimate these scores with neural networks, and use numerical SDE solvers to generate samples. We show that this framework encapsulates previous approaches in score-based generative modeling and diffusion probabilistic modeling, allowing for new sampling procedures and new modeling capabilities. In particular, we introduce a predictor-corrector framework to correct errors in the evolution of the discretized reverse-time SDE. We also derive an equivalent neural ODE that samples from the same distribution as the SDE, but additionally enables exact likelihood computation, and improved sampling efficiency. In addition, we provide a new way to solve inverse problems with score-based models, as demonstrated with experiments on class-conditional generation, image inpainting, and colorization. Combined with multiple architectural improvements, we achieve record-breaking performance for unconditional image generation on CIFAR-10 with an Inception score of 9.89 and FID of 2.20, a competitive likelihood of 2.99 bits/dim, and demonstrate high fidelity generation of 1024 x 1024 images for the first time from a score-based generative model. 🚧 This scheduler is under construction!  ScoreSdeVpScheduler  class diffusers.schedulers.ScoreSdeVpScheduler  < source > ( num_train_timesteps = 2000 beta_min = 0.1 beta_max = 20 sampling_eps = 0.001  )   Parameters   num_train_timesteps (int, defaults to 2000) —
+The number of diffusion steps to train the model.   beta_min (int, defaults to 0.1) —   beta_max (int, defaults to 20) —   sampling_eps (int, defaults to 1e-3) —
+The end value of sampling where timesteps decrease progressively from 1 to epsilon.    ScoreSdeVpScheduler is a variance preserving stochastic differential equation (SDE) scheduler. This model inherits from SchedulerMixin and ConfigMixin. Check the superclass documentation for the generic
+methods the library implements for all schedulers such as loading and saving.  set_timesteps  < source > ( num_inference_steps device: Union = None  )   Parameters   num_inference_steps (int) —
+The number of diffusion steps used when generating samples with a pre-trained model.   device (str or torch.device, optional) —
+The device to which the timesteps should be moved to. If None, the timesteps are not moved.    Sets the continuous timesteps used for the diffusion chain (to be run before inference).  step_pred  < source > ( score x t generator = None  )   Parameters   score () —   x () —   t () —   generator (torch.Generator, optional) —
+A random number generator.    Predict the sample from the previous timestep by reversing the SDE. This function propagates the diffusion
+process from the learned model outputs (most often the predicted noise).

scrapped_outputs/013e30f4683bc1e82d2b6b2027109bad.txt

@@ -0,0 +1,11 @@
+Installing xFormers
+	
+We recommend the use of xFormers for both inference and training. In our tests, the optimizations performed in the attention blocks allow for both faster speed and reduced memory consumption.
+Starting from version 0.0.16 of xFormers, released on January 2023, installation can be easily performed using pre-built pip wheels:
+
+
+	Copied
+pip install xformers
+The xFormers PIP package requires the latest version of PyTorch (1.13.1 as of xFormers 0.0.16). If you need to use a previous version of PyTorch, then we recommend you install xFormers from source using the project instructions.
+After xFormers is installed, you can use enable_xformers_memory_efficient_attention() for faster inference and reduced memory consumption, as discussed here.
+According to this issue, xFormers v0.0.16 cannot be used for training (fine-tune or Dreambooth) in some GPUs. If you observe that problem, please install a development version as indicated in that comment.

scrapped_outputs/014fb36531fe935112c5eaa247063735.txt

@@ -0,0 +1,163 @@
+RePaint scheduler
+	
+
+Overview
+	
+DDPM-based inpainting scheduler for unsupervised inpainting with extreme masks.
+Intended for use with RePaintPipeline.
+Based on the paper RePaint: Inpainting using Denoising Diffusion Probabilistic Models
+and the original implementation by Andreas Lugmayr et al.: https://github.com/andreas128/RePaint
+
+RePaintScheduler
+	
+
+class diffusers.RePaintScheduler
+
+<
+source
+>
+(
+num_train_timesteps: int = 1000
+beta_start: float = 0.0001
+beta_end: float = 0.02
+beta_schedule: str = 'linear'
+eta: float = 0.0
+trained_betas: typing.Optional[numpy.ndarray] = None
+clip_sample: bool = True
+
+)
+
+
+Parameters 
+
+num_train_timesteps (int) — number of diffusion steps used to train the model.
+
+
+beta_start (float) — the starting beta value of inference.
+
+
+beta_end (float) — the final beta value.
+
+
+beta_schedule (str) —
+the beta schedule, a mapping from a beta range to a sequence of betas for stepping the model. Choose from
+linear, scaled_linear, or squaredcos_cap_v2.
+
+
+eta (float) —
+The weight of noise for added noise in a diffusion step. Its value is between 0.0 and 1.0 -0.0 is DDIM and
+1.0 is DDPM scheduler respectively.
+
+
+trained_betas (np.ndarray, optional) —
+option to pass an array of betas directly to the constructor to bypass beta_start, beta_end etc.
+
+
+variance_type (str) —
+options to clip the variance used when adding noise to the denoised sample. Choose from fixed_small,
+fixed_small_log, fixed_large, fixed_large_log, learned or learned_range.
+
+
+clip_sample (bool, default True) —
+option to clip predicted sample between -1 and 1 for numerical stability.
+
+
+
+RePaint is a schedule for DDPM inpainting inside a given mask.
+~ConfigMixin takes care of storing all config attributes that are passed in the scheduler’s __init__
+function, such as num_train_timesteps. They can be accessed via scheduler.config.num_train_timesteps.
+SchedulerMixin provides general loading and saving functionality via the SchedulerMixin.save_pretrained() and
+from_pretrained() functions.
+For more details, see the original paper: https://arxiv.org/pdf/2201.09865.pdf
+
+scale_model_input
+
+<
+source
+>
+(
+sample: FloatTensor
+timestep: typing.Optional[int] = None
+
+)
+→
+torch.FloatTensor
+
+Parameters 
+
+sample (torch.FloatTensor) — input sample
+
+
+timestep (int, optional) — current timestep
+
+
+Returns
+
+torch.FloatTensor
+
+
+
+scaled input sample
+
+
+Ensures interchangeability with schedulers that need to scale the denoising model input depending on the
+current timestep.
+
+step
+
+<
+source
+>
+(
+model_output: FloatTensor
+timestep: int
+sample: FloatTensor
+original_image: FloatTensor
+mask: FloatTensor
+generator: typing.Optional[torch._C.Generator] = None
+return_dict: bool = True
+
+)
+→
+~schedulers.scheduling_utils.RePaintSchedulerOutput or tuple
+
+Parameters 
+
+model_output (torch.FloatTensor) — direct output from learned
+diffusion model.
+
+
+timestep (int) — current discrete timestep in the diffusion chain.
+
+
+sample (torch.FloatTensor) —
+current instance of sample being created by diffusion process.
+
+
+original_image (torch.FloatTensor) —
+the original image to inpaint on.
+
+
+mask (torch.FloatTensor) —
+the mask where 0.0 values define which part of the original image to inpaint (change).
+
+
+generator (torch.Generator, optional) — random number generator.
+
+
+return_dict (bool) — option for returning tuple rather than
+DDPMSchedulerOutput class
+
+
+Returns
+
+~schedulers.scheduling_utils.RePaintSchedulerOutput or tuple
+
+
+
+~schedulers.scheduling_utils.RePaintSchedulerOutput if return_dict is True, otherwise a tuple. When
+returning a tuple, the first element is the sample tensor.
+
+
+Predict the sample at the previous timestep by reversing the SDE. Core function to propagate the diffusion
+process from the learned model outputs (most often the predicted noise).

scrapped_outputs/01a8586bc0784a4627557a3815ff5b5d.txt

@@ -0,0 +1,100 @@
+Stochastic Karras VE
+	
+
+Overview
+	
+Elucidating the Design Space of Diffusion-Based Generative Models by Tero Karras, Miika Aittala, Timo Aila and Samuli Laine.
+The abstract of the paper is the following:
+We argue that the theory and practice of diffusion-based generative models are currently unnecessarily convoluted and seek to remedy the situation by presenting a design space that clearly separates the concrete design choices. This lets us identify several changes to both the sampling and training processes, as well as preconditioning of the score networks. Together, our improvements yield new state-of-the-art FID of 1.79 for CIFAR-10 in a class-conditional setting and 1.97 in an unconditional setting, with much faster sampling (35 network evaluations per image) than prior designs. To further demonstrate their modular nature, we show that our design changes dramatically improve both the efficiency and quality obtainable with pre-trained score networks from previous work, including improving the FID of an existing ImageNet-64 model from 2.07 to near-SOTA 1.55.
+This pipeline implements the Stochastic sampling tailored to the Variance-Expanding (VE) models.
+
+Available Pipelines:
+	
+Pipeline
+Tasks
+Colab
+pipeline_stochastic_karras_ve.py
+Unconditional Image Generation
+-
+
+KarrasVePipeline
+	
+
+class diffusers.KarrasVePipeline
+
+<
+source
+>
+(
+unet: UNet2DModel
+scheduler: KarrasVeScheduler
+
+)
+
+
+Parameters 
+
+unet (UNet2DModel) — U-Net architecture to denoise the encoded image.
+
+
+scheduler (KarrasVeScheduler) —
+Scheduler for the diffusion process to be used in combination with unet to denoise the encoded image.
+
+
+
+Stochastic sampling from Karras et al. [1] tailored to the Variance-Expanding (VE) models [2]. Use Algorithm 2 and
+the VE column of Table 1 from [1] for reference.
+[1] Karras, Tero, et al. “Elucidating the Design Space of Diffusion-Based Generative Models.”
+https://arxiv.org/abs/2206.00364 [2] Song, Yang, et al. “Score-based generative modeling through stochastic
+differential equations.” https://arxiv.org/abs/2011.13456
+
+__call__
+
+<
+source
+>
+(
+batch_size: int = 1
+num_inference_steps: int = 50
+generator: typing.Union[torch._C.Generator, typing.List[torch._C.Generator], NoneType] = None
+output_type: typing.Optional[str] = 'pil'
+return_dict: bool = True
+**kwargs
+
+)
+→
+ImagePipelineOutput or tuple
+
+Parameters 
+
+batch_size (int, optional, defaults to 1) —
+The number of images to generate.
+
+
+generator (torch.Generator, optional) —
+One or a list of torch generator(s)
+to make generation deterministic.
+
+
+num_inference_steps (int, optional, defaults to 50) —
+The number of denoising steps. More denoising steps usually lead to a higher quality image at the
+expense of slower inference.
+
+
+output_type (str, optional, defaults to "pil") —
+The output format of the generate image. Choose between
+PIL: PIL.Image.Image or np.array.
+
+
+return_dict (bool, optional, defaults to True) —
+Whether or not to return a ImagePipelineOutput instead of a plain tuple.
+
+
+Returns
+
+ImagePipelineOutput or tuple
+
+
+
+~pipelines.utils.ImagePipelineOutput if return_dict is
+True, otherwise a `tuple. When returning a tuple, the first element is a list with the generated images.

scrapped_outputs/01be2bbed29849c60e5daa8454e05de7.txt

@@ -0,0 +1,286 @@
+Custom Pipelines
+	
+For more information about community pipelines, please have a look at this issue.
+Community examples consist of both inference and training examples that have been added by the community.
+Please have a look at the following table to get an overview of all community examples. Click on the Code Example to get a copy-and-paste ready code example that you can try out.
+If a community doesn’t work as expected, please open an issue and ping the author on it.
+Example
+Description
+Code Example
+Colab
+Author
+CLIP Guided Stable Diffusion
+Doing CLIP guidance for text to image generation with Stable Diffusion
+CLIP Guided Stable Diffusion
+
+Suraj Patil
+One Step U-Net (Dummy)
+Example showcasing of how to use Community Pipelines (see https://github.com/huggingface/diffusers/issues/841)
+One Step U-Net
+-
+Patrick von Platen
+Stable Diffusion Interpolation
+Interpolate the latent space of Stable Diffusion between different prompts/seeds
+Stable Diffusion Interpolation
+-
+Nate Raw
+Stable Diffusion Mega
+One Stable Diffusion Pipeline with all functionalities of Text2Image, Image2Image and Inpainting
+Stable Diffusion Mega
+-
+Patrick von Platen
+Long Prompt Weighting Stable Diffusion
+One Stable Diffusion Pipeline without tokens length limit, and support parsing weighting in prompt.
+Long Prompt Weighting Stable Diffusion
+-
+SkyTNT
+Speech to Image
+Using automatic-speech-recognition to transcribe text and Stable Diffusion to generate images
+Speech to Image
+-
+Mikail Duzenli
+To load a custom pipeline you just need to pass the custom_pipeline argument to DiffusionPipeline, as one of the files in diffusers/examples/community. Feel free to send a PR with your own pipelines, we will merge them quickly.
+
+
+	Copied
+pipe = DiffusionPipeline.from_pretrained(
+    "CompVis/stable-diffusion-v1-4", custom_pipeline="filename_in_the_community_folder"
+)
+
+Example usages
+	
+
+CLIP Guided Stable Diffusion
+	
+CLIP guided stable diffusion can help to generate more realistic images
+by guiding stable diffusion at every denoising step with an additional CLIP model.
+The following code requires roughly 12GB of GPU RAM.
+
+
+	Copied
+from diffusers import DiffusionPipeline
+from transformers import CLIPFeatureExtractor, CLIPModel
+import torch
+
+
+feature_extractor = CLIPFeatureExtractor.from_pretrained("laion/CLIP-ViT-B-32-laion2B-s34B-b79K")
+clip_model = CLIPModel.from_pretrained("laion/CLIP-ViT-B-32-laion2B-s34B-b79K", torch_dtype=torch.float16)
+
+
+guided_pipeline = DiffusionPipeline.from_pretrained(
+    "CompVis/stable-diffusion-v1-4",
+    custom_pipeline="clip_guided_stable_diffusion",
+    clip_model=clip_model,
+    feature_extractor=feature_extractor,
+    torch_dtype=torch.float16,
+)
+guided_pipeline.enable_attention_slicing()
+guided_pipeline = guided_pipeline.to("cuda")
+
+prompt = "fantasy book cover, full moon, fantasy forest landscape, golden vector elements, fantasy magic, dark light night, intricate, elegant, sharp focus, illustration, highly detailed, digital painting, concept art, matte, art by WLOP and Artgerm and Albert Bierstadt, masterpiece"
+
+generator = torch.Generator(device="cuda").manual_seed(0)
+images = []
+for i in range(4):
+    image = guided_pipeline(
+        prompt,
+        num_inference_steps=50,
+        guidance_scale=7.5,
+        clip_guidance_scale=100,
+        num_cutouts=4,
+        use_cutouts=False,
+        generator=generator,
+    ).images[0]
+    images.append(image)
+
+# save images locally
+for i, img in enumerate(images):
+    img.save(f"./clip_guided_sd/image_{i}.png")
+The images list contains a list of PIL images that can be saved locally or displayed directly in a google colab.
+Generated images tend to be of higher qualtiy than natively using stable diffusion. E.g. the above script generates the following images:
+.
+
+One Step Unet
+	
+The dummy “one-step-unet” can be run as follows:
+
+
+	Copied
+from diffusers import DiffusionPipeline
+
+pipe = DiffusionPipeline.from_pretrained("google/ddpm-cifar10-32", custom_pipeline="one_step_unet")
+pipe()
+Note: This community pipeline is not useful as a feature, but rather just serves as an example of how community pipelines can be added (see https://github.com/huggingface/diffusers/issues/841).
+
+Stable Diffusion Interpolation
+	
+The following code can be run on a GPU of at least 8GB VRAM and should take approximately 5 minutes.
+
+
+	Copied
+from diffusers import DiffusionPipeline
+import torch
+
+pipe = DiffusionPipeline.from_pretrained(
+    "CompVis/stable-diffusion-v1-4",
+    torch_dtype=torch.float16,
+    safety_checker=None,  # Very important for videos...lots of false positives while interpolating
+    custom_pipeline="interpolate_stable_diffusion",
+).to("cuda")
+pipe.enable_attention_slicing()
+
+frame_filepaths = pipe.walk(
+    prompts=["a dog", "a cat", "a horse"],
+    seeds=[42, 1337, 1234],
+    num_interpolation_steps=16,
+    output_dir="./dreams",
+    batch_size=4,
+    height=512,
+    width=512,
+    guidance_scale=8.5,
+    num_inference_steps=50,
+)
+The output of the walk(...) function returns a list of images saved under the folder as defined in output_dir. You can use these images to create videos of stable diffusion.
+Please have a look at https://github.com/nateraw/stable-diffusion-videos for more in-detail information on how to create videos using stable diffusion as well as more feature-complete functionality.
+
+Stable Diffusion Mega
+	
+The Stable Diffusion Mega Pipeline lets you use the main use cases of the stable diffusion pipeline in a single class.
+
+
+	Copied
+#!/usr/bin/env python3
+from diffusers import DiffusionPipeline
+import PIL
+import requests
+from io import BytesIO
+import torch
+
+
+def download_image(url):
+    response = requests.get(url)
+    return PIL.Image.open(BytesIO(response.content)).convert("RGB")
+
+
+pipe = DiffusionPipeline.from_pretrained(
+    "CompVis/stable-diffusion-v1-4",
+    custom_pipeline="stable_diffusion_mega",
+    torch_dtype=torch.float16,
+)
+pipe.to("cuda")
+pipe.enable_attention_slicing()
+
+
+### Text-to-Image
+
+images = pipe.text2img("An astronaut riding a horse").images
+
+### Image-to-Image
+
+init_image = download_image(
+    "https://raw.githubusercontent.com/CompVis/stable-diffusion/main/assets/stable-samples/img2img/sketch-mountains-input.jpg"
+)
+
+prompt = "A fantasy landscape, trending on artstation"
+
+images = pipe.img2img(prompt=prompt, image=init_image, strength=0.75, guidance_scale=7.5).images
+
+### Inpainting
+
+img_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo.png"
+mask_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo_mask.png"
+init_image = download_image(img_url).resize((512, 512))
+mask_image = download_image(mask_url).resize((512, 512))
+
+prompt = "a cat sitting on a bench"
+images = pipe.inpaint(prompt=prompt, image=init_image, mask_image=mask_image, strength=0.75).images
+As shown above this one pipeline can run all both “text-to-image”, “image-to-image”, and “inpainting” in one pipeline.
+
+Long Prompt Weighting Stable Diffusion
+	
+The Pipeline lets you input prompt without 77 token length limit. And you can increase words weighting by using ”()” or decrease words weighting by using ”[]”
+The Pipeline also lets you use the main use cases of the stable diffusion pipeline in a single class.
+
+pytorch
+	
+
+
+	Copied
+from diffusers import DiffusionPipeline
+import torch
+
+pipe = DiffusionPipeline.from_pretrained(
+    "hakurei/waifu-diffusion", custom_pipeline="lpw_stable_diffusion", torch_dtype=torch.float16
+)
+pipe = pipe.to("cuda")
+
+prompt = "best_quality (1girl:1.3) bow bride brown_hair closed_mouth frilled_bow frilled_hair_tubes frills (full_body:1.3) fox_ear hair_bow hair_tubes happy hood japanese_clothes kimono long_sleeves red_bow smile solo tabi uchikake white_kimono wide_sleeves cherry_blossoms"
+neg_prompt = "lowres, bad_anatomy, error_body, error_hair, error_arm, error_hands, bad_hands, error_fingers, bad_fingers, missing_fingers, error_legs, bad_legs, multiple_legs, missing_legs, error_lighting, error_shadow, error_reflection, text, error, extra_digit, fewer_digits, cropped, worst_quality, low_quality, normal_quality, jpeg_artifacts, signature, watermark, username, blurry"
+
+pipe.text2img(prompt, negative_prompt=neg_prompt, width=512, height=512, max_embeddings_multiples=3).images[0]
+
+onnxruntime
+	
+
+
+	Copied
+from diffusers import DiffusionPipeline
+import torch
+
+pipe = DiffusionPipeline.from_pretrained(
+    "CompVis/stable-diffusion-v1-4",
+    custom_pipeline="lpw_stable_diffusion_onnx",
+    revision="onnx",
+    provider="CUDAExecutionProvider",
+)
+
+prompt = "a photo of an astronaut riding a horse on mars, best quality"
+neg_prompt = "lowres, bad anatomy, error body, error hair, error arm, error hands, bad hands, error fingers, bad fingers, missing fingers, error legs, bad legs, multiple legs, missing legs, error lighting, error shadow, error reflection, text, error, extra digit, fewer digits, cropped, worst quality, low quality, normal quality, jpeg artifacts, signature, watermark, username, blurry"
+
+pipe.text2img(prompt, negative_prompt=neg_prompt, width=512, height=512, max_embeddings_multiples=3).images[0]
+if you see Token indices sequence length is longer than the specified maximum sequence length for this model ( *** > 77 ) . Running this sequence through the model will result in indexing errors. Do not worry, it is normal.
+
+Speech to Image
+	
+The following code can generate an image from an audio sample using pre-trained OpenAI whisper-small and Stable Diffusion.
+
+
+	Copied
+import torch
+
+import matplotlib.pyplot as plt
+from datasets import load_dataset
+from diffusers import DiffusionPipeline
+from transformers import (
+    WhisperForConditionalGeneration,
+    WhisperProcessor,
+)
+
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
+
+audio_sample = ds[3]
+
+text = audio_sample["text"].lower()
+speech_data = audio_sample["audio"]["array"]
+
+model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-small").to(device)
+processor = WhisperProcessor.from_pretrained("openai/whisper-small")
+
+diffuser_pipeline = DiffusionPipeline.from_pretrained(
+    "CompVis/stable-diffusion-v1-4",
+    custom_pipeline="speech_to_image_diffusion",
+    speech_model=model,
+    speech_processor=processor,
+    
+    torch_dtype=torch.float16,
+)
+
+diffuser_pipeline.enable_attention_slicing()
+diffuser_pipeline = diffuser_pipeline.to(device)
+
+output = diffuser_pipeline(speech_data)
+plt.imshow(output.images[0])
+This example produces the following image:

scrapped_outputs/01d80081236d3aed18b8ca7aabd28034.txt

@@ -0,0 +1,18 @@
+VQModel The VQ-VAE model was introduced in Neural Discrete Representation Learning by Aaron van den Oord, Oriol Vinyals and Koray Kavukcuoglu. The model is used in 🤗 Diffusers to decode latent representations into images. Unlike AutoencoderKL, the VQModel works in a quantized latent space. The abstract from the paper is: Learning useful representations without supervision remains a key challenge in machine learning. In this paper, we propose a simple yet powerful generative model that learns such discrete representations. Our model, the Vector Quantised-Variational AutoEncoder (VQ-VAE), differs from VAEs in two key ways: the encoder network outputs discrete, rather than continuous, codes; and the prior is learnt rather than static. In order to learn a discrete latent representation, we incorporate ideas from vector quantisation (VQ). Using the VQ method allows the model to circumvent issues of “posterior collapse” — where the latents are ignored when they are paired with a powerful autoregressive decoder — typically observed in the VAE framework. Pairing these representations with an autoregressive prior, the model can generate high quality images, videos, and speech as well as doing high quality speaker conversion and unsupervised learning of phonemes, providing further evidence of the utility of the learnt representations.  VQModel  class diffusers.VQModel  < source > ( in_channels: int = 3 out_channels: int = 3 down_block_types: Tuple = ('DownEncoderBlock2D',) up_block_types: Tuple = ('UpDecoderBlock2D',) block_out_channels: Tuple = (64,) layers_per_block: int = 1 act_fn: str = 'silu' latent_channels: int = 3 sample_size: int = 32 num_vq_embeddings: int = 256 norm_num_groups: int = 32 vq_embed_dim: Optional = None scaling_factor: float = 0.18215 norm_type: str = 'group' mid_block_add_attention = True lookup_from_codebook = False force_upcast = False  )   Parameters   in_channels (int, optional, defaults to 3) — Number of channels in the input image.   out_channels (int,  optional, defaults to 3) — Number of channels in the output.   down_block_types (Tuple[str], optional, defaults to ("DownEncoderBlock2D",)) —
+Tuple of downsample block types.   up_block_types (Tuple[str], optional, defaults to ("UpDecoderBlock2D",)) —
+Tuple of upsample block types.   block_out_channels (Tuple[int], optional, defaults to (64,)) —
+Tuple of block output channels.   layers_per_block (int, optional, defaults to 1) — Number of layers per block.   act_fn (str, optional, defaults to "silu") — The activation function to use.   latent_channels (int, optional, defaults to 3) — Number of channels in the latent space.   sample_size (int, optional, defaults to 32) — Sample input size.   num_vq_embeddings (int, optional, defaults to 256) — Number of codebook vectors in the VQ-VAE.   norm_num_groups (int, optional, defaults to 32) — Number of groups for normalization layers.   vq_embed_dim (int, optional) — Hidden dim of codebook vectors in the VQ-VAE.   scaling_factor (float, optional, defaults to 0.18215) —
+The component-wise standard deviation of the trained latent space computed using the first batch of the
+training set. This is used to scale the latent space to have unit variance when training the diffusion
+model. The latents are scaled with the formula z = z * scaling_factor before being passed to the
+diffusion model. When decoding, the latents are scaled back to the original scale with the formula: z = 1 / scaling_factor * z. For more details, refer to sections 4.3.2 and D.1 of the High-Resolution Image
+Synthesis with Latent Diffusion Models paper.   norm_type (str, optional, defaults to "group") —
+Type of normalization layer to use. Can be one of "group" or "spatial".    A VQ-VAE model for decoding latent representations. This model inherits from ModelMixin. Check the superclass documentation for it’s generic methods implemented
+for all models (such as downloading or saving).  forward  < source > ( sample: FloatTensor return_dict: bool = True  ) → VQEncoderOutput or tuple  Parameters   sample (torch.FloatTensor) — Input sample.   return_dict (bool, optional, defaults to True) —
+Whether or not to return a models.vq_model.VQEncoderOutput instead of a plain tuple.   Returns 
+VQEncoderOutput or tuple
+  
+If return_dict is True, a VQEncoderOutput is returned, otherwise a plain tuple
+is returned.
+  The VQModel forward method.  VQEncoderOutput  class diffusers.models.vq_model.VQEncoderOutput  < source > ( latents: FloatTensor  )   Parameters   latents (torch.FloatTensor of shape (batch_size, num_channels, height, width)) —
+The encoded output sample from the last layer of the model.    Output of VQModel encoding method.

scrapped_outputs/01df407ddd0ca5935cbb0f71822a1c38.txt

@@ -0,0 +1,83 @@
+Paint by Example Paint by Example: Exemplar-based Image Editing with Diffusion Models is by Binxin Yang, Shuyang Gu, Bo Zhang, Ting Zhang, Xuejin Chen, Xiaoyan Sun, Dong Chen, Fang Wen. The abstract from the paper is: Language-guided image editing has achieved great success recently. In this paper, for the first time, we investigate exemplar-guided image editing for more precise control. We achieve this goal by leveraging self-supervised training to disentangle and re-organize the source image and the exemplar. However, the naive approach will cause obvious fusing artifacts. We carefully analyze it and propose an information bottleneck and strong augmentations to avoid the trivial solution of directly copying and pasting the exemplar image. Meanwhile, to ensure the controllability of the editing process, we design an arbitrary shape mask for the exemplar image and leverage the classifier-free guidance to increase the similarity to the exemplar image. The whole framework involves a single forward of the diffusion model without any iterative optimization. We demonstrate that our method achieves an impressive performance and enables controllable editing on in-the-wild images with high fidelity. The original codebase can be found at Fantasy-Studio/Paint-by-Example, and you can try it out in a demo.  Tips Paint by Example is supported by the official Fantasy-Studio/Paint-by-Example checkpoint. The checkpoint is warm-started from CompVis/stable-diffusion-v1-4 to inpaint partly masked images conditioned on example and reference images. Make sure to check out the Schedulers guide to learn how to explore the tradeoff between scheduler speed and quality, and see the reuse components across pipelines section to learn how to efficiently load the same components into multiple pipelines.  PaintByExamplePipeline  class diffusers.PaintByExamplePipeline  < source > ( vae: AutoencoderKL image_encoder: PaintByExampleImageEncoder unet: UNet2DConditionModel scheduler: Union safety_checker: StableDiffusionSafetyChecker feature_extractor: CLIPImageProcessor requires_safety_checker: bool = False  )   Parameters   vae (AutoencoderKL) —
+Variational Auto-Encoder (VAE) model to encode and decode images to and from latent representations.   image_encoder (PaintByExampleImageEncoder) —
+Encodes the example input image. The unet is conditioned on the example image instead of a text prompt.   tokenizer (CLIPTokenizer) —
+A CLIPTokenizer to tokenize text.   unet (UNet2DConditionModel) —
+A UNet2DConditionModel to denoise the encoded image latents.   scheduler (SchedulerMixin) —
+A scheduler to be used in combination with unet to denoise the encoded image latents. Can be one of
+DDIMScheduler, LMSDiscreteScheduler, or PNDMScheduler.   safety_checker (StableDiffusionSafetyChecker) —
+Classification module that estimates whether generated images could be considered offensive or harmful.
+Please refer to the model card for more details
+about a model’s potential harms.   feature_extractor (CLIPImageProcessor) —
+A CLIPImageProcessor to extract features from generated images; used as inputs to the safety_checker.    🧪 This is an experimental feature! Pipeline for image-guided image inpainting using Stable Diffusion. This model inherits from DiffusionPipeline. Check the superclass documentation for the generic methods
+implemented for all pipelines (downloading, saving, running on a particular device, etc.).  __call__  < source > ( example_image: Union image: Union mask_image: Union height: Optional = None width: Optional = None num_inference_steps: int = 50 guidance_scale: float = 5.0 negative_prompt: Union = None num_images_per_prompt: Optional = 1 eta: float = 0.0 generator: Union = None latents: Optional = None output_type: Optional = 'pil' return_dict: bool = True callback: Optional = None callback_steps: int = 1  ) → StableDiffusionPipelineOutput or tuple  Parameters   example_image (torch.FloatTensor or PIL.Image.Image or List[PIL.Image.Image]) —
+An example image to guide image generation.   image (torch.FloatTensor or PIL.Image.Image or List[PIL.Image.Image]) —
+Image or tensor representing an image batch to be inpainted (parts of the image are masked out with
+mask_image and repainted according to prompt).   mask_image (torch.FloatTensor or PIL.Image.Image or List[PIL.Image.Image]) —
+Image or tensor representing an image batch to mask image. White pixels in the mask are repainted,
+while black pixels are preserved. If mask_image is a PIL image, it is converted to a single channel
+(luminance) before use. If it’s a tensor, it should contain one color channel (L) instead of 3, so the
+expected shape would be (B, H, W, 1).   height (int, optional, defaults to self.unet.config.sample_size * self.vae_scale_factor) —
+The height in pixels of the generated image.   width (int, optional, defaults to self.unet.config.sample_size * self.vae_scale_factor) —
+The width in pixels of the generated image.   num_inference_steps (int, optional, defaults to 50) —
+The number of denoising steps. More denoising steps usually lead to a higher quality image at the
+expense of slower inference.   guidance_scale (float, optional, defaults to 7.5) —
+A higher guidance scale value encourages the model to generate images closely linked to the text
+prompt at the expense of lower image quality. Guidance scale is enabled when guidance_scale > 1.   negative_prompt (str or List[str], optional) —
+The prompt or prompts to guide what to not include in image generation. If not defined, you need to
+pass negative_prompt_embeds instead. Ignored when not using guidance (guidance_scale < 1).   num_images_per_prompt (int, optional, defaults to 1) —
+The number of images to generate per prompt.   eta (float, optional, defaults to 0.0) —
+Corresponds to parameter eta (η) from the DDIM paper. Only applies
+to the DDIMScheduler, and is ignored in other schedulers.   generator (torch.Generator or List[torch.Generator], optional) —
+A torch.Generator to make
+generation deterministic.   latents (torch.FloatTensor, optional) —
+Pre-generated noisy latents sampled from a Gaussian distribution, to be used as inputs for image
+generation. Can be used to tweak the same generation with different prompts. If not provided, a latents
+tensor is generated by sampling using the supplied random generator.   output_type (str, optional, defaults to "pil") —
+The output format of the generated image. Choose between PIL.Image or np.array.   return_dict (bool, optional, defaults to True) —
+Whether or not to return a StableDiffusionPipelineOutput instead of a
+plain tuple.   callback (Callable, optional) —
+A function that calls every callback_steps steps during inference. The function is called with the
+following arguments: callback(step: int, timestep: int, latents: torch.FloatTensor).   callback_steps (int, optional, defaults to 1) —
+The frequency at which the callback function is called. If not specified, the callback is called at
+every step.   Returns 
+StableDiffusionPipelineOutput or tuple
+  
+If return_dict is True, StableDiffusionPipelineOutput is returned,
+otherwise a tuple is returned where the first element is a list with the generated images and the
+second element is a list of bools indicating whether the corresponding generated image contains
+“not-safe-for-work” (nsfw) content.
+  The call function to the pipeline for generation.  Example:   Copied >>> import PIL
+>>> import requests
+>>> import torch
+>>> from io import BytesIO
+>>> from diffusers import PaintByExamplePipeline
+
+
+>>> def download_image(url):
+...     response = requests.get(url)
+...     return PIL.Image.open(BytesIO(response.content)).convert("RGB")
+
+
+>>> img_url = (
+...     "https://raw.githubusercontent.com/Fantasy-Studio/Paint-by-Example/main/examples/image/example_1.png"
+... )
+>>> mask_url = (
+...     "https://raw.githubusercontent.com/Fantasy-Studio/Paint-by-Example/main/examples/mask/example_1.png"
+... )
+>>> example_url = "https://raw.githubusercontent.com/Fantasy-Studio/Paint-by-Example/main/examples/reference/example_1.jpg"
+
+>>> init_image = download_image(img_url).resize((512, 512))
+>>> mask_image = download_image(mask_url).resize((512, 512))
+>>> example_image = download_image(example_url).resize((512, 512))
+
+>>> pipe = PaintByExamplePipeline.from_pretrained(
+...     "Fantasy-Studio/Paint-by-Example",
+...     torch_dtype=torch.float16,
+... )
+>>> pipe = pipe.to("cuda")
+
+>>> image = pipe(image=init_image, mask_image=mask_image, example_image=example_image).images[0]
+>>> image  StableDiffusionPipelineOutput  class diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput  < source > ( images: Union nsfw_content_detected: Optional  )   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).   nsfw_content_detected (List[bool]) —
+List indicating whether the corresponding generated image contains “not-safe-for-work” (nsfw) content or
+None if safety checking could not be performed.    Output class for Stable Diffusion pipelines.

scrapped_outputs/0247f496918051ff626a635f40c86068.txt

@@ -0,0 +1,217 @@
+Load pipelines, models, and schedulers            Having an easy way to use a diffusion system for inference is essential to 🧨 Diffusers. Diffusion systems often consist of multiple components like parameterized models, tokenizers, and schedulers that interact in complex ways. That is why we designed the DiffusionPipeline to wrap the complexity of the entire diffusion system into an easy-to-use API, while remaining flexible enough to be adapted for other use cases, such as loading each component individually as building blocks to assemble your own diffusion system. Everything you need for inference or training is accessible with the from_pretrained() method. This guide will show you how to load: pipelines from the Hub and locally different components into a pipeline checkpoint variants such as different floating point types or non-exponential mean averaged (EMA) weights models and schedulers  Diffusion Pipeline 💡 Skip to the DiffusionPipeline explained section if you are interested in learning in more detail about how the DiffusionPipeline class works. The DiffusionPipeline class is the simplest and most generic way to load the latest trending diffusion model from the Hub. The DiffusionPipeline.from_pretrained() method automatically detects the correct pipeline class from the checkpoint, downloads, and caches all the required configuration and weight files, and returns a pipeline instance ready for inference.   Copied from diffusers import DiffusionPipeline
+
+repo_id = "runwayml/stable-diffusion-v1-5"
+pipe = DiffusionPipeline.from_pretrained(repo_id, use_safetensors=True) You can also load a checkpoint with its specific pipeline class. The example above loaded a Stable Diffusion model; to get the same result, use the StableDiffusionPipeline class:   Copied from diffusers import StableDiffusionPipeline
+
+repo_id = "runwayml/stable-diffusion-v1-5"
+pipe = StableDiffusionPipeline.from_pretrained(repo_id, use_safetensors=True) A checkpoint (such as CompVis/stable-diffusion-v1-4 or runwayml/stable-diffusion-v1-5) may also be used for more than one task, like text-to-image or image-to-image. To differentiate what task you want to use the checkpoint for, you have to load it directly with its corresponding task-specific pipeline class:   Copied from diffusers import StableDiffusionImg2ImgPipeline
+
+repo_id = "runwayml/stable-diffusion-v1-5"
+pipe = StableDiffusionImg2ImgPipeline.from_pretrained(repo_id)  Local pipeline To load a diffusion pipeline locally, use git-lfs to manually download the checkpoint (in this case, runwayml/stable-diffusion-v1-5) to your local disk. This creates a local folder, ./stable-diffusion-v1-5, on your disk:   Copied git-lfs install
+git clone https://huggingface.co/runwayml/stable-diffusion-v1-5 Then pass the local path to from_pretrained():   Copied from diffusers import DiffusionPipeline
+
+repo_id = "./stable-diffusion-v1-5"
+stable_diffusion = DiffusionPipeline.from_pretrained(repo_id, use_safetensors=True) The from_pretrained() method won’t download any files from the Hub when it detects a local path, but this also means it won’t download and cache the latest changes to a checkpoint.  Swap components in a pipeline You can customize the default components of any pipeline with another compatible component. Customization is important because: Changing the scheduler is important for exploring the trade-off between generation speed and quality. Different components of a model are typically trained independently and you can swap out a component with a better-performing one. During finetuning, usually only some components - like the UNet or text encoder - are trained. To find out which schedulers are compatible for customization, you can use the compatibles method:   Copied from diffusers import DiffusionPipeline
+
+repo_id = "runwayml/stable-diffusion-v1-5"
+stable_diffusion = DiffusionPipeline.from_pretrained(repo_id, use_safetensors=True)
+stable_diffusion.scheduler.compatibles Let’s use the SchedulerMixin.from_pretrained() method to replace the default PNDMScheduler with a more performant scheduler, EulerDiscreteScheduler. The subfolder="scheduler" argument is required to load the scheduler configuration from the correct subfolder of the pipeline repository. Then you can pass the new EulerDiscreteScheduler instance to the scheduler argument in DiffusionPipeline:   Copied from diffusers import DiffusionPipeline, EulerDiscreteScheduler
+
+repo_id = "runwayml/stable-diffusion-v1-5"
+scheduler = EulerDiscreteScheduler.from_pretrained(repo_id, subfolder="scheduler")
+stable_diffusion = DiffusionPipeline.from_pretrained(repo_id, scheduler=scheduler, use_safetensors=True)  Safety checker Diffusion models like Stable Diffusion can generate harmful content, which is why 🧨 Diffusers has a safety checker to check generated outputs against known hardcoded NSFW content. If you’d like to disable the safety checker for whatever reason, pass None to the safety_checker argument:   Copied from diffusers import DiffusionPipeline
+
+repo_id = "runwayml/stable-diffusion-v1-5"
+stable_diffusion = DiffusionPipeline.from_pretrained(repo_id, safety_checker=None, use_safetensors=True)
+"""
+You have disabled the safety checker for <class 'diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline'> by passing `safety_checker=None`. Ensure that you abide by the conditions of the Stable Diffusion license and do not expose unfiltered results in services or applications open to the public. Both the diffusers team and Hugging Face strongly recommend keeping the safety filter enabled in all public-facing circumstances, disabling it only for use cases that involve analyzing network behavior or auditing its results. For more information, please have a look at https://github.com/huggingface/diffusers/pull/254 .
+"""  Reuse components across pipelines You can also reuse the same components in multiple pipelines to avoid loading the weights into RAM twice. Use the components method to save the components:   Copied from diffusers import StableDiffusionPipeline, StableDiffusionImg2ImgPipeline
+
+model_id = "runwayml/stable-diffusion-v1-5"
+stable_diffusion_txt2img = StableDiffusionPipeline.from_pretrained(model_id, use_safetensors=True)
+
+components = stable_diffusion_txt2img.components Then you can pass the components to another pipeline without reloading the weights into RAM:   Copied stable_diffusion_img2img = StableDiffusionImg2ImgPipeline(**components) You can also pass the components individually to the pipeline if you want more flexibility over which components to reuse or disable. For example, to reuse the same components in the text-to-image pipeline, except for the safety checker and feature extractor, in the image-to-image pipeline:   Copied from diffusers import StableDiffusionPipeline, StableDiffusionImg2ImgPipeline
+
+model_id = "runwayml/stable-diffusion-v1-5"
+stable_diffusion_txt2img = StableDiffusionPipeline.from_pretrained(model_id, use_safetensors=True)
+stable_diffusion_img2img = StableDiffusionImg2ImgPipeline(
+    vae=stable_diffusion_txt2img.vae,
+    text_encoder=stable_diffusion_txt2img.text_encoder,
+    tokenizer=stable_diffusion_txt2img.tokenizer,
+    unet=stable_diffusion_txt2img.unet,
+    scheduler=stable_diffusion_txt2img.scheduler,
+    safety_checker=None,
+    feature_extractor=None,
+    requires_safety_checker=False,
+)  Checkpoint variants A checkpoint variant is usually a checkpoint whose weights are: Stored in a different floating point type for lower precision and lower storage, such as torch.float16, because it only requires half the bandwidth and storage to download. You can’t use this variant if you’re continuing training or using a CPU. Non-exponential mean averaged (EMA) weights, which shouldn’t be used for inference. You should use these to continue fine-tuning a model. 💡 When the checkpoints have identical model structures, but they were trained on different datasets and with a different training setup, they should be stored in separate repositories instead of variations (for example, stable-diffusion-v1-4 and stable-diffusion-v1-5). Otherwise, a variant is identical to the original checkpoint. They have exactly the same serialization format (like Safetensors), model structure, and weights that have identical tensor shapes. checkpoint type weight name argument for loading weights original diffusion_pytorch_model.bin  floating point diffusion_pytorch_model.fp16.bin variant, torch_dtype non-EMA diffusion_pytorch_model.non_ema.bin variant There are two important arguments to know for loading variants: torch_dtype defines the floating point precision of the loaded checkpoints. For example, if you want to save bandwidth by loading a fp16 variant, you should specify torch_dtype=torch.float16 to convert the weights to fp16. Otherwise, the fp16 weights are converted to the default fp32 precision. You can also load the original checkpoint without defining the variant argument, and convert it to fp16 with torch_dtype=torch.float16. In this case, the default fp32 weights are downloaded first, and then they’re converted to fp16 after loading. variant defines which files should be loaded from the repository. For example, if you want to load a non_ema variant from the diffusers/stable-diffusion-variants repository, you should specify variant="non_ema" to download the non_ema files.   Copied from diffusers import DiffusionPipeline
+import torch
+
+# load fp16 variant
+stable_diffusion = DiffusionPipeline.from_pretrained(
+    "runwayml/stable-diffusion-v1-5", variant="fp16", torch_dtype=torch.float16, use_safetensors=True
+)
+# load non_ema variant
+stable_diffusion = DiffusionPipeline.from_pretrained(
+    "runwayml/stable-diffusion-v1-5", variant="non_ema", use_safetensors=True
+) To save a checkpoint stored in a different floating-point type or as a non-EMA variant, use the DiffusionPipeline.save_pretrained() method and specify the variant argument. You should try and save a variant to the same folder as the original checkpoint, so you can load both from the same folder:   Copied from diffusers import DiffusionPipeline
+
+# save as fp16 variant
+stable_diffusion.save_pretrained("runwayml/stable-diffusion-v1-5", variant="fp16")
+# save as non-ema variant
+stable_diffusion.save_pretrained("runwayml/stable-diffusion-v1-5", variant="non_ema") If you don’t save the variant to an existing folder, you must specify the variant argument otherwise it’ll throw an Exception because it can’t find the original checkpoint:   Copied # 👎 this won't work
+stable_diffusion = DiffusionPipeline.from_pretrained(
+    "./stable-diffusion-v1-5", torch_dtype=torch.float16, use_safetensors=True
+)
+# 👍 this works
+stable_diffusion = DiffusionPipeline.from_pretrained(
+    "./stable-diffusion-v1-5", variant="fp16", torch_dtype=torch.float16, use_safetensors=True
+)  Models Models are loaded from the ModelMixin.from_pretrained() method, which downloads and caches the latest version of the model weights and configurations. If the latest files are available in the local cache, from_pretrained() reuses files in the cache instead of re-downloading them. Models can be loaded from a subfolder with the subfolder argument. For example, the model weights for runwayml/stable-diffusion-v1-5 are stored in the unet subfolder:   Copied from diffusers import UNet2DConditionModel
+
+repo_id = "runwayml/stable-diffusion-v1-5"
+model = UNet2DConditionModel.from_pretrained(repo_id, subfolder="unet", use_safetensors=True) Or directly from a repository’s directory:   Copied from diffusers import UNet2DModel
+
+repo_id = "google/ddpm-cifar10-32"
+model = UNet2DModel.from_pretrained(repo_id, use_safetensors=True) You can also load and save model variants by specifying the variant argument in ModelMixin.from_pretrained() and ModelMixin.save_pretrained():   Copied from diffusers import UNet2DConditionModel
+
+model = UNet2DConditionModel.from_pretrained(
+    "runwayml/stable-diffusion-v1-5", subfolder="unet", variant="non_ema", use_safetensors=True
+)
+model.save_pretrained("./local-unet", variant="non_ema")  Schedulers Schedulers are loaded from the SchedulerMixin.from_pretrained() method, and unlike models, schedulers are not parameterized or trained; they are defined by a configuration file. Loading schedulers does not consume any significant amount of memory and the same configuration file can be used for a variety of different schedulers.
+For example, the following schedulers are compatible with StableDiffusionPipeline, which means you can load the same scheduler configuration file in any of these classes:   Copied from diffusers import StableDiffusionPipeline
+from diffusers import (
+    DDPMScheduler,
+    DDIMScheduler,
+    PNDMScheduler,
+    LMSDiscreteScheduler,
+    EulerAncestralDiscreteScheduler,
+    EulerDiscreteScheduler,
+    DPMSolverMultistepScheduler,
+)
+
+repo_id = "runwayml/stable-diffusion-v1-5"
+
+ddpm = DDPMScheduler.from_pretrained(repo_id, subfolder="scheduler")
+ddim = DDIMScheduler.from_pretrained(repo_id, subfolder="scheduler")
+pndm = PNDMScheduler.from_pretrained(repo_id, subfolder="scheduler")
+lms = LMSDiscreteScheduler.from_pretrained(repo_id, subfolder="scheduler")
+euler_anc = EulerAncestralDiscreteScheduler.from_pretrained(repo_id, subfolder="scheduler")
+euler = EulerDiscreteScheduler.from_pretrained(repo_id, subfolder="scheduler")
+dpm = DPMSolverMultistepScheduler.from_pretrained(repo_id, subfolder="scheduler")
+
+# replace `dpm` with any of `ddpm`, `ddim`, `pndm`, `lms`, `euler_anc`, `euler`
+pipeline = StableDiffusionPipeline.from_pretrained(repo_id, scheduler=dpm, use_safetensors=True)  DiffusionPipeline explained As a class method, DiffusionPipeline.from_pretrained() is responsible for two things: Download the latest version of the folder structure required for inference and cache it. If the latest folder structure is available in the local cache, DiffusionPipeline.from_pretrained() reuses the cache and won’t redownload the files. Load the cached weights into the correct pipeline class - retrieved from the model_index.json file - and return an instance of it. The pipelines’ underlying folder structure corresponds directly with their class instances. For example, the StableDiffusionPipeline corresponds to the folder structure in runwayml/stable-diffusion-v1-5.   Copied from diffusers import DiffusionPipeline
+
+repo_id = "runwayml/stable-diffusion-v1-5"
+pipeline = DiffusionPipeline.from_pretrained(repo_id, use_safetensors=True)
+print(pipeline) You’ll see pipeline is an instance of StableDiffusionPipeline, which consists of seven components: "feature_extractor": a CLIPImageProcessor from 🤗 Transformers. "safety_checker": a component for screening against harmful content. "scheduler": an instance of PNDMScheduler. "text_encoder": a CLIPTextModel from 🤗 Transformers. "tokenizer": a CLIPTokenizer from 🤗 Transformers. "unet": an instance of UNet2DConditionModel. "vae": an instance of AutoencoderKL.   Copied StableDiffusionPipeline {
+  "feature_extractor": [
+    "transformers",
+    "CLIPImageProcessor"
+  ],
+  "safety_checker": [
+    "stable_diffusion",
+    "StableDiffusionSafetyChecker"
+  ],
+  "scheduler": [
+    "diffusers",
+    "PNDMScheduler"
+  ],
+  "text_encoder": [
+    "transformers",
+    "CLIPTextModel"
+  ],
+  "tokenizer": [
+    "transformers",
+    "CLIPTokenizer"
+  ],
+  "unet": [
+    "diffusers",
+    "UNet2DConditionModel"
+  ],
+  "vae": [
+    "diffusers",
+    "AutoencoderKL"
+  ]
+} Compare the components of the pipeline instance to the runwayml/stable-diffusion-v1-5 folder structure, and you’ll see there is a separate folder for each of the components in the repository:   Copied .
+├── feature_extractor
+│   └── preprocessor_config.json
+├── model_index.json
+├── safety_checker
+│   ├── config.json
+|   ├── model.fp16.safetensors
+│   ├── model.safetensors
+│   ├── pytorch_model.bin
+|   └── pytorch_model.fp16.bin
+├── scheduler
+│   └── scheduler_config.json
+├── text_encoder
+│   ├── config.json
+|   ├── model.fp16.safetensors
+│   ├── model.safetensors
+│   |── pytorch_model.bin
+|   └── pytorch_model.fp16.bin
+├── tokenizer
+│   ├── merges.txt
+│   ├── special_tokens_map.json
+│   ├── tokenizer_config.json
+│   └── vocab.json
+├── unet
+│   ├── config.json
+│   ├── diffusion_pytorch_model.bin
+|   |── diffusion_pytorch_model.fp16.bin
+│   |── diffusion_pytorch_model.f16.safetensors
+│   |── diffusion_pytorch_model.non_ema.bin
+│   |── diffusion_pytorch_model.non_ema.safetensors
+│   └── diffusion_pytorch_model.safetensors
+|── vae
+.   ├── config.json
+.   ├── diffusion_pytorch_model.bin
+    ├── diffusion_pytorch_model.fp16.bin
+    ├── diffusion_pytorch_model.fp16.safetensors
+    └── diffusion_pytorch_model.safetensors You can access each of the components of the pipeline as an attribute to view its configuration:   Copied pipeline.tokenizer
+CLIPTokenizer(
+    name_or_path="/root/.cache/huggingface/hub/models--runwayml--stable-diffusion-v1-5/snapshots/39593d5650112b4cc580433f6b0435385882d819/tokenizer",
+    vocab_size=49408,
+    model_max_length=77,
+    is_fast=False,
+    padding_side="right",
+    truncation_side="right",
+    special_tokens={
+        "bos_token": AddedToken("<|startoftext|>", rstrip=False, lstrip=False, single_word=False, normalized=True),
+        "eos_token": AddedToken("<|endoftext|>", rstrip=False, lstrip=False, single_word=False, normalized=True),
+        "unk_token": AddedToken("<|endoftext|>", rstrip=False, lstrip=False, single_word=False, normalized=True),
+        "pad_token": "<|endoftext|>",
+    },
+    clean_up_tokenization_spaces=True
+) Every pipeline expects a model_index.json file that tells the DiffusionPipeline: which pipeline class to load from _class_name which version of 🧨 Diffusers was used to create the model in _diffusers_version what components from which library are stored in the subfolders (name corresponds to the component and subfolder name, library corresponds to the name of the library to load the class from, and class corresponds to the class name)   Copied {
+  "_class_name": "StableDiffusionPipeline",
+  "_diffusers_version": "0.6.0",
+  "feature_extractor": [
+    "transformers",
+    "CLIPImageProcessor"
+  ],
+  "safety_checker": [
+    "stable_diffusion",
+    "StableDiffusionSafetyChecker"
+  ],
+  "scheduler": [
+    "diffusers",
+    "PNDMScheduler"
+  ],
+  "text_encoder": [
+    "transformers",
+    "CLIPTextModel"
+  ],
+  "tokenizer": [
+    "transformers",
+    "CLIPTokenizer"
+  ],
+  "unet": [
+    "diffusers",
+    "UNet2DConditionModel"
+  ],
+  "vae": [
+    "diffusers",
+    "AutoencoderKL"
+  ]
+}

scrapped_outputs/024b6d495f66ffbe96d4b6dc2553b492.txt

@@ -0,0 +1,260 @@
+Performing inference with LCM-LoRA Latent Consistency Models (LCM) enable quality image generation in typically 2-4 steps making it possible to use diffusion models in almost real-time settings. From the official website: LCMs can be distilled from any pre-trained Stable Diffusion (SD) in only 4,000 training steps (~32 A100 GPU Hours) for generating high quality 768 x 768 resolution images in 2~4 steps or even one step, significantly accelerating text-to-image generation. We employ LCM to distill the Dreamshaper-V7 version of SD in just 4,000 training iterations. For a more technical overview of LCMs, refer to the paper. However, each model needs to be distilled separately for latent consistency distillation. The core idea with LCM-LoRA is to train just a few adapter layers, the adapter being LoRA in this case.
+This way, we don’t have to train the full model and keep the number of trainable parameters manageable. The resulting LoRAs can then be applied to any fine-tuned version of the model without distilling them separately.
+Additionally, the LoRAs can be applied to image-to-image, ControlNet/T2I-Adapter, inpainting, AnimateDiff etc.
+The LCM-LoRA can also be combined with other LoRAs to generate styled images in very few steps (4-8). LCM-LoRAs are available for stable-diffusion-v1-5, stable-diffusion-xl-base-1.0, and the SSD-1B model. All the checkpoints can be found in this collection. For more details about LCM-LoRA, refer to the technical report. This guide shows how to perform inference with LCM-LoRAs for text-to-image image-to-image combined with styled LoRAs ControlNet/T2I-Adapter inpainting AnimateDiff Before going through this guide, we’ll take a look at the general workflow for performing inference with LCM-LoRAs.
+LCM-LoRAs are similar to other Stable Diffusion LoRAs so they can be used with any DiffusionPipeline that supports LoRAs. Load the task specific pipeline and model. Set the scheduler to LCMScheduler. Load the LCM-LoRA weights for the model. Reduce the guidance_scale between [1.0, 2.0] and set the num_inference_steps between [4, 8]. Perform inference with the pipeline with the usual parameters. Let’s look at how we can perform inference with LCM-LoRAs for different tasks. First, make sure you have peft installed, for better LoRA support.   Copied pip install -U peft  Text-to-image You’ll use the StableDiffusionXLPipeline with the scheduler: LCMScheduler and then load the LCM-LoRA. Together with the LCM-LoRA and the scheduler, the pipeline enables a fast inference workflow overcoming the slow iterative nature of diffusion models.   Copied import torch
+from diffusers import DiffusionPipeline, LCMScheduler
+
+pipe = DiffusionPipeline.from_pretrained(
+    "stabilityai/stable-diffusion-xl-base-1.0",
+    variant="fp16",
+    torch_dtype=torch.float16
+).to("cuda")
+
+# set scheduler
+pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)
+
+# load LCM-LoRA
+pipe.load_lora_weights("latent-consistency/lcm-lora-sdxl")
+
+prompt = "Self-portrait oil painting, a beautiful cyborg with golden hair, 8k"
+
+generator = torch.manual_seed(42)
+image = pipe(
+    prompt=prompt, num_inference_steps=4, generator=generator, guidance_scale=1.0
+).images[0]  Notice that we use only 4 steps for generation which is way less than what’s typically used for standard SDXL. You may have noticed that we set guidance_scale=1.0, which disables classifer-free-guidance. This is because the LCM-LoRA is trained with guidance, so the batch size does not have to be doubled in this case. This leads to a faster inference time, with the drawback that negative prompts don’t have any effect on the denoising process. You can also use guidance with LCM-LoRA, but due to the nature of training the model is very sensitve to the guidance_scale values, high values can lead to artifacts in the generated images. In our experiments, we found that the best values are in the range of [1.0, 2.0].  Inference with a fine-tuned model As mentioned above, the LCM-LoRA can be applied to any fine-tuned version of the model without having to distill them separately. Let’s look at how we can perform inference with a fine-tuned model. In this example, we’ll use the animagine-xl model, which is a fine-tuned version of the SDXL model for generating anime.   Copied from diffusers import DiffusionPipeline, LCMScheduler
+
+pipe = DiffusionPipeline.from_pretrained(
+    "Linaqruf/animagine-xl",
+    variant="fp16",
+    torch_dtype=torch.float16
+).to("cuda")
+
+# set scheduler
+pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)
+
+# load LCM-LoRA
+pipe.load_lora_weights("latent-consistency/lcm-lora-sdxl")
+
+prompt = "face focus, cute, masterpiece, best quality, 1girl, green hair, sweater, looking at viewer, upper body, beanie, outdoors, night, turtleneck"
+
+generator = torch.manual_seed(0)
+image = pipe(
+    prompt=prompt, num_inference_steps=4, generator=generator, guidance_scale=1.0
+).images[0]   Image-to-image LCM-LoRA can be applied to image-to-image tasks too. Let’s look at how we can perform image-to-image generation with LCMs. For this example we’ll use the dreamshaper-7 model and the LCM-LoRA for stable-diffusion-v1-5 .   Copied import torch
+from diffusers import AutoPipelineForImage2Image, LCMScheduler
+from diffusers.utils import make_image_grid, load_image
+
+pipe = AutoPipelineForImage2Image.from_pretrained(
+    "Lykon/dreamshaper-7",
+    torch_dtype=torch.float16,
+    variant="fp16",
+).to("cuda")
+
+# set scheduler
+pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)
+
+# load LCM-LoRA
+pipe.load_lora_weights("latent-consistency/lcm-lora-sdv1-5")
+
+# prepare image
+url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/img2img-init.png"
+init_image = load_image(url)
+prompt = "Astronauts in a jungle, cold color palette, muted colors, detailed, 8k"
+
+# pass prompt and image to pipeline
+generator = torch.manual_seed(0)
+image = pipe(
+    prompt,
+    image=init_image,
+    num_inference_steps=4,
+    guidance_scale=1,
+    strength=0.6,
+    generator=generator
+).images[0]
+make_image_grid([init_image, image], rows=1, cols=2)  You can get different results based on your prompt and the image you provide. To get the best results, we recommend trying different values for num_inference_steps, strength, and guidance_scale parameters and choose the best one.  Combine with styled LoRAs LCM-LoRA can be combined with other LoRAs to generate styled-images in very few steps (4-8). In the following example, we’ll use the LCM-LoRA with the papercut LoRA.
+To learn more about how to combine LoRAs, refer to this guide.   Copied import torch
+from diffusers import DiffusionPipeline, LCMScheduler
+
+pipe = DiffusionPipeline.from_pretrained(
+    "stabilityai/stable-diffusion-xl-base-1.0",
+    variant="fp16",
+    torch_dtype=torch.float16
+).to("cuda")
+
+# set scheduler
+pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)
+
+# load LoRAs
+pipe.load_lora_weights("latent-consistency/lcm-lora-sdxl", adapter_name="lcm")
+pipe.load_lora_weights("TheLastBen/Papercut_SDXL", weight_name="papercut.safetensors", adapter_name="papercut")
+
+# Combine LoRAs
+pipe.set_adapters(["lcm", "papercut"], adapter_weights=[1.0, 0.8])
+
+prompt = "papercut, a cute fox"
+generator = torch.manual_seed(0)
+image = pipe(prompt, num_inference_steps=4, guidance_scale=1, generator=generator).images[0]
+image   ControlNet/T2I-Adapter Let’s look at how we can perform inference with ControlNet/T2I-Adapter and LCM-LoRA.  ControlNet For this example, we’ll use the SD-v1-5 model and the LCM-LoRA for SD-v1-5 with canny ControlNet.   Copied import torch
+import cv2
+import numpy as np
+from PIL import Image
+
+from diffusers import StableDiffusionControlNetPipeline, ControlNetModel, LCMScheduler
+from diffusers.utils import load_image
+
+image = load_image(
+    "https://hf.co/datasets/huggingface/documentation-images/resolve/main/diffusers/input_image_vermeer.png"
+).resize((512, 512))
+
+image = np.array(image)
+
+low_threshold = 100
+high_threshold = 200
+
+image = cv2.Canny(image, low_threshold, high_threshold)
+image = image[:, :, None]
+image = np.concatenate([image, image, image], axis=2)
+canny_image = Image.fromarray(image)
+
+controlnet = ControlNetModel.from_pretrained("lllyasviel/sd-controlnet-canny", torch_dtype=torch.float16)
+pipe = StableDiffusionControlNetPipeline.from_pretrained(
+    "runwayml/stable-diffusion-v1-5",
+    controlnet=controlnet,
+    torch_dtype=torch.float16,
+    safety_checker=None,
+    variant="fp16"
+).to("cuda")
+
+# set scheduler
+pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)
+
+# load LCM-LoRA
+pipe.load_lora_weights("latent-consistency/lcm-lora-sdv1-5")
+
+generator = torch.manual_seed(0)
+image = pipe(
+    "the mona lisa",
+    image=canny_image,
+    num_inference_steps=4,
+    guidance_scale=1.5,
+    controlnet_conditioning_scale=0.8,
+    cross_attention_kwargs={"scale": 1},
+    generator=generator,
+).images[0]
+make_image_grid([canny_image, image], rows=1, cols=2)  The inference parameters in this example might not work for all examples, so we recommend you to try different values for `num_inference_steps`, `guidance_scale`, `controlnet_conditioning_scale` and `cross_attention_kwargs` parameters and choose the best one.  T2I-Adapter This example shows how to use the LCM-LoRA with the Canny T2I-Adapter and SDXL.   Copied import torch
+import cv2
+import numpy as np
+from PIL import Image
+
+from diffusers import StableDiffusionXLAdapterPipeline, T2IAdapter, LCMScheduler
+from diffusers.utils import load_image, make_image_grid
+
+# Prepare image
+# Detect the canny map in low resolution to avoid high-frequency details
+image = load_image(
+    "https://huggingface.co/Adapter/t2iadapter/resolve/main/figs_SDXLV1.0/org_canny.jpg"
+).resize((384, 384))
+
+image = np.array(image)
+
+low_threshold = 100
+high_threshold = 200
+
+image = cv2.Canny(image, low_threshold, high_threshold)
+image = image[:, :, None]
+image = np.concatenate([image, image, image], axis=2)
+canny_image = Image.fromarray(image).resize((1024, 1024))
+
+# load adapter
+adapter = T2IAdapter.from_pretrained("TencentARC/t2i-adapter-canny-sdxl-1.0", torch_dtype=torch.float16, varient="fp16").to("cuda")
+
+pipe = StableDiffusionXLAdapterPipeline.from_pretrained(
+    "stabilityai/stable-diffusion-xl-base-1.0", 
+    adapter=adapter,
+    torch_dtype=torch.float16,
+    variant="fp16", 
+).to("cuda")
+
+# set scheduler
+pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)
+
+# load LCM-LoRA
+pipe.load_lora_weights("latent-consistency/lcm-lora-sdxl")
+
+prompt = "Mystical fairy in real, magic, 4k picture, high quality"
+negative_prompt = "extra digit, fewer digits, cropped, worst quality, low quality, glitch, deformed, mutated, ugly, disfigured"
+
+generator = torch.manual_seed(0)
+image = pipe(
+    prompt=prompt,
+    negative_prompt=negative_prompt,
+    image=canny_image,
+    num_inference_steps=4,
+    guidance_scale=1.5, 
+    adapter_conditioning_scale=0.8, 
+    adapter_conditioning_factor=1,
+    generator=generator,
+).images[0]
+make_image_grid([canny_image, image], rows=1, cols=2)   Inpainting LCM-LoRA can be used for inpainting as well.   Copied import torch
+from diffusers import AutoPipelineForInpainting, LCMScheduler
+from diffusers.utils import load_image, make_image_grid
+
+pipe = AutoPipelineForInpainting.from_pretrained(
+    "runwayml/stable-diffusion-inpainting",
+    torch_dtype=torch.float16,
+    variant="fp16",
+).to("cuda")
+
+# set scheduler
+pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)
+
+# load LCM-LoRA
+pipe.load_lora_weights("latent-consistency/lcm-lora-sdv1-5")
+
+# load base and mask image
+init_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/inpaint.png")
+mask_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/inpaint_mask.png")
+
+# generator = torch.Generator("cuda").manual_seed(92)
+prompt = "concept art digital painting of an elven castle, inspired by lord of the rings, highly detailed, 8k"
+generator = torch.manual_seed(0)
+image = pipe(
+    prompt=prompt,
+    image=init_image,
+    mask_image=mask_image,
+    generator=generator,
+    num_inference_steps=4,
+    guidance_scale=4, 
+).images[0]
+make_image_grid([init_image, mask_image, image], rows=1, cols=3)   AnimateDiff AnimateDiff allows you to animate images using Stable Diffusion models. To get good results, we need to generate multiple frames (16-24), and doing this with standard SD models can be very slow.
+LCM-LoRA can be used to speed up the process significantly, as you just need to do 4-8 steps for each frame. Let’s look at how we can perform animation with LCM-LoRA and AnimateDiff.   Copied import torch
+from diffusers import MotionAdapter, AnimateDiffPipeline, DDIMScheduler, LCMScheduler
+from diffusers.utils import export_to_gif
+
+adapter = MotionAdapter.from_pretrained("diffusers/animatediff-motion-adapter-v1-5")
+pipe = AnimateDiffPipeline.from_pretrained(
+    "frankjoshua/toonyou_beta6",
+    motion_adapter=adapter,
+).to("cuda")
+
+# set scheduler
+pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)
+
+# load LCM-LoRA
+pipe.load_lora_weights("latent-consistency/lcm-lora-sdv1-5", adapter_name="lcm")
+pipe.load_lora_weights("guoyww/animatediff-motion-lora-zoom-in", weight_name="diffusion_pytorch_model.safetensors", adapter_name="motion-lora")
+
+pipe.set_adapters(["lcm", "motion-lora"], adapter_weights=[0.55, 1.2])
+
+prompt = "best quality, masterpiece, 1girl, looking at viewer, blurry background, upper body, contemporary, dress"
+generator = torch.manual_seed(0)
+frames = pipe(
+    prompt=prompt,
+    num_inference_steps=5,
+    guidance_scale=1.25,
+    cross_attention_kwargs={"scale": 1},
+    num_frames=24,
+    generator=generator
+).frames[0]
+export_to_gif(frames, "animation.gif")

scrapped_outputs/029a71d92796bdac8ab84604964508c7.txt

@@ -0,0 +1,53 @@
+UNet3DConditionModel The UNet model was originally introduced by Ronneberger et al. for biomedical image segmentation, but it is also commonly used in 🤗 Diffusers because it outputs images that are the same size as the input. It is one of the most important components of a diffusion system because it facilitates the actual diffusion process. There are several variants of the UNet model in 🤗 Diffusers, depending on it’s number of dimensions and whether it is a conditional model or not. This is a 3D UNet conditional model. The abstract from the paper is: There is large consent that successful training of deep networks requires many thousand annotated training samples. In this paper, we present a network and training strategy that relies on the strong use of data augmentation to use the available annotated samples more efficiently. The architecture consists of a contracting path to capture context and a symmetric expanding path that enables precise localization. We show that such a network can be trained end-to-end from very few images and outperforms the prior best method (a sliding-window convolutional network) on the ISBI challenge for segmentation of neuronal structures in electron microscopic stacks. Using the same network trained on transmitted light microscopy images (phase contrast and DIC) we won the ISBI cell tracking challenge 2015 in these categories by a large margin. Moreover, the network is fast. Segmentation of a 512x512 image takes less than a second on a recent GPU. The full implementation (based on Caffe) and the trained networks are available at http://lmb.informatik.uni-freiburg.de/people/ronneber/u-net.  UNet3DConditionModel  class diffusers.UNet3DConditionModel  < source > ( sample_size: Optional = None in_channels: int = 4 out_channels: int = 4 down_block_types: Tuple = ('CrossAttnDownBlock3D', 'CrossAttnDownBlock3D', 'CrossAttnDownBlock3D', 'DownBlock3D') up_block_types: Tuple = ('UpBlock3D', 'CrossAttnUpBlock3D', 'CrossAttnUpBlock3D', 'CrossAttnUpBlock3D') block_out_channels: Tuple = (320, 640, 1280, 1280) layers_per_block: int = 2 downsample_padding: int = 1 mid_block_scale_factor: float = 1 act_fn: str = 'silu' norm_num_groups: Optional = 32 norm_eps: float = 1e-05 cross_attention_dim: int = 1024 attention_head_dim: Union = 64 num_attention_heads: Union = None  )   Parameters   sample_size (int or Tuple[int, int], optional, defaults to None) —
+Height and width of input/output sample.   in_channels (int, optional, defaults to 4) — The number of channels in the input sample.   out_channels (int, optional, defaults to 4) — The number of channels in the output.   down_block_types (Tuple[str], optional, defaults to ("CrossAttnDownBlock3D", "CrossAttnDownBlock3D", "CrossAttnDownBlock3D", "DownBlock3D")) —
+The tuple of downsample blocks to use.   up_block_types (Tuple[str], optional, defaults to ("UpBlock3D", "CrossAttnUpBlock3D", "CrossAttnUpBlock3D", "CrossAttnUpBlock3D")) —
+The tuple of upsample blocks to use.   block_out_channels (Tuple[int], optional, defaults to (320, 640, 1280, 1280)) —
+The tuple of output channels for each block.   layers_per_block (int, optional, defaults to 2) — The number of layers per block.   downsample_padding (int, optional, defaults to 1) — The padding to use for the downsampling convolution.   mid_block_scale_factor (float, optional, defaults to 1.0) — The scale factor to use for the mid block.   act_fn (str, optional, defaults to "silu") — The activation function to use.   norm_num_groups (int, optional, defaults to 32) — The number of groups to use for the normalization.
+If None, normalization and activation layers is skipped in post-processing.   norm_eps (float, optional, defaults to 1e-5) — The epsilon to use for the normalization.   cross_attention_dim (int, optional, defaults to 1024) — The dimension of the cross attention features.   attention_head_dim (int, optional, defaults to 64) — The dimension of the attention heads.   num_attention_heads (int, optional) — The number of attention heads.    A conditional 3D UNet model that takes a noisy sample, conditional state, and a timestep and returns a sample
+shaped output. This model inherits from ModelMixin. Check the superclass documentation for it’s generic methods implemented
+for all models (such as downloading or saving).  disable_freeu  < source > ( )    Disables the FreeU mechanism.  enable_forward_chunking  < source > ( chunk_size: Optional = None dim: int = 0  )   Parameters   chunk_size (int, optional) —
+The chunk size of the feed-forward layers. If not specified, will run feed-forward layer individually
+over each tensor of dim=dim.   dim (int, optional, defaults to 0) —
+The dimension over which the feed-forward computation should be chunked. Choose between dim=0 (batch)
+or dim=1 (sequence length).    Sets the attention processor to use feed forward
+chunking.  enable_freeu  < source > ( s1 s2 b1 b2  )   Parameters   s1 (float) —
+Scaling factor for stage 1 to attenuate the contributions of the skip features. This is done to
+mitigate the “oversmoothing effect” in the enhanced denoising process.   s2 (float) —
+Scaling factor for stage 2 to attenuate the contributions of the skip features. This is done to
+mitigate the “oversmoothing effect” in the enhanced denoising process.   b1 (float) — Scaling factor for stage 1 to amplify the contributions of backbone features.   b2 (float) — Scaling factor for stage 2 to amplify the contributions of backbone features.    Enables the FreeU mechanism from https://arxiv.org/abs/2309.11497. The suffixes after the scaling factors represent the stage blocks where they are being applied. Please refer to the official repository for combinations of values that
+are known to work well for different pipelines such as Stable Diffusion v1, v2, and Stable Diffusion XL.  forward  < source > ( sample: FloatTensor timestep: Union encoder_hidden_states: Tensor class_labels: Optional = None timestep_cond: Optional = None attention_mask: Optional = None cross_attention_kwargs: Optional = None down_block_additional_residuals: Optional = None mid_block_additional_residual: Optional = None return_dict: bool = True  ) → ~models.unet_3d_condition.UNet3DConditionOutput or tuple  Parameters   sample (torch.FloatTensor) —
+The noisy input tensor with the following shape (batch, num_channels, num_frames, height, width.   timestep (torch.FloatTensor or float or int) — The number of timesteps to denoise an input.   encoder_hidden_states (torch.FloatTensor) —
+The encoder hidden states with shape (batch, sequence_length, feature_dim).   class_labels (torch.Tensor, optional, defaults to None) —
+Optional class labels for conditioning. Their embeddings will be summed with the timestep embeddings.
+timestep_cond — (torch.Tensor, optional, defaults to None):
+Conditional embeddings for timestep. If provided, the embeddings will be summed with the samples passed
+through the self.time_embedding layer to obtain the timestep embeddings.   attention_mask (torch.Tensor, optional, defaults to None) —
+An attention mask of shape (batch, key_tokens) is applied to encoder_hidden_states. If 1 the mask
+is kept, otherwise if 0 it is discarded. Mask will be converted into a bias, which adds large
+negative values to the attention scores corresponding to “discard” tokens.   cross_attention_kwargs (dict, optional) —
+A kwargs dictionary that if specified is passed along to the AttentionProcessor as defined under
+self.processor in
+diffusers.models.attention_processor.
+down_block_additional_residuals — (tuple of torch.Tensor, optional):
+A tuple of tensors that if specified are added to the residuals of down unet blocks.
+mid_block_additional_residual — (torch.Tensor, optional):
+A tensor that if specified is added to the residual of the middle unet block.   return_dict (bool, optional, defaults to True) —
+Whether or not to return a ~models.unet_3d_condition.UNet3DConditionOutput instead of a plain
+tuple.   cross_attention_kwargs (dict, optional) —
+A kwargs dictionary that if specified is passed along to the AttnProcessor.   Returns 
+~models.unet_3d_condition.UNet3DConditionOutput or tuple
+  
+If return_dict is True, an ~models.unet_3d_condition.UNet3DConditionOutput is returned, otherwise
+a tuple is returned where the first element is the sample tensor.
+  The UNet3DConditionModel forward method.  fuse_qkv_projections  < source > ( )    Enables fused QKV projections. For self-attention modules, all projection matrices (i.e., query,
+key, value) are fused. For cross-attention modules, key and value projection matrices are fused. This API is 🧪 experimental.  set_attention_slice  < source > ( slice_size: Union  )   Parameters   slice_size (str or int or list(int), optional, defaults to "auto") —
+When "auto", input to the attention heads is halved, so attention is computed in two steps. If
+"max", maximum amount of memory is saved by running only one slice at a time. If a number is
+provided, uses as many slices as attention_head_dim // slice_size. In this case, attention_head_dim
+must be a multiple of slice_size.    Enable sliced attention computation. When this option is enabled, the attention module splits the input tensor in slices to compute attention in
+several steps. This is useful for saving some memory in exchange for a small decrease in speed.  set_attn_processor  < source > ( processor: Union  )   Parameters   processor (dict of AttentionProcessor or only AttentionProcessor) —
+The instantiated processor class or a dictionary of processor classes that will be set as the processor
+for all Attention layers.
+If processor is a dict, the key needs to define the path to the corresponding cross attention
+processor. This is strongly recommended when setting trainable attention processors.    Sets the attention processor to use to compute attention.  set_default_attn_processor  < source > ( )    Disables custom attention processors and sets the default attention implementation.  unfuse_qkv_projections  < source > ( )    Disables the fused QKV projection if enabled. This API is 🧪 experimental.  unload_lora  < source > ( )    Unloads LoRA weights.  UNet3DConditionOutput  class diffusers.models.unets.unet_3d_condition.UNet3DConditionOutput  < source > ( sample: FloatTensor  )   Parameters   sample (torch.FloatTensor of shape (batch_size, num_channels, num_frames, height, width)) —
+The hidden states output conditioned on encoder_hidden_states input. Output of last layer of model.    The output of UNet3DConditionModel.

scrapped_outputs/02aee9759affa29fb25ab0383cbb3c8d.txt

@@ -0,0 +1,138 @@
+UNet2DConditionModel The UNet model was originally introduced by Ronneberger et al. for biomedical image segmentation, but it is also commonly used in 🤗 Diffusers because it outputs images that are the same size as the input. It is one of the most important components of a diffusion system because it facilitates the actual diffusion process. There are several variants of the UNet model in 🤗 Diffusers, depending on it’s number of dimensions and whether it is a conditional model or not. This is a 2D UNet conditional model. The abstract from the paper is: There is large consent that successful training of deep networks requires many thousand annotated training samples. In this paper, we present a network and training strategy that relies on the strong use of data augmentation to use the available annotated samples more efficiently. The architecture consists of a contracting path to capture context and a symmetric expanding path that enables precise localization. We show that such a network can be trained end-to-end from very few images and outperforms the prior best method (a sliding-window convolutional network) on the ISBI challenge for segmentation of neuronal structures in electron microscopic stacks. Using the same network trained on transmitted light microscopy images (phase contrast and DIC) we won the ISBI cell tracking challenge 2015 in these categories by a large margin. Moreover, the network is fast. Segmentation of a 512x512 image takes less than a second on a recent GPU. The full implementation (based on Caffe) and the trained networks are available at http://lmb.informatik.uni-freiburg.de/people/ronneber/u-net.  UNet2DConditionModel  class diffusers.UNet2DConditionModel  < source > ( sample_size: Optional = None in_channels: int = 4 out_channels: int = 4 center_input_sample: bool = False flip_sin_to_cos: bool = True freq_shift: int = 0 down_block_types: Tuple = ('CrossAttnDownBlock2D', 'CrossAttnDownBlock2D', 'CrossAttnDownBlock2D', 'DownBlock2D') mid_block_type: Optional = 'UNetMidBlock2DCrossAttn' up_block_types: Tuple = ('UpBlock2D', 'CrossAttnUpBlock2D', 'CrossAttnUpBlock2D', 'CrossAttnUpBlock2D') only_cross_attention: Union = False block_out_channels: Tuple = (320, 640, 1280, 1280) layers_per_block: Union = 2 downsample_padding: int = 1 mid_block_scale_factor: float = 1 dropout: float = 0.0 act_fn: str = 'silu' norm_num_groups: Optional = 32 norm_eps: float = 1e-05 cross_attention_dim: Union = 1280 transformer_layers_per_block: Union = 1 reverse_transformer_layers_per_block: Optional = None encoder_hid_dim: Optional = None encoder_hid_dim_type: Optional = None attention_head_dim: Union = 8 num_attention_heads: Union = None dual_cross_attention: bool = False use_linear_projection: bool = False class_embed_type: Optional = None addition_embed_type: Optional = None addition_time_embed_dim: Optional = None num_class_embeds: Optional = None upcast_attention: bool = False resnet_time_scale_shift: str = 'default' resnet_skip_time_act: bool = False resnet_out_scale_factor: int = 1.0 time_embedding_type: str = 'positional' time_embedding_dim: Optional = None time_embedding_act_fn: Optional = None timestep_post_act: Optional = None time_cond_proj_dim: Optional = None conv_in_kernel: int = 3 conv_out_kernel: int = 3 projection_class_embeddings_input_dim: Optional = None attention_type: str = 'default' class_embeddings_concat: bool = False mid_block_only_cross_attention: Optional = None cross_attention_norm: Optional = None addition_embed_type_num_heads = 64  )   Parameters   sample_size (int or Tuple[int, int], optional, defaults to None) —
+Height and width of input/output sample.   in_channels (int, optional, defaults to 4) — Number of channels in the input sample.   out_channels (int, optional, defaults to 4) — Number of channels in the output.   center_input_sample (bool, optional, defaults to False) — Whether to center the input sample.   flip_sin_to_cos (bool, optional, defaults to False) —
+Whether to flip the sin to cos in the time embedding.   freq_shift (int, optional, defaults to 0) — The frequency shift to apply to the time embedding.   down_block_types (Tuple[str], optional, defaults to ("CrossAttnDownBlock2D", "CrossAttnDownBlock2D", "CrossAttnDownBlock2D", "DownBlock2D")) —
+The tuple of downsample blocks to use.   mid_block_type (str, optional, defaults to "UNetMidBlock2DCrossAttn") —
+Block type for middle of UNet, it can be one of UNetMidBlock2DCrossAttn, UNetMidBlock2D, or
+UNetMidBlock2DSimpleCrossAttn. If None, the mid block layer is skipped.   up_block_types (Tuple[str], optional, defaults to ("UpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D")) —
+The tuple of upsample blocks to use.   only_cross_attention(bool or Tuple[bool], optional, default to False) —
+Whether to include self-attention in the basic transformer blocks, see
+BasicTransformerBlock.   block_out_channels (Tuple[int], optional, defaults to (320, 640, 1280, 1280)) —
+The tuple of output channels for each block.   layers_per_block (int, optional, defaults to 2) — The number of layers per block.   downsample_padding (int, optional, defaults to 1) — The padding to use for the downsampling convolution.   mid_block_scale_factor (float, optional, defaults to 1.0) — The scale factor to use for the mid block.   dropout (float, optional, defaults to 0.0) — The dropout probability to use.   act_fn (str, optional, defaults to "silu") — The activation function to use.   norm_num_groups (int, optional, defaults to 32) — The number of groups to use for the normalization.
+If None, normalization and activation layers is skipped in post-processing.   norm_eps (float, optional, defaults to 1e-5) — The epsilon to use for the normalization.   cross_attention_dim (int or Tuple[int], optional, defaults to 1280) —
+The dimension of the cross attention features.   transformer_layers_per_block (int, Tuple[int], or Tuple[Tuple] , optional, defaults to 1) —
+The number of transformer blocks of type BasicTransformerBlock. Only relevant for
+CrossAttnDownBlock2D, CrossAttnUpBlock2D,
+UNetMidBlock2DCrossAttn.    A conditional 2D UNet model that takes a noisy sample, conditional state, and a timestep and returns a sample
+shaped output. This model inherits from ModelMixin. Check the superclass documentation for it’s generic methods implemented
+for all models (such as downloading or saving). reverse_transformer_layers_per_block : (Tuple[Tuple], optional, defaults to None):
+The number of transformer blocks of type BasicTransformerBlock, in the upsampling
+blocks of the U-Net. Only relevant if transformer_layers_per_block is of type Tuple[Tuple] and for
+CrossAttnDownBlock2D, CrossAttnUpBlock2D,
+UNetMidBlock2DCrossAttn.
+encoder_hid_dim (int, optional, defaults to None):
+If encoder_hid_dim_type is defined, encoder_hidden_states will be projected from encoder_hid_dim
+dimension to cross_attention_dim.
+encoder_hid_dim_type (str, optional, defaults to None):
+If given, the encoder_hidden_states and potentially other embeddings are down-projected to text
+embeddings of dimension cross_attention according to encoder_hid_dim_type.
+attention_head_dim (int, optional, defaults to 8): The dimension of the attention heads.
+num_attention_heads (int, optional):
+The number of attention heads. If not defined, defaults to attention_head_dim
+resnet_time_scale_shift (str, optional, defaults to "default"): Time scale shift config
+for ResNet blocks (see ResnetBlock2D). Choose from default or scale_shift.
+class_embed_type (str, optional, defaults to None):
+The type of class embedding to use which is ultimately summed with the time embeddings. Choose from None,
+"timestep", "identity", "projection", or "simple_projection".
+addition_embed_type (str, optional, defaults to None):
+Configures an optional embedding which will be summed with the time embeddings. Choose from None or
+“text”. “text” will use the TextTimeEmbedding layer.
+addition_time_embed_dim: (int, optional, defaults to None):
+Dimension for the timestep embeddings.
+num_class_embeds (int, optional, defaults to None):
+Input dimension of the learnable embedding matrix to be projected to time_embed_dim, when performing
+class conditioning with class_embed_type equal to None.
+time_embedding_type (str, optional, defaults to positional):
+The type of position embedding to use for timesteps. Choose from positional or fourier.
+time_embedding_dim (int, optional, defaults to None):
+An optional override for the dimension of the projected time embedding.
+time_embedding_act_fn (str, optional, defaults to None):
+Optional activation function to use only once on the time embeddings before they are passed to the rest of
+the UNet. Choose from silu, mish, gelu, and swish.
+timestep_post_act (str, optional, defaults to None):
+The second activation function to use in timestep embedding. Choose from silu, mish and gelu.
+time_cond_proj_dim (int, optional, defaults to None):
+The dimension of cond_proj layer in the timestep embedding.
+conv_in_kernel (int, optional, default to 3): The kernel size of conv_in layer. conv_out_kernel (int,
+optional, default to 3): The kernel size of conv_out layer. projection_class_embeddings_input_dim (int,
+optional): The dimension of the class_labels input when
+class_embed_type="projection". Required when class_embed_type="projection".
+class_embeddings_concat (bool, optional, defaults to False): Whether to concatenate the time
+embeddings with the class embeddings.
+mid_block_only_cross_attention (bool, optional, defaults to None):
+Whether to use cross attention with the mid block when using the UNetMidBlock2DSimpleCrossAttn. If
+only_cross_attention is given as a single boolean and mid_block_only_cross_attention is None, the
+only_cross_attention value is used as the value for mid_block_only_cross_attention. Default to False
+otherwise.  disable_freeu  < source > ( )    Disables the FreeU mechanism.  enable_freeu  < source > ( s1 s2 b1 b2  )   Parameters   s1 (float) —
+Scaling factor for stage 1 to attenuate the contributions of the skip features. This is done to
+mitigate the “oversmoothing effect” in the enhanced denoising process.   s2 (float) —
+Scaling factor for stage 2 to attenuate the contributions of the skip features. This is done to
+mitigate the “oversmoothing effect” in the enhanced denoising process.   b1 (float) — Scaling factor for stage 1 to amplify the contributions of backbone features.   b2 (float) — Scaling factor for stage 2 to amplify the contributions of backbone features.    Enables the FreeU mechanism from https://arxiv.org/abs/2309.11497. The suffixes after the scaling factors represent the stage blocks where they are being applied. Please refer to the official repository for combinations of values that
+are known to work well for different pipelines such as Stable Diffusion v1, v2, and Stable Diffusion XL.  forward  < source > ( sample: FloatTensor timestep: Union encoder_hidden_states: Tensor class_labels: Optional = None timestep_cond: Optional = None attention_mask: Optional = None cross_attention_kwargs: Optional = None added_cond_kwargs: Optional = None down_block_additional_residuals: Optional = None mid_block_additional_residual: Optional = None down_intrablock_additional_residuals: Optional = None encoder_attention_mask: Optional = None return_dict: bool = True  ) → UNet2DConditionOutput or tuple  Parameters   sample (torch.FloatTensor) —
+The noisy input tensor with the following shape (batch, channel, height, width).   timestep (torch.FloatTensor or float or int) — The number of timesteps to denoise an input.   encoder_hidden_states (torch.FloatTensor) —
+The encoder hidden states with shape (batch, sequence_length, feature_dim).   class_labels (torch.Tensor, optional, defaults to None) —
+Optional class labels for conditioning. Their embeddings will be summed with the timestep embeddings.
+timestep_cond — (torch.Tensor, optional, defaults to None):
+Conditional embeddings for timestep. If provided, the embeddings will be summed with the samples passed
+through the self.time_embedding layer to obtain the timestep embeddings.   attention_mask (torch.Tensor, optional, defaults to None) —
+An attention mask of shape (batch, key_tokens) is applied to encoder_hidden_states. If 1 the mask
+is kept, otherwise if 0 it is discarded. Mask will be converted into a bias, which adds large
+negative values to the attention scores corresponding to “discard” tokens.   cross_attention_kwargs (dict, optional) —
+A kwargs dictionary that if specified is passed along to the AttentionProcessor as defined under
+self.processor in
+diffusers.models.attention_processor.
+added_cond_kwargs — (dict, optional):
+A kwargs dictionary containing additional embeddings that if specified are added to the embeddings that
+are passed along to the UNet blocks.
+down_block_additional_residuals — (tuple of torch.Tensor, optional):
+A tuple of tensors that if specified are added to the residuals of down unet blocks.
+mid_block_additional_residual — (torch.Tensor, optional):
+A tensor that if specified is added to the residual of the middle unet block.   encoder_attention_mask (torch.Tensor) —
+A cross-attention mask of shape (batch, sequence_length) is applied to encoder_hidden_states. If
+True the mask is kept, otherwise if False it is discarded. Mask will be converted into a bias,
+which adds large negative values to the attention scores corresponding to “discard” tokens.   return_dict (bool, optional, defaults to True) —
+Whether or not to return a UNet2DConditionOutput instead of a plain
+tuple.   cross_attention_kwargs (dict, optional) —
+A kwargs dictionary that if specified is passed along to the AttnProcessor.
+added_cond_kwargs — (dict, optional):
+A kwargs dictionary containin additional embeddings that if specified are added to the embeddings that
+are passed along to the UNet blocks.   down_block_additional_residuals (tuple of torch.Tensor, optional) —
+additional residuals to be added to UNet long skip connections from down blocks to up blocks for
+example from ControlNet side model(s)   mid_block_additional_residual (torch.Tensor, optional) —
+additional residual to be added to UNet mid block output, for example from ControlNet side model   down_intrablock_additional_residuals (tuple of torch.Tensor, optional) —
+additional residuals to be added within UNet down blocks, for example from T2I-Adapter side model(s)   Returns 
+UNet2DConditionOutput or tuple
+  
+If return_dict is True, an UNet2DConditionOutput is returned, otherwise
+a tuple is returned where the first element is the sample tensor.
+  The UNet2DConditionModel forward method.  fuse_qkv_projections  < source > ( )    Enables fused QKV projections. For self-attention modules, all projection matrices (i.e., query,
+key, value) are fused. For cross-attention modules, key and value projection matrices are fused. This API is 🧪 experimental.  set_attention_slice  < source > ( slice_size  )   Parameters   slice_size (str or int or list(int), optional, defaults to "auto") —
+When "auto", input to the attention heads is halved, so attention is computed in two steps. If
+"max", maximum amount of memory is saved by running only one slice at a time. If a number is
+provided, uses as many slices as attention_head_dim // slice_size. In this case, attention_head_dim
+must be a multiple of slice_size.    Enable sliced attention computation. When this option is enabled, the attention module splits the input tensor in slices to compute attention in
+several steps. This is useful for saving some memory in exchange for a small decrease in speed.  set_attn_processor  < source > ( processor: Union _remove_lora = False  )   Parameters   processor (dict of AttentionProcessor or only AttentionProcessor) —
+The instantiated processor class or a dictionary of processor classes that will be set as the processor
+for all Attention layers.
+If processor is a dict, the key needs to define the path to the corresponding cross attention
+processor. This is strongly recommended when setting trainable attention processors.    Sets the attention processor to use to compute attention.  set_default_attn_processor  < source > ( )    Disables custom attention processors and sets the default attention implementation.  unfuse_qkv_projections  < source > ( )    Disables the fused QKV projection if enabled. This API is 🧪 experimental.  UNet2DConditionOutput  class diffusers.models.unet_2d_condition.UNet2DConditionOutput  < source > ( sample: FloatTensor = None  )   Parameters   sample (torch.FloatTensor of shape (batch_size, num_channels, height, width)) —
+The hidden states output conditioned on encoder_hidden_states input. Output of last layer of model.    The output of UNet2DConditionModel.  FlaxUNet2DConditionModel  class diffusers.FlaxUNet2DConditionModel  < source > ( sample_size: int = 32 in_channels: int = 4 out_channels: int = 4 down_block_types: Tuple = ('CrossAttnDownBlock2D', 'CrossAttnDownBlock2D', 'CrossAttnDownBlock2D', 'DownBlock2D') up_block_types: Tuple = ('UpBlock2D', 'CrossAttnUpBlock2D', 'CrossAttnUpBlock2D', 'CrossAttnUpBlock2D') only_cross_attention: Union = False block_out_channels: Tuple = (320, 640, 1280, 1280) layers_per_block: int = 2 attention_head_dim: Union = 8 num_attention_heads: Union = None cross_attention_dim: int = 1280 dropout: float = 0.0 use_linear_projection: bool = False dtype: dtype = <class 'jax.numpy.float32'> flip_sin_to_cos: bool = True freq_shift: int = 0 use_memory_efficient_attention: bool = False split_head_dim: bool = False transformer_layers_per_block: Union = 1 addition_embed_type: Optional = None addition_time_embed_dim: Optional = None addition_embed_type_num_heads: int = 64 projection_class_embeddings_input_dim: Optional = None parent: Union = <flax.linen.module._Sentinel object at 0x7fb48fdbfdf0> name: Optional = None  )   Parameters   sample_size (int, optional) —
+The size of the input sample.   in_channels (int, optional, defaults to 4) —
+The number of channels in the input sample.   out_channels (int, optional, defaults to 4) —
+The number of channels in the output.   down_block_types (Tuple[str], optional, defaults to ("FlaxCrossAttnDownBlock2D", "FlaxCrossAttnDownBlock2D", "FlaxCrossAttnDownBlock2D", "FlaxDownBlock2D")) —
+The tuple of downsample blocks to use.   up_block_types (Tuple[str], optional, defaults to ("FlaxUpBlock2D", "FlaxCrossAttnUpBlock2D", "FlaxCrossAttnUpBlock2D", "FlaxCrossAttnUpBlock2D")) —
+The tuple of upsample blocks to use.   block_out_channels (Tuple[int], optional, defaults to (320, 640, 1280, 1280)) —
+The tuple of output channels for each block.   layers_per_block (int, optional, defaults to 2) —
+The number of layers per block.   attention_head_dim (int or Tuple[int], optional, defaults to 8) —
+The dimension of the attention heads.   num_attention_heads (int or Tuple[int], optional) —
+The number of attention heads.   cross_attention_dim (int, optional, defaults to 768) —
+The dimension of the cross attention features.   dropout (float, optional, defaults to 0) —
+Dropout probability for down, up and bottleneck blocks.   flip_sin_to_cos (bool, optional, defaults to True) —
+Whether to flip the sin to cos in the time embedding.   freq_shift (int, optional, defaults to 0) — The frequency shift to apply to the time embedding.   use_memory_efficient_attention (bool, optional, defaults to False) —
+Enable memory efficient attention as described here.   split_head_dim (bool, optional, defaults to False) —
+Whether to split the head dimension into a new axis for the self-attention computation. In most cases,
+enabling this flag should speed up the computation for Stable Diffusion 2.x and Stable Diffusion XL.    A conditional 2D UNet model that takes a noisy sample, conditional state, and a timestep and returns a sample
+shaped output. This model inherits from FlaxModelMixin. Check the superclass documentation for it’s generic methods
+implemented for all models (such as downloading or saving). This model is also a Flax Linen flax.linen.Module
+subclass. Use it as a regular Flax Linen module and refer to the Flax documentation for all matters related to its
+general usage and behavior. Inherent JAX features such as the following are supported: Just-In-Time (JIT) compilation Automatic Differentiation Vectorization Parallelization  FlaxUNet2DConditionOutput  class diffusers.models.unet_2d_condition_flax.FlaxUNet2DConditionOutput  < source > ( sample: Array  )   Parameters   sample (jnp.ndarray of shape (batch_size, num_channels, height, width)) —
+The hidden states output conditioned on encoder_hidden_states input. Output of last layer of model.    The output of FlaxUNet2DConditionModel.  replace  < source > ( **updates  )    “Returns a new object replacing the specified fields with new values.

scrapped_outputs/02bd848b35977a9c9f00ad003cb069ef.txt

@@ -0,0 +1,48 @@
+How to use Stable Diffusion in Apple Silicon (M1/M2)
+	
+🤗 Diffusers is compatible with Apple silicon for Stable Diffusion inference, using the PyTorch mps device. These are the steps you need to follow to use your M1 or M2 computer with Stable Diffusion.
+
+Requirements
+	
+Mac computer with Apple silicon (M1/M2) hardware.
+macOS 12.6 or later (13.0 or later recommended).
+arm64 version of Python.
+PyTorch 1.13. You can install it with pip or conda using the instructions in https://pytorch.org/get-started/locally/.
+
+Inference Pipeline
+	
+The snippet below demonstrates how to use the mps backend using the familiar to() interface to move the Stable Diffusion pipeline to your M1 or M2 device.
+We recommend to “prime” the pipeline using an additional one-time pass through it. This is a temporary workaround for a weird issue we have detected: the first inference pass produces slightly different results than subsequent ones. You only need to do this pass once, and it’s ok to use just one inference step and discard the result.
+
+
+	Copied
+# make sure you're logged in with `huggingface-cli login`
+from diffusers import StableDiffusionPipeline
+
+pipe = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5")
+pipe = pipe.to("mps")
+
+# Recommended if your computer has < 64 GB of RAM
+pipe.enable_attention_slicing()
+
+prompt = "a photo of an astronaut riding a horse on mars"
+
+# First-time "warmup" pass (see explanation above)
+_ = pipe(prompt, num_inference_steps=1)
+
+# Results match those from the CPU device after the warmup pass.
+image = pipe(prompt).images[0]
+
+Performance Recommendations
+	
+M1/M2 performance is very sensitive to memory pressure. The system will automatically swap if it needs to, but performance will degrade significantly when it does.
+We recommend you use attention slicing to reduce memory pressure during inference and prevent swapping, particularly if your computer has lass than 64 GB of system RAM, or if you generate images at non-standard resolutions larger than 512 × 512 pixels. Attention slicing performs the costly attention operation in multiple steps instead of all at once. It usually has a performance impact of ~20% in computers without universal memory, but we have observed better performance in most Apple Silicon computers, unless you have 64 GB or more.
+
+
+	Copied
+pipeline.enable_attention_slicing()
+
+Known Issues
+	
+As mentioned above, we are investigating a strange first-time inference issue.
+Generating multiple prompts in a batch crashes or doesn’t work reliably. We believe this is related to the mps backend in PyTorch. This is being resolved, but for now we recommend to iterate instead of batching.

scrapped_outputs/031de0c7e6fbc268b733b53d76fd629b.txt

@@ -0,0 +1,58 @@
+Tiny AutoEncoder Tiny AutoEncoder for Stable Diffusion (TAESD) was introduced in madebyollin/taesd by Ollin Boer Bohan. It is a tiny distilled version of Stable Diffusion’s VAE that can quickly decode the latents in a StableDiffusionPipeline or StableDiffusionXLPipeline almost instantly. To use with Stable Diffusion v-2.1:   Copied import torch
+from diffusers import DiffusionPipeline, AutoencoderTiny
+
+pipe = DiffusionPipeline.from_pretrained(
+    "stabilityai/stable-diffusion-2-1-base", torch_dtype=torch.float16
+)
+pipe.vae = AutoencoderTiny.from_pretrained("madebyollin/taesd", torch_dtype=torch.float16)
+pipe = pipe.to("cuda")
+
+prompt = "slice of delicious New York-style berry cheesecake"
+image = pipe(prompt, num_inference_steps=25).images[0]
+image To use with Stable Diffusion XL 1.0   Copied import torch
+from diffusers import DiffusionPipeline, AutoencoderTiny
+
+pipe = DiffusionPipeline.from_pretrained(
+    "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16
+)
+pipe.vae = AutoencoderTiny.from_pretrained("madebyollin/taesdxl", torch_dtype=torch.float16)
+pipe = pipe.to("cuda")
+
+prompt = "slice of delicious New York-style berry cheesecake"
+image = pipe(prompt, num_inference_steps=25).images[0]
+image  AutoencoderTiny  class diffusers.AutoencoderTiny  < source > ( in_channels: int = 3 out_channels: int = 3 encoder_block_out_channels: Tuple = (64, 64, 64, 64) decoder_block_out_channels: Tuple = (64, 64, 64, 64) act_fn: str = 'relu' latent_channels: int = 4 upsampling_scaling_factor: int = 2 num_encoder_blocks: Tuple = (1, 3, 3, 3) num_decoder_blocks: Tuple = (3, 3, 3, 1) latent_magnitude: int = 3 latent_shift: float = 0.5 force_upcast: bool = False scaling_factor: float = 1.0  )   Parameters   in_channels (int, optional, defaults to 3) — Number of channels in the input image.   out_channels (int,  optional, defaults to 3) — Number of channels in the output.   encoder_block_out_channels (Tuple[int], optional, defaults to (64, 64, 64, 64)) —
+Tuple of integers representing the number of output channels for each encoder block. The length of the
+tuple should be equal to the number of encoder blocks.   decoder_block_out_channels (Tuple[int], optional, defaults to (64, 64, 64, 64)) —
+Tuple of integers representing the number of output channels for each decoder block. The length of the
+tuple should be equal to the number of decoder blocks.   act_fn (str, optional, defaults to "relu") —
+Activation function to be used throughout the model.   latent_channels (int, optional, defaults to 4) —
+Number of channels in the latent representation. The latent space acts as a compressed representation of
+the input image.   upsampling_scaling_factor (int, optional, defaults to 2) —
+Scaling factor for upsampling in the decoder. It determines the size of the output image during the
+upsampling process.   num_encoder_blocks (Tuple[int], optional, defaults to (1, 3, 3, 3)) —
+Tuple of integers representing the number of encoder blocks at each stage of the encoding process. The
+length of the tuple should be equal to the number of stages in the encoder. Each stage has a different
+number of encoder blocks.   num_decoder_blocks (Tuple[int], optional, defaults to (3, 3, 3, 1)) —
+Tuple of integers representing the number of decoder blocks at each stage of the decoding process. The
+length of the tuple should be equal to the number of stages in the decoder. Each stage has a different
+number of decoder blocks.   latent_magnitude (float, optional, defaults to 3.0) —
+Magnitude of the latent representation. This parameter scales the latent representation values to control
+the extent of information preservation.   latent_shift (float, optional, defaults to 0.5) —
+Shift applied to the latent representation. This parameter controls the center of the latent space.   scaling_factor (float, optional, defaults to 1.0) —
+The component-wise standard deviation of the trained latent space computed using the first batch of the
+training set. This is used to scale the latent space to have unit variance when training the diffusion
+model. The latents are scaled with the formula z = z * scaling_factor before being passed to the
+diffusion model. When decoding, the latents are scaled back to the original scale with the formula: z = 1 / scaling_factor * z. For more details, refer to sections 4.3.2 and D.1 of the High-Resolution Image
+Synthesis with Latent Diffusion Models paper. For this Autoencoder,
+however, no such scaling factor was used, hence the value of 1.0 as the default.   force_upcast (bool, optional, default to False) —
+If enabled it will force the VAE to run in float32 for high image resolution pipelines, such as SD-XL. VAE
+can be fine-tuned / trained to a lower range without losing too much precision, in which case
+force_upcast can be set to False (see this fp16-friendly
+AutoEncoder).    A tiny distilled VAE model for encoding images into latents and decoding latent representations into images. AutoencoderTiny is a wrapper around the original implementation of TAESD. This model inherits from ModelMixin. Check the superclass documentation for its generic methods implemented for
+all models (such as downloading or saving).  disable_slicing  < source > ( )    Disable sliced VAE decoding. If enable_slicing was previously enabled, this method will go back to computing
+decoding in one step.  disable_tiling  < source > ( )    Disable tiled VAE decoding. If enable_tiling was previously enabled, this method will go back to computing
+decoding in one step.  enable_slicing  < source > ( )    Enable sliced VAE decoding. When this option is enabled, the VAE will split the input tensor in slices to
+compute decoding in several steps. This is useful to save some memory and allow larger batch sizes.  enable_tiling  < source > ( use_tiling: bool = True  )    Enable tiled VAE decoding. When this option is enabled, the VAE will split the input tensor into tiles to
+compute decoding and encoding in several steps. This is useful for saving a large amount of memory and to allow
+processing larger images.  forward  < source > ( sample: FloatTensor return_dict: bool = True  )   Parameters   sample (torch.FloatTensor) — Input sample.   return_dict (bool, optional, defaults to True) —
+Whether or not to return a DecoderOutput instead of a plain tuple.     scale_latents  < source > ( x: FloatTensor  )    raw latents -> [0, 1]  unscale_latents  < source > ( x: FloatTensor  )    [0, 1] -> raw latents  AutoencoderTinyOutput  class diffusers.models.autoencoders.autoencoder_tiny.AutoencoderTinyOutput  < source > ( latents: Tensor  )   Parameters   latents (torch.Tensor) — Encoded outputs of the Encoder.    Output of AutoencoderTiny encoding method.

scrapped_outputs/0337e3a463f82d01341bcedbe24ef622.txt

@@ -0,0 +1,217 @@
+Load pipelines, models, and schedulers            Having an easy way to use a diffusion system for inference is essential to 🧨 Diffusers. Diffusion systems often consist of multiple components like parameterized models, tokenizers, and schedulers that interact in complex ways. That is why we designed the DiffusionPipeline to wrap the complexity of the entire diffusion system into an easy-to-use API, while remaining flexible enough to be adapted for other use cases, such as loading each component individually as building blocks to assemble your own diffusion system. Everything you need for inference or training is accessible with the from_pretrained() method. This guide will show you how to load: pipelines from the Hub and locally different components into a pipeline checkpoint variants such as different floating point types or non-exponential mean averaged (EMA) weights models and schedulers  Diffusion Pipeline 💡 Skip to the DiffusionPipeline explained section if you are interested in learning in more detail about how the DiffusionPipeline class works. The DiffusionPipeline class is the simplest and most generic way to load the latest trending diffusion model from the Hub. The DiffusionPipeline.from_pretrained() method automatically detects the correct pipeline class from the checkpoint, downloads, and caches all the required configuration and weight files, and returns a pipeline instance ready for inference.   Copied from diffusers import DiffusionPipeline
+
+repo_id = "runwayml/stable-diffusion-v1-5"
+pipe = DiffusionPipeline.from_pretrained(repo_id, use_safetensors=True) You can also load a checkpoint with its specific pipeline class. The example above loaded a Stable Diffusion model; to get the same result, use the StableDiffusionPipeline class:   Copied from diffusers import StableDiffusionPipeline
+
+repo_id = "runwayml/stable-diffusion-v1-5"
+pipe = StableDiffusionPipeline.from_pretrained(repo_id, use_safetensors=True) A checkpoint (such as CompVis/stable-diffusion-v1-4 or runwayml/stable-diffusion-v1-5) may also be used for more than one task, like text-to-image or image-to-image. To differentiate what task you want to use the checkpoint for, you have to load it directly with its corresponding task-specific pipeline class:   Copied from diffusers import StableDiffusionImg2ImgPipeline
+
+repo_id = "runwayml/stable-diffusion-v1-5"
+pipe = StableDiffusionImg2ImgPipeline.from_pretrained(repo_id)  Local pipeline To load a diffusion pipeline locally, use git-lfs to manually download the checkpoint (in this case, runwayml/stable-diffusion-v1-5) to your local disk. This creates a local folder, ./stable-diffusion-v1-5, on your disk:   Copied git-lfs install
+git clone https://huggingface.co/runwayml/stable-diffusion-v1-5 Then pass the local path to from_pretrained():   Copied from diffusers import DiffusionPipeline
+
+repo_id = "./stable-diffusion-v1-5"
+stable_diffusion = DiffusionPipeline.from_pretrained(repo_id, use_safetensors=True) The from_pretrained() method won’t download any files from the Hub when it detects a local path, but this also means it won’t download and cache the latest changes to a checkpoint.  Swap components in a pipeline You can customize the default components of any pipeline with another compatible component. Customization is important because: Changing the scheduler is important for exploring the trade-off between generation speed and quality. Different components of a model are typically trained independently and you can swap out a component with a better-performing one. During finetuning, usually only some components - like the UNet or text encoder - are trained. To find out which schedulers are compatible for customization, you can use the compatibles method:   Copied from diffusers import DiffusionPipeline
+
+repo_id = "runwayml/stable-diffusion-v1-5"
+stable_diffusion = DiffusionPipeline.from_pretrained(repo_id, use_safetensors=True)
+stable_diffusion.scheduler.compatibles Let’s use the SchedulerMixin.from_pretrained() method to replace the default PNDMScheduler with a more performant scheduler, EulerDiscreteScheduler. The subfolder="scheduler" argument is required to load the scheduler configuration from the correct subfolder of the pipeline repository. Then you can pass the new EulerDiscreteScheduler instance to the scheduler argument in DiffusionPipeline:   Copied from diffusers import DiffusionPipeline, EulerDiscreteScheduler
+
+repo_id = "runwayml/stable-diffusion-v1-5"
+scheduler = EulerDiscreteScheduler.from_pretrained(repo_id, subfolder="scheduler")
+stable_diffusion = DiffusionPipeline.from_pretrained(repo_id, scheduler=scheduler, use_safetensors=True)  Safety checker Diffusion models like Stable Diffusion can generate harmful content, which is why 🧨 Diffusers has a safety checker to check generated outputs against known hardcoded NSFW content. If you’d like to disable the safety checker for whatever reason, pass None to the safety_checker argument:   Copied from diffusers import DiffusionPipeline
+
+repo_id = "runwayml/stable-diffusion-v1-5"
+stable_diffusion = DiffusionPipeline.from_pretrained(repo_id, safety_checker=None, use_safetensors=True)
+"""
+You have disabled the safety checker for <class 'diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline'> by passing `safety_checker=None`. Ensure that you abide by the conditions of the Stable Diffusion license and do not expose unfiltered results in services or applications open to the public. Both the diffusers team and Hugging Face strongly recommend keeping the safety filter enabled in all public-facing circumstances, disabling it only for use cases that involve analyzing network behavior or auditing its results. For more information, please have a look at https://github.com/huggingface/diffusers/pull/254 .
+"""  Reuse components across pipelines You can also reuse the same components in multiple pipelines to avoid loading the weights into RAM twice. Use the components method to save the components:   Copied from diffusers import StableDiffusionPipeline, StableDiffusionImg2ImgPipeline
+
+model_id = "runwayml/stable-diffusion-v1-5"
+stable_diffusion_txt2img = StableDiffusionPipeline.from_pretrained(model_id, use_safetensors=True)
+
+components = stable_diffusion_txt2img.components Then you can pass the components to another pipeline without reloading the weights into RAM:   Copied stable_diffusion_img2img = StableDiffusionImg2ImgPipeline(**components) You can also pass the components individually to the pipeline if you want more flexibility over which components to reuse or disable. For example, to reuse the same components in the text-to-image pipeline, except for the safety checker and feature extractor, in the image-to-image pipeline:   Copied from diffusers import StableDiffusionPipeline, StableDiffusionImg2ImgPipeline
+
+model_id = "runwayml/stable-diffusion-v1-5"
+stable_diffusion_txt2img = StableDiffusionPipeline.from_pretrained(model_id, use_safetensors=True)
+stable_diffusion_img2img = StableDiffusionImg2ImgPipeline(
+    vae=stable_diffusion_txt2img.vae,
+    text_encoder=stable_diffusion_txt2img.text_encoder,
+    tokenizer=stable_diffusion_txt2img.tokenizer,
+    unet=stable_diffusion_txt2img.unet,
+    scheduler=stable_diffusion_txt2img.scheduler,
+    safety_checker=None,
+    feature_extractor=None,
+    requires_safety_checker=False,
+)  Checkpoint variants A checkpoint variant is usually a checkpoint whose weights are: Stored in a different floating point type for lower precision and lower storage, such as torch.float16, because it only requires half the bandwidth and storage to download. You can’t use this variant if you’re continuing training or using a CPU. Non-exponential mean averaged (EMA) weights, which shouldn’t be used for inference. You should use these to continue fine-tuning a model. 💡 When the checkpoints have identical model structures, but they were trained on different datasets and with a different training setup, they should be stored in separate repositories instead of variations (for example, stable-diffusion-v1-4 and stable-diffusion-v1-5). Otherwise, a variant is identical to the original checkpoint. They have exactly the same serialization format (like Safetensors), model structure, and weights that have identical tensor shapes. checkpoint type weight name argument for loading weights original diffusion_pytorch_model.bin  floating point diffusion_pytorch_model.fp16.bin variant, torch_dtype non-EMA diffusion_pytorch_model.non_ema.bin variant There are two important arguments to know for loading variants: torch_dtype defines the floating point precision of the loaded checkpoints. For example, if you want to save bandwidth by loading a fp16 variant, you should specify torch_dtype=torch.float16 to convert the weights to fp16. Otherwise, the fp16 weights are converted to the default fp32 precision. You can also load the original checkpoint without defining the variant argument, and convert it to fp16 with torch_dtype=torch.float16. In this case, the default fp32 weights are downloaded first, and then they’re converted to fp16 after loading. variant defines which files should be loaded from the repository. For example, if you want to load a non_ema variant from the diffusers/stable-diffusion-variants repository, you should specify variant="non_ema" to download the non_ema files.   Copied from diffusers import DiffusionPipeline
+import torch
+
+# load fp16 variant
+stable_diffusion = DiffusionPipeline.from_pretrained(
+    "runwayml/stable-diffusion-v1-5", variant="fp16", torch_dtype=torch.float16, use_safetensors=True
+)
+# load non_ema variant
+stable_diffusion = DiffusionPipeline.from_pretrained(
+    "runwayml/stable-diffusion-v1-5", variant="non_ema", use_safetensors=True
+) To save a checkpoint stored in a different floating-point type or as a non-EMA variant, use the DiffusionPipeline.save_pretrained() method and specify the variant argument. You should try and save a variant to the same folder as the original checkpoint, so you can load both from the same folder:   Copied from diffusers import DiffusionPipeline
+
+# save as fp16 variant
+stable_diffusion.save_pretrained("runwayml/stable-diffusion-v1-5", variant="fp16")
+# save as non-ema variant
+stable_diffusion.save_pretrained("runwayml/stable-diffusion-v1-5", variant="non_ema") If you don’t save the variant to an existing folder, you must specify the variant argument otherwise it’ll throw an Exception because it can’t find the original checkpoint:   Copied # 👎 this won't work
+stable_diffusion = DiffusionPipeline.from_pretrained(
+    "./stable-diffusion-v1-5", torch_dtype=torch.float16, use_safetensors=True
+)
+# 👍 this works
+stable_diffusion = DiffusionPipeline.from_pretrained(
+    "./stable-diffusion-v1-5", variant="fp16", torch_dtype=torch.float16, use_safetensors=True
+)  Models Models are loaded from the ModelMixin.from_pretrained() method, which downloads and caches the latest version of the model weights and configurations. If the latest files are available in the local cache, from_pretrained() reuses files in the cache instead of re-downloading them. Models can be loaded from a subfolder with the subfolder argument. For example, the model weights for runwayml/stable-diffusion-v1-5 are stored in the unet subfolder:   Copied from diffusers import UNet2DConditionModel
+
+repo_id = "runwayml/stable-diffusion-v1-5"
+model = UNet2DConditionModel.from_pretrained(repo_id, subfolder="unet", use_safetensors=True) Or directly from a repository’s directory:   Copied from diffusers import UNet2DModel
+
+repo_id = "google/ddpm-cifar10-32"
+model = UNet2DModel.from_pretrained(repo_id, use_safetensors=True) You can also load and save model variants by specifying the variant argument in ModelMixin.from_pretrained() and ModelMixin.save_pretrained():   Copied from diffusers import UNet2DConditionModel
+
+model = UNet2DConditionModel.from_pretrained(
+    "runwayml/stable-diffusion-v1-5", subfolder="unet", variant="non_ema", use_safetensors=True
+)
+model.save_pretrained("./local-unet", variant="non_ema")  Schedulers Schedulers are loaded from the SchedulerMixin.from_pretrained() method, and unlike models, schedulers are not parameterized or trained; they are defined by a configuration file. Loading schedulers does not consume any significant amount of memory and the same configuration file can be used for a variety of different schedulers.
+For example, the following schedulers are compatible with StableDiffusionPipeline, which means you can load the same scheduler configuration file in any of these classes:   Copied from diffusers import StableDiffusionPipeline
+from diffusers import (
+    DDPMScheduler,
+    DDIMScheduler,
+    PNDMScheduler,
+    LMSDiscreteScheduler,
+    EulerAncestralDiscreteScheduler,
+    EulerDiscreteScheduler,
+    DPMSolverMultistepScheduler,
+)
+
+repo_id = "runwayml/stable-diffusion-v1-5"
+
+ddpm = DDPMScheduler.from_pretrained(repo_id, subfolder="scheduler")
+ddim = DDIMScheduler.from_pretrained(repo_id, subfolder="scheduler")
+pndm = PNDMScheduler.from_pretrained(repo_id, subfolder="scheduler")
+lms = LMSDiscreteScheduler.from_pretrained(repo_id, subfolder="scheduler")
+euler_anc = EulerAncestralDiscreteScheduler.from_pretrained(repo_id, subfolder="scheduler")
+euler = EulerDiscreteScheduler.from_pretrained(repo_id, subfolder="scheduler")
+dpm = DPMSolverMultistepScheduler.from_pretrained(repo_id, subfolder="scheduler")
+
+# replace `dpm` with any of `ddpm`, `ddim`, `pndm`, `lms`, `euler_anc`, `euler`
+pipeline = StableDiffusionPipeline.from_pretrained(repo_id, scheduler=dpm, use_safetensors=True)  DiffusionPipeline explained As a class method, DiffusionPipeline.from_pretrained() is responsible for two things: Download the latest version of the folder structure required for inference and cache it. If the latest folder structure is available in the local cache, DiffusionPipeline.from_pretrained() reuses the cache and won’t redownload the files. Load the cached weights into the correct pipeline class - retrieved from the model_index.json file - and return an instance of it. The pipelines’ underlying folder structure corresponds directly with their class instances. For example, the StableDiffusionPipeline corresponds to the folder structure in runwayml/stable-diffusion-v1-5.   Copied from diffusers import DiffusionPipeline
+
+repo_id = "runwayml/stable-diffusion-v1-5"
+pipeline = DiffusionPipeline.from_pretrained(repo_id, use_safetensors=True)
+print(pipeline) You’ll see pipeline is an instance of StableDiffusionPipeline, which consists of seven components: "feature_extractor": a CLIPImageProcessor from 🤗 Transformers. "safety_checker": a component for screening against harmful content. "scheduler": an instance of PNDMScheduler. "text_encoder": a CLIPTextModel from 🤗 Transformers. "tokenizer": a CLIPTokenizer from 🤗 Transformers. "unet": an instance of UNet2DConditionModel. "vae": an instance of AutoencoderKL.   Copied StableDiffusionPipeline {
+  "feature_extractor": [
+    "transformers",
+    "CLIPImageProcessor"
+  ],
+  "safety_checker": [
+    "stable_diffusion",
+    "StableDiffusionSafetyChecker"
+  ],
+  "scheduler": [
+    "diffusers",
+    "PNDMScheduler"
+  ],
+  "text_encoder": [
+    "transformers",
+    "CLIPTextModel"
+  ],
+  "tokenizer": [
+    "transformers",
+    "CLIPTokenizer"
+  ],
+  "unet": [
+    "diffusers",
+    "UNet2DConditionModel"
+  ],
+  "vae": [
+    "diffusers",
+    "AutoencoderKL"
+  ]
+} Compare the components of the pipeline instance to the runwayml/stable-diffusion-v1-5 folder structure, and you’ll see there is a separate folder for each of the components in the repository:   Copied .
+├── feature_extractor
+│   └── preprocessor_config.json
+├── model_index.json
+├── safety_checker
+│   ├── config.json
+|   ├── model.fp16.safetensors
+│   ├── model.safetensors
+│   ├── pytorch_model.bin
+|   └── pytorch_model.fp16.bin
+├── scheduler
+│   └── scheduler_config.json
+├── text_encoder
+│   ├── config.json
+|   ├── model.fp16.safetensors
+│   ├── model.safetensors
+│   |── pytorch_model.bin
+|   └── pytorch_model.fp16.bin
+├── tokenizer
+│   ├── merges.txt
+│   ├── special_tokens_map.json
+│   ├── tokenizer_config.json
+│   └── vocab.json
+├── unet
+│   ├── config.json
+│   ├── diffusion_pytorch_model.bin
+|   |── diffusion_pytorch_model.fp16.bin
+│   |── diffusion_pytorch_model.f16.safetensors
+│   |── diffusion_pytorch_model.non_ema.bin
+│   |── diffusion_pytorch_model.non_ema.safetensors
+│   └── diffusion_pytorch_model.safetensors
+|── vae
+.   ├── config.json
+.   ├── diffusion_pytorch_model.bin
+    ├── diffusion_pytorch_model.fp16.bin
+    ├── diffusion_pytorch_model.fp16.safetensors
+    └── diffusion_pytorch_model.safetensors You can access each of the components of the pipeline as an attribute to view its configuration:   Copied pipeline.tokenizer
+CLIPTokenizer(
+    name_or_path="/root/.cache/huggingface/hub/models--runwayml--stable-diffusion-v1-5/snapshots/39593d5650112b4cc580433f6b0435385882d819/tokenizer",
+    vocab_size=49408,
+    model_max_length=77,
+    is_fast=False,
+    padding_side="right",
+    truncation_side="right",
+    special_tokens={
+        "bos_token": AddedToken("<|startoftext|>", rstrip=False, lstrip=False, single_word=False, normalized=True),
+        "eos_token": AddedToken("<|endoftext|>", rstrip=False, lstrip=False, single_word=False, normalized=True),
+        "unk_token": AddedToken("<|endoftext|>", rstrip=False, lstrip=False, single_word=False, normalized=True),
+        "pad_token": "<|endoftext|>",
+    },
+    clean_up_tokenization_spaces=True
+) Every pipeline expects a model_index.json file that tells the DiffusionPipeline: which pipeline class to load from _class_name which version of 🧨 Diffusers was used to create the model in _diffusers_version what components from which library are stored in the subfolders (name corresponds to the component and subfolder name, library corresponds to the name of the library to load the class from, and class corresponds to the class name)   Copied {
+  "_class_name": "StableDiffusionPipeline",
+  "_diffusers_version": "0.6.0",
+  "feature_extractor": [
+    "transformers",
+    "CLIPImageProcessor"
+  ],
+  "safety_checker": [
+    "stable_diffusion",
+    "StableDiffusionSafetyChecker"
+  ],
+  "scheduler": [
+    "diffusers",
+    "PNDMScheduler"
+  ],
+  "text_encoder": [
+    "transformers",
+    "CLIPTextModel"
+  ],
+  "tokenizer": [
+    "transformers",
+    "CLIPTokenizer"
+  ],
+  "unet": [
+    "diffusers",
+    "UNet2DConditionModel"
+  ],
+  "vae": [
+    "diffusers",
+    "AutoencoderKL"
+  ]
+}

scrapped_outputs/0355b252e25654dc434b0da048d15629.txt

@@ -0,0 +1,56 @@
+Community pipelines            For more context about the design choices behind community pipelines, please have a look at this issue. Community pipelines allow you to get creative and build your own unique pipelines to share with the community. You can find all community pipelines in the diffusers/examples/community folder along with inference and training examples for how to use them. This guide showcases some of the community pipelines and hopefully it’ll inspire you to create your own (feel free to open a PR with your own pipeline and we will merge it!). To load a community pipeline, use the custom_pipeline argument in DiffusionPipeline to specify one of the files in diffusers/examples/community:   Copied from diffusers import DiffusionPipeline
+
+pipe = DiffusionPipeline.from_pretrained(
+    "CompVis/stable-diffusion-v1-4", custom_pipeline="filename_in_the_community_folder", use_safetensors=True
+) If a community pipeline doesn’t work as expected, please open a GitHub issue and mention the author. You can learn more about community pipelines in the how to load community pipelines and how to contribute a community pipeline guides.  Multilingual Stable Diffusion The multilingual Stable Diffusion pipeline uses a pretrained XLM-RoBERTa to identify a language and the mBART-large-50 model to handle the translation. This allows you to generate images from text in 20 languages.   Copied import torch
+from diffusers import DiffusionPipeline
+from diffusers.utils import make_image_grid
+from transformers import (
+    pipeline,
+    MBart50TokenizerFast,
+    MBartForConditionalGeneration,
+)
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+device_dict = {"cuda": 0, "cpu": -1}
+
+# add language detection pipeline
+language_detection_model_ckpt = "papluca/xlm-roberta-base-language-detection"
+language_detection_pipeline = pipeline("text-classification",
+                                       model=language_detection_model_ckpt,
+                                       device=device_dict[device])
+
+# add model for language translation
+translation_tokenizer = MBart50TokenizerFast.from_pretrained("facebook/mbart-large-50-many-to-one-mmt")
+translation_model = MBartForConditionalGeneration.from_pretrained("facebook/mbart-large-50-many-to-one-mmt").to(device)
+
+diffuser_pipeline = DiffusionPipeline.from_pretrained(
+    "CompVis/stable-diffusion-v1-4",
+    custom_pipeline="multilingual_stable_diffusion",
+    detection_pipeline=language_detection_pipeline,
+    translation_model=translation_model,
+    translation_tokenizer=translation_tokenizer,
+    torch_dtype=torch.float16,
+)
+
+diffuser_pipeline.enable_attention_slicing()
+diffuser_pipeline = diffuser_pipeline.to(device)
+
+prompt = ["a photograph of an astronaut riding a horse",
+          "Una casa en la playa",
+          "Ein Hund, der Orange isst",
+          "Un restaurant parisien"]
+
+images = diffuser_pipeline(prompt).images
+make_image_grid(images, rows=2, cols=2)   MagicMix MagicMix is a pipeline that can mix an image and text prompt to generate a new image that preserves the image structure. The mix_factor determines how much influence the prompt has on the layout generation, kmin controls the number of steps during the content generation process, and kmax determines how much information is kept in the layout of the original image.   Copied from diffusers import DiffusionPipeline, DDIMScheduler
+from diffusers.utils import load_image, make_image_grid
+
+pipeline = DiffusionPipeline.from_pretrained(
+    "CompVis/stable-diffusion-v1-4",
+    custom_pipeline="magic_mix",
+    scheduler=DDIMScheduler.from_pretrained("CompVis/stable-diffusion-v1-4", subfolder="scheduler"),
+).to('cuda')
+
+img = load_image("https://user-images.githubusercontent.com/59410571/209578593-141467c7-d831-4792-8b9a-b17dc5e47816.jpg")
+mix_img = pipeline(img, prompt="bed", kmin=0.3, kmax=0.5, mix_factor=0.5)
+make_image_grid([img, mix_img], rows=1, cols=2)  original image  image and text prompt mix

scrapped_outputs/035d2eb81551ae17f2f6548c483bb4ce.txt

@@ -0,0 +1,61 @@
+Attention Processor An attention processor is a class for applying different types of attention mechanisms.  AttnProcessor  class diffusers.models.attention_processor.AttnProcessor  < source > ( )    Default processor for performing attention-related computations.  AttnProcessor2_0  class diffusers.models.attention_processor.AttnProcessor2_0  < source > ( )    Processor for implementing scaled dot-product attention (enabled by default if you’re using PyTorch 2.0).  FusedAttnProcessor2_0  class diffusers.models.attention_processor.FusedAttnProcessor2_0  < source > ( )    Processor for implementing scaled dot-product attention (enabled by default if you’re using PyTorch 2.0).
+It uses fused projection layers. For self-attention modules, all projection matrices (i.e., query,
+key, value) are fused. For cross-attention modules, key and value projection matrices are fused. This API is currently 🧪 experimental in nature and can change in future.  LoRAAttnProcessor  class diffusers.models.attention_processor.LoRAAttnProcessor  < source > ( hidden_size: int cross_attention_dim: Optional = None rank: int = 4 network_alpha: Optional = None **kwargs  )   Parameters   hidden_size (int, optional) —
+The hidden size of the attention layer.   cross_attention_dim (int, optional) —
+The number of channels in the encoder_hidden_states.   rank (int, defaults to 4) —
+The dimension of the LoRA update matrices.   network_alpha (int, optional) —
+Equivalent to alpha but it’s usage is specific to Kohya (A1111) style LoRAs.   kwargs (dict) —
+Additional keyword arguments to pass to the LoRALinearLayer layers.    Processor for implementing the LoRA attention mechanism.  LoRAAttnProcessor2_0  class diffusers.models.attention_processor.LoRAAttnProcessor2_0  < source > ( hidden_size: int cross_attention_dim: Optional = None rank: int = 4 network_alpha: Optional = None **kwargs  )   Parameters   hidden_size (int) —
+The hidden size of the attention layer.   cross_attention_dim (int, optional) —
+The number of channels in the encoder_hidden_states.   rank (int, defaults to 4) —
+The dimension of the LoRA update matrices.   network_alpha (int, optional) —
+Equivalent to alpha but it’s usage is specific to Kohya (A1111) style LoRAs.   kwargs (dict) —
+Additional keyword arguments to pass to the LoRALinearLayer layers.    Processor for implementing the LoRA attention mechanism using PyTorch 2.0’s memory-efficient scaled dot-product
+attention.  CustomDiffusionAttnProcessor  class diffusers.models.attention_processor.CustomDiffusionAttnProcessor  < source > ( train_kv: bool = True train_q_out: bool = True hidden_size: Optional = None cross_attention_dim: Optional = None out_bias: bool = True dropout: float = 0.0  )   Parameters   train_kv (bool, defaults to True) —
+Whether to newly train the key and value matrices corresponding to the text features.   train_q_out (bool, defaults to True) —
+Whether to newly train query matrices corresponding to the latent image features.   hidden_size (int, optional, defaults to None) —
+The hidden size of the attention layer.   cross_attention_dim (int, optional, defaults to None) —
+The number of channels in the encoder_hidden_states.   out_bias (bool, defaults to True) —
+Whether to include the bias parameter in train_q_out.   dropout (float, optional, defaults to 0.0) —
+The dropout probability to use.    Processor for implementing attention for the Custom Diffusion method.  CustomDiffusionAttnProcessor2_0  class diffusers.models.attention_processor.CustomDiffusionAttnProcessor2_0  < source > ( train_kv: bool = True train_q_out: bool = True hidden_size: Optional = None cross_attention_dim: Optional = None out_bias: bool = True dropout: float = 0.0  )   Parameters   train_kv (bool, defaults to True) —
+Whether to newly train the key and value matrices corresponding to the text features.   train_q_out (bool, defaults to True) —
+Whether to newly train query matrices corresponding to the latent image features.   hidden_size (int, optional, defaults to None) —
+The hidden size of the attention layer.   cross_attention_dim (int, optional, defaults to None) —
+The number of channels in the encoder_hidden_states.   out_bias (bool, defaults to True) —
+Whether to include the bias parameter in train_q_out.   dropout (float, optional, defaults to 0.0) —
+The dropout probability to use.    Processor for implementing attention for the Custom Diffusion method using PyTorch 2.0’s memory-efficient scaled
+dot-product attention.  AttnAddedKVProcessor  class diffusers.models.attention_processor.AttnAddedKVProcessor  < source > ( )    Processor for performing attention-related computations with extra learnable key and value matrices for the text
+encoder.  AttnAddedKVProcessor2_0  class diffusers.models.attention_processor.AttnAddedKVProcessor2_0  < source > ( )    Processor for performing scaled dot-product attention (enabled by default if you’re using PyTorch 2.0), with extra
+learnable key and value matrices for the text encoder.  LoRAAttnAddedKVProcessor  class diffusers.models.attention_processor.LoRAAttnAddedKVProcessor  < source > ( hidden_size: int cross_attention_dim: Optional = None rank: int = 4 network_alpha: Optional = None  )   Parameters   hidden_size (int, optional) —
+The hidden size of the attention layer.   cross_attention_dim (int, optional, defaults to None) —
+The number of channels in the encoder_hidden_states.   rank (int, defaults to 4) —
+The dimension of the LoRA update matrices.   network_alpha (int, optional) —
+Equivalent to alpha but it’s usage is specific to Kohya (A1111) style LoRAs.   kwargs (dict) —
+Additional keyword arguments to pass to the LoRALinearLayer layers.    Processor for implementing the LoRA attention mechanism with extra learnable key and value matrices for the text
+encoder.  XFormersAttnProcessor  class diffusers.models.attention_processor.XFormersAttnProcessor  < source > ( attention_op: Optional = None  )   Parameters   attention_op (Callable, optional, defaults to None) —
+The base
+operator to
+use as the attention operator. It is recommended to set to None, and allow xFormers to choose the best
+operator.    Processor for implementing memory efficient attention using xFormers.  LoRAXFormersAttnProcessor  class diffusers.models.attention_processor.LoRAXFormersAttnProcessor  < source > ( hidden_size: int cross_attention_dim: int rank: int = 4 attention_op: Optional = None network_alpha: Optional = None **kwargs  )   Parameters   hidden_size (int, optional) —
+The hidden size of the attention layer.   cross_attention_dim (int, optional) —
+The number of channels in the encoder_hidden_states.   rank (int, defaults to 4) —
+The dimension of the LoRA update matrices.   attention_op (Callable, optional, defaults to None) —
+The base
+operator to
+use as the attention operator. It is recommended to set to None, and allow xFormers to choose the best
+operator.   network_alpha (int, optional) —
+Equivalent to alpha but it’s usage is specific to Kohya (A1111) style LoRAs.   kwargs (dict) —
+Additional keyword arguments to pass to the LoRALinearLayer layers.    Processor for implementing the LoRA attention mechanism with memory efficient attention using xFormers.  CustomDiffusionXFormersAttnProcessor  class diffusers.models.attention_processor.CustomDiffusionXFormersAttnProcessor  < source > ( train_kv: bool = True train_q_out: bool = False hidden_size: Optional = None cross_attention_dim: Optional = None out_bias: bool = True dropout: float = 0.0 attention_op: Optional = None  )   Parameters   train_kv (bool, defaults to True) —
+Whether to newly train the key and value matrices corresponding to the text features.   train_q_out (bool, defaults to True) —
+Whether to newly train query matrices corresponding to the latent image features.   hidden_size (int, optional, defaults to None) —
+The hidden size of the attention layer.   cross_attention_dim (int, optional, defaults to None) —
+The number of channels in the encoder_hidden_states.   out_bias (bool, defaults to True) —
+Whether to include the bias parameter in train_q_out.   dropout (float, optional, defaults to 0.0) —
+The dropout probability to use.   attention_op (Callable, optional, defaults to None) —
+The base
+operator to use
+as the attention operator. It is recommended to set to None, and allow xFormers to choose the best operator.    Processor for implementing memory efficient attention using xFormers for the Custom Diffusion method.  SlicedAttnProcessor  class diffusers.models.attention_processor.SlicedAttnProcessor  < source > ( slice_size: int  )   Parameters   slice_size (int, optional) —
+The number of steps to compute attention. Uses as many slices as attention_head_dim // slice_size, and
+attention_head_dim must be a multiple of the slice_size.    Processor for implementing sliced attention.  SlicedAttnAddedKVProcessor  class diffusers.models.attention_processor.SlicedAttnAddedKVProcessor  < source > ( slice_size  )   Parameters   slice_size (int, optional) —
+The number of steps to compute attention. Uses as many slices as attention_head_dim // slice_size, and
+attention_head_dim must be a multiple of the slice_size.    Processor for implementing sliced attention with extra learnable key and value matrices for the text encoder.

scrapped_outputs/037a312aaecccf6bc6297a4be6c94e34.txt

@@ -0,0 +1,107 @@
+Semantic Guidance Semantic Guidance for Diffusion Models was proposed in SEGA: Instructing Text-to-Image Models using Semantic Guidance and provides strong semantic control over image generation.
+Small changes to the text prompt usually result in entirely different output images. However, with SEGA a variety of changes to the image are enabled that can be controlled easily and intuitively, while staying true to the original image composition. The abstract from the paper is: Text-to-image diffusion models have recently received a lot of interest for their astonishing ability to produce high-fidelity images from text only. However, achieving one-shot generation that aligns with the user’s intent is nearly impossible, yet small changes to the input prompt often result in very different images. This leaves the user with little semantic control. To put the user in control, we show how to interact with the diffusion process to flexibly steer it along semantic directions. This semantic guidance (SEGA) generalizes to any generative architecture using classifier-free guidance. More importantly, it allows for subtle and extensive edits, changes in composition and style, as well as optimizing the overall artistic conception. We demonstrate SEGA’s effectiveness on both latent and pixel-based diffusion models such as Stable Diffusion, Paella, and DeepFloyd-IF using a variety of tasks, thus providing strong evidence for its versatility, flexibility, and improvements over existing methods. Make sure to check out the Schedulers guide to learn how to explore the tradeoff between scheduler speed and quality, and see the reuse components across pipelines section to learn how to efficiently load the same components into multiple pipelines.  SemanticStableDiffusionPipeline  class diffusers.SemanticStableDiffusionPipeline  < source > ( vae: AutoencoderKL text_encoder: CLIPTextModel tokenizer: CLIPTokenizer unet: UNet2DConditionModel scheduler: KarrasDiffusionSchedulers safety_checker: StableDiffusionSafetyChecker feature_extractor: CLIPImageProcessor requires_safety_checker: bool = True  )   Parameters   vae (AutoencoderKL) —
+Variational Auto-Encoder (VAE) model to encode and decode images to and from latent representations.   text_encoder (CLIPTextModel) —
+Frozen text-encoder (clip-vit-large-patch14).   tokenizer (CLIPTokenizer) —
+A CLIPTokenizer to tokenize text.   unet (UNet2DConditionModel) —
+A UNet2DConditionModel to denoise the encoded image latents.   scheduler (SchedulerMixin) —
+A scheduler to be used in combination with unet to denoise the encoded image latents. Can be one of
+DDIMScheduler, LMSDiscreteScheduler, or PNDMScheduler.   safety_checker (Q16SafetyChecker) —
+Classification module that estimates whether generated images could be considered offensive or harmful.
+Please refer to the model card for more details
+about a model’s potential harms.   feature_extractor (CLIPImageProcessor) —
+A CLIPImageProcessor to extract features from generated images; used as inputs to the safety_checker.    Pipeline for text-to-image generation using Stable Diffusion with latent editing. This model inherits from DiffusionPipeline and builds on the StableDiffusionPipeline. Check the superclass
+documentation for the generic methods implemented for all pipelines (downloading, saving, running on a particular
+device, etc.).  __call__  < source > ( prompt: Union height: Optional = None width: Optional = None num_inference_steps: int = 50 guidance_scale: float = 7.5 negative_prompt: Union = None num_images_per_prompt: int = 1 eta: float = 0.0 generator: Union = None latents: Optional = None output_type: Optional = 'pil' return_dict: bool = True callback: Optional = None callback_steps: int = 1 editing_prompt: Union = None editing_prompt_embeddings: Optional = None reverse_editing_direction: Union = False edit_guidance_scale: Union = 5 edit_warmup_steps: Union = 10 edit_cooldown_steps: Union = None edit_threshold: Union = 0.9 edit_momentum_scale: Optional = 0.1 edit_mom_beta: Optional = 0.4 edit_weights: Optional = None sem_guidance: Optional = None  ) → ~pipelines.semantic_stable_diffusion.SemanticStableDiffusionPipelineOutput or tuple  Parameters   prompt (str or List[str]) —
+The prompt or prompts to guide image generation.   height (int, optional, defaults to self.unet.config.sample_size * self.vae_scale_factor) —
+The height in pixels of the generated image.   width (int, optional, defaults to self.unet.config.sample_size * self.vae_scale_factor) —
+The width in pixels of the generated image.   num_inference_steps (int, optional, defaults to 50) —
+The number of denoising steps. More denoising steps usually lead to a higher quality image at the
+expense of slower inference.   guidance_scale (float, optional, defaults to 7.5) —
+A higher guidance scale value encourages the model to generate images closely linked to the text
+prompt at the expense of lower image quality. Guidance scale is enabled when guidance_scale > 1.   negative_prompt (str or List[str], optional) —
+The prompt or prompts to guide what to not include in image generation. If not defined, you need to
+pass negative_prompt_embeds instead. Ignored when not using guidance (guidance_scale < 1).   num_images_per_prompt (int, optional, defaults to 1) —
+The number of images to generate per prompt.   eta (float, optional, defaults to 0.0) —
+Corresponds to parameter eta (η) from the DDIM paper. Only applies
+to the DDIMScheduler, and is ignored in other schedulers.   generator (torch.Generator or List[torch.Generator], optional) —
+A torch.Generator to make
+generation deterministic.   latents (torch.FloatTensor, optional) —
+Pre-generated noisy latents sampled from a Gaussian distribution, to be used as inputs for image
+generation. Can be used to tweak the same generation with different prompts. If not provided, a latents
+tensor is generated by sampling using the supplied random generator.   output_type (str, optional, defaults to "pil") —
+The output format of the generated image. Choose between PIL.Image or np.array.   return_dict (bool, optional, defaults to True) —
+Whether or not to return a StableDiffusionPipelineOutput instead of a
+plain tuple.   callback (Callable, optional) —
+A function that calls every callback_steps steps during inference. The function is called with the
+following arguments: callback(step: int, timestep: int, latents: torch.FloatTensor).   callback_steps (int, optional, defaults to 1) —
+The frequency at which the callback function is called. If not specified, the callback is called at
+every step.   editing_prompt (str or List[str], optional) —
+The prompt or prompts to use for semantic guidance. Semantic guidance is disabled by setting
+editing_prompt = None. Guidance direction of prompt should be specified via
+reverse_editing_direction.   editing_prompt_embeddings (torch.Tensor, optional) —
+Pre-computed embeddings to use for semantic guidance. Guidance direction of embedding should be
+specified via reverse_editing_direction.   reverse_editing_direction (bool or List[bool], optional, defaults to False) —
+Whether the corresponding prompt in editing_prompt should be increased or decreased.   edit_guidance_scale (float or List[float], optional, defaults to 5) —
+Guidance scale for semantic guidance. If provided as a list, values should correspond to
+editing_prompt.   edit_warmup_steps (float or List[float], optional, defaults to 10) —
+Number of diffusion steps (for each prompt) for which semantic guidance is not applied. Momentum is
+calculated for those steps and applied once all warmup periods are over.   edit_cooldown_steps (float or List[float], optional, defaults to None) —
+Number of diffusion steps (for each prompt) after which semantic guidance is longer applied.   edit_threshold (float or List[float], optional, defaults to 0.9) —
+Threshold of semantic guidance.   edit_momentum_scale (float, optional, defaults to 0.1) —
+Scale of the momentum to be added to the semantic guidance at each diffusion step. If set to 0.0,
+momentum is disabled. Momentum is already built up during warmup (for diffusion steps smaller than
+sld_warmup_steps). Momentum is only added to latent guidance once all warmup periods are finished.   edit_mom_beta (float, optional, defaults to 0.4) —
+Defines how semantic guidance momentum builds up. edit_mom_beta indicates how much of the previous
+momentum is kept. Momentum is already built up during warmup (for diffusion steps smaller than
+edit_warmup_steps).   edit_weights (List[float], optional, defaults to None) —
+Indicates how much each individual concept should influence the overall guidance. If no weights are
+provided all concepts are applied equally.   sem_guidance (List[torch.Tensor], optional) —
+List of pre-generated guidance vectors to be applied at generation. Length of the list has to
+correspond to num_inference_steps.   Returns 
+~pipelines.semantic_stable_diffusion.SemanticStableDiffusionPipelineOutput or tuple
+  
+If return_dict is True,
+~pipelines.semantic_stable_diffusion.SemanticStableDiffusionPipelineOutput is returned, otherwise a
+tuple is returned where the first element is a list with the generated images and the second element
+is a list of bools indicating whether the corresponding generated image contains “not-safe-for-work”
+(nsfw) content.
+  The call function to the pipeline for generation.  Examples:   Copied >>> import torch
+>>> from diffusers import SemanticStableDiffusionPipeline
+
+>>> pipe = SemanticStableDiffusionPipeline.from_pretrained(
+...     "runwayml/stable-diffusion-v1-5", torch_dtype=torch.float16
+... )
+>>> pipe = pipe.to("cuda")
+
+>>> out = pipe(
+...     prompt="a photo of the face of a woman",
+...     num_images_per_prompt=1,
+...     guidance_scale=7,
+...     editing_prompt=[
+...         "smiling, smile",  # Concepts to apply
+...         "glasses, wearing glasses",
+...         "curls, wavy hair, curly hair",
+...         "beard, full beard, mustache",
+...     ],
+...     reverse_editing_direction=[
+...         False,
+...         False,
+...         False,
+...         False,
+...     ],  # Direction of guidance i.e. increase all concepts
+...     edit_warmup_steps=[10, 10, 10, 10],  # Warmup period for each concept
+...     edit_guidance_scale=[4, 5, 5, 5.4],  # Guidance scale for each concept
+...     edit_threshold=[
+...         0.99,
+...         0.975,
+...         0.925,
+...         0.96,
+...     ],  # Threshold for each concept. Threshold equals the percentile of the latent space that will be discarded. I.e. threshold=0.99 uses 1% of the latent dimensions
+...     edit_momentum_scale=0.3,  # Momentum scale that will be added to the latent guidance
+...     edit_mom_beta=0.6,  # Momentum beta
+...     edit_weights=[1, 1, 1, 1, 1],  # Weights of the individual concepts against each other
+... )
+>>> image = out.images[0]  StableDiffusionSafePipelineOutput  class diffusers.pipelines.semantic_stable_diffusion.pipeline_output.SemanticStableDiffusionPipelineOutput  < source > ( images: Union nsfw_content_detected: Optional  )   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).   nsfw_content_detected (List[bool]) —
+List indicating whether the corresponding generated image contains “not-safe-for-work” (nsfw) content or
+None if safety checking could not be performed.    Output class for Stable Diffusion pipelines.

scrapped_outputs/039174a093290e2204530344edb27be3.txt

@@ -0,0 +1,265 @@
+ControlNet ControlNet is a type of model for controlling image diffusion models by conditioning the model with an additional input image. There are many types of conditioning inputs (canny edge, user sketching, human pose, depth, and more) you can use to control a diffusion model. This is hugely useful because it affords you greater control over image generation, making it easier to generate specific images without experimenting with different text prompts or denoising values as much. Check out Section 3.5 of the ControlNet paper v1 for a list of ControlNet implementations on various conditioning inputs. You can find the official Stable Diffusion ControlNet conditioned models on lllyasviel’s Hub profile, and more community-trained ones on the Hub. For Stable Diffusion XL (SDXL) ControlNet models, you can find them on the 🤗 Diffusers Hub organization, or you can browse community-trained ones on the Hub. A ControlNet model has two sets of weights (or blocks) connected by a zero-convolution layer: a locked copy keeps everything a large pretrained diffusion model has learned a trainable copy is trained on the additional conditioning input Since the locked copy preserves the pretrained model, training and implementing a ControlNet on a new conditioning input is as fast as finetuning any other model because you aren’t training the model from scratch. This guide will show you how to use ControlNet for text-to-image, image-to-image, inpainting, and more! There are many types of ControlNet conditioning inputs to choose from, but in this guide we’ll only focus on several of them. Feel free to experiment with other conditioning inputs! 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 opencv-python  Text-to-image For text-to-image, you normally pass a text prompt to the model. But with ControlNet, you can specify an additional conditioning input. Let’s condition the model with a canny image, a white outline of an image on a black background. This way, the ControlNet can use the canny image as a control to guide the model to generate an image with the same outline. Load an image and use the opencv-python library to extract the canny image:   Copied from diffusers.utils import load_image, make_image_grid
+from PIL import Image
+import cv2
+import numpy as np
+
+original_image = load_image(
+    "https://hf.co/datasets/huggingface/documentation-images/resolve/main/diffusers/input_image_vermeer.png"
+)
+
+image = np.array(original_image)
+
+low_threshold = 100
+high_threshold = 200
+
+image = cv2.Canny(image, low_threshold, high_threshold)
+image = image[:, :, None]
+image = np.concatenate([image, image, image], axis=2)
+canny_image = Image.fromarray(image)  original image  canny image Next, load a ControlNet model conditioned on canny edge detection and pass it to the StableDiffusionControlNetPipeline. Use the faster UniPCMultistepScheduler and enable model offloading to speed up inference and reduce memory usage.   Copied from diffusers import StableDiffusionControlNetPipeline, ControlNetModel, UniPCMultistepScheduler
+import torch
+
+controlnet = ControlNetModel.from_pretrained("lllyasviel/sd-controlnet-canny", torch_dtype=torch.float16, use_safetensors=True)
+pipe = StableDiffusionControlNetPipeline.from_pretrained(
+    "runwayml/stable-diffusion-v1-5", controlnet=controlnet, torch_dtype=torch.float16, use_safetensors=True
+)
+
+pipe.scheduler = UniPCMultistepScheduler.from_config(pipe.scheduler.config)
+pipe.enable_model_cpu_offload() Now pass your prompt and canny image to the pipeline:   Copied output = pipe(
+    "the mona lisa", image=canny_image
+).images[0]
+make_image_grid([original_image, canny_image, output], rows=1, cols=3)   Image-to-image For image-to-image, you’d typically pass an initial image and a prompt to the pipeline to generate a new image. With ControlNet, you can pass an additional conditioning input to guide the model. Let’s condition the model with a depth map, an image which contains spatial information. This way, the ControlNet can use the depth map as a control to guide the model to generate an image that preserves spatial information. You’ll use the StableDiffusionControlNetImg2ImgPipeline for this task, which is different from the StableDiffusionControlNetPipeline because it allows you to pass an initial image as the starting point for the image generation process. Load an image and use the depth-estimation Pipeline from 🤗 Transformers to extract the depth map of an image:   Copied import torch
+import numpy as np
+
+from transformers import pipeline
+from diffusers.utils import load_image, make_image_grid
+
+image = load_image(
+    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/controlnet-img2img.jpg"
+)
+
+def get_depth_map(image, depth_estimator):
+    image = depth_estimator(image)["depth"]
+    image = np.array(image)
+    image = image[:, :, None]
+    image = np.concatenate([image, image, image], axis=2)
+    detected_map = torch.from_numpy(image).float() / 255.0
+    depth_map = detected_map.permute(2, 0, 1)
+    return depth_map
+
+depth_estimator = pipeline("depth-estimation")
+depth_map = get_depth_map(image, depth_estimator).unsqueeze(0).half().to("cuda") Next, load a ControlNet model conditioned on depth maps and pass it to the StableDiffusionControlNetImg2ImgPipeline. Use the faster UniPCMultistepScheduler and enable model offloading to speed up inference and reduce memory usage.   Copied from diffusers import StableDiffusionControlNetImg2ImgPipeline, ControlNetModel, UniPCMultistepScheduler
+import torch
+
+controlnet = ControlNetModel.from_pretrained("lllyasviel/control_v11f1p_sd15_depth", torch_dtype=torch.float16, use_safetensors=True)
+pipe = StableDiffusionControlNetImg2ImgPipeline.from_pretrained(
+    "runwayml/stable-diffusion-v1-5", controlnet=controlnet, torch_dtype=torch.float16, use_safetensors=True
+)
+
+pipe.scheduler = UniPCMultistepScheduler.from_config(pipe.scheduler.config)
+pipe.enable_model_cpu_offload() Now pass your prompt, initial image, and depth map to the pipeline:   Copied output = pipe(
+    "lego batman and robin", image=image, control_image=depth_map,
+).images[0]
+make_image_grid([image, output], rows=1, cols=2)  original image  generated image  Inpainting For inpainting, you need an initial image, a mask image, and a prompt describing what to replace the mask with. ControlNet models allow you to add another control image to condition a model with. Let’s condition the model with an inpainting mask. This way, the ControlNet can use the inpainting mask as a control to guide the model to generate an image within the mask area. Load an initial image and a mask image:   Copied from diffusers.utils import load_image, make_image_grid
+
+init_image = load_image(
+    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/controlnet-inpaint.jpg"
+)
+init_image = init_image.resize((512, 512))
+
+mask_image = load_image(
+    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/controlnet-inpaint-mask.jpg"
+)
+mask_image = mask_image.resize((512, 512))
+make_image_grid([init_image, mask_image], rows=1, cols=2) Create a function to prepare the control image from the initial and mask images. This’ll create a tensor to mark the pixels in init_image as masked if the corresponding pixel in mask_image is over a certain threshold.   Copied import numpy as np
+import torch
+
+def make_inpaint_condition(image, image_mask):
+    image = np.array(image.convert("RGB")).astype(np.float32) / 255.0
+    image_mask = np.array(image_mask.convert("L")).astype(np.float32) / 255.0
+
+    assert image.shape[0:1] == image_mask.shape[0:1]
+    image[image_mask > 0.5] = -1.0  # set as masked pixel
+    image = np.expand_dims(image, 0).transpose(0, 3, 1, 2)
+    image = torch.from_numpy(image)
+    return image
+
+control_image = make_inpaint_condition(init_image, mask_image)  original image  mask image Load a ControlNet model conditioned on inpainting and pass it to the StableDiffusionControlNetInpaintPipeline. Use the faster UniPCMultistepScheduler and enable model offloading to speed up inference and reduce memory usage.   Copied from diffusers import StableDiffusionControlNetInpaintPipeline, ControlNetModel, UniPCMultistepScheduler
+
+controlnet = ControlNetModel.from_pretrained("lllyasviel/control_v11p_sd15_inpaint", torch_dtype=torch.float16, use_safetensors=True)
+pipe = StableDiffusionControlNetInpaintPipeline.from_pretrained(
+    "runwayml/stable-diffusion-v1-5", controlnet=controlnet, torch_dtype=torch.float16, use_safetensors=True
+)
+
+pipe.scheduler = UniPCMultistepScheduler.from_config(pipe.scheduler.config)
+pipe.enable_model_cpu_offload() Now pass your prompt, initial image, mask image, and control image to the pipeline:   Copied output = pipe(
+    "corgi face with large ears, detailed, pixar, animated, disney",
+    num_inference_steps=20,
+    eta=1.0,
+    image=init_image,
+    mask_image=mask_image,
+    control_image=control_image,
+).images[0]
+make_image_grid([init_image, mask_image, output], rows=1, cols=3)   Guess mode Guess mode does not require supplying a prompt to a ControlNet at all! This forces the ControlNet encoder to do it’s best to “guess” the contents of the input control map (depth map, pose estimation, canny edge, etc.). Guess mode adjusts the scale of the output residuals from a ControlNet by a fixed ratio depending on the block depth. The shallowest DownBlock corresponds to 0.1, and as the blocks get deeper, the scale increases exponentially such that the scale of the MidBlock output becomes 1.0. Guess mode does not have any impact on prompt conditioning and you can still provide a prompt if you want. Set guess_mode=True in the pipeline, and it is recommended to set the guidance_scale value between 3.0 and 5.0.   Copied from diffusers import StableDiffusionControlNetPipeline, ControlNetModel
+from diffusers.utils import load_image, make_image_grid
+import numpy as np
+import torch
+from PIL import Image
+import cv2
+
+controlnet = ControlNetModel.from_pretrained("lllyasviel/sd-controlnet-canny", use_safetensors=True)
+pipe = StableDiffusionControlNetPipeline.from_pretrained("runwayml/stable-diffusion-v1-5", controlnet=controlnet, use_safetensors=True).to("cuda")
+
+original_image = load_image("https://huggingface.co/takuma104/controlnet_dev/resolve/main/bird_512x512.png")
+
+image = np.array(original_image)
+
+low_threshold = 100
+high_threshold = 200
+
+image = cv2.Canny(image, low_threshold, high_threshold)
+image = image[:, :, None]
+image = np.concatenate([image, image, image], axis=2)
+canny_image = Image.fromarray(image)
+
+image = pipe("", image=canny_image, guess_mode=True, guidance_scale=3.0).images[0]
+make_image_grid([original_image, canny_image, image], rows=1, cols=3)  regular mode with prompt  guess mode without prompt  ControlNet with Stable Diffusion XL There aren’t too many ControlNet models compatible with Stable Diffusion XL (SDXL) at the moment, but we’ve trained two full-sized ControlNet models for SDXL conditioned on canny edge detection and depth maps. We’re also experimenting with creating smaller versions of these SDXL-compatible ControlNet models so it is easier to run on resource-constrained hardware. You can find these checkpoints on the 🤗 Diffusers Hub organization! Let’s use a SDXL ControlNet conditioned on canny images to generate an image. Start by loading an image and prepare the canny image:   Copied from diffusers import StableDiffusionXLControlNetPipeline, ControlNetModel, AutoencoderKL
+from diffusers.utils import load_image, make_image_grid
+from PIL import Image
+import cv2
+import numpy as np
+import torch
+
+original_image = load_image(
+    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/hf-logo.png"
+)
+
+image = np.array(original_image)
+
+low_threshold = 100
+high_threshold = 200
+
+image = cv2.Canny(image, low_threshold, high_threshold)
+image = image[:, :, None]
+image = np.concatenate([image, image, image], axis=2)
+canny_image = Image.fromarray(image)
+make_image_grid([original_image, canny_image], rows=1, cols=2)  original image  canny image Load a SDXL ControlNet model conditioned on canny edge detection and pass it to the StableDiffusionXLControlNetPipeline. You can also enable model offloading to reduce memory usage.   Copied controlnet = ControlNetModel.from_pretrained(
+    "diffusers/controlnet-canny-sdxl-1.0",
+    torch_dtype=torch.float16,
+    use_safetensors=True
+)
+vae = AutoencoderKL.from_pretrained("madebyollin/sdxl-vae-fp16-fix", torch_dtype=torch.float16, use_safetensors=True)
+pipe = StableDiffusionXLControlNetPipeline.from_pretrained(
+    "stabilityai/stable-diffusion-xl-base-1.0",
+    controlnet=controlnet,
+    vae=vae,
+    torch_dtype=torch.float16,
+    use_safetensors=True
+)
+pipe.enable_model_cpu_offload() Now pass your prompt (and optionally a negative prompt if you’re using one) and canny image to the pipeline: The controlnet_conditioning_scale parameter determines how much weight to assign to the conditioning inputs. A value of 0.5 is recommended for good generalization, but feel free to experiment with this number!   Copied prompt = "aerial view, a futuristic research complex in a bright foggy jungle, hard lighting"
+negative_prompt = 'low quality, bad quality, sketches'
+
+image = pipe(
+    prompt,
+    negative_prompt=negative_prompt,
+    image=canny_image,
+    controlnet_conditioning_scale=0.5,
+).images[0]
+make_image_grid([original_image, canny_image, image], rows=1, cols=3)  You can use StableDiffusionXLControlNetPipeline in guess mode as well by setting the parameter to True:   Copied from diffusers import StableDiffusionXLControlNetPipeline, ControlNetModel, AutoencoderKL
+from diffusers.utils import load_image, make_image_grid
+import numpy as np
+import torch
+import cv2
+from PIL import Image
+
+prompt = "aerial view, a futuristic research complex in a bright foggy jungle, hard lighting"
+negative_prompt = "low quality, bad quality, sketches"
+
+original_image = load_image(
+    "https://hf.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/hf-logo.png"
+)
+
+controlnet = ControlNetModel.from_pretrained(
+    "diffusers/controlnet-canny-sdxl-1.0", torch_dtype=torch.float16, use_safetensors=True
+)
+vae = AutoencoderKL.from_pretrained("madebyollin/sdxl-vae-fp16-fix", torch_dtype=torch.float16, use_safetensors=True)
+pipe = StableDiffusionXLControlNetPipeline.from_pretrained(
+    "stabilityai/stable-diffusion-xl-base-1.0", controlnet=controlnet, vae=vae, torch_dtype=torch.float16, use_safetensors=True
+)
+pipe.enable_model_cpu_offload()
+
+image = np.array(original_image)
+image = cv2.Canny(image, 100, 200)
+image = image[:, :, None]
+image = np.concatenate([image, image, image], axis=2)
+canny_image = Image.fromarray(image)
+
+image = pipe(
+    prompt, negative_prompt=negative_prompt, controlnet_conditioning_scale=0.5, image=canny_image, guess_mode=True,
+).images[0]
+make_image_grid([original_image, canny_image, image], rows=1, cols=3)  MultiControlNet Replace the SDXL model with a model like runwayml/stable-diffusion-v1-5 to use multiple conditioning inputs with Stable Diffusion models. You can compose multiple ControlNet conditionings from different image inputs to create a MultiControlNet. To get better results, it is often helpful to: mask conditionings such that they don’t overlap (for example, mask the area of a canny image where the pose conditioning is located) experiment with the controlnet_conditioning_scale parameter to determine how much weight to assign to each conditioning input In this example, you’ll combine a canny image and a human pose estimation image to generate a new image. Prepare the canny image conditioning:   Copied from diffusers.utils import load_image, make_image_grid
+from PIL import Image
+import numpy as np
+import cv2
+
+original_image = load_image(
+    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/landscape.png"
+)
+image = np.array(original_image)
+
+low_threshold = 100
+high_threshold = 200
+
+image = cv2.Canny(image, low_threshold, high_threshold)
+
+# zero out middle columns of image where pose will be overlaid
+zero_start = image.shape[1] // 4
+zero_end = zero_start + image.shape[1] // 2
+image[:, zero_start:zero_end] = 0
+
+image = image[:, :, None]
+image = np.concatenate([image, image, image], axis=2)
+canny_image = Image.fromarray(image)
+make_image_grid([original_image, canny_image], rows=1, cols=2)  original image  canny image For human pose estimation, install controlnet_aux:   Copied # uncomment to install the necessary library in Colab
+#!pip install -q controlnet-aux Prepare the human pose estimation conditioning:   Copied from controlnet_aux import OpenposeDetector
+
+openpose = OpenposeDetector.from_pretrained("lllyasviel/ControlNet")
+original_image = load_image(
+    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/person.png"
+)
+openpose_image = openpose(original_image)
+make_image_grid([original_image, openpose_image], rows=1, cols=2)  original image  human pose image Load a list of ControlNet models that correspond to each conditioning, and pass them to the StableDiffusionXLControlNetPipeline. Use the faster UniPCMultistepScheduler and enable model offloading to reduce memory usage.   Copied from diffusers import StableDiffusionXLControlNetPipeline, ControlNetModel, AutoencoderKL, UniPCMultistepScheduler
+import torch
+
+controlnets = [
+    ControlNetModel.from_pretrained(
+        "thibaud/controlnet-openpose-sdxl-1.0", torch_dtype=torch.float16
+    ),
+    ControlNetModel.from_pretrained(
+        "diffusers/controlnet-canny-sdxl-1.0", torch_dtype=torch.float16, use_safetensors=True
+    ),
+]
+
+vae = AutoencoderKL.from_pretrained("madebyollin/sdxl-vae-fp16-fix", torch_dtype=torch.float16, use_safetensors=True)
+pipe = StableDiffusionXLControlNetPipeline.from_pretrained(
+    "stabilityai/stable-diffusion-xl-base-1.0", controlnet=controlnets, vae=vae, torch_dtype=torch.float16, use_safetensors=True
+)
+pipe.scheduler = UniPCMultistepScheduler.from_config(pipe.scheduler.config)
+pipe.enable_model_cpu_offload() Now you can pass your prompt (an optional negative prompt if you’re using one), canny image, and pose image to the pipeline:   Copied prompt = "a giant standing in a fantasy landscape, best quality"
+negative_prompt = "monochrome, lowres, bad anatomy, worst quality, low quality"
+
+generator = torch.manual_seed(1)
+
+images = [openpose_image.resize((1024, 1024)), canny_image.resize((1024, 1024))]
+
+images = pipe(
+    prompt,
+    image=images,
+    num_inference_steps=25,
+    generator=generator,
+    negative_prompt=negative_prompt,
+    num_images_per_prompt=3,
+    controlnet_conditioning_scale=[1.0, 0.8],
+).images
+make_image_grid([original_image, canny_image, openpose_image,
+                images[0].resize((512, 512)), images[1].resize((512, 512)), images[2].resize((512, 512))], rows=2, cols=3)

scrapped_outputs/03a8acbaedc64b38f5af066e6bbee2e3.txt

@@ -0,0 +1,10 @@
+Using Diffusers with other modalities
+	
+Diffusers is in the process of expanding to modalities other than images.
+Example type
+Colab
+Pipeline
+Molecule conformation generation
+
+❌
+More coming soon!

scrapped_outputs/041d6ec5bc898d377b96ad1c3e5ce22b.txt

@@ -0,0 +1 @@
+Overview Generating high-quality outputs is computationally intensive, especially during each iterative step where you go from a noisy output to a less noisy output. One of 🤗 Diffuser’s goals is to make this technology widely accessible to everyone, which includes enabling fast inference on consumer and specialized hardware. This section will cover tips and tricks - like half-precision weights and sliced attention - for optimizing inference speed and reducing memory-consumption. You’ll also learn how to speed up your PyTorch code with torch.compile or ONNX Runtime, and enable memory-efficient attention with xFormers. There are also guides for running inference on specific hardware like Apple Silicon, and Intel or Habana processors.

scrapped_outputs/04343d970e3a9bf96cf88b007a727277.txt

@@ -0,0 +1,17 @@
+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 function:   Copied   from diffusers import StableDiffusionPipeline
+  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 merged during the forward pass. As reported in the paper, ToMe can greatly preserve the quality of the generated images while boosting inference speed. By increasing the ratio, you can speed-up inference even further, but at the cost of some degraded image quality. To test the quality of the generated images, we sampled a few prompts from Parti Prompts and performed inference with the StableDiffusionPipeline with the following settings:  We didn’t notice any significant decrease in the quality of the generated samples, and you can check out the generated samples in this WandB report. If you’re interested in reproducing this experiment, use this script.  Benchmarks We also benchmarked the impact of tomesd on the StableDiffusionPipeline with xFormers enabled across several image resolutions. The results are obtained from A100 and V100 GPUs in the following development environment:   Copied - `diffusers` version: 0.15.1
+- 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.55%) 4.69 (+31.83%)  768 10 OOM 14.71 11   8 OOM 11.56 8.84   4 OOM 5.98 4.66   2 4.99 3.24 (+35.07%) 2.1 (+37.88%)   1 3.29 2.24 (+31.91%) 2.03 (+38.3%)  1024 10 OOM OOM OOM   8 OOM OOM OOM   4 OOM 12.51 9.09   2 OOM 6.52 4.96   1 6.4 3.61 (+43.59%) 2.81 (+56.09%) V100 512 10 OOM 10.03 9.29   8 OOM 8.05 7.47   4 5.7 4.3 (+24.56%) 3.98 (+30.18%)   2 3.14 2.43 (+22.61%) 2.27 (+27.71%)   1 1.88 1.57 (+16.49%) 1.57 (+16.49%)  768 10 OOM OOM 23.67   8 OOM OOM 18.81   4 OOM 11.81 9.7   2 OOM 6.27 5.2   1 5.43 3.38 (+37.75%) 2.82 (+48.07%)  1024 10 OOM OOM OOM   8 OOM OOM OOM   4 OOM OOM 19.35   2 OOM 13 10.78   1 OOM 6.66 5.54 As seen in the tables above, the speed-up from tomesd becomes more pronounced for larger image resolutions. It is also interesting to note that with tomesd, it is possible to run the pipeline on a higher resolution like 1024x1024. You may be able to speed-up inference even more with torch.compile.

scrapped_outputs/044358532f240b4e1a89ecfcec43efdc.txt

@@ -0,0 +1 @@
+Overview Generating high-quality outputs is computationally intensive, especially during each iterative step where you go from a noisy output to a less noisy output. One of 🤗 Diffuser’s goals is to make this technology widely accessible to everyone, which includes enabling fast inference on consumer and specialized hardware. This section will cover tips and tricks - like half-precision weights and sliced attention - for optimizing inference speed and reducing memory-consumption. You’ll also learn how to speed up your PyTorch code with torch.compile or ONNX Runtime, and enable memory-efficient attention with xFormers. There are also guides for running inference on specific hardware like Apple Silicon, and Intel or Habana processors.

scrapped_outputs/04532fa8bf4664942bca163e9ce7d3af.txt

@@ -0,0 +1,18 @@
+Installation 🤗 Diffusers is tested on Python 3.8+, PyTorch 1.7.0+, and Flax. Follow the installation instructions below for the deep learning library you are using: PyTorch installation instructions Flax installation instructions  Install with pip You should install 🤗 Diffusers in a virtual environment.
+If you’re unfamiliar with Python virtual environments, take a look at this guide.
+A virtual environment makes it easier to manage different projects and avoid compatibility issues between dependencies. Start by creating a virtual environment in your project directory:   Copied python -m venv .env Activate the virtual environment:   Copied source .env/bin/activate You should also install 🤗 Transformers because 🤗 Diffusers relies on its models:   Pytorch  Hide Pytorch content  Note - PyTorch only supports Python 3.8 - 3.11 on Windows.   Copied pip install diffusers["torch"] transformers  JAX  Hide JAX content    Copied pip install diffusers["flax"] transformers   Install with conda After activating your virtual environment, with conda (maintained by the community):   Copied conda install -c conda-forge diffusers  Install from source Before installing 🤗 Diffusers from source, make sure you have PyTorch and 🤗 Accelerate installed. To install 🤗 Accelerate:   Copied pip install accelerate Then install 🤗 Diffusers from source:   Copied pip install git+https://github.com/huggingface/diffusers This command installs the bleeding edge main version rather than the latest stable version.
+The main version is useful for staying up-to-date with the latest developments.
+For instance, if a bug has been fixed since the last official release but a new release hasn’t been rolled out yet.
+However, this means the main version may not always be stable.
+We strive to keep the main version operational, and most issues are usually resolved within a few hours or a day.
+If you run into a problem, please open an Issue so we can fix it even sooner!  Editable install You will need an editable install if you’d like to: Use the main version of the source code. Contribute to 🤗 Diffusers and need to test changes in the code. Clone the repository and install 🤗 Diffusers with the following commands:   Copied git clone https://github.com/huggingface/diffusers.git
+cd diffusers   Pytorch  Hide Pytorch content    Copied pip install -e ".[torch]"  JAX  Hide JAX content    Copied pip install -e ".[flax]"  These commands will link the folder you cloned the repository to and your Python library paths.
+Python will now look inside the folder you cloned to in addition to the normal library paths.
+For example, if your Python packages are typically installed in ~/anaconda3/envs/main/lib/python3.8/site-packages/, Python will also search the ~/diffusers/ folder you cloned to. You must keep the diffusers folder if you want to keep using the library. Now you can easily update your clone to the latest version of 🤗 Diffusers with the following command:   Copied cd ~/diffusers/
+git pull Your Python environment will find the main version of 🤗 Diffusers on the next run.  Cache Model weights and files are downloaded from the Hub to a cache which is usually your home directory. You can change the cache location by specifying the HF_HOME or HUGGINFACE_HUB_CACHE environment variables or configuring the cache_dir parameter in methods like from_pretrained(). Cached files allow you to run 🤗 Diffusers offline. To prevent 🤗 Diffusers from connecting to the internet, set the HF_HUB_OFFLINE environment variable to True and 🤗 Diffusers will only load previously downloaded files in the cache.   Copied export HF_HUB_OFFLINE=True For more details about managing and cleaning the cache, take a look at the caching guide.  Telemetry logging Our library gathers telemetry information during from_pretrained() requests.
+The data gathered includes the version of 🤗 Diffusers and PyTorch/Flax, the requested model or pipeline class,
+and the path to a pretrained checkpoint if it is hosted on the Hugging Face Hub.
+This usage data helps us debug issues and prioritize new features.
+Telemetry is only sent when loading models and pipelines from the Hub,
+and it is not collected if you’re loading local files. We understand that not everyone wants to share additional information,and we respect your privacy.
+You can disable telemetry collection by setting the DISABLE_TELEMETRY environment variable from your terminal: On Linux/MacOS:   Copied export DISABLE_TELEMETRY=YES On Windows:   Copied set DISABLE_TELEMETRY=YES

scrapped_outputs/04863d9d6a0a778c9d89bfaf5c722799.txt

@@ -0,0 +1,58 @@
+Tiny AutoEncoder Tiny AutoEncoder for Stable Diffusion (TAESD) was introduced in madebyollin/taesd by Ollin Boer Bohan. It is a tiny distilled version of Stable Diffusion’s VAE that can quickly decode the latents in a StableDiffusionPipeline or StableDiffusionXLPipeline almost instantly. To use with Stable Diffusion v-2.1:   Copied import torch
+from diffusers import DiffusionPipeline, AutoencoderTiny
+
+pipe = DiffusionPipeline.from_pretrained(
+    "stabilityai/stable-diffusion-2-1-base", torch_dtype=torch.float16
+)
+pipe.vae = AutoencoderTiny.from_pretrained("madebyollin/taesd", torch_dtype=torch.float16)
+pipe = pipe.to("cuda")
+
+prompt = "slice of delicious New York-style berry cheesecake"
+image = pipe(prompt, num_inference_steps=25).images[0]
+image To use with Stable Diffusion XL 1.0   Copied import torch
+from diffusers import DiffusionPipeline, AutoencoderTiny
+
+pipe = DiffusionPipeline.from_pretrained(
+    "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16
+)
+pipe.vae = AutoencoderTiny.from_pretrained("madebyollin/taesdxl", torch_dtype=torch.float16)
+pipe = pipe.to("cuda")
+
+prompt = "slice of delicious New York-style berry cheesecake"
+image = pipe(prompt, num_inference_steps=25).images[0]
+image  AutoencoderTiny  class diffusers.AutoencoderTiny  < source > ( in_channels: int = 3 out_channels: int = 3 encoder_block_out_channels: Tuple = (64, 64, 64, 64) decoder_block_out_channels: Tuple = (64, 64, 64, 64) act_fn: str = 'relu' latent_channels: int = 4 upsampling_scaling_factor: int = 2 num_encoder_blocks: Tuple = (1, 3, 3, 3) num_decoder_blocks: Tuple = (3, 3, 3, 1) latent_magnitude: int = 3 latent_shift: float = 0.5 force_upcast: bool = False scaling_factor: float = 1.0  )   Parameters   in_channels (int, optional, defaults to 3) — Number of channels in the input image.   out_channels (int,  optional, defaults to 3) — Number of channels in the output.   encoder_block_out_channels (Tuple[int], optional, defaults to (64, 64, 64, 64)) —
+Tuple of integers representing the number of output channels for each encoder block. The length of the
+tuple should be equal to the number of encoder blocks.   decoder_block_out_channels (Tuple[int], optional, defaults to (64, 64, 64, 64)) —
+Tuple of integers representing the number of output channels for each decoder block. The length of the
+tuple should be equal to the number of decoder blocks.   act_fn (str, optional, defaults to "relu") —
+Activation function to be used throughout the model.   latent_channels (int, optional, defaults to 4) —
+Number of channels in the latent representation. The latent space acts as a compressed representation of
+the input image.   upsampling_scaling_factor (int, optional, defaults to 2) —
+Scaling factor for upsampling in the decoder. It determines the size of the output image during the
+upsampling process.   num_encoder_blocks (Tuple[int], optional, defaults to (1, 3, 3, 3)) —
+Tuple of integers representing the number of encoder blocks at each stage of the encoding process. The
+length of the tuple should be equal to the number of stages in the encoder. Each stage has a different
+number of encoder blocks.   num_decoder_blocks (Tuple[int], optional, defaults to (3, 3, 3, 1)) —
+Tuple of integers representing the number of decoder blocks at each stage of the decoding process. The
+length of the tuple should be equal to the number of stages in the decoder. Each stage has a different
+number of decoder blocks.   latent_magnitude (float, optional, defaults to 3.0) —
+Magnitude of the latent representation. This parameter scales the latent representation values to control
+the extent of information preservation.   latent_shift (float, optional, defaults to 0.5) —
+Shift applied to the latent representation. This parameter controls the center of the latent space.   scaling_factor (float, optional, defaults to 1.0) —
+The component-wise standard deviation of the trained latent space computed using the first batch of the
+training set. This is used to scale the latent space to have unit variance when training the diffusion
+model. The latents are scaled with the formula z = z * scaling_factor before being passed to the
+diffusion model. When decoding, the latents are scaled back to the original scale with the formula: z = 1 / scaling_factor * z. For more details, refer to sections 4.3.2 and D.1 of the High-Resolution Image
+Synthesis with Latent Diffusion Models paper. For this Autoencoder,
+however, no such scaling factor was used, hence the value of 1.0 as the default.   force_upcast (bool, optional, default to False) —
+If enabled it will force the VAE to run in float32 for high image resolution pipelines, such as SD-XL. VAE
+can be fine-tuned / trained to a lower range without losing too much precision, in which case
+force_upcast can be set to False (see this fp16-friendly
+AutoEncoder).    A tiny distilled VAE model for encoding images into latents and decoding latent representations into images. AutoencoderTiny is a wrapper around the original implementation of TAESD. This model inherits from ModelMixin. Check the superclass documentation for its generic methods implemented for
+all models (such as downloading or saving).  disable_slicing  < source > ( )    Disable sliced VAE decoding. If enable_slicing was previously enabled, this method will go back to computing
+decoding in one step.  disable_tiling  < source > ( )    Disable tiled VAE decoding. If enable_tiling was previously enabled, this method will go back to computing
+decoding in one step.  enable_slicing  < source > ( )    Enable sliced VAE decoding. When this option is enabled, the VAE will split the input tensor in slices to
+compute decoding in several steps. This is useful to save some memory and allow larger batch sizes.  enable_tiling  < source > ( use_tiling: bool = True  )    Enable tiled VAE decoding. When this option is enabled, the VAE will split the input tensor into tiles to
+compute decoding and encoding in several steps. This is useful for saving a large amount of memory and to allow
+processing larger images.  forward  < source > ( sample: FloatTensor return_dict: bool = True  )   Parameters   sample (torch.FloatTensor) — Input sample.   return_dict (bool, optional, defaults to True) —
+Whether or not to return a DecoderOutput instead of a plain tuple.     scale_latents  < source > ( x: FloatTensor  )    raw latents -> [0, 1]  unscale_latents  < source > ( x: FloatTensor  )    [0, 1] -> raw latents  AutoencoderTinyOutput  class diffusers.models.autoencoders.autoencoder_tiny.AutoencoderTinyOutput  < source > ( latents: Tensor  )   Parameters   latents (torch.Tensor) — Encoded outputs of the Encoder.    Output of AutoencoderTiny encoding method.

scrapped_outputs/04a5c43352cba1852d9743227a5502ec.txt

@@ -0,0 +1,11 @@
+Installing xFormers
+	
+We recommend the use of xFormers for both inference and training. In our tests, the optimizations performed in the attention blocks allow for both faster speed and reduced memory consumption.
+Starting from version 0.0.16 of xFormers, released on January 2023, installation can be easily performed using pre-built pip wheels:
+
+
+	Copied
+pip install xformers
+The xFormers PIP package requires the latest version of PyTorch (1.13.1 as of xFormers 0.0.16). If you need to use a previous version of PyTorch, then we recommend you install xFormers from source using the project instructions.
+After xFormers is installed, you can use enable_xformers_memory_efficient_attention() for faster inference and reduced memory consumption, as discussed here.
+According to this issue, xFormers v0.0.16 cannot be used for training (fine-tune or Dreambooth) in some GPUs. If you observe that problem, please install a development version as indicated in that comment.

scrapped_outputs/04b6c971d3b3042cb398245d60d142af.txt

@@ -0,0 +1,50 @@
+Attention Processor An attention processor is a class for applying different types of attention mechanisms.  AttnProcessor  class diffusers.models.attention_processor.AttnProcessor  < source > ( )    Default processor for performing attention-related computations.  AttnProcessor2_0  class diffusers.models.attention_processor.AttnProcessor2_0  < source > ( )    Processor for implementing scaled dot-product attention (enabled by default if you’re using PyTorch 2.0).  AttnAddedKVProcessor  class diffusers.models.attention_processor.AttnAddedKVProcessor  < source > ( )    Processor for performing attention-related computations with extra learnable key and value matrices for the text
+encoder.  AttnAddedKVProcessor2_0  class diffusers.models.attention_processor.AttnAddedKVProcessor2_0  < source > ( )    Processor for performing scaled dot-product attention (enabled by default if you’re using PyTorch 2.0), with extra
+learnable key and value matrices for the text encoder.  CrossFrameAttnProcessor  class diffusers.pipelines.text_to_video_synthesis.pipeline_text_to_video_zero.CrossFrameAttnProcessor  < source > ( batch_size = 2  )    Cross frame attention processor. Each frame attends the first frame.  CustomDiffusionAttnProcessor  class diffusers.models.attention_processor.CustomDiffusionAttnProcessor  < source > ( train_kv: bool = True train_q_out: bool = True hidden_size: Optional = None cross_attention_dim: Optional = None out_bias: bool = True dropout: float = 0.0  )   Parameters   train_kv (bool, defaults to True) —
+Whether to newly train the key and value matrices corresponding to the text features.   train_q_out (bool, defaults to True) —
+Whether to newly train query matrices corresponding to the latent image features.   hidden_size (int, optional, defaults to None) —
+The hidden size of the attention layer.   cross_attention_dim (int, optional, defaults to None) —
+The number of channels in the encoder_hidden_states.   out_bias (bool, defaults to True) —
+Whether to include the bias parameter in train_q_out.   dropout (float, optional, defaults to 0.0) —
+The dropout probability to use.    Processor for implementing attention for the Custom Diffusion method.  CustomDiffusionAttnProcessor2_0  class diffusers.models.attention_processor.CustomDiffusionAttnProcessor2_0  < source > ( train_kv: bool = True train_q_out: bool = True hidden_size: Optional = None cross_attention_dim: Optional = None out_bias: bool = True dropout: float = 0.0  )   Parameters   train_kv (bool, defaults to True) —
+Whether to newly train the key and value matrices corresponding to the text features.   train_q_out (bool, defaults to True) —
+Whether to newly train query matrices corresponding to the latent image features.   hidden_size (int, optional, defaults to None) —
+The hidden size of the attention layer.   cross_attention_dim (int, optional, defaults to None) —
+The number of channels in the encoder_hidden_states.   out_bias (bool, defaults to True) —
+Whether to include the bias parameter in train_q_out.   dropout (float, optional, defaults to 0.0) —
+The dropout probability to use.    Processor for implementing attention for the Custom Diffusion method using PyTorch 2.0’s memory-efficient scaled
+dot-product attention.  CustomDiffusionXFormersAttnProcessor  class diffusers.models.attention_processor.CustomDiffusionXFormersAttnProcessor  < source > ( train_kv: bool = True train_q_out: bool = False hidden_size: Optional = None cross_attention_dim: Optional = None out_bias: bool = True dropout: float = 0.0 attention_op: Optional = None  )   Parameters   train_kv (bool, defaults to True) —
+Whether to newly train the key and value matrices corresponding to the text features.   train_q_out (bool, defaults to True) —
+Whether to newly train query matrices corresponding to the latent image features.   hidden_size (int, optional, defaults to None) —
+The hidden size of the attention layer.   cross_attention_dim (int, optional, defaults to None) —
+The number of channels in the encoder_hidden_states.   out_bias (bool, defaults to True) —
+Whether to include the bias parameter in train_q_out.   dropout (float, optional, defaults to 0.0) —
+The dropout probability to use.   attention_op (Callable, optional, defaults to None) —
+The base
+operator to use
+as the attention operator. It is recommended to set to None, and allow xFormers to choose the best operator.    Processor for implementing memory efficient attention using xFormers for the Custom Diffusion method.  FusedAttnProcessor2_0  class diffusers.models.attention_processor.FusedAttnProcessor2_0  < source > ( )    Processor for implementing scaled dot-product attention (enabled by default if you’re using PyTorch 2.0).
+It uses fused projection layers. For self-attention modules, all projection matrices (i.e., query,
+key, value) are fused. For cross-attention modules, key and value projection matrices are fused. This API is currently 🧪 experimental in nature and can change in future.  LoRAAttnAddedKVProcessor  class diffusers.models.attention_processor.LoRAAttnAddedKVProcessor  < source > ( hidden_size: int cross_attention_dim: Optional = None rank: int = 4 network_alpha: Optional = None  )   Parameters   hidden_size (int, optional) —
+The hidden size of the attention layer.   cross_attention_dim (int, optional, defaults to None) —
+The number of channels in the encoder_hidden_states.   rank (int, defaults to 4) —
+The dimension of the LoRA update matrices.   network_alpha (int, optional) —
+Equivalent to alpha but it’s usage is specific to Kohya (A1111) style LoRAs.   kwargs (dict) —
+Additional keyword arguments to pass to the LoRALinearLayer layers.    Processor for implementing the LoRA attention mechanism with extra learnable key and value matrices for the text
+encoder.  LoRAXFormersAttnProcessor  class diffusers.models.attention_processor.LoRAXFormersAttnProcessor  < source > ( hidden_size: int cross_attention_dim: int rank: int = 4 attention_op: Optional = None network_alpha: Optional = None **kwargs  )   Parameters   hidden_size (int, optional) —
+The hidden size of the attention layer.   cross_attention_dim (int, optional) —
+The number of channels in the encoder_hidden_states.   rank (int, defaults to 4) —
+The dimension of the LoRA update matrices.   attention_op (Callable, optional, defaults to None) —
+The base
+operator to
+use as the attention operator. It is recommended to set to None, and allow xFormers to choose the best
+operator.   network_alpha (int, optional) —
+Equivalent to alpha but it’s usage is specific to Kohya (A1111) style LoRAs.   kwargs (dict) —
+Additional keyword arguments to pass to the LoRALinearLayer layers.    Processor for implementing the LoRA attention mechanism with memory efficient attention using xFormers.  SlicedAttnProcessor  class diffusers.models.attention_processor.SlicedAttnProcessor  < source > ( slice_size: int  )   Parameters   slice_size (int, optional) —
+The number of steps to compute attention. Uses as many slices as attention_head_dim // slice_size, and
+attention_head_dim must be a multiple of the slice_size.    Processor for implementing sliced attention.  SlicedAttnAddedKVProcessor  class diffusers.models.attention_processor.SlicedAttnAddedKVProcessor  < source > ( slice_size  )   Parameters   slice_size (int, optional) —
+The number of steps to compute attention. Uses as many slices as attention_head_dim // slice_size, and
+attention_head_dim must be a multiple of the slice_size.    Processor for implementing sliced attention with extra learnable key and value matrices for the text encoder.  XFormersAttnProcessor  class diffusers.models.attention_processor.XFormersAttnProcessor  < source > ( attention_op: Optional = None  )   Parameters   attention_op (Callable, optional, defaults to None) —
+The base
+operator to
+use as the attention operator. It is recommended to set to None, and allow xFormers to choose the best
+operator.    Processor for implementing memory efficient attention using xFormers.

scrapped_outputs/0513b0801d8c780910edb8268d9b7b3b.txt

@@ -0,0 +1 @@
+SDXL Turbo Stable Diffusion XL (SDXL) Turbo was proposed in Adversarial Diffusion Distillation by Axel Sauer, Dominik Lorenz, Andreas Blattmann, and Robin Rombach. The abstract from the paper is: We introduce Adversarial Diffusion Distillation (ADD), a novel training approach that efficiently samples large-scale foundational image diffusion models in just 1–4 steps while maintaining high image quality. We use score distillation to leverage large-scale off-the-shelf image diffusion models as a teacher signal in combination with an adversarial loss to ensure high image fidelity even in the low-step regime of one or two sampling steps. Our analyses show that our model clearly outperforms existing few-step methods (GANs,Latent Consistency Models) in a single step and reaches the performance of state-of-the-art diffusion models (SDXL) in only four steps. ADD is the first method to unlock single-step, real-time image synthesis with foundation models.  Tips SDXL Turbo uses the exact same architecture as SDXL, which means it also has the same API. Please refer to the SDXL API reference for more details. SDXL Turbo should disable guidance scale by setting guidance_scale=0.0. SDXL Turbo should use timestep_spacing='trailing' for the scheduler and use between 1 and 4 steps. SDXL Turbo has been trained to generate images of size 512x512. SDXL Turbo is open-access, but not open-source meaning that one might have to buy a model license in order to use it for commercial applications. Make sure to read the official model card to learn more. To learn how to use SDXL Turbo for various tasks, how to optimize performance, and other usage examples, take a look at the SDXL Turbo guide. Check out the Stability AI Hub organization for the official base and refiner model checkpoints!

scrapped_outputs/05377f15590571c32cefbc2656f68eeb.txt

@@ -0,0 +1,137 @@
+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 image conditioned on some query text and reference text which produces different noise estimates for different areas of the image; the difference is used to infer a mask to identify which area of the image needs to be changed to match the query text the input image is encoded into latent space with DDIM the latents are decoded with the diffusion model conditioned on the text query, using the mask as a guide such that pixels outside the mask remain the same as in the input image This guide will show you how to use DiffEdit to edit images without manually creating a mask. 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 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 the image. For example, if you want to change a bowl of fruits to a bowl of pears, then:   Copied source_prompt = "a bowl of fruits"
+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 other text descriptions! Let’s load the pipeline, scheduler, inverse scheduler, and enable some optimizations to reduce memory usage:   Copied import torch
+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 target_prompt becomes the prompt now, and the source_prompt is used as the negative_prompt:   Copied output_image = pipeline(
+    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 🤗 Transformers library:   Copied import torch
+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 import torch
+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(
+            sent,
+            padding="max_length",
+            max_length=tokenizer.model_max_length,
+            truncation=True,
+            return_tensors="pt",
+        )
+        text_input_ids = text_inputs.input_ids
+        prompt_embeds = text_encoder(text_input_ids.to(device), attention_mask=None)[0]
+        embeddings.append(prompt_embeds)
+    return torch.concatenate(embeddings, dim=0).mean(dim=0).unsqueeze(0)
+
+source_embeds = embed_prompts(source_prompts, pipeline.tokenizer, pipeline.text_encoder)
+target_embeds = embed_prompts(target_prompts, pipeline.tokenizer, pipeline.text_encoder) Finally, pass the embeddings to the generate_mask() and invert() functions, and pipeline to generate the image:   Copied   from diffusers import DDIMInverseScheduler, DDIMScheduler
+  from diffusers.utils import load_image, make_image_grid
+  from PIL import Image
+
+  pipeline.scheduler = DDIMScheduler.from_config(pipeline.scheduler.config)
+  pipeline.inverse_scheduler = DDIMInverseScheduler.from_config(pipeline.scheduler.config)
+
+  img_url = "https://github.com/Xiang-cd/DiffEdit-stable-diffusion/raw/main/assets/origin.png"
+  raw_image = load_image(img_url).resize((768, 768))
+
+  mask_image = pipeline.generate_mask(
+      image=raw_image,
+-     source_prompt=source_prompt,
+-     target_prompt=target_prompt,
++     source_prompt_embeds=source_embeds,
++     target_prompt_embeds=target_embeds,
+  )
+
+  inv_latents = pipeline.invert(
+-     prompt=source_prompt,
++     prompt_embeds=source_embeds,
+      image=raw_image,
+  ).latents
+
+  output_image = pipeline(
+      mask_image=mask_image,
+      image_latents=inv_latents,
+-     prompt=target_prompt,
+-     negative_prompt=source_prompt,
++     prompt_embeds=target_embeds,
++     negative_prompt_embeds=source_embeds,
+  ).images[0]
+  mask_image = Image.fromarray((mask_image.squeeze()*255).astype("uint8"), "L")
+  make_image_grid([raw_image, mask_image, output_image], rows=1, cols=3)  Generate a caption for inversion While you can use the source_prompt as a caption to help generate the partially inverted latents, you can also use the BLIP model to automatically generate a caption. Load the BLIP model and processor from the 🤗 Transformers library:   Copied import torch
+from transformers import BlipForConditionalGeneration, BlipProcessor
+
+processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
+model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base", torch_dtype=torch.float16, low_cpu_mem_usage=True) Create a utility function to generate a caption from the input image:   Copied @torch.no_grad()
+def generate_caption(images, caption_generator, caption_processor):
+    text = "a photograph of"
+
+    inputs = caption_processor(images, text, return_tensors="pt").to(device="cuda", dtype=caption_generator.dtype)
+    caption_generator.to("cuda")
+    outputs = caption_generator.generate(**inputs, max_new_tokens=128)
+
+    # offload caption generator
+    caption_generator.to("cpu")
+
+    caption = caption_processor.batch_decode(outputs, skip_special_tokens=True)[0]
+    return caption Load an input image and generate a caption for it using the generate_caption function:   Copied from diffusers.utils import load_image
+
+img_url = "https://github.com/Xiang-cd/DiffEdit-stable-diffusion/raw/main/assets/origin.png"
+raw_image = load_image(img_url).resize((768, 768))
+caption = generate_caption(raw_image, model, processor)  generated caption: "a photograph of a bowl of fruit on a table" Now you can drop the caption into the invert() function to generate the partially inverted latents!

scrapped_outputs/05582e67bfcec7fa9b41e4219522b5e8.txt

@@ -0,0 +1,75 @@
+Shap-E            Shap-E is a conditional model for generating 3D assets which could be used for video game development, interior design, and architecture. It is trained on a large dataset of 3D assets, and post-processed to render more views of each object and produce 16K instead of 4K point clouds. The Shap-E model is trained in two steps: an encoder accepts the point clouds and rendered views of a 3D asset and outputs the parameters of implicit functions that represent the asset a diffusion model is trained on the latents produced by the encoder to generate either neural radiance fields (NeRFs) or a textured 3D mesh, making it easier to render and use the 3D asset in downstream applications This guide will show you how to use Shap-E to start generating your own 3D assets! 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 trimesh  Text-to-3D To generate a gif of a 3D object, pass a text prompt to the ShapEPipeline. The pipeline generates a list of image frames which are used to create the 3D object.   Copied import torch
+from diffusers import ShapEPipeline
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+pipe = ShapEPipeline.from_pretrained("openai/shap-e", torch_dtype=torch.float16, variant="fp16")
+pipe = pipe.to(device)
+
+guidance_scale = 15.0
+prompt = ["A firecracker", "A birthday cupcake"]
+
+images = pipe(
+    prompt,
+    guidance_scale=guidance_scale,
+    num_inference_steps=64,
+    frame_size=256,
+).images Now use the export_to_gif() function to turn the list of image frames into a gif of the 3D object.   Copied from diffusers.utils import export_to_gif
+
+export_to_gif(images[0], "firecracker_3d.gif")
+export_to_gif(images[1], "cake_3d.gif")  prompt = "A firecracker"  prompt = "A birthday cupcake"  Image-to-3D To generate a 3D object from another image, use the ShapEImg2ImgPipeline. You can use an existing image or generate an entirely new one. Let’s use the Kandinsky 2.1 model to generate a new image.   Copied from diffusers import DiffusionPipeline
+import torch
+
+prior_pipeline = DiffusionPipeline.from_pretrained("kandinsky-community/kandinsky-2-1-prior", torch_dtype=torch.float16, use_safetensors=True).to("cuda")
+pipeline = DiffusionPipeline.from_pretrained("kandinsky-community/kandinsky-2-1", torch_dtype=torch.float16, use_safetensors=True).to("cuda")
+
+prompt = "A cheeseburger, white background"
+
+image_embeds, negative_image_embeds = prior_pipeline(prompt, guidance_scale=1.0).to_tuple()
+image = pipeline(
+    prompt,
+    image_embeds=image_embeds,
+    negative_image_embeds=negative_image_embeds,
+).images[0]
+
+image.save("burger.png") Pass the cheeseburger to the ShapEImg2ImgPipeline to generate a 3D representation of it.   Copied from PIL import Image
+from diffusers import ShapEImg2ImgPipeline
+from diffusers.utils import export_to_gif
+
+pipe = ShapEImg2ImgPipeline.from_pretrained("openai/shap-e-img2img", torch_dtype=torch.float16, variant="fp16").to("cuda")
+
+guidance_scale = 3.0
+image = Image.open("burger.png").resize((256, 256))
+
+images = pipe(
+    image,
+    guidance_scale=guidance_scale,
+    num_inference_steps=64,
+    frame_size=256,
+).images
+
+gif_path = export_to_gif(images[0], "burger_3d.gif")  cheeseburger  3D cheeseburger  Generate mesh Shap-E is a flexible model that can also generate textured mesh outputs to be rendered for downstream applications. In this example, you’ll convert the output into a glb file because the 🤗 Datasets library supports mesh visualization of glb files which can be rendered by the Dataset viewer. You can generate mesh outputs for both the ShapEPipeline and ShapEImg2ImgPipeline by specifying the output_type parameter as "mesh":   Copied import torch
+from diffusers import ShapEPipeline
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+pipe = ShapEPipeline.from_pretrained("openai/shap-e", torch_dtype=torch.float16, variant="fp16")
+pipe = pipe.to(device)
+
+guidance_scale = 15.0
+prompt = "A birthday cupcake"
+
+images = pipe(prompt, guidance_scale=guidance_scale, num_inference_steps=64, frame_size=256, output_type="mesh").images Use the export_to_ply() function to save the mesh output as a ply file: You can optionally save the mesh output as an obj file with the export_to_obj() function. The ability to save the mesh output in a variety of formats makes it more flexible for downstream usage!   Copied from diffusers.utils import export_to_ply
+
+ply_path = export_to_ply(images[0], "3d_cake.ply")
+print(f"Saved to folder: {ply_path}") Then you can convert the ply file to a glb file with the trimesh library:   Copied import trimesh
+
+mesh = trimesh.load("3d_cake.ply")
+mesh_export = mesh.export("3d_cake.glb", file_type="glb") By default, the mesh output is focused from the bottom viewpoint but you can change the default viewpoint by applying a rotation transform:   Copied import trimesh
+import numpy as np
+
+mesh = trimesh.load("3d_cake.ply")
+rot = trimesh.transformations.rotation_matrix(-np.pi / 2, [1, 0, 0])
+mesh = mesh.apply_transform(rot)
+mesh_export = mesh.export("3d_cake.glb", file_type="glb") Upload the mesh file to your dataset repository to visualize it with the Dataset viewer!

scrapped_outputs/0563c13a7c1c4c7bf534f8ba98328463.txt

@@ -0,0 +1,66 @@
+Latent Consistency Model Multistep Scheduler  Overview Multistep and onestep scheduler (Algorithm 3) introduced alongside latent consistency models in the paper Latent Consistency Models: Synthesizing High-Resolution Images with Few-Step Inference by Simian Luo, Yiqin Tan, Longbo Huang, Jian Li, and Hang Zhao.
+This scheduler should be able to generate good samples from LatentConsistencyModelPipeline in 1-8 steps.  LCMScheduler  class diffusers.LCMScheduler  < source > ( num_train_timesteps: int = 1000 beta_start: float = 0.00085 beta_end: float = 0.012 beta_schedule: str = 'scaled_linear' trained_betas: Union = None original_inference_steps: int = 50 clip_sample: bool = False clip_sample_range: float = 1.0 set_alpha_to_one: bool = True steps_offset: int = 0 prediction_type: str = 'epsilon' thresholding: bool = False dynamic_thresholding_ratio: float = 0.995 sample_max_value: float = 1.0 timestep_spacing: str = 'leading' timestep_scaling: float = 10.0 rescale_betas_zero_snr: bool = False  )   Parameters   num_train_timesteps (int, defaults to 1000) —
+The number of diffusion steps to train the model.   beta_start (float, defaults to 0.0001) —
+The starting beta value of inference.   beta_end (float, defaults to 0.02) —
+The final beta value.   beta_schedule (str, defaults to "linear") —
+The beta schedule, a mapping from a beta range to a sequence of betas for stepping the model. Choose from
+linear, scaled_linear, or squaredcos_cap_v2.   trained_betas (np.ndarray, optional) —
+Pass an array of betas directly to the constructor to bypass beta_start and beta_end.   original_inference_steps (int, optional, defaults to 50) —
+The default number of inference steps used to generate a linearly-spaced timestep schedule, from which we
+will ultimately take num_inference_steps evenly spaced timesteps to form the final timestep schedule.   clip_sample (bool, defaults to True) —
+Clip the predicted sample for numerical stability.   clip_sample_range (float, defaults to 1.0) —
+The maximum magnitude for sample clipping. Valid only when clip_sample=True.   set_alpha_to_one (bool, defaults to True) —
+Each diffusion step uses the alphas product value at that step and at the previous one. For the final step
+there is no previous alpha. When this option is True the previous alpha product is fixed to 1,
+otherwise it uses the alpha value at step 0.   steps_offset (int, defaults to 0) —
+An offset added to the inference steps. You can use a combination of offset=1 and
+set_alpha_to_one=False to make the last step use step 0 for the previous alpha product like in Stable
+Diffusion.   prediction_type (str, defaults to epsilon, optional) —
+Prediction type of the scheduler function; can be epsilon (predicts the noise of the diffusion process),
+sample (directly predicts the noisy sample) or v_prediction` (see section 2.4 of Imagen
+Video paper).   thresholding (bool, defaults to False) —
+Whether to use the “dynamic thresholding” method. This is unsuitable for latent-space diffusion models such
+as Stable Diffusion.   dynamic_thresholding_ratio (float, defaults to 0.995) —
+The ratio for the dynamic thresholding method. Valid only when thresholding=True.   sample_max_value (float, defaults to 1.0) —
+The threshold value for dynamic thresholding. Valid only when thresholding=True.   timestep_spacing (str, defaults to "leading") —
+The way the timesteps should be scaled. Refer to Table 2 of the Common Diffusion Noise Schedules and
+Sample Steps are Flawed for more information.   timestep_scaling (float, defaults to 10.0) —
+The factor the timesteps will be multiplied by when calculating the consistency model boundary conditions
+c_skip and c_out. Increasing this will decrease the approximation error (although the approximation
+error at the default of 10.0 is already pretty small).   rescale_betas_zero_snr (bool, defaults to False) —
+Whether to rescale the betas to have zero terminal SNR. This enables the model to generate very bright and
+dark samples instead of limiting it to samples with medium brightness. Loosely related to
+--offset_noise.    LCMScheduler extends the denoising procedure introduced in denoising diffusion probabilistic models (DDPMs) with
+non-Markovian guidance. This model inherits from SchedulerMixin and ConfigMixin. ~ConfigMixin takes care of storing all config
+attributes that are passed in the scheduler’s __init__ function, such as num_train_timesteps. They can be
+accessed via scheduler.config.num_train_timesteps. SchedulerMixin provides general loading and saving
+functionality via the SchedulerMixin.save_pretrained() and from_pretrained() functions.  scale_model_input  < source > ( sample: FloatTensor timestep: Optional = None  ) → torch.FloatTensor  Parameters   sample (torch.FloatTensor) —
+The input sample.   timestep (int, optional) —
+The current timestep in the diffusion chain.   Returns 
+torch.FloatTensor
+  
+A scaled input sample.
+  Ensures interchangeability with schedulers that need to scale the denoising model input depending on the
+current timestep.  set_begin_index  < source > ( begin_index: int = 0  )   Parameters   begin_index (int) —
+The begin index for the scheduler.    Sets the begin index for the scheduler. This function should be run from pipeline before the inference.  set_timesteps  < source > ( num_inference_steps: Optional = None device: Union = None original_inference_steps: Optional = None timesteps: Optional = None strength: int = 1.0  )   Parameters   num_inference_steps (int, optional) —
+The number of diffusion steps used when generating samples with a pre-trained model. If used,
+timesteps must be None.   device (str or torch.device, optional) —
+The device to which the timesteps should be moved to. If None, the timesteps are not moved.   original_inference_steps (int, optional) —
+The original number of inference steps, which will be used to generate a linearly-spaced timestep
+schedule (which is different from the standard diffusers implementation). We will then take
+num_inference_steps timesteps from this schedule, evenly spaced in terms of indices, and use that as
+our final timestep schedule. If not set, this will default to the original_inference_steps attribute.   timesteps (List[int], optional) —
+Custom timesteps used to support arbitrary spacing between timesteps. If None, then the default
+timestep spacing strategy of equal spacing between timesteps on the training/distillation timestep
+schedule is used. If timesteps is passed, num_inference_steps must be None.    Sets the discrete timesteps used for the diffusion chain (to be run before inference).  step  < source > ( model_output: FloatTensor timestep: int sample: FloatTensor generator: Optional = None return_dict: bool = True  ) → ~schedulers.scheduling_utils.LCMSchedulerOutput or tuple  Parameters   model_output (torch.FloatTensor) —
+The direct output from learned diffusion model.   timestep (float) —
+The current discrete timestep in the diffusion chain.   sample (torch.FloatTensor) —
+A current instance of a sample created by the diffusion process.   generator (torch.Generator, optional) —
+A random number generator.   return_dict (bool, optional, defaults to True) —
+Whether or not to return a LCMSchedulerOutput or tuple.   Returns 
+~schedulers.scheduling_utils.LCMSchedulerOutput or tuple
+  
+If return_dict is True, LCMSchedulerOutput is returned, otherwise a
+tuple is returned where the first element is the sample tensor.
+  Predict the sample from the previous timestep by reversing the SDE. This function propagates the diffusion
+process from the learned model outputs (most often the predicted noise).

scrapped_outputs/056988b6242e71f9baa34a0128b3b910.txt

@@ -0,0 +1,61 @@
+Stable Diffusion 2 Stable Diffusion 2 is a text-to-image latent diffusion model built upon the work of the original Stable Diffusion, and it was led by Robin Rombach and Katherine Crowson from Stability AI and LAION. The Stable Diffusion 2.0 release includes robust text-to-image models trained using a brand new text encoder (OpenCLIP), developed by LAION with support from Stability AI, which greatly improves the quality of the generated images compared to earlier V1 releases. The text-to-image models in this release can generate images with default resolutions of both 512x512 pixels and 768x768 pixels.
+These models are trained on an aesthetic subset of the LAION-5B dataset created by the DeepFloyd team at Stability AI, which is then further filtered to remove adult content using LAION’s NSFW filter. For more details about how Stable Diffusion 2 works and how it differs from the original Stable Diffusion, please refer to the official announcement post. The architecture of Stable Diffusion 2 is more or less identical to the original Stable Diffusion model so check out it’s API documentation for how to use Stable Diffusion 2. We recommend using the DPMSolverMultistepScheduler as it gives a reasonable speed/quality trade-off and can be run with as little as 20 steps. Stable Diffusion 2 is available for tasks like text-to-image, inpainting, super-resolution, and depth-to-image: Task Repository text-to-image (512x512) stabilityai/stable-diffusion-2-base text-to-image (768x768) stabilityai/stable-diffusion-2 inpainting stabilityai/stable-diffusion-2-inpainting super-resolution stable-diffusion-x4-upscaler depth-to-image stabilityai/stable-diffusion-2-depth Here are some examples for how to use Stable Diffusion 2 for each task: Make sure to check out the Stable Diffusion Tips section to learn how to explore the tradeoff between scheduler speed and quality, and how to reuse pipeline components efficiently! If you’re interested in using one of the official checkpoints for a task, explore the CompVis, Runway, and Stability AI Hub organizations!  Text-to-image   Copied from diffusers import DiffusionPipeline, DPMSolverMultistepScheduler
+import torch
+
+repo_id = "stabilityai/stable-diffusion-2-base"
+pipe = DiffusionPipeline.from_pretrained(repo_id, torch_dtype=torch.float16, revision="fp16")
+
+pipe.scheduler = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
+pipe = pipe.to("cuda")
+
+prompt = "High quality photo of an astronaut riding a horse in space"
+image = pipe(prompt, num_inference_steps=25).images[0]
+image  Inpainting   Copied import torch
+from diffusers import DiffusionPipeline, DPMSolverMultistepScheduler
+from diffusers.utils import load_image, make_image_grid
+
+img_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo.png"
+mask_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo_mask.png"
+
+init_image = load_image(img_url).resize((512, 512))
+mask_image = load_image(mask_url).resize((512, 512))
+
+repo_id = "stabilityai/stable-diffusion-2-inpainting"
+pipe = DiffusionPipeline.from_pretrained(repo_id, torch_dtype=torch.float16, revision="fp16")
+
+pipe.scheduler = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
+pipe = pipe.to("cuda")
+
+prompt = "Face of a yellow cat, high resolution, sitting on a park bench"
+image = pipe(prompt=prompt, image=init_image, mask_image=mask_image, num_inference_steps=25).images[0]
+make_image_grid([init_image, mask_image, image], rows=1, cols=3)  Super-resolution   Copied from diffusers import StableDiffusionUpscalePipeline
+from diffusers.utils import load_image, make_image_grid
+import torch
+
+# load model and scheduler
+model_id = "stabilityai/stable-diffusion-x4-upscaler"
+pipeline = StableDiffusionUpscalePipeline.from_pretrained(model_id, torch_dtype=torch.float16)
+pipeline = pipeline.to("cuda")
+
+# let's download an  image
+url = "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale/low_res_cat.png"
+low_res_img = load_image(url)
+low_res_img = low_res_img.resize((128, 128))
+prompt = "a white cat"
+upscaled_image = pipeline(prompt=prompt, image=low_res_img).images[0]
+make_image_grid([low_res_img.resize((512, 512)), upscaled_image.resize((512, 512))], rows=1, cols=2)  Depth-to-image   Copied import torch
+from diffusers import StableDiffusionDepth2ImgPipeline
+from diffusers.utils import load_image, make_image_grid
+
+pipe = StableDiffusionDepth2ImgPipeline.from_pretrained(
+    "stabilityai/stable-diffusion-2-depth",
+    torch_dtype=torch.float16,
+).to("cuda")
+
+
+url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+init_image = load_image(url)
+prompt = "two tigers"
+negative_prompt = "bad, deformed, ugly, bad anotomy"
+image = pipe(prompt=prompt, image=init_image, negative_prompt=negative_prompt, strength=0.7).images[0]
+make_image_grid([init_image, image], rows=1, cols=2)

scrapped_outputs/0589ba813ef6923277cca7ee6b454f67.txt

@@ -0,0 +1,138 @@
+Single files Diffusers supports loading pretrained pipeline (or model) weights stored in a single file, such as a ckpt or safetensors file. These single file types are typically produced from community trained models. There are three classes for loading single file weights: FromSingleFileMixin supports loading pretrained pipeline weights stored in a single file, which can either be a ckpt or safetensors file. FromOriginalVAEMixin supports loading a pretrained AutoencoderKL from pretrained ControlNet weights stored in a single file, which can either be a ckpt or safetensors file. FromOriginalControlnetMixin supports loading pretrained ControlNet weights stored in a single file, which can either be a ckpt or safetensors file. To learn more about how to load single file weights, see the Load different Stable Diffusion formats loading guide.  FromSingleFileMixin  class diffusers.loaders.FromSingleFileMixin  < source > ( )    Load model weights saved in the .ckpt format into a DiffusionPipeline.  from_single_file  < source > ( pretrained_model_link_or_path **kwargs  )   Parameters   pretrained_model_link_or_path (str or os.PathLike, optional) —
+Can be either:
+A link to the .ckpt file (for example
+"https://huggingface.co/<repo_id>/blob/main/<path_to_file>.ckpt") on the Hub.
+A path to a file containing all pipeline weights.
+   torch_dtype (str or torch.dtype, optional) —
+Override the default torch.dtype and load the model with another dtype. If "auto" is passed, the
+dtype is automatically derived from the model’s weights.   force_download (bool, optional, defaults to False) —
+Whether or not to force the (re-)download of the model weights and configuration files, overriding the
+cached versions if they exist.   cache_dir (Union[str, os.PathLike], optional) —
+Path to a directory where a downloaded pretrained model configuration is cached if the standard cache
+is not used.   resume_download (bool, optional, defaults to False) —
+Whether or not to resume downloading the model weights and configuration files. If set to False, any
+incompletely downloaded files are deleted.   proxies (Dict[str, str], optional) —
+A dictionary of proxy servers to use by protocol or endpoint, for example, {'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}. The proxies are used on each request.   local_files_only (bool, optional, defaults to False) —
+Whether to only load local model weights and configuration files or not. If set to True, the model
+won’t be downloaded from the Hub.   token (str or bool, optional) —
+The token to use as HTTP bearer authorization for remote files. If True, the token generated from
+diffusers-cli login (stored in ~/.huggingface) is used.   revision (str, optional, defaults to "main") —
+The specific model version to use. It can be a branch name, a tag name, a commit id, or any identifier
+allowed by Git.   use_safetensors (bool, optional, defaults to None) —
+If set to None, the safetensors weights are downloaded if they’re available and if the
+safetensors library is installed. If set to True, the model is forcibly loaded from safetensors
+weights. If set to False, safetensors weights are not loaded.   extract_ema (bool, optional, defaults to False) —
+Whether to extract the EMA weights or not. Pass True to extract the EMA weights which usually yield
+higher quality images for inference. Non-EMA weights are usually better for continuing finetuning.   upcast_attention (bool, optional, defaults to None) —
+Whether the attention computation should always be upcasted.   image_size (int, optional, defaults to 512) —
+The image size the model was trained on. Use 512 for all Stable Diffusion v1 models and the Stable
+Diffusion v2 base model. Use 768 for Stable Diffusion v2.   prediction_type (str, optional) —
+The prediction type the model was trained on. Use 'epsilon' for all Stable Diffusion v1 models and
+the Stable Diffusion v2 base model. Use 'v_prediction' for Stable Diffusion v2.   num_in_channels (int, optional, defaults to None) —
+The number of input channels. If None, it is automatically inferred.   scheduler_type (str, optional, defaults to "pndm") —
+Type of scheduler to use. Should be one of ["pndm", "lms", "heun", "euler", "euler-ancestral", "dpm", "ddim"].   load_safety_checker (bool, optional, defaults to True) —
+Whether to load the safety checker or not.   text_encoder (CLIPTextModel, optional, defaults to None) —
+An instance of CLIPTextModel to use, specifically the
+clip-vit-large-patch14 variant. If this
+parameter is None, the function loads a new instance of CLIPTextModel by itself if needed.   vae (AutoencoderKL, optional, defaults to None) —
+Variational Auto-Encoder (VAE) Model to encode and decode images to and from latent representations. If
+this parameter is None, the function will load a new instance of [CLIP] by itself, if needed.   tokenizer (CLIPTokenizer, optional, defaults to None) —
+An instance of CLIPTokenizer to use. If this parameter is None, the function loads a new instance
+of CLIPTokenizer by itself if needed.   original_config_file (str) —
+Path to .yaml config file corresponding to the original architecture. If None, will be
+automatically inferred by looking for a key that only exists in SD2.0 models.   kwargs (remaining dictionary of keyword arguments, optional) —
+Can be used to overwrite load and saveable variables (for example the pipeline components of the
+specific pipeline class). The overwritten components are directly passed to the pipelines __init__
+method. See example below for more information.    Instantiate a DiffusionPipeline from pretrained pipeline weights saved in the .ckpt or .safetensors
+format. The pipeline is set in evaluation mode (model.eval()) by default.  Examples:   Copied >>> from diffusers import StableDiffusionPipeline
+
+>>> # Download pipeline from huggingface.co and cache.
+>>> pipeline = StableDiffusionPipeline.from_single_file(
+...     "https://huggingface.co/WarriorMama777/OrangeMixs/blob/main/Models/AbyssOrangeMix/AbyssOrangeMix.safetensors"
+... )
+
+>>> # Download pipeline from local file
+>>> # file is downloaded under ./v1-5-pruned-emaonly.ckpt
+>>> pipeline = StableDiffusionPipeline.from_single_file("./v1-5-pruned-emaonly")
+
+>>> # Enable float16 and move to GPU
+>>> pipeline = StableDiffusionPipeline.from_single_file(
+...     "https://huggingface.co/runwayml/stable-diffusion-v1-5/blob/main/v1-5-pruned-emaonly.ckpt",
+...     torch_dtype=torch.float16,
+... )
+>>> pipeline.to("cuda")  FromOriginalVAEMixin  class diffusers.loaders.FromOriginalVAEMixin  < source > ( )    Load pretrained ControlNet weights saved in the .ckpt or .safetensors format into an AutoencoderKL.  from_single_file  < source > ( pretrained_model_link_or_path **kwargs  )   Parameters   pretrained_model_link_or_path (str or os.PathLike, optional) —
+Can be either:
+A link to the .ckpt file (for example
+"https://huggingface.co/<repo_id>/blob/main/<path_to_file>.ckpt") on the Hub.
+A path to a file containing all pipeline weights.
+   torch_dtype (str or torch.dtype, optional) —
+Override the default torch.dtype and load the model with another dtype. If "auto" is passed, the
+dtype is automatically derived from the model’s weights.   force_download (bool, optional, defaults to False) —
+Whether or not to force the (re-)download of the model weights and configuration files, overriding the
+cached versions if they exist.   cache_dir (Union[str, os.PathLike], optional) —
+Path to a directory where a downloaded pretrained model configuration is cached if the standard cache
+is not used.   resume_download (bool, optional, defaults to False) —
+Whether or not to resume downloading the model weights and configuration files. If set to False, any
+incompletely downloaded files are deleted.   proxies (Dict[str, str], optional) —
+A dictionary of proxy servers to use by protocol or endpoint, for example, {'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}. The proxies are used on each request.   local_files_only (bool, optional, defaults to False) —
+Whether to only load local model weights and configuration files or not. If set to True, the model
+won’t be downloaded from the Hub.   token (str or bool, optional) —
+The token to use as HTTP bearer authorization for remote files. If True, the token generated from
+diffusers-cli login (stored in ~/.huggingface) is used.   revision (str, optional, defaults to "main") —
+The specific model version to use. It can be a branch name, a tag name, a commit id, or any identifier
+allowed by Git.   image_size (int, optional, defaults to 512) —
+The image size the model was trained on. Use 512 for all Stable Diffusion v1 models and the Stable
+Diffusion v2 base model. Use 768 for Stable Diffusion v2.   use_safetensors (bool, optional, defaults to None) —
+If set to None, the safetensors weights are downloaded if they’re available and if the
+safetensors library is installed. If set to True, the model is forcibly loaded from safetensors
+weights. If set to False, safetensors weights are not loaded.   upcast_attention (bool, optional, defaults to None) —
+Whether the attention computation should always be upcasted.   scaling_factor (float, optional, defaults to 0.18215) —
+The component-wise standard deviation of the trained latent space computed using the first batch of the
+training set. This is used to scale the latent space to have unit variance when training the diffusion
+model. The latents are scaled with the formula z = z * scaling_factor before being passed to the
+diffusion model. When decoding, the latents are scaled back to the original scale with the formula: z = 1 / scaling_factor * z. For more details, refer to sections 4.3.2 and D.1 of the High-Resolution
+Image Synthesis with Latent Diffusion Models paper.   kwargs (remaining dictionary of keyword arguments, optional) —
+Can be used to overwrite load and saveable variables (for example the pipeline components of the
+specific pipeline class). The overwritten components are directly passed to the pipelines __init__
+method. See example below for more information.    Instantiate a AutoencoderKL from pretrained ControlNet weights saved in the original .ckpt or
+.safetensors format. The pipeline is set in evaluation mode (model.eval()) by default. Make sure to pass both image_size and scaling_factor to from_single_file() if you’re loading
+a VAE from SDXL or a Stable Diffusion v2 model or higher.  Examples:   Copied from diffusers import AutoencoderKL
+
+url = "https://huggingface.co/stabilityai/sd-vae-ft-mse-original/blob/main/vae-ft-mse-840000-ema-pruned.safetensors"  # can also be local file
+model = AutoencoderKL.from_single_file(url)  FromOriginalControlnetMixin  class diffusers.loaders.FromOriginalControlnetMixin  < source > ( )    Load pretrained ControlNet weights saved in the .ckpt or .safetensors format into a ControlNetModel.  from_single_file  < source > ( pretrained_model_link_or_path **kwargs  )   Parameters   pretrained_model_link_or_path (str or os.PathLike, optional) —
+Can be either:
+A link to the .ckpt file (for example
+"https://huggingface.co/<repo_id>/blob/main/<path_to_file>.ckpt") on the Hub.
+A path to a file containing all pipeline weights.
+   torch_dtype (str or torch.dtype, optional) —
+Override the default torch.dtype and load the model with another dtype. If "auto" is passed, the
+dtype is automatically derived from the model’s weights.   force_download (bool, optional, defaults to False) —
+Whether or not to force the (re-)download of the model weights and configuration files, overriding the
+cached versions if they exist.   cache_dir (Union[str, os.PathLike], optional) —
+Path to a directory where a downloaded pretrained model configuration is cached if the standard cache
+is not used.   resume_download (bool, optional, defaults to False) —
+Whether or not to resume downloading the model weights and configuration files. If set to False, any
+incompletely downloaded files are deleted.   proxies (Dict[str, str], optional) —
+A dictionary of proxy servers to use by protocol or endpoint, for example, {'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}. The proxies are used on each request.   local_files_only (bool, optional, defaults to False) —
+Whether to only load local model weights and configuration files or not. If set to True, the model
+won’t be downloaded from the Hub.   token (str or bool, optional) —
+The token to use as HTTP bearer authorization for remote files. If True, the token generated from
+diffusers-cli login (stored in ~/.huggingface) is used.   revision (str, optional, defaults to "main") —
+The specific model version to use. It can be a branch name, a tag name, a commit id, or any identifier
+allowed by Git.   use_safetensors (bool, optional, defaults to None) —
+If set to None, the safetensors weights are downloaded if they’re available and if the
+safetensors library is installed. If set to True, the model is forcibly loaded from safetensors
+weights. If set to False, safetensors weights are not loaded.   image_size (int, optional, defaults to 512) —
+The image size the model was trained on. Use 512 for all Stable Diffusion v1 models and the Stable
+Diffusion v2 base model. Use 768 for Stable Diffusion v2.   upcast_attention (bool, optional, defaults to None) —
+Whether the attention computation should always be upcasted.   kwargs (remaining dictionary of keyword arguments, optional) —
+Can be used to overwrite load and saveable variables (for example the pipeline components of the
+specific pipeline class). The overwritten components are directly passed to the pipelines __init__
+method. See example below for more information.    Instantiate a ControlNetModel from pretrained ControlNet weights saved in the original .ckpt or
+.safetensors format. The pipeline is set in evaluation mode (model.eval()) by default.  Examples:   Copied from diffusers import StableDiffusionControlNetPipeline, ControlNetModel
+
+url = "https://huggingface.co/lllyasviel/ControlNet-v1-1/blob/main/control_v11p_sd15_canny.pth"  # can also be a local path
+model = ControlNetModel.from_single_file(url)
+
+url = "https://huggingface.co/runwayml/stable-diffusion-v1-5/blob/main/v1-5-pruned.safetensors"  # can also be a local path
+pipe = StableDiffusionControlNetPipeline.from_single_file(url, controlnet=controlnet)

scrapped_outputs/05fc9a1b7b04cc46e3de44a240e518af.txt

@@ -0,0 +1,40 @@
+DDIM Denoising Diffusion Implicit Models (DDIM) by Jiaming Song, Chenlin Meng and Stefano Ermon. The abstract from the paper is: Denoising diffusion probabilistic models (DDPMs) have achieved high quality image generation without adversarial training, yet they require simulating a Markov chain for many steps to produce a sample. To accelerate sampling, we present denoising diffusion implicit models (DDIMs), a more efficient class of iterative implicit probabilistic models with the same training procedure as DDPMs. In DDPMs, the generative process is defined as the reverse of a Markovian diffusion process. We construct a class of non-Markovian diffusion processes that lead to the same training objective, but whose reverse process can be much faster to sample from. We empirically demonstrate that DDIMs can produce high quality samples 10× to 50× faster in terms of wall-clock time compared to DDPMs, allow us to trade off computation for sample quality, and can perform semantically meaningful image interpolation directly in the latent space. The original codebase can be found at ermongroup/ddim.  DDIMPipeline  class diffusers.DDIMPipeline  < source > ( unet scheduler  )   Parameters   unet (UNet2DModel) —
+A UNet2DModel to denoise the encoded image latents.   scheduler (SchedulerMixin) —
+A scheduler to be used in combination with unet to denoise the encoded image. Can be one of
+DDPMScheduler, or DDIMScheduler.    Pipeline for image generation. This model inherits from DiffusionPipeline. Check the superclass documentation for the generic methods
+implemented for all pipelines (downloading, saving, running on a particular device, etc.).  __call__  < source > ( batch_size: int = 1 generator: Union = None eta: float = 0.0 num_inference_steps: int = 50 use_clipped_model_output: Optional = None output_type: Optional = 'pil' return_dict: bool = True  ) → ImagePipelineOutput or tuple  Parameters   batch_size (int, optional, defaults to 1) —
+The number of images to generate.   generator (torch.Generator, optional) —
+A torch.Generator to make
+generation deterministic.   eta (float, optional, defaults to 0.0) —
+Corresponds to parameter eta (η) from the DDIM paper. Only applies
+to the DDIMScheduler, and is ignored in other schedulers. A value of 0 corresponds to
+DDIM and 1 corresponds to DDPM.   num_inference_steps (int, optional, defaults to 50) —
+The number of denoising steps. More denoising steps usually lead to a higher quality image at the
+expense of slower inference.   use_clipped_model_output (bool, optional, defaults to None) —
+If True or False, see documentation for DDIMScheduler.step(). If None, nothing is passed
+downstream to the scheduler (use None for schedulers which don’t support this argument).   output_type (str, optional, defaults to "pil") —
+The output format of the generated image. Choose between PIL.Image or np.array.   return_dict (bool, optional, defaults to True) —
+Whether or not to return a ImagePipelineOutput instead of a plain tuple.   Returns 
+ImagePipelineOutput or tuple
+  
+If return_dict is True, ImagePipelineOutput is returned, otherwise a tuple is
+returned where the first element is a list with the generated images
+  The call function to the pipeline for generation.  Example:   Copied >>> from diffusers import DDIMPipeline
+>>> import PIL.Image
+>>> import numpy as np
+
+>>> # load model and scheduler
+>>> pipe = DDIMPipeline.from_pretrained("fusing/ddim-lsun-bedroom")
+
+>>> # run pipeline in inference (sample random noise and denoise)
+>>> image = pipe(eta=0.0, num_inference_steps=50)
+
+>>> # process image to PIL
+>>> image_processed = image.cpu().permute(0, 2, 3, 1)
+>>> image_processed = (image_processed + 1.0) * 127.5
+>>> image_processed = image_processed.numpy().astype(np.uint8)
+>>> image_pil = PIL.Image.fromarray(image_processed[0])
+
+>>> # save image
+>>> image_pil.save("test.png")  ImagePipelineOutput  class diffusers.ImagePipelineOutput  < source > ( images: Union  )   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.

scrapped_outputs/060ba29d724ef0efe0746d1279958f67.txt

@@ -0,0 +1,24 @@
+IPNDMScheduler IPNDMScheduler is a fourth-order Improved Pseudo Linear Multistep scheduler. The original implementation can be found at crowsonkb/v-diffusion-pytorch.  IPNDMScheduler  class diffusers.IPNDMScheduler  < source > ( num_train_timesteps: int = 1000 trained_betas: Union = None  )   Parameters   num_train_timesteps (int, defaults to 1000) —
+The number of diffusion steps to train the model.   trained_betas (np.ndarray, optional) —
+Pass an array of betas directly to the constructor to bypass beta_start and beta_end.    A fourth-order Improved Pseudo Linear Multistep scheduler. This model inherits from SchedulerMixin and ConfigMixin. Check the superclass documentation for the generic
+methods the library implements for all schedulers such as loading and saving.  scale_model_input  < source > ( sample: FloatTensor *args **kwargs  ) → torch.FloatTensor  Parameters   sample (torch.FloatTensor) —
+The input sample.   Returns 
+torch.FloatTensor
+  
+A scaled input sample.
+  Ensures interchangeability with schedulers that need to scale the denoising model input depending on the
+current timestep.  set_timesteps  < source > ( num_inference_steps: int device: Union = None  )   Parameters   num_inference_steps (int) —
+The number of diffusion steps used when generating samples with a pre-trained model.   device (str or torch.device, optional) —
+The device to which the timesteps should be moved to. If None, the timesteps are not moved.    Sets the discrete timesteps used for the diffusion chain (to be run before inference).  step  < source > ( model_output: FloatTensor timestep: int sample: FloatTensor return_dict: bool = True  ) → SchedulerOutput or tuple  Parameters   model_output (torch.FloatTensor) —
+The direct output from learned diffusion model.   timestep (int) —
+The current discrete timestep in the diffusion chain.   sample (torch.FloatTensor) —
+A current instance of a sample created by the diffusion process.   return_dict (bool) —
+Whether or not to return a SchedulerOutput or tuple.   Returns 
+SchedulerOutput or tuple
+  
+If return_dict is True, SchedulerOutput is returned, otherwise a
+tuple is returned where the first element is the sample tensor.
+  Predict the sample from the previous timestep by reversing the SDE. This function propagates the sample with
+the linear multistep method. It performs one forward pass multiple times to approximate the solution.  SchedulerOutput  class diffusers.schedulers.scheduling_utils.SchedulerOutput  < source > ( prev_sample: FloatTensor  )   Parameters   prev_sample (torch.FloatTensor of shape (batch_size, num_channels, height, width) for images) —
+Computed sample (x_{t-1}) of previous timestep. prev_sample should be used as next model input in the
+denoising loop.    Base class for the output of a scheduler’s step function.