Datasets:

PennyJX
/

stable-diffusion-webui

+# These are supported funding model platforms
+github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: conrevo # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: conrevo # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
+custom: ['https://paypal.me/conrevo', 'https://afdian.net/a/conrevo'] # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

extensions/sd-webui-animatediff/.github/ISSUE_TEMPLATE/bug_report.yml ADDED Viewed

	@@ -0,0 +1,91 @@

+name: Bug Report
+description: Create a bug report
+title: "[Bug]: "
+labels: ["bug-report"]
+body:
+  - type: checkboxes
+    attributes:
+      label: Is there an existing issue for this?
+      description: Please search both open issues and closed issues to see if an issue already exists for the bug you encountered, and that it hasn't been fixed in a recent build/commit.
+      options:
+        - label: I have searched the existing issues and checked the recent builds/commits of both this extension and the webui
+          required: true
+  - type: checkboxes
+    attributes:
+      label: Have you read FAQ on README?
+      description: I have collected some common questions from AnimateDiff original repository.
+      options:
+        - label: I have updated WebUI and this extension to the latest version
+          required: true
+  - type: markdown
+    attributes:
+      value: |
+        *Please fill this form with as much information as possible, don't forget to fill "What OS..." and "What browsers" and *provide screenshots if possible**
+  - type: textarea
+    id: what-did
+    attributes:
+      label: What happened?
+      description: Tell us what happened in a very clear and simple way
+    validations:
+      required: true
+  - type: textarea
+    id: steps
+    attributes:
+      label: Steps to reproduce the problem
+      description: Please provide us with precise step by step information on how to reproduce the bug
+      value: |
+        1. Go to ....
+        2. Press ....
+        3. ...
+    validations:
+      required: true
+  - type: textarea
+    id: what-should
+    attributes:
+      label: What should have happened?
+      description: Tell what you think the normal behavior should be
+    validations:
+      required: true
+  - type: textarea
+    id: commits
+    attributes:
+      label: Commit where the problem happens
+      description: Which commit of the extension are you running on? Please include the commit of both the extension and the webui (Do not write *Latest version/repo/commit*, as this means nothing and will have changed by the time we read your issue. Rather, copy the **Commit** link at the bottom of the UI, or from the cmd/terminal if you can't launch it.)
+      value: |
+        webui:
+        extension:
+    validations:
+      required: true
+  - type: dropdown
+    id: browsers
+    attributes:
+      label: What browsers do you use to access the UI ?
+      multiple: true
+      options:
+        - Mozilla Firefox
+        - Google Chrome
+        - Brave
+        - Apple Safari
+        - Microsoft Edge
+  - type: textarea
+    id: cmdargs
+    attributes:
+      label: Command Line Arguments
+      description: Are you using any launching parameters/command line arguments (modified webui-user .bat/.sh) ? If yes, please write them below. Write "No" otherwise.
+      render: Shell
+    validations:
+      required: true
+  - type: textarea
+    id: logs
+    attributes:
+      label: Console logs
+      description: Please provide the errors printed on your console log of your browser (type F12 and go to console) and your terminal, after your bug happened.
+      render: Shell
+    validations:
+      required: true
+  - type: textarea
+    id: misc
+    attributes:
+      label: Additional information
+      description: Please provide us with any relevant additional info or context.

extensions/sd-webui-animatediff/.github/ISSUE_TEMPLATE/config.yml ADDED Viewed

	@@ -0,0 +1 @@


1	+ blank_issues_enabled: true

extensions/sd-webui-animatediff/.github/ISSUE_TEMPLATE/feature_request.yml ADDED Viewed

	@@ -0,0 +1,13 @@

+name: Feature Request
+description: Create a feature request
+title: "[Feature]: "
+labels: ["feature-request"]
+body:
+  - type: textarea
+    id: feature
+    attributes:
+      label: Expected behavior
+      description: Please describe the feature you want.
+    validations:
+      required: true

extensions/sd-webui-animatediff/.gitignore ADDED Viewed

	@@ -0,0 +1,4 @@

+__pycache__
+model/*.*
+model/*.*
+TODO.md

extensions/sd-webui-animatediff/README.md ADDED Viewed

	@@ -0,0 +1,349 @@

+# AnimateDiff for Stable Diffusion WebUI
+This extension aim for integrating [AnimateDiff](https://github.com/guoyww/AnimateDiff/) w/ [CLI](https://github.com/s9roll7/animatediff-cli-prompt-travel) into [AUTOMATIC1111 Stable Diffusion WebUI](https://github.com/AUTOMATIC1111/stable-diffusion-webui) w/ [ControlNet](https://github.com/Mikubill/sd-webui-controlnet). You can generate GIFs in exactly the same way as generating images after enabling this extension.
+This extension implements AnimateDiff in a different way. It does not require you to clone the whole SD1.5 repository. It also applied (probably) the least modification to `ldm`, so that you do not need to reload your model weights if you don't want to.
+You might also be interested in another extension I created: [Segment Anything for Stable Diffusion WebUI](https://github.com/continue-revolution/sd-webui-segment-anything).
+## Table of Contents
+- [Update](#update)
+- [How to Use](#how-to-use)
+  - [WebUI](#webui)
+  - [API](#api)
+- [WebUI Parameters](#webui-parameters)
+- [Img2GIF](#img2gif)
+- [Prompt Travel](#prompt-travel)
+- [ControlNet V2V](#controlnet-v2v)
+- [Model Spec](#model-spec)
+  - [Motion LoRA](#motion-lora)
+  - [V3](#v3)
+  - [SDXL](#sdxl)
+- [Optimizations](#optimizations)
+  - [Attention](#attention)
+  - [FP8](#fp8)
+  - [LCM](#lcm)
+  - [Others](#others)
+- [Model Zoo](#model-zoo)
+- [VRAM](#vram)
+- [Batch Size](#batch-size)
+- [Demo](#demo)
+  - [Basic Usage](#basic-usage)
+  - [Motion LoRA](#motion-lora-1)
+  - [Prompt Travel](#prompt-travel-1)
+  - [AnimateDiff V3](#animatediff-v3)
+  - [AnimateDiff SDXL](#animatediff-sdxl)
+  - [ControlNet V2V](#controlnet-v2v-1)
+- [Tutorial](#tutorial)
+- [Thanks](#thanks)
+- [Star History](#star-history)
+- [Sponsor](#sponsor)
+## Update
+- `2023/07/20` [v1.1.0](https://github.com/continue-revolution/sd-webui-animatediff/releases/tag/v1.1.0): Fix gif duration, add loop number, remove auto-download, remove xformers, remove instructions on gradio UI, refactor README, add [sponsor](#sponsor) QR code.
+- `2023/07/24` [v1.2.0](https://github.com/continue-revolution/sd-webui-animatediff/releases/tag/v1.2.0): Fix incorrect insertion of motion modules, add option to change path to motion modules in `Settings/AnimateDiff`, fix loading different motion modules.
+- `2023/09/04` [v1.3.0](https://github.com/continue-revolution/sd-webui-animatediff/releases/tag/v1.3.0): Support any community models with the same architecture; fix grey problem via [#63](https://github.com/continue-revolution/sd-webui-animatediff/issues/63)
+- `2023/09/11` [v1.4.0](https://github.com/continue-revolution/sd-webui-animatediff/releases/tag/v1.4.0): Support official v2 motion module (different architecture: GroupNorm not hacked, UNet middle layer has motion module).
+- `2023/09/14`: [v1.4.1](https://github.com/continue-revolution/sd-webui-animatediff/releases/tag/v1.4.1): Always change `beta`, `alpha_comprod` and `alpha_comprod_prev` to resolve grey problem in other samplers.
+- `2023/09/16`: [v1.5.0](https://github.com/continue-revolution/sd-webui-animatediff/releases/tag/v1.5.0): Randomize init latent to support [better img2gif](#img2gif); add other output formats and infotext output; add appending reversed frames; refactor code to ease maintaining.
+- `2023/09/19`: [v1.5.1](https://github.com/continue-revolution/sd-webui-animatediff/releases/tag/v1.5.1): Support xformers, sdp, sub-quadratic attention optimization - [VRAM](#vram) usage decrease to 5.60GB with default setting.
+- `2023/09/22`: [v1.5.2](https://github.com/continue-revolution/sd-webui-animatediff/releases/tag/v1.5.2): Option to disable xformers at `Settings/AnimateDiff` [due to a bug in xformers](https://github.com/facebookresearch/xformers/issues/845), [API support](#api), option to enable GIF paletter optimization at `Settings/AnimateDiff`, gifsicle optimization move to `Settings/AnimateDiff`.
+- `2023/09/25`: [v1.6.0](https://github.com/continue-revolution/sd-webui-animatediff/releases/tag/v1.6.0): [Motion LoRA](https://github.com/guoyww/AnimateDiff#features) supported. See [Motion Lora](#motion-lora) for more information.
+- `2023/09/27`: [v1.7.0](https://github.com/continue-revolution/sd-webui-animatediff/releases/tag/v1.7.0): [ControlNet](https://github.com/Mikubill/sd-webui-controlnet) supported. See [ControlNet V2V](#controlnet-v2v) for more information. [Safetensors](#model-zoo) for some motion modules are also available now.
+- `2023/09/29`: [v1.8.0](https://github.com/continue-revolution/sd-webui-animatediff/releases/tag/v1.8.0): Infinite generation supported. See [WebUI Parameters](#webui-parameters) for more information.
+- `2023/10/01`: [v1.8.1](https://github.com/continue-revolution/sd-webui-animatediff/releases/tag/v1.8.1): Now you can uncheck `Batch cond/uncond` in `Settings/Optimization` if you want. This will reduce your [VRAM](#vram) (5.31GB -> 4.21GB for SDP) but take longer time.
+- `2023/10/08`: [v1.9.0](https://github.com/continue-revolution/sd-webui-animatediff/releases/tag/v1.9.0): Prompt travel supported. You must have ControlNet installed (you do not need to enable ControlNet) to try it. See [Prompt Travel](#prompt-travel) for how to trigger this feature.
+- `2023/10/11`: [v1.9.1](https://github.com/continue-revolution/sd-webui-animatediff/releases/tag/v1.9.1): Use state_dict key to guess mm version, replace match case with if else to support python<3.10, option to save PNG to custom dir
+ (see `Settings/AnimateDiff` for detail), move hints to js, install imageio\[ffmpeg\] automatically when MP4 save fails.
+- `2023/10/16`: [v1.9.2](https://github.com/continue-revolution/sd-webui-animatediff/releases/tag/v1.9.2): Add context generator to completely remove any closed loop, prompt travel support closed loop, infotext fully supported including prompt travel, README refactor
+- `2023/10/19`: [v1.9.3](https://github.com/continue-revolution/sd-webui-animatediff/releases/tag/v1.9.3): Support webp output format. See [#233](https://github.com/continue-revolution/sd-webui-animatediff/pull/233) for more information.
+- `2023/10/21`: [v1.9.4](https://github.com/continue-revolution/sd-webui-animatediff/releases/tag/v1.9.4): Save prompt travel to output images, `Reverse` merged to `Closed loop` (See [WebUI Parameters](#webui-parameters)), remove `TimestepEmbedSequential` hijack, remove `hints.js`, better explanation of several context-related parameters.
+- `2023/10/25`: [v1.10.0](https://github.com/continue-revolution/sd-webui-animatediff/releases/tag/v1.10.0): Support img2img batch. You need ControlNet installed to make it work properly (you do not need to enable ControlNet). See [ControlNet V2V](#controlnet-v2v) for more information.
+- `2023/10/29`: [v1.11.0](https://github.com/continue-revolution/sd-webui-animatediff/releases/tag/v1.11.0): [HotShot-XL](https://github.com/hotshotco/Hotshot-XL) supported. See [SDXL](#sdxl) for more information.
+- `2023/11/06`: [v1.11.1](https://github.com/continue-revolution/sd-webui-animatediff/releases/tag/v1.11.1): Optimize VRAM for ControlNet V2V, patch [encode_pil_to_base64](https://github.com/AUTOMATIC1111/stable-diffusion-webui/blob/master/modules/api/api.py#L104-L133) for api return a video, save frames to `AnimateDiff/yy-mm-dd/`, recover from assertion error, optional [request id](#api) for API.
+- `2023/11/10`: [v1.12.0](https://github.com/continue-revolution/sd-webui-animatediff/releases/tag/v1.12.0): [AnimateDiff for SDXL](https://github.com/guoyww/AnimateDiff/tree/sdxl) supported. See [SDXL](#sdxl) for more information.
+- `2023/11/16`: [v1.12.1](https://github.com/continue-revolution/sd-webui-animatediff/releases/tag/v1.12.1): FP8 precision and LCM sampler supported. See [Optimizations](#optimizations) for more information. You can also optionally upload videos to AWS S3 storage by configuring appropriately via `Settings/AnimateDiff AWS`.
+- `2023/12/19`: [v1.13.0](https://github.com/continue-revolution/sd-webui-animatediff/releases/tag/v1.13.0): [AnimateDiff V3](https://github.com/guoyww/AnimateDiff?tab=readme-ov-file#202312-animatediff-v3-and-sparsectrl) supported. See [V3](#v3) for more information. Also: release all official models in fp16 & safetensors format [here](https://huggingface.co/conrevo/AnimateDiff-A1111/tree/main), add option to disable LCM sampler in `Settings/AnimateDiff`, remove patch [encode_pil_to_base64](https://github.com/AUTOMATIC1111/stable-diffusion-webui/blob/master/modules/api/api.py#L104-L133) because A1111 [v1.7.0](https://github.com/AUTOMATIC1111/stable-diffusion-webui/tree/v1.7.0) now supports video return for API.
+For future update plan, please query [#366](https://github.com/continue-revolution/sd-webui-animatediff/pull/366). `v1.13.x` is the last version update for `v1`. SparseCtrl, Magic Animate and other control methods will be supported in `v2` via updating both this repo and sd-webui-controlnet.
+## How to Use
+1. Update your WebUI to v1.6.0 and ControlNet to v1.1.410, then install this extension via link. I do not plan to support older version.
+1. Download motion modules and put the model weights under `stable-diffusion-webui/extensions/sd-webui-animatediff/model/`. If you want to use another directory to save model weights, please go to `Settings/AnimateDiff`. See [model zoo](#model-zoo) for a list of available motion modules.
+1. Enable `Pad prompt/negative prompt to be same length` in `Settings/Optimization` and click `Apply settings`. You must do this to prevent generating two separate unrelated GIFs. Checking `Batch cond/uncond` is optional, which can improve speed but increase VRAM usage.
+1. DO NOT disable hash calculation, otherwise AnimateDiff will have trouble figuring out when you switch motion module.
+### WebUI
+1. Go to txt2img if you want to try txt2gif and img2img if you want to try img2gif.
+1. Choose an SD1.5 checkpoint, write prompts, set configurations such as image width/height. If you want to generate multiple GIFs at once, please [change batch number, instead of batch size](#batch-size).
+1. Enable AnimateDiff extension, set up [each parameter](#webui-parameters), then click `Generate`.
+1. You should see the output GIF on the output gallery. You can access GIF output at `stable-diffusion-webui/outputs/{txt2img or img2img}-images/AnimateDiff/{yy-mm-dd}`. You can also access image frames at `stable-diffusion-webui/outputs/{txt2img or img2img}-images/{yy-mm-dd}`. You may choose to save frames for each generation into separate directories in `Settings/AnimateDiff`.
+### API
+It is quite similar to the way you use ControlNet. API will return a video in base64 format. In `format`, `PNG` means to save frames to your file system without returning all the frames. If you want your API to return all frames, please add `Frame` to `format` list. For most up-to-date parameters, please read [here](https://github.com/continue-revolution/sd-webui-animatediff/blob/master/scripts/animatediff_ui.py#L26).
+```
+'alwayson_scripts': {
+  'AnimateDiff': {
+    'args': [{
+      'model': 'mm_sd_v15_v2.ckpt',   # Motion module
+      'format': ['GIF'],      # Save format, 'GIF' | 'MP4' | 'PNG' | 'WEBP' | 'WEBM' | 'TXT' | 'Frame'
+      'enable': True,         # Enable AnimateDiff
+      'video_length': 16,     # Number of frames
+      'fps': 8,               # FPS
+      'loop_number': 0,       # Display loop number
+      'closed_loop': 'R+P',   # Closed loop, 'N' | 'R-P' | 'R+P' | 'A'
+      'batch_size': 16,       # Context batch size
+      'stride': 1,            # Stride
+      'overlap': -1,          # Overlap
+      'interp': 'Off',        # Frame interpolation, 'Off' | 'FILM'
+      'interp_x': 10          # Interp X
+      'video_source': 'path/to/video.mp4',  # Video source
+      'video_path': 'path/to/frames',       # Video path
+      'latent_power': 1,      # Latent power
+      'latent_scale': 32,     # Latent scale
+      'last_frame': None,     # Optional last frame
+      'latent_power_last': 1, # Optional latent power for last frame
+      'latent_scale_last': 32,# Optional latent scale for last frame
+      'request_id': ''        # Optional request id. If provided, outputs will have request id as filename suffix
+      }
+    ]
+  }
+},
+```
+## WebUI Parameters
+1. **Save format** — Format of the output. Choose at least one of "GIF"|"MP4"|"WEBP"|"WEBM"|"PNG". Check "TXT" if you want infotext, which will live in the same directory as the output GIF. Infotext is also accessible via `stable-diffusion-webui/params.txt` and outputs in all formats.
+    1. You can optimize GIF with `gifsicle` (`apt install gifsicle` required, read [#91](https://github.com/continue-revolution/sd-webui-animatediff/pull/91) for more information) and/or `palette` (read [#104](https://github.com/continue-revolution/sd-webui-animatediff/pull/104) for more information). Go to `Settings/AnimateDiff` to enable them.
+    1. You can set quality and lossless for WEBP via `Settings/AnimateDiff`. Read [#233](https://github.com/continue-revolution/sd-webui-animatediff/pull/233) for more information.
+    1. If you are using API, by adding "PNG" to `format`, you can save all frames to your file system without returning all the frames. If you want your API to return all frames, please add `Frame` to `format` list.
+1. **Number of frames** — Choose whatever number you like.
+    If you enter 0 (default):
+    - If you submit a video via `Video source` / enter a video path via `Video path` / enable ANY batch ControlNet, the number of frames will be the number of frames in the video (use shortest if more than one videos are submitted).
+    - Otherwise, the number of frames will be your `Context batch size` described below.
+    If you enter something smaller than your `Context batch size` other than 0: you will get the first `Number of frames` frames as your output GIF from your whole generation. All following frames will not appear in your generated GIF, but will be saved as PNGs as usual. Do not set `Number of frames` to be something smaler than `Context batch size` other than 0 because of [#213](https://github.com/continue-revolution/sd-webui-animatediff/issues/213).
+1. **FPS** — Frames per second, which is how many frames (images) are shown every second. If 16 frames are generated at 8 frames per second, your GIF’s duration is 2 seconds. If you submit a source video, your FPS will be the same as the source video.
+1. **Display loop number** — How many times the GIF is played. A value of `0` means the GIF never stops playing.
+1. **Context batch size** — How many frames will be passed into the motion module at once. The SD1.5 motion modules are trained with 16 frames, so it’ll give the best results when the number of frames is set to `16`. SDXL HotShotXL motion modules are trained with 8 frames instead. Choose [1, 24] for V1 / HotShotXL motion modules and [1, 32] for V2 / AnimateDiffXL motion modules.
+1. **Closed loop** — Closed loop means that this extension will try to make the last frame the same as the first frame.
+    1. When `Number of frames` > `Context batch size`, including when ControlNet is enabled and the source video frame number > `Context batch size` and `Number of frames` is 0, closed loop will be performed by AnimateDiff infinite context generator.
+    1. When `Number of frames` <= `Context batch size`, AnimateDiff infinite context generator will not be effective. Only when you choose `A` will AnimateDiff append reversed list of frames to the original list of frames to form closed loop.
+    See below for explanation of each choice:
+    - `N` means absolutely no closed loop - this is the only available option if `Number of frames` is smaller than `Context batch size` other than 0.
+    - `R-P` means that the extension will try to reduce the number of closed loop context. The prompt travel will not be interpolated to be a closed loop.
+    - `R+P` means that the extension will try to reduce the number of closed loop context. The prompt travel will be interpolated to be a closed loop.
+    - `A` means that the extension will aggressively try to make the last frame the same as the first frame. The prompt travel will be interpolated to be a closed loop.
+1. **Stride** — Max motion stride as a power of 2 (default: 1).
+    1. Due to the limitation of the infinite context generator, this parameter is effective only when `Number of frames` > `Context batch size`, including when ControlNet is enabled and the source video frame number > `Context batch size` and `Number of frames` is 0.
+    1. "Absolutely no closed loop" is only possible when `Stride` is 1.
+    1. For each 1 <= $2^i$ <= `Stride`, the infinite context generator will try to make frames $2^i$ apart temporal consistent. For example, if `Stride` is 4 and `Number of frames` is 8, it will make the following frames temporal consistent:
+        - `Stride` == 1: [0, 1, 2, 3, 4, 5, 6, 7]
+        - `Stride` == 2: [0, 2, 4, 6], [1, 3, 5, 7]
+        - `Stride` == 4: [0, 4], [1, 5], [2, 6], [3, 7]
+1. **Overlap** — Number of frames to overlap in context. If overlap is -1 (default): your overlap will be `Context batch size` // 4.
+    1. Due to the limitation of the infinite context generator, this parameter is effective only when `Number of frames` > `Context batch size`, including when ControlNet is enabled and the source video frame number > `Context batch size` and `Number of frames` is 0.
+1. **Frame Interpolation** — Interpolate between frames with Deforum's FILM implementation. Requires Deforum extension. [#128](https://github.com/continue-revolution/sd-webui-animatediff/pull/128)
+1. **Interp X** — Replace each input frame with X interpolated output frames. [#128](https://github.com/continue-revolution/sd-webui-animatediff/pull/128).
+1. **Video source** — [Optional] Video source file for [ControlNet V2V](#controlnet-v2v). You MUST enable ControlNet. It will be the source control for ALL ControlNet units that you enable without submitting a control image or a path to ControlNet panel. You can of course submit one control image via `Single Image` tab or an input directory via `Batch` tab, which will override this video source input and work as usual.
+1. **Video path** — [Optional] Folder for source frames for [ControlNet V2V](#controlnet-v2v), but lower priority than `Video source`. You MUST enable ControlNet. It will be the source control for ALL ControlNet units that you enable without submitting a control image or a path to ControlNet. You can of course submit one control image via `Single Image` tab or an input directory via `Batch` tab, which will override this video path input and work as usual.
+    - For people who want to inpaint videos: enter a folder which contains two sub-folders `image` and `mask` on ControlNet inpainting unit. These two sub-folders should contain the same number of images. This extension will match them according to the same sequence. Using my [Segment Anything](https://github.com/continue-revolution/sd-webui-segment-anything) extension can make your life much easier.
+Please read
+- [Img2GIF](#img2gif) for extra parameters on img2gif panel.
+- [Prompt Travel](#prompt-travel) for how to trigger prompt travel.
+- [ControlNet V2V](#controlnet-v2v) for how to use ControlNet V2V.
+- [Model Spec](#model-spec) for how to use Motion LoRA, V3 and SDXL.
+## Img2GIF
+You need to go to img2img and submit an init frame via A1111 panel. You can optionally submit a last frame via extension panel.
+By default: your `init_latent` will be changed to
+```
+init_alpha = (1 - frame_number ^ latent_power / latent_scale)
+init_latent = init_latent * init_alpha + random_tensor * (1 - init_alpha)
+```
+If you upload a last frame: your `init_latent` will be changed in a similar way. Read [this code](https://github.com/continue-revolution/sd-webui-animatediff/tree/v1.5.0/scripts/animatediff_latent.py#L28-L65) to understand how it works.
+## Prompt Travel
+Write positive prompt following the example below.
+The first line is head prompt, which is optional. You can write no/single/multiple lines of head prompts.
+The second and third lines are for prompt interpolation, in format `frame number`: `prompt`. Your `frame number` should be in ascending order, smaller than the total `Number of frames`. The first frame is 0 index.
+The last line is tail prompt, which is optional. You can write no/single/multiple lines of tail prompts. If you don't need this feature, just write prompts in the old way.
+```
+1girl, yoimiya (genshin impact), origen, line, comet, wink, Masterpiece, BestQuality. UltraDetailed, <lora:LineLine2D:0.7>,  <lora:yoimiya:0.8>,
+0: closed mouth
+8: open mouth
+smile
+```
+## ControlNet V2V
+You need to go to txt2img / img2img-batch and submit source video or path to frames. Each ControlNet will find control images according to this priority:
+1. ControlNet `Single Image` tab or `Batch` tab. Simply upload a control image or a directory of control frames is enough.
+1. Img2img Batch tab `Input directory` if you are using img2img batch. If you upload a directory of control frames, it will be the source control for ALL ControlNet units that you enable without submitting a control image or a path to ControlNet panel.
+1. AnimateDiff `Video Source`. If you upload a video through `Video Source`, it will be the source control for ALL ControlNet units that you enable without submitting a control image or a path to ControlNet panel.
+1. AnimateDiff `Video Path`. If you upload a path to frames through `Video Path`, it will be the source control for ALL ControlNet units that you enable without submitting a control image or a path to ControlNet panel.
+`Number of frames` will be capped to the minimum number of images among all **folders** you provide. Each control image in each folder will be applied to one single frame. If you upload one single image for a ControlNet unit, that image will control **ALL** frames.
+For people who want to inpaint videos: enter a folder which contains two sub-folders `image` and `mask` on ControlNet inpainting unit. These two sub-folders should contain the same number of images. This extension will match them according to the same sequence. Using my [Segment Anything](https://github.com/continue-revolution/sd-webui-segment-anything) extension can make your life much easier.
+AnimateDiff in img2img batch will be available in [v1.10.0](https://github.com/continue-revolution/sd-webui-animatediff/pull/224).
+## Model Spec
+### Motion LoRA
+[Download](https://huggingface.co/conrevo/AnimateDiff-A1111/tree/main/lora) and use them like any other LoRA you use (example: download motion lora to `stable-diffusion-webui/models/Lora` and add `<lora:mm_sd15_v2_lora_PanLeft:0.8>` to your positive prompt). **Motion LoRA only supports V2 motion modules**.
+### V3
+V3 has identical state dict keys as V1 but slightly different inference logic (GroupNorm is not hacked for V3). You may optionally use [adapter](https://huggingface.co/conrevo/AnimateDiff-A1111/resolve/main/lora/mm_sd15_v3_adapter.safetensors?download=true) for V3, in the same way as the way you use LoRA. You MUST use [my link](https://huggingface.co/conrevo/AnimateDiff-A1111/resolve/main/lora/mm_sd15_v3_adapter.safetensors?download=true) instead of the [official link](https://huggingface.co/guoyww/animatediff/resolve/main/v3_sd15_adapter.ckpt?download=true). The official adapter won't work for A1111 due to state dict incompatibility.
+### SDXL
+[AnimateDiffXL](https://github.com/guoyww/AnimateDiff/tree/sdxl) and [HotShot-XL](https://github.com/hotshotco/Hotshot-XL) have identical architecture to AnimateDiff-SD1.5. The only 2 difference are
+- HotShot-XL is trained with 8 frames instead of 16 frames. You are recommended to set `Context batch size` to 8 for HotShot-XL.
+- AnimateDiffXL is still trained with 16 frames. You do not need to change `Context batch size` for AnimateDiffXL.
+- AnimateDiffXL & HotShot-XL have fewer layers compared to AnimateDiff-SD1.5 because of SDXL.
+- AnimateDiffXL is trained with higher resolution compared to HotShot-XL.
+Although AnimateDiffXL & HotShot-XL have identical structure with AnimateDiff-SD1.5, I strongly discourage you from using AnimateDiff-SD1.5 for SDXL, or using HotShot / AnimateDiffXL for SD1.5 - you will get severe artifect if you do that. I have decided not to supported that, despite the fact that it is not hard for me to do that.
+Technically all features available for AnimateDiff + SD1.5 are also available for (AnimateDiff / HotShot) + SDXL. However, I have not tested all of them. I have tested infinite context generation and prompt travel; I have not tested ControlNet. If you find any bug, please report it to me.
+## Optimizations
+Optimizations can be significantly helpful if you want to improve speed and reduce VRAM usage. With [attention optimization](#attention), [FP8](#fp8) and unchecking `Batch cond/uncond` in `Settings/Optimization`, I am able to run 4 x ControlNet + AnimateDiff + Stable Diffusion to generate 36 frames of 1024 * 1024 images with 18GB VRAM.
+### Attention
+Adding `--xformers` / `--opt-sdp-attention` to your command lines can significantly reduce VRAM and improve speed. However, due to a bug in xformers, you may or may not get CUDA error. If you get CUDA error, please either completely switch to `--opt-sdp-attention`, or preserve `--xformers` -> go to `Settings/AnimateDiff` -> choose "Optimize attention layers with sdp (torch >= 2.0.0 required)".
+### FP8
+FP8 requires torch >= 2.1.0 and WebUI [test-fp8](https://github.com/AUTOMATIC1111/stable-diffusion-webui/tree/test-fp8) branch by [@KohakuBlueleaf](https://github.com/KohakuBlueleaf). Follow these steps to enable FP8:
+1. Switch to `test-fp8` branch via `git checkout test-fp8` in your `stable-diffusion-webui` directory.
+1. Reinstall torch via adding `--reinstall-torch` ONCE to your command line arguments.
+1. Goto Settings Tab > Optimizations > FP8 weight, change it to `Enable`
+### LCM
+[Latent Consistency Model](https://github.com/luosiallen/latent-consistency-model) is a recent breakthrough in Stable Diffusion community. I provide a "gift" to everyone who update this extension to >= [v1.12.1](https://github.com/continue-revolution/sd-webui-animatediff/releases/tag/v1.12.1) - you will find `LCM` sampler in the normal place you select samplers in WebUI. You can generate images / videos within 6-8 steps if you
+- select `Euler A` / `Euler` / `LCM` sampler (other samplers may also work, subject to further experiments)
+- use [LCM LoRA](https://civitai.com/models/195519/lcm-lora-weights-stable-diffusion-acceleration-module)
+- use a low CFG denoising strength (1-2 is recommended)
+Note that LCM sampler is still under experiment and subject to change adhering to [@luosiallen](https://github.com/luosiallen)'s wish.
+Benefits of using this extension instead of [sd-webui-lcm](https://github.com/0xbitches/sd-webui-lcm) are
+- you do not need to install diffusers
+- you can use LCM sampler with any other extensions, such as ControlNet and AnimateDiff
+### Others
+- Remove any VRAM heavy arguments such as `--no-half`. These arguments can significantly increase VRAM usage and reduce speed.
+- Check `Batch cond/uncond` in `Settings/Optimization` to improve speed; uncheck it to reduce VRAM usage.
+## Model Zoo
+I am maintaining a [huggingface repo](https://huggingface.co/conrevo/AnimateDiff-A1111/tree/main) to provide all official models in fp16 & safetensors format. You are highly recommended to use my link. You MUST use my link to download adapter for V3. You may still use the old links if you want, for all models except adapter for V3.
+- "Official" models by [@guoyww](https://github.com/guoyww): [Google Drive](https://drive.google.com/drive/folders/1EqLC65eR1-W-sGD0Im7fkED6c8GkiNFI) | [HuggingFace](https://huggingface.co/guoyww/animatediff/tree/main) | [CivitAI](https://civitai.com/models/108836)
+- "Stabilized" community models by [@manshoety](https://huggingface.co/manshoety): [HuggingFace](https://huggingface.co/manshoety/AD_Stabilized_Motion/tree/main)
+- "TemporalDiff" models by [@CiaraRowles](https://huggingface.co/CiaraRowles): [HuggingFace](https://huggingface.co/CiaraRowles/TemporalDiff/tree/main)
+- "HotShotXL" models by [@hotshotco](https://huggingface.co/hotshotco/): [HuggingFace](https://huggingface.co/hotshotco/Hotshot-XL/tree/main)
+## VRAM
+Actual VRAM usage depends on your image size and context batch size. You can try to reduce image size or context batch size to reduce VRAM usage.
+The following data are SD1.5 + AnimateDiff, tested on Ubuntu 22.04, NVIDIA 4090, torch 2.0.1+cu117, H=W=512, frame=16 (default setting). `w/`/`w/o` means `Batch cond/uncond` in `Settings/Optimization` is checked/unchecked.
+| Optimization | VRAM w/ | VRAM w/o |
+| --- | --- | --- |
+| No optimization | 12.13GB |  |
+| xformers/sdp | 5.60GB | 4.21GB |
+| sub-quadratic | 10.39GB |  |
+For SDXL + HotShot + SDP, tested on Ubuntu 22.04, NVIDIA 4090, torch 2.0.1+cu117, H=W=512, frame=8 (default setting), you need 8.66GB VRAM.
+For SDXL + AnimateDiff + SDP, tested on Ubuntu 22.04, NVIDIA 4090, torch 2.0.1+cu117, H=1024, W=768, frame=16, you need 13.87GB VRAM.
+## Batch Size
+Batch size on WebUI will be replaced by GIF frame number internally: 1 full GIF generated in 1 batch. If you want to generate multiple GIF at once, please change batch number.
+Batch number is NOT the same as batch size. In A1111 WebUI, batch number is above batch size. Batch number means the number of sequential steps, but batch size means the number of parallel steps. You do not have to worry too much when you increase batch number, but you do need to worry about your VRAM when you increase your batch size (where in this extension, video frame number). You do not need to change batch size at all when you are using this extension.
+We are currently developing approach to support batch size on WebUI in the near future.
+## Demo
+### Basic Usage
+| AnimateDiff | Extension | img2img |
+| --- | --- | --- |
+| ![image](https://user-images.githubusercontent.com/63914308/255306527-5105afe8-d497-4ab1-b5c4-37540e9601f8.gif) |![00013-10788741199826055000](https://github.com/continue-revolution/sd-webui-animatediff/assets/63914308/43b9cf34-dbd1-4120-b220-ea8cb7882272) | ![00018-727621716](https://github.com/continue-revolution/sd-webui-animatediff/assets/63914308/d04bb573-c8ca-4ae6-a2d9-81f8012bec3a) |
+### Motion LoRA
+| No LoRA | PanDown | PanLeft |
+| --- | --- | --- |
+| ![00094-1401397431](https://github.com/continue-revolution/sd-webui-animatediff/assets/63914308/d8d2b860-c781-4dd0-8c0a-0eb26970130b) | ![00095-3197605735](https://github.com/continue-revolution/sd-webui-animatediff/assets/63914308/aed2243f-5494-4fe3-a10a-96c57f6f2906) | ![00093-2722547708](https://github.com/continue-revolution/sd-webui-animatediff/assets/63914308/c32e9aaf-54f2-4f40-879b-e800c7c7848c) |
+### Prompt Travel
+![00201-2296305953](https://github.com/continue-revolution/sd-webui-animatediff/assets/63914308/881f317c-f1d2-4635-b84b-b4c4881650f6)
+The prompt is similar to [above](#prompt-travel).
+### AnimateDiff V3
+You should be able to read infotext to understand how I generated this sample.
+![00024-3973810345](https://github.com/continue-revolution/sd-webui-animatediff/assets/63914308/5f3e3858-8033-4a16-94b0-4dbc0d0a67fc)
+### AnimateDiff SDXL
+You should be able to read infotext to understand how I generated this sample.
+![00025-1668075705](https://github.com/continue-revolution/sd-webui-animatediff/assets/63914308/6d32daf9-51c6-490f-a942-db36f84f23cf)
+### ControlNet V2V
+TODO
+## Tutorial
+TODO
+## Thanks
+I thank researchers from [Shanghai AI Lab](https://www.shlab.org.cn/), especially [@guoyww](https://github.com/guoyww) for creating AnimateDiff. I also thank [@neggles](https://github.com/neggles) and [@s9roll7](https://github.com/s9roll7) for creating and improving [AnimateDiff CLI Prompt Travel](https://github.com/s9roll7/animatediff-cli-prompt-travel). This extension could not be made possible without these creative works.
+I also thank community developers, especially
+- [@zappityzap](https://github.com/zappityzap) who developed the majority of the [output features](https://github.com/continue-revolution/sd-webui-animatediff/blob/master/scripts/animatediff_output.py)
+- [@TDS4874](https://github.com/TDS4874) and [@opparco](https://github.com/opparco) for resolving the grey issue which significantly improve the performance
+- [@talesofai](https://github.com/talesofai) who developed i2v in [this forked repo](https://github.com/talesofai/AnimateDiff)
+- [@rkfg](https://github.com/rkfg) for developing GIF palette optimization
+and many others who have contributed to this extension.
+I also thank community users, especially [@streamline](https://twitter.com/kaizirod) who provided dataset and workflow of ControlNet V2V. His workflow is extremely amazing and definitely worth checking out.
+## Star History
+<a href="https://star-history.com/#continue-revolution/sd-webui-animatediff&Date">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=continue-revolution/sd-webui-animatediff&type=Date&theme=dark" />
+    <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=continue-revolution/sd-webui-animatediff&type=Date" />
+    <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=continue-revolution/sd-webui-animatediff&type=Date" />
+  </picture>
+</a>
+## Sponsor
+You can sponsor me via WeChat, AliPay or [PayPal](https://paypal.me/conrevo). You can also support me via [patreon](https://www.patreon.com/conrevo), [ko-fi](https://ko-fi.com/conrevo) or [afdian](https://afdian.net/a/conrevo).
+| WeChat | AliPay | PayPal |
+| --- | --- | --- |
+| ![216aff0250c7fd2bb32eeb4f7aae623](https://user-images.githubusercontent.com/63914308/232824466-21051be9-76ce-4862-bb0d-a431c186fce1.jpg) | ![15fe95b4ada738acf3e44c1d45a1805](https://user-images.githubusercontent.com/63914308/232824545-fb108600-729d-4204-8bec-4fd5cc8a14ec.jpg) | ![IMG_1419_](https://github.com/continue-revolution/sd-webui-animatediff/assets/63914308/eaa7b114-a2e6-4ecc-a29f-253ace06d1ea) |

extensions/sd-webui-animatediff/__pycache__/motion_module.cpython-310.pyc ADDED Viewed

Binary file (17.6 kB). View file

extensions/sd-webui-animatediff/model/.gitkeep ADDED Viewed

File without changes

extensions/sd-webui-animatediff/motion_module.py ADDED Viewed

	@@ -0,0 +1,657 @@

+from enum import Enum
+from typing import Optional
+import torch
+import torch.nn.functional as F
+from torch import nn
+from modules import sd_hijack, shared
+from ldm.modules.attention import FeedForward
+from einops import rearrange, repeat
+import math
+class MotionModuleType(Enum):
+    AnimateDiffV1 = "AnimateDiff V1, Yuwei GUo, Shanghai AI Lab"
+    AnimateDiffV2 = "AnimateDiff V2, Yuwei Guo, Shanghai AI Lab"
+    AnimateDiffV3 = "AnimateDiff V3, Yuwei Guo, Shanghai AI Lab"
+    AnimateDiffXL = "AnimateDiff SDXL, Yuwei Guo, Shanghai AI Lab"
+    HotShotXL = "HotShot-XL, John Mullan, Natural Synthetics Inc"
+    @staticmethod
+    def get_mm_type(state_dict: dict[str, torch.Tensor]):
+        keys = list(state_dict.keys())
+        if any(["mid_block" in k for k in keys]):
+            return MotionModuleType.AnimateDiffV2
+        elif any(["temporal_attentions" in k for k in keys]):
+            return MotionModuleType.HotShotXL
+        elif any(["down_blocks.3" in k for k in keys]):
+            if 32 in next((state_dict[key] for key in state_dict if 'pe' in key), None).shape:
+                return MotionModuleType.AnimateDiffV3
+            else:
+                return MotionModuleType.AnimateDiffV1
+        else:
+            return MotionModuleType.AnimateDiffXL
+def zero_module(module):
+    # Zero out the parameters of a module and return it.
+    for p in module.parameters():
+        p.detach().zero_()
+    return module
+class MotionWrapper(nn.Module):
+    def __init__(self, mm_name: str, mm_hash: str, mm_type: MotionModuleType):
+        super().__init__()
+        self.is_v2 = mm_type == MotionModuleType.AnimateDiffV2
+        self.is_v3 = mm_type == MotionModuleType.AnimateDiffV3
+        self.is_hotshot = mm_type == MotionModuleType.HotShotXL
+        self.is_adxl = mm_type == MotionModuleType.AnimateDiffXL
+        self.is_xl = self.is_hotshot or self.is_adxl
+        max_len = 32 if (self.is_v2 or self.is_adxl or self.is_v3) else 24
+        in_channels = (320, 640, 1280) if (self.is_xl) else (320, 640, 1280, 1280)
+        self.down_blocks = nn.ModuleList([])
+        self.up_blocks = nn.ModuleList([])
+        for c in in_channels:
+            self.down_blocks.append(MotionModule(c, num_mm=2, max_len=max_len, is_hotshot=self.is_hotshot))
+            self.up_blocks.insert(0,MotionModule(c, num_mm=3, max_len=max_len, is_hotshot=self.is_hotshot))
+        if self.is_v2:
+            self.mid_block = MotionModule(1280, num_mm=1, max_len=max_len)
+        self.mm_name = mm_name
+        self.mm_type = mm_type
+        self.mm_hash = mm_hash
+    def enable_gn_hack(self):
+        return not (self.is_adxl or self.is_v3)
+class MotionModule(nn.Module):
+    def __init__(self, in_channels, num_mm, max_len, is_hotshot=False):
+        super().__init__()
+        motion_modules = nn.ModuleList([get_motion_module(in_channels, max_len, is_hotshot) for _ in range(num_mm)])
+        if is_hotshot:
+            self.temporal_attentions = motion_modules
+        else:
+            self.motion_modules = motion_modules
+def get_motion_module(in_channels, max_len, is_hotshot):
+    vtm = VanillaTemporalModule(in_channels=in_channels, temporal_position_encoding_max_len=max_len, is_hotshot=is_hotshot)
+    return vtm.temporal_transformer if is_hotshot else vtm
+class VanillaTemporalModule(nn.Module):
+    def __init__(
+        self,
+        in_channels,
+        num_attention_heads                = 8,
+        num_transformer_block              = 1,
+        attention_block_types              =( "Temporal_Self", "Temporal_Self" ),
+        cross_frame_attention_mode         = None,
+        temporal_position_encoding         = True,
+        temporal_position_encoding_max_len = 24,
+        temporal_attention_dim_div         = 1,
+        zero_initialize                    = True,
+        is_hotshot                            = False,
+    ):
+        super().__init__()
+        self.temporal_transformer = TemporalTransformer3DModel(
+            in_channels=in_channels,
+            num_attention_heads=num_attention_heads,
+            attention_head_dim=in_channels // num_attention_heads // temporal_attention_dim_div,
+            num_layers=num_transformer_block,
+            attention_block_types=attention_block_types,
+            cross_frame_attention_mode=cross_frame_attention_mode,
+            temporal_position_encoding=temporal_position_encoding,
+            temporal_position_encoding_max_len=temporal_position_encoding_max_len,
+            is_hotshot=is_hotshot,
+        )
+        if zero_initialize:
+            self.temporal_transformer.proj_out = zero_module(self.temporal_transformer.proj_out)
+    def forward(self, input_tensor, encoder_hidden_states=None, attention_mask=None): # TODO: encoder_hidden_states do seem to be always None
+        return self.temporal_transformer(input_tensor, encoder_hidden_states, attention_mask)
+class TemporalTransformer3DModel(nn.Module):
+    def __init__(
+        self,
+        in_channels,
+        num_attention_heads,
+        attention_head_dim,
+        num_layers,
+        attention_block_types              = ( "Temporal_Self", "Temporal_Self", ),
+        dropout                            = 0.0,
+        norm_num_groups                    = 32,
+        cross_attention_dim                = 768,
+        activation_fn                      = "geglu",
+        attention_bias                     = False,
+        upcast_attention                   = False,
+        cross_frame_attention_mode         = None,
+        temporal_position_encoding         = False,
+        temporal_position_encoding_max_len = 24,
+        is_hotshot                            = False,
+    ):
+        super().__init__()
+        inner_dim = num_attention_heads * attention_head_dim
+        self.norm = torch.nn.GroupNorm(num_groups=norm_num_groups, num_channels=in_channels, eps=1e-6, affine=True)
+        self.proj_in = nn.Linear(in_channels, inner_dim)
+        self.transformer_blocks = nn.ModuleList(
+            [
+                TemporalTransformerBlock(
+                    dim=inner_dim,
+                    num_attention_heads=num_attention_heads,
+                    attention_head_dim=attention_head_dim,
+                    attention_block_types=attention_block_types,
+                    dropout=dropout,
+                    norm_num_groups=norm_num_groups,
+                    cross_attention_dim=cross_attention_dim,
+                    activation_fn=activation_fn,
+                    attention_bias=attention_bias,
+                    upcast_attention=upcast_attention,
+                    cross_frame_attention_mode=cross_frame_attention_mode,
+                    temporal_position_encoding=temporal_position_encoding,
+                    temporal_position_encoding_max_len=temporal_position_encoding_max_len,
+                    is_hotshot=is_hotshot,
+                )
+                for d in range(num_layers)
+            ]
+        )
+        self.proj_out = nn.Linear(inner_dim, in_channels)
+    def forward(self, hidden_states, encoder_hidden_states=None, attention_mask=None):
+        video_length = hidden_states.shape[0] // (2 if shared.opts.batch_cond_uncond else 1)
+        batch, channel, height, weight = hidden_states.shape
+        residual = hidden_states
+        hidden_states = self.norm(hidden_states).type(hidden_states.dtype)
+        inner_dim = hidden_states.shape[1]
+        hidden_states = hidden_states.permute(0, 2, 3, 1).reshape(batch, height * weight, inner_dim)
+        hidden_states = self.proj_in(hidden_states)
+        # Transformer Blocks
+        for block in self.transformer_blocks:
+            hidden_states = block(hidden_states, encoder_hidden_states=encoder_hidden_states, video_length=video_length)
+        # output
+        hidden_states = self.proj_out(hidden_states)
+        hidden_states = hidden_states.reshape(batch, height, weight, inner_dim).permute(0, 3, 1, 2).contiguous()
+        output = hidden_states + residual
+        return output
+class TemporalTransformerBlock(nn.Module):
+    def __init__(
+        self,
+        dim,
+        num_attention_heads,
+        attention_head_dim,
+        attention_block_types              = ( "Temporal_Self", "Temporal_Self", ),
+        dropout                            = 0.0,
+        norm_num_groups                    = 32,
+        cross_attention_dim                = 768,
+        activation_fn                      = "geglu",
+        attention_bias                     = False,
+        upcast_attention                   = False,
+        cross_frame_attention_mode         = None,
+        temporal_position_encoding         = False,
+        temporal_position_encoding_max_len = 24,
+        is_hotshot                            = False,
+    ):
+        super().__init__()
+        attention_blocks = []
+        norms = []
+        for block_name in attention_block_types:
+            attention_blocks.append(
+                VersatileAttention(
+                    attention_mode=block_name.split("_")[0],
+                    cross_attention_dim=cross_attention_dim if block_name.endswith("_Cross") else None,
+                    query_dim=dim,
+                    heads=num_attention_heads,
+                    dim_head=attention_head_dim,
+                    dropout=dropout,
+                    bias=attention_bias,
+                    upcast_attention=upcast_attention,
+                    cross_frame_attention_mode=cross_frame_attention_mode,
+                    temporal_position_encoding=temporal_position_encoding,
+                    temporal_position_encoding_max_len=temporal_position_encoding_max_len,
+                    is_hotshot=is_hotshot,
+                )
+            )
+            norms.append(nn.LayerNorm(dim))
+        self.attention_blocks = nn.ModuleList(attention_blocks)
+        self.norms = nn.ModuleList(norms)
+        self.ff = FeedForward(dim, dropout=dropout, glu=(activation_fn=='geglu'))
+        self.ff_norm = nn.LayerNorm(dim)
+    def forward(self, hidden_states, encoder_hidden_states=None, attention_mask=None, video_length=None):
+        for attention_block, norm in zip(self.attention_blocks, self.norms):
+            norm_hidden_states = norm(hidden_states).type(hidden_states.dtype)
+            hidden_states = attention_block(
+                norm_hidden_states,
+                encoder_hidden_states=encoder_hidden_states if attention_block.is_cross_attention else None,
+                video_length=video_length,
+            ) + hidden_states
+        hidden_states = self.ff(self.ff_norm(hidden_states).type(hidden_states.dtype)) + hidden_states
+        output = hidden_states
+        return output
+class PositionalEncoding(nn.Module):
+    def __init__(
+        self,
+        d_model,
+        dropout = 0.,
+        max_len = 24,
+        is_hotshot = False,
+    ):
+        super().__init__()
+        self.dropout = nn.Dropout(p=dropout)
+        position = torch.arange(max_len).unsqueeze(1)
+        div_term = torch.exp(torch.arange(0, d_model, 2) * (-math.log(10000.0) / d_model))
+        pe = torch.zeros(1, max_len, d_model)
+        pe[0, :, 0::2] = torch.sin(position * div_term)
+        pe[0, :, 1::2] = torch.cos(position * div_term)
+        self.register_buffer('positional_encoding' if is_hotshot else 'pe', pe)
+        self.is_hotshot = is_hotshot
+    def forward(self, x):
+        x = x + (self.positional_encoding[:, :x.size(1)] if self.is_hotshot else self.pe[:, :x.size(1)])
+        return self.dropout(x)
+class CrossAttention(nn.Module):
+    r"""
+    A cross attention layer.
+    Parameters:
+        query_dim (`int`): The number of channels in the query.
+        cross_attention_dim (`int`, *optional*):
+            The number of channels in the encoder_hidden_states. If not given, defaults to `query_dim`.
+        heads (`int`,  *optional*, defaults to 8): The number of heads to use for multi-head attention.
+        dim_head (`int`,  *optional*, defaults to 64): The number of channels in each head.
+        dropout (`float`, *optional*, defaults to 0.0): The dropout probability to use.
+        bias (`bool`, *optional*, defaults to False):
+            Set to `True` for the query, key, and value linear layers to contain a bias parameter.
+    """
+    def __init__(
+        self,
+        query_dim: int,
+        cross_attention_dim: Optional[int] = None,
+        heads: int = 8,
+        dim_head: int = 64,
+        dropout: float = 0.0,
+        bias=False,
+        upcast_attention: bool = False,
+        upcast_softmax: bool = False,
+        added_kv_proj_dim: Optional[int] = None,
+        norm_num_groups: Optional[int] = None,
+    ):
+        super().__init__()
+        inner_dim = dim_head * heads
+        cross_attention_dim = cross_attention_dim if cross_attention_dim is not None else query_dim
+        self.upcast_attention = upcast_attention
+        self.upcast_softmax = upcast_softmax
+        self.scale = dim_head**-0.5
+        self.heads = heads
+        # for slice_size > 0 the attention score computation
+        # is split across the batch axis to save memory
+        # You can set slice_size with `set_attention_slice`
+        self.sliceable_head_dim = heads
+        self._slice_size = None
+        self.added_kv_proj_dim = added_kv_proj_dim
+        if norm_num_groups is not None:
+            self.group_norm = nn.GroupNorm(num_channels=inner_dim, num_groups=norm_num_groups, eps=1e-5, affine=True)
+        else:
+            self.group_norm = None
+        self.to_q = nn.Linear(query_dim, inner_dim, bias=bias)
+        self.to_k = nn.Linear(cross_attention_dim, inner_dim, bias=bias)
+        self.to_v = nn.Linear(cross_attention_dim, inner_dim, bias=bias)
+        if self.added_kv_proj_dim is not None:
+            self.add_k_proj = nn.Linear(added_kv_proj_dim, cross_attention_dim)
+            self.add_v_proj = nn.Linear(added_kv_proj_dim, cross_attention_dim)
+        self.to_out = nn.ModuleList([])
+        self.to_out.append(nn.Linear(inner_dim, query_dim))
+        self.to_out.append(nn.Dropout(dropout))
+    def reshape_heads_to_batch_dim(self, tensor):
+        batch_size, seq_len, dim = tensor.shape
+        head_size = self.heads
+        tensor = tensor.reshape(batch_size, seq_len, head_size, dim // head_size)
+        tensor = tensor.permute(0, 2, 1, 3).reshape(batch_size * head_size, seq_len, dim // head_size)
+        return tensor
+    def reshape_batch_dim_to_heads(self, tensor):
+        batch_size, seq_len, dim = tensor.shape
+        head_size = self.heads
+        tensor = tensor.reshape(batch_size // head_size, head_size, seq_len, dim)
+        tensor = tensor.permute(0, 2, 1, 3).reshape(batch_size // head_size, seq_len, dim * head_size)
+        return tensor
+    def set_attention_slice(self, slice_size):
+        if slice_size is not None and slice_size > self.sliceable_head_dim:
+            raise ValueError(f"slice_size {slice_size} has to be smaller or equal to {self.sliceable_head_dim}.")
+        self._slice_size = slice_size
+    def forward(self, hidden_states, encoder_hidden_states=None, attention_mask=None):
+        batch_size, sequence_length, _ = hidden_states.shape
+        encoder_hidden_states = encoder_hidden_states
+        if self.group_norm is not None:
+            hidden_states = self.group_norm(hidden_states.transpose(1, 2)).transpose(1, 2).type(hidden_states.dtype)
+        query = self.to_q(hidden_states)
+        dim = query.shape[-1]
+        query = self.reshape_heads_to_batch_dim(query)
+        if self.added_kv_proj_dim is not None:
+            key = self.to_k(hidden_states)
+            value = self.to_v(hidden_states)
+            encoder_hidden_states_key_proj = self.add_k_proj(encoder_hidden_states)
+            encoder_hidden_states_value_proj = self.add_v_proj(encoder_hidden_states)
+            key = self.reshape_heads_to_batch_dim(key)
+            value = self.reshape_heads_to_batch_dim(value)
+            encoder_hidden_states_key_proj = self.reshape_heads_to_batch_dim(encoder_hidden_states_key_proj)
+            encoder_hidden_states_value_proj = self.reshape_heads_to_batch_dim(encoder_hidden_states_value_proj)
+            key = torch.concat([encoder_hidden_states_key_proj, key], dim=1)
+            value = torch.concat([encoder_hidden_states_value_proj, value], dim=1)
+        else:
+            encoder_hidden_states = encoder_hidden_states if encoder_hidden_states is not None else hidden_states
+            key = self.to_k(encoder_hidden_states)
+            value = self.to_v(encoder_hidden_states)
+            key = self.reshape_heads_to_batch_dim(key)
+            value = self.reshape_heads_to_batch_dim(value)
+        if attention_mask is not None:
+            if attention_mask.shape[-1] != query.shape[1]:
+                target_length = query.shape[1]
+                attention_mask = F.pad(attention_mask, (0, target_length), value=0.0)
+                attention_mask = attention_mask.repeat_interleave(self.heads, dim=0)
+        # attention, what we cannot get enough of
+        if sd_hijack.current_optimizer is not None and sd_hijack.current_optimizer.name in ["xformers", "sdp", "sdp-no-mem", "sub-quadratic"]:
+            hidden_states = self._memory_efficient_attention(query, key, value, attention_mask, sd_hijack.current_optimizer.name)
+            # Some versions of xformers return output in fp32, cast it back to the dtype of the input
+            hidden_states = hidden_states.to(query.dtype)
+        else:
+            if self._slice_size is None or query.shape[0] // self._slice_size == 1:
+                hidden_states = self._attention(query, key, value, attention_mask)
+            else:
+                hidden_states = self._sliced_attention(query, key, value, sequence_length, dim, attention_mask)
+        # linear proj
+        hidden_states = self.to_out[0](hidden_states)
+        # dropout
+        hidden_states = self.to_out[1](hidden_states)
+        return hidden_states
+    def _attention(self, query, key, value, attention_mask=None):
+        if self.upcast_attention:
+            query = query.float()
+            key = key.float()
+        attention_scores = torch.baddbmm(
+            torch.empty(query.shape[0], query.shape[1], key.shape[1], dtype=query.dtype, device=query.device),
+            query,
+            key.transpose(-1, -2),
+            beta=0,
+            alpha=self.scale,
+        )
+        if attention_mask is not None:
+            attention_scores = attention_scores + attention_mask
+        if self.upcast_softmax:
+            attention_scores = attention_scores.float()
+        attention_probs = attention_scores.softmax(dim=-1)
+        # cast back to the original dtype
+        attention_probs = attention_probs.to(value.dtype)
+        # compute attention output
+        hidden_states = torch.bmm(attention_probs, value)
+        # reshape hidden_states
+        hidden_states = self.reshape_batch_dim_to_heads(hidden_states)
+        return hidden_states
+    def _sliced_attention(self, query, key, value, sequence_length, dim, attention_mask):
+        batch_size_attention = query.shape[0]
+        hidden_states = torch.zeros(
+            (batch_size_attention, sequence_length, dim // self.heads), device=query.device, dtype=query.dtype
+        )
+        slice_size = self._slice_size if self._slice_size is not None else hidden_states.shape[0]
+        for i in range(hidden_states.shape[0] // slice_size):
+            start_idx = i * slice_size
+            end_idx = (i + 1) * slice_size
+            query_slice = query[start_idx:end_idx]
+            key_slice = key[start_idx:end_idx]
+            if self.upcast_attention:
+                query_slice = query_slice.float()
+                key_slice = key_slice.float()
+            attn_slice = torch.baddbmm(
+                torch.empty(slice_size, query.shape[1], key.shape[1], dtype=query_slice.dtype, device=query.device),
+                query_slice,
+                key_slice.transpose(-1, -2),
+                beta=0,
+                alpha=self.scale,
+            )
+            if attention_mask is not None:
+                attn_slice = attn_slice + attention_mask[start_idx:end_idx]
+            if self.upcast_softmax:
+                attn_slice = attn_slice.float()
+            attn_slice = attn_slice.softmax(dim=-1)
+            # cast back to the original dtype
+            attn_slice = attn_slice.to(value.dtype)
+            attn_slice = torch.bmm(attn_slice, value[start_idx:end_idx])
+            hidden_states[start_idx:end_idx] = attn_slice
+        # reshape hidden_states
+        hidden_states = self.reshape_batch_dim_to_heads(hidden_states)
+        return hidden_states
+    def _memory_efficient_attention(self, q, k, v, mask, current_optimizer_name):
+        # TODO attention_mask
+        q = q.contiguous()
+        k = k.contiguous()
+        v = v.contiguous()
+        fallthrough = False
+        if current_optimizer_name == "xformers" or fallthrough:
+            fallthrough = False
+            try:
+                import xformers.ops
+                from modules.sd_hijack_optimizations import get_xformers_flash_attention_op
+                hidden_states = xformers.ops.memory_efficient_attention(
+                    q, k, v, attn_bias=mask,
+                    op=get_xformers_flash_attention_op(q, k, v))
+            except (ImportError, RuntimeError, AttributeError):
+                fallthrough = True
+        if current_optimizer_name == "sdp" or fallthrough:
+            fallthrough = False
+            try:
+                hidden_states = torch.nn.functional.scaled_dot_product_attention(
+                    q, k, v, attn_mask=mask, dropout_p=0.0, is_causal=False
+                )
+            except (ImportError, RuntimeError, AttributeError):
+                fallthrough = True
+        if current_optimizer_name == "sdp-no-mem" or fallthrough:
+            fallthrough = False
+            try:
+                with torch.backends.cuda.sdp_kernel(enable_flash=True, enable_math=True, enable_mem_efficient=False):
+                    hidden_states = torch.nn.functional.scaled_dot_product_attention(
+                        q, k, v, attn_mask=mask, dropout_p=0.0, is_causal=False
+                    )
+            except (ImportError, RuntimeError, AttributeError):
+                fallthrough = True
+        if current_optimizer_name == "sub-quadratic" or fallthrough:
+            fallthrough = False
+            try:
+                from modules.sd_hijack_optimizations import sub_quad_attention
+                from modules import shared
+                hidden_states = sub_quad_attention(
+                    q, k, v,
+                    q_chunk_size=shared.cmd_opts.sub_quad_q_chunk_size,
+                    kv_chunk_size=shared.cmd_opts.sub_quad_kv_chunk_size,
+                    chunk_threshold=shared.cmd_opts.sub_quad_chunk_threshold,
+                    use_checkpoint=self.training
+                )
+            except (ImportError, RuntimeError, AttributeError):
+                fallthrough = True
+        if fallthrough:
+            fallthrough = False
+            if self._slice_size is None or query.shape[0] // self._slice_size == 1:
+                hidden_states = self._attention(query, key, value, attention_mask)
+            else:
+                hidden_states = self._sliced_attention(query, key, value, sequence_length, dim, attention_mask)
+            return hidden_states
+        hidden_states = self.reshape_batch_dim_to_heads(hidden_states)
+        return hidden_states
+class VersatileAttention(CrossAttention):
+    def __init__(
+            self,
+            attention_mode                     = None,
+            cross_frame_attention_mode         = None,
+            temporal_position_encoding         = False,
+            temporal_position_encoding_max_len = 24,
+            is_hotshot                            = False,
+            *args, **kwargs
+        ):
+        super().__init__(*args, **kwargs)
+        assert attention_mode == "Temporal"
+        self.attention_mode = attention_mode
+        self.is_cross_attention = kwargs["cross_attention_dim"] is not None
+        self.pos_encoder = PositionalEncoding(
+            kwargs["query_dim"],
+            dropout=0.,
+            max_len=temporal_position_encoding_max_len,
+            is_hotshot=is_hotshot,
+        ) if (temporal_position_encoding and attention_mode == "Temporal") else None
+    def extra_repr(self):
+        return f"(Module Info) Attention_Mode: {self.attention_mode}, Is_Cross_Attention: {self.is_cross_attention}"
+    def forward(self, hidden_states, encoder_hidden_states=None, attention_mask=None, video_length=None):
+        batch_size, sequence_length, _ = hidden_states.shape
+        if self.attention_mode == "Temporal":
+            d = hidden_states.shape[1]
+            hidden_states = rearrange(hidden_states, "(b f) d c -> (b d) f c", f=video_length)
+            if self.pos_encoder is not None:
+                hidden_states = self.pos_encoder(hidden_states)
+            encoder_hidden_states = repeat(encoder_hidden_states, "b n c -> (b d) n c", d=d) if encoder_hidden_states is not None else encoder_hidden_states
+        else:
+            raise NotImplementedError
+        encoder_hidden_states = encoder_hidden_states
+        if self.group_norm is not None:
+            hidden_states = self.group_norm(hidden_states.transpose(1, 2)).transpose(1, 2).dtype(hidden_states.dtype)
+        query = self.to_q(hidden_states)
+        dim = query.shape[-1]
+        query = self.reshape_heads_to_batch_dim(query)
+        if self.added_kv_proj_dim is not None:
+            raise NotImplementedError
+        encoder_hidden_states = encoder_hidden_states if encoder_hidden_states is not None else hidden_states
+        key = self.to_k(encoder_hidden_states)
+        value = self.to_v(encoder_hidden_states)
+        key = self.reshape_heads_to_batch_dim(key)
+        value = self.reshape_heads_to_batch_dim(value)
+        if attention_mask is not None:
+            if attention_mask.shape[-1] != query.shape[1]:
+                target_length = query.shape[1]
+                attention_mask = F.pad(attention_mask, (0, target_length), value=0.0)
+                attention_mask = attention_mask.repeat_interleave(self.heads, dim=0)
+        xformers_option = shared.opts.data.get("animatediff_xformers", "Optimize attention layers with xformers")
+        optimizer_collections = ["xformers", "sdp", "sdp-no-mem", "sub-quadratic"]
+        if xformers_option == "Do not optimize attention layers": # "Do not optimize attention layers"
+            optimizer_collections = optimizer_collections[1:]
+        # attention, what we cannot get enough of
+        if sd_hijack.current_optimizer is not None and sd_hijack.current_optimizer.name in optimizer_collections:
+            optimizer_name = sd_hijack.current_optimizer.name
+            if xformers_option == "Optimize attention layers with sdp (torch >= 2.0.0 required)" and optimizer_name == "xformers":
+                optimizer_name = "sdp" # "Optimize attention layers with sdp (torch >= 2.0.0 required)"
+            hidden_states = self._memory_efficient_attention(query, key, value, attention_mask, optimizer_name)
+            # Some versions of xformers return output in fp32, cast it back to the dtype of the input
+            hidden_states = hidden_states.to(query.dtype)
+        else:
+            if self._slice_size is None or query.shape[0] // self._slice_size == 1:
+                hidden_states = self._attention(query, key, value, attention_mask)
+            else:
+                hidden_states = self._sliced_attention(query, key, value, sequence_length, dim, attention_mask)
+        # linear proj
+        hidden_states = self.to_out[0](hidden_states)
+        # dropout
+        hidden_states = self.to_out[1](hidden_states)
+        if self.attention_mode == "Temporal":
+            hidden_states = rearrange(hidden_states, "(b d) f c -> (b f) d c", d=d)
+        return hidden_states

extensions/sd-webui-animatediff/scripts/__pycache__/animatediff.cpython-310.pyc ADDED Viewed

Binary file (7.49 kB). View file

extensions/sd-webui-animatediff/scripts/__pycache__/animatediff_cn.cpython-310.pyc ADDED Viewed

Binary file (19.2 kB). View file

extensions/sd-webui-animatediff/scripts/__pycache__/animatediff_i2ibatch.cpython-310.pyc ADDED Viewed

Binary file (9.34 kB). View file

extensions/sd-webui-animatediff/scripts/__pycache__/animatediff_infotext.cpython-310.pyc ADDED Viewed

Binary file (1.53 kB). View file

extensions/sd-webui-animatediff/scripts/__pycache__/animatediff_infv2v.cpython-310.pyc ADDED Viewed

Binary file (12.4 kB). View file

extensions/sd-webui-animatediff/scripts/__pycache__/animatediff_latent.cpython-310.pyc ADDED Viewed

Binary file (2.66 kB). View file

extensions/sd-webui-animatediff/scripts/__pycache__/animatediff_lcm.cpython-310.pyc ADDED Viewed

Binary file (5.9 kB). View file

extensions/sd-webui-animatediff/scripts/__pycache__/animatediff_logger.cpython-310.pyc ADDED Viewed

Binary file (1.29 kB). View file

extensions/sd-webui-animatediff/scripts/__pycache__/animatediff_lora.cpython-310.pyc ADDED Viewed

Binary file (2.77 kB). View file

extensions/sd-webui-animatediff/scripts/__pycache__/animatediff_mm.cpython-310.pyc ADDED Viewed

Binary file (6.79 kB). View file

extensions/sd-webui-animatediff/scripts/__pycache__/animatediff_output.cpython-310.pyc ADDED Viewed

Binary file (11.2 kB). View file

extensions/sd-webui-animatediff/scripts/__pycache__/animatediff_prompt.cpython-310.pyc ADDED Viewed

Binary file (5.22 kB). View file

extensions/sd-webui-animatediff/scripts/__pycache__/animatediff_ui.cpython-310.pyc ADDED Viewed

Binary file (9.55 kB). View file

extensions/sd-webui-animatediff/scripts/animatediff.py ADDED Viewed

	@@ -0,0 +1,279 @@

+import gradio as gr
+from modules import script_callbacks, scripts, shared
+from modules.processing import (Processed, StableDiffusionProcessing,
+                                StableDiffusionProcessingImg2Img)
+from modules.scripts import PostprocessBatchListArgs, PostprocessImageArgs
+from scripts.animatediff_cn import AnimateDiffControl
+from scripts.animatediff_infv2v import AnimateDiffInfV2V
+from scripts.animatediff_latent import AnimateDiffI2VLatent
+from scripts.animatediff_logger import logger_animatediff as logger
+from scripts.animatediff_lora import AnimateDiffLora
+from scripts.animatediff_mm import mm_animatediff as motion_module
+from scripts.animatediff_prompt import AnimateDiffPromptSchedule
+from scripts.animatediff_output import AnimateDiffOutput
+from scripts.animatediff_ui import AnimateDiffProcess, AnimateDiffUiGroup
+from scripts.animatediff_infotext import update_infotext
+script_dir = scripts.basedir()
+motion_module.set_script_dir(script_dir)
+class AnimateDiffScript(scripts.Script):
+    def __init__(self):
+        self.lora_hacker = None
+        self.cfg_hacker = None
+        self.cn_hacker = None
+        self.prompt_scheduler = None
+        self.hacked = False
+    def title(self):
+        return "AnimateDiff"
+    def show(self, is_img2img):
+        return scripts.AlwaysVisible
+    def ui(self, is_img2img):
+        return (AnimateDiffUiGroup().render(is_img2img, motion_module.get_model_dir()),)
+    def before_process(self, p: StableDiffusionProcessing, params: AnimateDiffProcess):
+        if p.is_api and isinstance(params, dict):
+            self.ad_params = AnimateDiffProcess(**params)
+            params = self.ad_params
+        if params.enable:
+            logger.info("AnimateDiff process start.")
+            params.set_p(p)
+            motion_module.inject(p.sd_model, params.model)
+            self.prompt_scheduler = AnimateDiffPromptSchedule()
+            self.lora_hacker = AnimateDiffLora(motion_module.mm.is_v2)
+            self.lora_hacker.hack()
+            self.cfg_hacker = AnimateDiffInfV2V(p, self.prompt_scheduler)
+            self.cfg_hacker.hack(params)
+            self.cn_hacker = AnimateDiffControl(p, self.prompt_scheduler)
+            self.cn_hacker.hack(params)
+            update_infotext(p, params)
+            self.hacked = True
+        elif self.hacked:
+            self.cn_hacker.restore()
+            self.cfg_hacker.restore()
+            self.lora_hacker.restore()
+            motion_module.restore(p.sd_model)
+            self.hacked = False
+    def before_process_batch(self, p: StableDiffusionProcessing, params: AnimateDiffProcess, **kwargs):
+        if p.is_api and isinstance(params, dict): params = self.ad_params
+        if params.enable and isinstance(p, StableDiffusionProcessingImg2Img) and not hasattr(p, '_animatediff_i2i_batch'):
+            AnimateDiffI2VLatent().randomize(p, params)
+    def postprocess_batch_list(self, p: StableDiffusionProcessing, pp: PostprocessBatchListArgs, params: AnimateDiffProcess, **kwargs):
+        if p.is_api and isinstance(params, dict): params = self.ad_params
+        if params.enable:
+            self.prompt_scheduler.save_infotext_img(p)
+    def postprocess_image(self, p: StableDiffusionProcessing, pp: PostprocessImageArgs, params: AnimateDiffProcess, *args):
+        if p.is_api and isinstance(params, dict): params = self.ad_params
+        if params.enable and isinstance(p, StableDiffusionProcessingImg2Img) and hasattr(p, '_animatediff_paste_to_full'):
+            p.paste_to = p._animatediff_paste_to_full[p.batch_index]
+    def postprocess(self, p: StableDiffusionProcessing, res: Processed, params: AnimateDiffProcess):
+        if p.is_api and isinstance(params, dict): params = self.ad_params
+        if params.enable:
+            self.prompt_scheduler.save_infotext_txt(res)
+            self.cn_hacker.restore()
+            self.cfg_hacker.restore()
+            self.lora_hacker.restore()
+            motion_module.restore(p.sd_model)
+            self.hacked = False
+            AnimateDiffOutput().output(p, res, params)
+            logger.info("AnimateDiff process end.")
+def on_ui_settings():
+    section = ("animatediff", "AnimateDiff")
+    s3_selection =("animatediff", "AnimateDiff AWS")
+    shared.opts.add_option(
+        "animatediff_model_path",
+        shared.OptionInfo(
+            None,
+            "Path to save AnimateDiff motion modules",
+            gr.Textbox,
+            section=section,
+        ),
+    )
+    shared.opts.add_option(
+        "animatediff_optimize_gif_palette",
+        shared.OptionInfo(
+            False,
+            "Calculate the optimal GIF palette, improves quality significantly, removes banding",
+            gr.Checkbox,
+            section=section
+        )
+    )
+    shared.opts.add_option(
+        "animatediff_optimize_gif_gifsicle",
+        shared.OptionInfo(
+            False,
+            "Optimize GIFs with gifsicle, reduces file size",
+            gr.Checkbox,
+            section=section
+        )
+    )
+    shared.opts.add_option(
+        key="animatediff_mp4_crf",
+        info=shared.OptionInfo(
+            default=23,
+            label="MP4 Quality (CRF)",
+            component=gr.Slider,
+            component_args={
+                "minimum": 0,
+                "maximum": 51,
+                "step": 1},
+            section=section
+        )
+        .link("docs", "https://trac.ffmpeg.org/wiki/Encode/H.264#crf")
+        .info("17 for best quality, up to 28 for smaller size")
+    )
+    shared.opts.add_option(
+        key="animatediff_mp4_preset",
+        info=shared.OptionInfo(
+            default="",
+            label="MP4 Encoding Preset",
+            component=gr.Dropdown,
+            component_args={"choices": ["", 'veryslow', 'slower', 'slow', 'medium', 'fast', 'faster', 'veryfast', 'superfast', 'ultrafast']},
+            section=section,
+        )
+        .link("docs", "https://trac.ffmpeg.org/wiki/Encode/H.264#Preset")
+        .info("encoding speed, use the slowest you can tolerate")
+    )
+    shared.opts.add_option(
+        key="animatediff_mp4_tune",
+        info=shared.OptionInfo(
+            default="",
+            label="MP4 Tune encoding for content type",
+            component=gr.Dropdown,
+            component_args={"choices": ["", "film", "animation", "grain"]},
+            section=section
+        )
+        .link("docs", "https://trac.ffmpeg.org/wiki/Encode/H.264#Tune")
+        .info("optimize for specific content types")
+    )
+    shared.opts.add_option(
+        "animatediff_webp_quality",
+        shared.OptionInfo(
+            80,
+            "WebP Quality (if lossless=True, increases compression and CPU usage)",
+            gr.Slider,
+            {
+                "minimum": 1,
+                "maximum": 100,
+                "step": 1},
+            section=section
+        )
+    )
+    shared.opts.add_option(
+        "animatediff_webp_lossless",
+        shared.OptionInfo(
+            False,
+            "Save WebP in lossless format (highest quality, largest file size)",
+            gr.Checkbox,
+            section=section
+        )
+    )
+    shared.opts.add_option(
+        "animatediff_save_to_custom",
+        shared.OptionInfo(
+            False,
+            "Save frames to stable-diffusion-webui/outputs/{ txt|img }2img-images/AnimateDiff/{gif filename}/{date} "
+            "instead of stable-diffusion-webui/outputs/{ txt|img }2img-images/{date}/.",
+            gr.Checkbox,
+            section=section
+        )
+    )
+    shared.opts.add_option(
+        "animatediff_xformers",
+        shared.OptionInfo(
+            "Optimize attention layers with xformers",
+            "When you have --xformers in your command line args, you want AnimateDiff to ",
+            gr.Radio,
+            {"choices": ["Optimize attention layers with xformers",
+                         "Optimize attention layers with sdp (torch >= 2.0.0 required)",
+                         "Do not optimize attention layers"]},
+            section=section
+        )
+    )
+    shared.opts.add_option(
+        "animatediff_disable_lcm",
+        shared.OptionInfo(
+            False,
+            "Disable LCM",
+            gr.Checkbox,
+            section=section
+        )
+    )
+    shared.opts.add_option(
+        "animatediff_s3_enable",
+        shared.OptionInfo(
+            False,
+            "Enable to Store file in object storage that supports the s3 protocol",
+            gr.Checkbox,
+            section=s3_selection
+        )
+    )
+    shared.opts.add_option(
+        "animatediff_s3_host",
+        shared.OptionInfo(
+            None,
+            "S3 protocol host",
+            gr.Textbox,
+            section=s3_selection,
+        ),
+    )
+    shared.opts.add_option(
+        "animatediff_s3_port",
+        shared.OptionInfo(
+            None,
+            "S3 protocol port",
+            gr.Textbox,
+            section=s3_selection,
+        ),
+    )
+    shared.opts.add_option(
+        "animatediff_s3_access_key",
+        shared.OptionInfo(
+            None,
+            "S3 protocol access_key",
+            gr.Textbox,
+            section=s3_selection,
+        ),
+    )
+    shared.opts.add_option(
+        "animatediff_s3_secret_key",
+        shared.OptionInfo(
+            None,
+            "S3 protocol secret_key",
+            gr.Textbox,
+            section=s3_selection,
+        ),
+    )
+    shared.opts.add_option(
+        "animatediff_s3_storge_bucket",
+        shared.OptionInfo(
+            None,
+            "Bucket for file storage",
+            gr.Textbox,
+            section=s3_selection,
+        ),
+    )
+script_callbacks.on_ui_settings(on_ui_settings)
+script_callbacks.on_after_component(AnimateDiffUiGroup.on_after_component)
+script_callbacks.on_before_ui(AnimateDiffUiGroup.on_before_ui)

extensions/sd-webui-animatediff/scripts/animatediff_cn.py ADDED Viewed

	@@ -0,0 +1,641 @@

+from pathlib import Path
+from types import MethodType
+from typing import Optional
+import os
+import shutil
+import cv2
+import numpy as np
+import torch
+from tqdm import tqdm
+from PIL import Image, ImageFilter, ImageOps
+from modules import processing, shared, masking, images, devices
+from modules.paths import data_path
+from modules.processing import (StableDiffusionProcessing,
+                                StableDiffusionProcessingImg2Img,
+                                StableDiffusionProcessingTxt2Img)
+from scripts.animatediff_logger import logger_animatediff as logger
+from scripts.animatediff_ui import AnimateDiffProcess
+from scripts.animatediff_prompt import AnimateDiffPromptSchedule
+from scripts.animatediff_infotext import update_infotext
+from scripts.animatediff_i2ibatch import animatediff_i2ibatch
+class AnimateDiffControl:
+    original_processing_process_images_hijack = None
+    original_controlnet_main_entry = None
+    original_postprocess_batch = None
+    def __init__(self, p: StableDiffusionProcessing, prompt_scheduler: AnimateDiffPromptSchedule):
+        try:
+            from scripts.external_code import find_cn_script
+            self.cn_script = find_cn_script(p.scripts)
+        except:
+            self.cn_script = None
+        self.prompt_scheduler = prompt_scheduler
+    def hack_batchhijack(self, params: AnimateDiffProcess):
+        cn_script = self.cn_script
+        prompt_scheduler = self.prompt_scheduler
+        def get_input_frames():
+            if params.video_source is not None and params.video_source != '':
+                cap = cv2.VideoCapture(params.video_source)
+                frame_count = 0
+                tmp_frame_dir = Path(f'{data_path}/tmp/animatediff-frames/')
+                tmp_frame_dir.mkdir(parents=True, exist_ok=True)
+                while cap.isOpened():
+                    ret, frame = cap.read()
+                    if not ret:
+                        break
+                    cv2.imwrite(f"{tmp_frame_dir}/{frame_count}.png", frame)
+                    frame_count += 1
+                cap.release()
+                return str(tmp_frame_dir)
+            elif params.video_path is not None and params.video_path != '':
+                return params.video_path
+            return ''
+        from scripts.batch_hijack import BatchHijack, instance
+        def hacked_processing_process_images_hijack(self, p: StableDiffusionProcessing, *args, **kwargs):
+            from scripts import external_code
+            from scripts.batch_hijack import InputMode
+            units = external_code.get_all_units_in_processing(p)
+            units = [unit for unit in units if getattr(unit, 'enabled', False)]
+            if len(units) > 0:
+                global_input_frames = get_input_frames()
+                for idx, unit in enumerate(units):
+                    # i2i-batch mode
+                    if getattr(p, '_animatediff_i2i_batch', None) and not unit.image:
+                        unit.input_mode = InputMode.BATCH
+                    # if no input given for this unit, use global input
+                    if getattr(unit, 'input_mode', InputMode.SIMPLE) == InputMode.BATCH:
+                        if not unit.batch_images:
+                            assert global_input_frames, 'No input images found for ControlNet module'
+                            unit.batch_images = global_input_frames
+                    elif not unit.image:
+                        try:
+                            cn_script.choose_input_image(p, unit, idx)
+                        except:
+                            assert global_input_frames != '', 'No input images found for ControlNet module'
+                            unit.batch_images = global_input_frames
+                            unit.input_mode = InputMode.BATCH
+                    if getattr(unit, 'input_mode', InputMode.SIMPLE) == InputMode.BATCH:
+                        if 'inpaint' in unit.module:
+                            images = shared.listfiles(f'{unit.batch_images}/image')
+                            masks = shared.listfiles(f'{unit.batch_images}/mask')
+                            assert len(images) == len(masks), 'Inpainting image mask count mismatch'
+                            unit.batch_images = [{'image': images[i], 'mask': masks[i]} for i in range(len(images))]
+                        else:
+                            unit.batch_images = shared.listfiles(unit.batch_images)
+                unit_batch_list = [len(unit.batch_images) for unit in units
+                                   if getattr(unit, 'input_mode', InputMode.SIMPLE) == InputMode.BATCH]
+                if getattr(p, '_animatediff_i2i_batch', None):
+                    unit_batch_list.append(len(p.init_images))
+                if len(unit_batch_list) > 0:
+                    video_length = min(unit_batch_list)
+                    # ensure that params.video_length <= video_length and params.batch_size <= video_length
+                    if params.video_length > video_length:
+                        params.video_length = video_length
+                    if params.batch_size > video_length:
+                        params.batch_size = video_length
+                    if params.video_default:
+                        params.video_length = video_length
+                        p.batch_size = video_length
+                    for unit in units:
+                        if getattr(unit, 'input_mode', InputMode.SIMPLE) == InputMode.BATCH:
+                            unit.batch_images = unit.batch_images[:params.video_length]
+            animatediff_i2ibatch.cap_init_image(p, params)
+            prompt_scheduler.parse_prompt(p)
+            update_infotext(p, params)
+            return getattr(processing, '__controlnet_original_process_images_inner')(p, *args, **kwargs)
+        if AnimateDiffControl.original_processing_process_images_hijack is not None:
+            logger.info('BatchHijack already hacked.')
+            return
+        AnimateDiffControl.original_processing_process_images_hijack = BatchHijack.processing_process_images_hijack
+        BatchHijack.processing_process_images_hijack = hacked_processing_process_images_hijack
+        processing.process_images_inner = instance.processing_process_images_hijack
+    def restore_batchhijack(self):
+        if AnimateDiffControl.original_processing_process_images_hijack is not None:
+            from scripts.batch_hijack import BatchHijack, instance
+            BatchHijack.processing_process_images_hijack = AnimateDiffControl.original_processing_process_images_hijack
+            AnimateDiffControl.original_processing_process_images_hijack = None
+            processing.process_images_inner = instance.processing_process_images_hijack
+    def hack_cn(self):
+        cn_script = self.cn_script
+        def hacked_main_entry(self, p: StableDiffusionProcessing):
+            from scripts import external_code, global_state, hook
+            from scripts.controlnet_lora import bind_control_lora
+            from scripts.adapter import Adapter, Adapter_light, StyleAdapter
+            from scripts.batch_hijack import InputMode
+            from scripts.controlnet_lllite import PlugableControlLLLite, clear_all_lllite
+            from scripts.controlmodel_ipadapter import (PlugableIPAdapter,
+                                                        clear_all_ip_adapter)
+            from scripts.hook import ControlModelType, ControlParams, UnetHook
+            from scripts.logging import logger
+            from scripts.processor import model_free_preprocessors
+            # TODO: i2i-batch mode, what should I change?
+            def image_has_mask(input_image: np.ndarray) -> bool:
+                return (
+                    input_image.ndim == 3 and
+                    input_image.shape[2] == 4 and
+                    np.max(input_image[:, :, 3]) > 127
+                )
+            def prepare_mask(
+                mask: Image.Image, p: processing.StableDiffusionProcessing
+            ) -> Image.Image:
+                mask = mask.convert("L")
+                if getattr(p, "inpainting_mask_invert", False):
+                    mask = ImageOps.invert(mask)
+                if hasattr(p, 'mask_blur_x'):
+                    if getattr(p, "mask_blur_x", 0) > 0:
+                        np_mask = np.array(mask)
+                        kernel_size = 2 * int(2.5 * p.mask_blur_x + 0.5) + 1
+                        np_mask = cv2.GaussianBlur(np_mask, (kernel_size, 1), p.mask_blur_x)
+                        mask = Image.fromarray(np_mask)
+                    if getattr(p, "mask_blur_y", 0) > 0:
+                        np_mask = np.array(mask)
+                        kernel_size = 2 * int(2.5 * p.mask_blur_y + 0.5) + 1
+                        np_mask = cv2.GaussianBlur(np_mask, (1, kernel_size), p.mask_blur_y)
+                        mask = Image.fromarray(np_mask)
+                else:
+                    if getattr(p, "mask_blur", 0) > 0:
+                        mask = mask.filter(ImageFilter.GaussianBlur(p.mask_blur))
+                return mask
+            def set_numpy_seed(p: processing.StableDiffusionProcessing) -> Optional[int]:
+                try:
+                    tmp_seed = int(p.all_seeds[0] if p.seed == -1 else max(int(p.seed), 0))
+                    tmp_subseed = int(p.all_seeds[0] if p.subseed == -1 else max(int(p.subseed), 0))
+                    seed = (tmp_seed + tmp_subseed) & 0xFFFFFFFF
+                    np.random.seed(seed)
+                    return seed
+                except Exception as e:
+                    logger.warning(e)
+                    logger.warning('Warning: Failed to use consistent random seed.')
+                    return None
+            sd_ldm = p.sd_model
+            unet = sd_ldm.model.diffusion_model
+            self.noise_modifier = None
+            setattr(p, 'controlnet_control_loras', [])
+            if self.latest_network is not None:
+                # always restore (~0.05s)
+                self.latest_network.restore()
+            # always clear (~0.05s)
+            clear_all_lllite()
+            clear_all_ip_adapter()
+            self.enabled_units = cn_script.get_enabled_units(p)
+            if len(self.enabled_units) == 0:
+                self.latest_network = None
+                return
+            detected_maps = []
+            forward_params = []
+            post_processors = []
+            # cache stuff
+            if self.latest_model_hash != p.sd_model.sd_model_hash:
+                cn_script.clear_control_model_cache()
+            for idx, unit in enumerate(self.enabled_units):
+                unit.module = global_state.get_module_basename(unit.module)
+            # unload unused preproc
+            module_list = [unit.module for unit in self.enabled_units]
+            for key in self.unloadable:
+                if key not in module_list:
+                    self.unloadable.get(key, lambda:None)()
+            self.latest_model_hash = p.sd_model.sd_model_hash
+            for idx, unit in enumerate(self.enabled_units):
+                cn_script.bound_check_params(unit)
+                resize_mode = external_code.resize_mode_from_value(unit.resize_mode)
+                control_mode = external_code.control_mode_from_value(unit.control_mode)
+                if unit.module in model_free_preprocessors:
+                    model_net = None
+                else:
+                    model_net = cn_script.load_control_model(p, unet, unit.model)
+                    model_net.reset()
+                    if model_net is not None and getattr(devices, "fp8", False) and not isinstance(model_net, PlugableIPAdapter):
+                        for _module in model_net.modules():
+                            if isinstance(_module, (torch.nn.Conv2d, torch.nn.Linear)):
+                                _module.to(torch.float8_e4m3fn)
+                    if getattr(model_net, 'is_control_lora', False):
+                        control_lora = model_net.control_model
+                        bind_control_lora(unet, control_lora)
+                        p.controlnet_control_loras.append(control_lora)
+                if getattr(unit, 'input_mode', InputMode.SIMPLE) == InputMode.BATCH:
+                    input_images = []
+                    for img in unit.batch_images:
+                        unit.image = img
+                        input_image, _ = cn_script.choose_input_image(p, unit, idx)
+                        input_images.append(input_image)
+                else:
+                    input_image, image_from_a1111 = cn_script.choose_input_image(p, unit, idx)
+                    input_images = [input_image]
+                    if image_from_a1111:
+                        a1111_i2i_resize_mode = getattr(p, "resize_mode", None)
+                        if a1111_i2i_resize_mode is not None:
+                            resize_mode = external_code.resize_mode_from_value(a1111_i2i_resize_mode)
+                for idx, input_image in enumerate(input_images):
+                    a1111_mask_image : Optional[Image.Image] = getattr(p, "image_mask", None)
+                    if a1111_mask_image and isinstance(a1111_mask_image, list):
+                        a1111_mask_image = a1111_mask_image[idx]
+                    if 'inpaint' in unit.module and not image_has_mask(input_image) and a1111_mask_image is not None:
+                        a1111_mask = np.array(prepare_mask(a1111_mask_image, p))
+                        if a1111_mask.ndim == 2:
+                            if a1111_mask.shape[0] == input_image.shape[0]:
+                                if a1111_mask.shape[1] == input_image.shape[1]:
+                                    input_image = np.concatenate([input_image[:, :, 0:3], a1111_mask[:, :, None]], axis=2)
+                                    a1111_i2i_resize_mode = getattr(p, "resize_mode", None)
+                                    if a1111_i2i_resize_mode is not None:
+                                        resize_mode = external_code.resize_mode_from_value(a1111_i2i_resize_mode)
+                    if 'reference' not in unit.module and issubclass(type(p), StableDiffusionProcessingImg2Img) \
+                            and p.inpaint_full_res and a1111_mask_image is not None:
+                        logger.debug("A1111 inpaint mask START")
+                        input_image = [input_image[:, :, i] for i in range(input_image.shape[2])]
+                        input_image = [Image.fromarray(x) for x in input_image]
+                        mask = prepare_mask(a1111_mask_image, p)
+                        crop_region = masking.get_crop_region(np.array(mask), p.inpaint_full_res_padding)
+                        crop_region = masking.expand_crop_region(crop_region, p.width, p.height, mask.width, mask.height)
+                        input_image = [
+                            images.resize_image(resize_mode.int_value(), i, mask.width, mask.height)
+                            for i in input_image
+                        ]
+                        input_image = [x.crop(crop_region) for x in input_image]
+                        input_image = [
+                            images.resize_image(external_code.ResizeMode.OUTER_FIT.int_value(), x, p.width, p.height)
+                            for x in input_image
+                        ]
+                        input_image = [np.asarray(x)[:, :, 0] for x in input_image]
+                        input_image = np.stack(input_image, axis=2)
+                        logger.debug("A1111 inpaint mask END")
+                    # safe numpy
+                    logger.debug("Safe numpy convertion START")
+                    input_image = np.ascontiguousarray(input_image.copy()).copy()
+                    logger.debug("Safe numpy convertion END")
+                    input_images[idx] = input_image
+                if 'inpaint_only' == unit.module and issubclass(type(p), StableDiffusionProcessingImg2Img) and p.image_mask is not None:
+                    logger.warning('A1111 inpaint and ControlNet inpaint duplicated. ControlNet support enabled.')
+                    unit.module = 'inpaint'
+                logger.info(f"Loading preprocessor: {unit.module}")
+                preprocessor = self.preprocessor[unit.module]
+                high_res_fix = isinstance(p, StableDiffusionProcessingTxt2Img) and getattr(p, 'enable_hr', False)
+                h = (p.height // 8) * 8
+                w = (p.width // 8) * 8
+                if high_res_fix:
+                    if p.hr_resize_x == 0 and p.hr_resize_y == 0:
+                        hr_y = int(p.height * p.hr_scale)
+                        hr_x = int(p.width * p.hr_scale)
+                    else:
+                        hr_y, hr_x = p.hr_resize_y, p.hr_resize_x
+                    hr_y = (hr_y // 8) * 8
+                    hr_x = (hr_x // 8) * 8
+                else:
+                    hr_y = h
+                    hr_x = w
+                if unit.module == 'inpaint_only+lama' and resize_mode == external_code.ResizeMode.OUTER_FIT:
+                    # inpaint_only+lama is special and required outpaint fix
+                    for idx, input_image in enumerate(input_images):
+                        _, input_image = cn_script.detectmap_proc(input_image, unit.module, resize_mode, hr_y, hr_x)
+                        input_images[idx] = input_image
+                control_model_type = ControlModelType.ControlNet
+                global_average_pooling = False
+                if 'reference' in unit.module:
+                    control_model_type = ControlModelType.AttentionInjection
+                elif 'revision' in unit.module:
+                    control_model_type = ControlModelType.ReVision
+                elif hasattr(model_net, 'control_model') and (isinstance(model_net.control_model, Adapter) or isinstance(model_net.control_model, Adapter_light)):
+                    control_model_type = ControlModelType.T2I_Adapter
+                elif hasattr(model_net, 'control_model') and isinstance(model_net.control_model, StyleAdapter):
+                    control_model_type = ControlModelType.T2I_StyleAdapter
+                elif isinstance(model_net, PlugableIPAdapter):
+                    control_model_type = ControlModelType.IPAdapter
+                elif isinstance(model_net, PlugableControlLLLite):
+                    control_model_type = ControlModelType.Controlllite
+                if control_model_type is ControlModelType.ControlNet:
+                    global_average_pooling = model_net.control_model.global_average_pooling
+                preprocessor_resolution = unit.processor_res
+                if unit.pixel_perfect:
+                    preprocessor_resolution = external_code.pixel_perfect_resolution(
+                        input_images[0],
+                        target_H=h,
+                        target_W=w,
+                        resize_mode=resize_mode
+                    )
+                logger.info(f'preprocessor resolution = {preprocessor_resolution}')
+                # Preprocessor result may depend on numpy random operations, use the
+                # random seed in `StableDiffusionProcessing` to make the
+                # preprocessor result reproducable.
+                # Currently following preprocessors use numpy random:
+                # - shuffle
+                seed = set_numpy_seed(p)
+                logger.debug(f"Use numpy seed {seed}.")
+                controls = []
+                hr_controls = []
+                controls_ipadapter = {'hidden_states': [], 'image_embeds': []}
+                hr_controls_ipadapter = {'hidden_states': [], 'image_embeds': []}
+                for idx, input_image in tqdm(enumerate(input_images), total=len(input_images)):
+                    detected_map, is_image = preprocessor(
+                        input_image,
+                        res=preprocessor_resolution,
+                        thr_a=unit.threshold_a,
+                        thr_b=unit.threshold_b,
+                    )
+                    if high_res_fix:
+                        if is_image:
+                            hr_control, hr_detected_map = cn_script.detectmap_proc(detected_map, unit.module, resize_mode, hr_y, hr_x)
+                            detected_maps.append((hr_detected_map, unit.module))
+                        else:
+                            hr_control = detected_map
+                    else:
+                        hr_control = None
+                    if is_image:
+                        control, detected_map = cn_script.detectmap_proc(detected_map, unit.module, resize_mode, h, w)
+                        detected_maps.append((detected_map, unit.module))
+                    else:
+                        control = detected_map
+                        detected_maps.append((input_image, unit.module))
+                    if control_model_type == ControlModelType.T2I_StyleAdapter:
+                        control = control['last_hidden_state']
+                    if control_model_type == ControlModelType.ReVision:
+                        control = control['image_embeds']
+                    if control_model_type == ControlModelType.IPAdapter:
+                        if model_net.is_plus:
+                            controls_ipadapter['hidden_states'].append(control['hidden_states'][-2].cpu())
+                        else:
+                            controls_ipadapter['image_embeds'].append(control['image_embeds'].cpu())
+                        if hr_control is not None:
+                            if model_net.is_plus:
+                                hr_controls_ipadapter['hidden_states'].append(hr_control['hidden_states'][-2].cpu())
+                            else:
+                                hr_controls_ipadapter['image_embeds'].append(hr_control['image_embeds'].cpu())
+                        else:
+                            hr_controls_ipadapter = None
+                            hr_controls = None
+                    else:
+                        controls.append(control.cpu())
+                        if hr_control is not None:
+                            hr_controls.append(hr_control.cpu())
+                        else:
+                            hr_controls = None
+                if control_model_type == ControlModelType.IPAdapter:
+                    ipadapter_key = 'hidden_states' if model_net.is_plus else 'image_embeds'
+                    controls = {ipadapter_key: torch.cat(controls_ipadapter[ipadapter_key], dim=0)}
+                    if controls[ipadapter_key].shape[0] > 1:
+                        controls[ipadapter_key] = torch.cat([controls[ipadapter_key], controls[ipadapter_key]], dim=0)
+                    if model_net.is_plus:
+                        controls[ipadapter_key] = [controls[ipadapter_key], None]
+                    if hr_controls_ipadapter is not None:
+                        hr_controls = {ipadapter_key: torch.cat(hr_controls_ipadapter[ipadapter_key], dim=0)}
+                        if hr_controls[ipadapter_key].shape[0] > 1:
+                            hr_controls[ipadapter_key] = torch.cat([hr_controls[ipadapter_key], hr_controls[ipadapter_key]], dim=0)
+                        if model_net.is_plus:
+                            hr_controls[ipadapter_key] = [hr_controls[ipadapter_key], None]
+                else:
+                    controls = torch.cat(controls, dim=0)
+                    if controls.shape[0] > 1:
+                        controls = torch.cat([controls, controls], dim=0)
+                    if hr_controls is not None:
+                        hr_controls = torch.cat(hr_controls, dim=0)
+                        if hr_controls.shape[0] > 1:
+                            hr_controls = torch.cat([hr_controls, hr_controls], dim=0)
+                preprocessor_dict = dict(
+                    name=unit.module,
+                    preprocessor_resolution=preprocessor_resolution,
+                    threshold_a=unit.threshold_a,
+                    threshold_b=unit.threshold_b
+                )
+                forward_param = ControlParams(
+                    control_model=model_net,
+                    preprocessor=preprocessor_dict,
+                    hint_cond=controls,
+                    weight=unit.weight,
+                    guidance_stopped=False,
+                    start_guidance_percent=unit.guidance_start,
+                    stop_guidance_percent=unit.guidance_end,
+                    advanced_weighting=None,
+                    control_model_type=control_model_type,
+                    global_average_pooling=global_average_pooling,
+                    hr_hint_cond=hr_controls,
+                    soft_injection=control_mode != external_code.ControlMode.BALANCED,
+                    cfg_injection=control_mode == external_code.ControlMode.CONTROL,
+                )
+                forward_params.append(forward_param)
+                unit_is_batch = getattr(unit, 'input_mode', InputMode.SIMPLE) == InputMode.BATCH
+                if 'inpaint_only' in unit.module:
+                    final_inpaint_raws = []
+                    final_inpaint_masks = []
+                    for i in range(len(controls)):
+                        final_inpaint_feed = hr_controls[i] if hr_controls is not None else controls[i]
+                        final_inpaint_feed = final_inpaint_feed.detach().cpu().numpy()
+                        final_inpaint_feed = np.ascontiguousarray(final_inpaint_feed).copy()
+                        final_inpaint_mask = final_inpaint_feed[0, 3, :, :].astype(np.float32)
+                        final_inpaint_raw = final_inpaint_feed[0, :3].astype(np.float32)
+                        sigma = shared.opts.data.get("control_net_inpaint_blur_sigma", 7)
+                        final_inpaint_mask = cv2.dilate(final_inpaint_mask, np.ones((sigma, sigma), dtype=np.uint8))
+                        final_inpaint_mask = cv2.blur(final_inpaint_mask, (sigma, sigma))[None]
+                        _, Hmask, Wmask = final_inpaint_mask.shape
+                        final_inpaint_raw = torch.from_numpy(np.ascontiguousarray(final_inpaint_raw).copy())
+                        final_inpaint_mask = torch.from_numpy(np.ascontiguousarray(final_inpaint_mask).copy())
+                        final_inpaint_raws.append(final_inpaint_raw)
+                        final_inpaint_masks.append(final_inpaint_mask)
+                    def inpaint_only_post_processing(x, i):
+                        _, H, W = x.shape
+                        if Hmask != H or Wmask != W:
+                            logger.error('Error: ControlNet find post-processing resolution mismatch. This could be related to other extensions hacked processing.')
+                            return x
+                        idx = i if unit_is_batch else 0
+                        r = final_inpaint_raw[idx].to(x.dtype).to(x.device)
+                        m = final_inpaint_mask[idx].to(x.dtype).to(x.device)
+                        y = m * x.clip(0, 1) + (1 - m) * r
+                        y = y.clip(0, 1)
+                        return y
+                    post_processors.append(inpaint_only_post_processing)
+                if 'recolor' in unit.module:
+                    final_feeds = []
+                    for i in range(len(controls)):
+                        final_feed = hr_control if hr_control is not None else control
+                        final_feed = final_feed.detach().cpu().numpy()
+                        final_feed = np.ascontiguousarray(final_feed).copy()
+                        final_feed = final_feed[0, 0, :, :].astype(np.float32)
+                        final_feed = (final_feed * 255).clip(0, 255).astype(np.uint8)
+                        Hfeed, Wfeed = final_feed.shape
+                        final_feeds.append(final_feed)
+                    if 'luminance' in unit.module:
+                        def recolor_luminance_post_processing(x, i):
+                            C, H, W = x.shape
+                            if Hfeed != H or Wfeed != W or C != 3:
+                                logger.error('Error: ControlNet find post-processing resolution mismatch. This could be related to other extensions hacked processing.')
+                                return x
+                            h = x.detach().cpu().numpy().transpose((1, 2, 0))
+                            h = (h * 255).clip(0, 255).astype(np.uint8)
+                            h = cv2.cvtColor(h, cv2.COLOR_RGB2LAB)
+                            h[:, :, 0] = final_feed[i if unit_is_batch else 0]
+                            h = cv2.cvtColor(h, cv2.COLOR_LAB2RGB)
+                            h = (h.astype(np.float32) / 255.0).transpose((2, 0, 1))
+                            y = torch.from_numpy(h).clip(0, 1).to(x)
+                            return y
+                        post_processors.append(recolor_luminance_post_processing)
+                    if 'intensity' in unit.module:
+                        def recolor_intensity_post_processing(x, i):
+                            C, H, W = x.shape
+                            if Hfeed != H or Wfeed != W or C != 3:
+                                logger.error('Error: ControlNet find post-processing resolution mismatch. This could be related to other extensions hacked processing.')
+                                return x
+                            h = x.detach().cpu().numpy().transpose((1, 2, 0))
+                            h = (h * 255).clip(0, 255).astype(np.uint8)
+                            h = cv2.cvtColor(h, cv2.COLOR_RGB2HSV)
+                            h[:, :, 2] = final_feed[i if unit_is_batch else 0]
+                            h = cv2.cvtColor(h, cv2.COLOR_HSV2RGB)
+                            h = (h.astype(np.float32) / 255.0).transpose((2, 0, 1))
+                            y = torch.from_numpy(h).clip(0, 1).to(x)
+                            return y
+                        post_processors.append(recolor_intensity_post_processing)
+                if '+lama' in unit.module:
+                    forward_param.used_hint_cond_latent = hook.UnetHook.call_vae_using_process(p, control)
+                    self.noise_modifier = forward_param.used_hint_cond_latent
+                del model_net
+            is_low_vram = any(unit.low_vram for unit in self.enabled_units)
+            self.latest_network = UnetHook(lowvram=is_low_vram)
+            self.latest_network.hook(model=unet, sd_ldm=sd_ldm, control_params=forward_params, process=p)
+            for param in forward_params:
+                if param.control_model_type == ControlModelType.IPAdapter:
+                    param.control_model.hook(
+                        model=unet,
+                        clip_vision_output=param.hint_cond,
+                        weight=param.weight,
+                        dtype=torch.float32,
+                        start=param.start_guidance_percent,
+                        end=param.stop_guidance_percent
+                    )
+                if param.control_model_type == ControlModelType.Controlllite:
+                    param.control_model.hook(
+                        model=unet,
+                        cond=param.hint_cond,
+                        weight=param.weight,
+                        start=param.start_guidance_percent,
+                        end=param.stop_guidance_percent
+                    )
+            self.detected_map = detected_maps
+            self.post_processors = post_processors
+            if os.path.exists(f'{data_path}/tmp/animatediff-frames/'):
+                shutil.rmtree(f'{data_path}/tmp/animatediff-frames/')
+        def hacked_postprocess_batch(self, p, *args, **kwargs):
+            images = kwargs.get('images', [])
+            for post_processor in self.post_processors:
+                for i in range(len(images)):
+                    images[i] = post_processor(images[i], i)
+            return
+        if AnimateDiffControl.original_controlnet_main_entry is not None:
+            logger.info('ControlNet Main Entry already hacked.')
+            return
+        AnimateDiffControl.original_controlnet_main_entry = self.cn_script.controlnet_main_entry
+        AnimateDiffControl.original_postprocess_batch = self.cn_script.postprocess_batch
+        self.cn_script.controlnet_main_entry = MethodType(hacked_main_entry, self.cn_script)
+        self.cn_script.postprocess_batch = MethodType(hacked_postprocess_batch, self.cn_script)
+    def restore_cn(self):
+        if AnimateDiffControl.original_controlnet_main_entry is not None:
+            self.cn_script.controlnet_main_entry = AnimateDiffControl.original_controlnet_main_entry
+            AnimateDiffControl.original_controlnet_main_entry = None
+        if AnimateDiffControl.original_postprocess_batch is not None:
+            self.cn_script.postprocess_batch = AnimateDiffControl.original_postprocess_batch
+            AnimateDiffControl.original_postprocess_batch = None
+    def hack(self, params: AnimateDiffProcess):
+        if self.cn_script is not None:
+            logger.info(f"Hacking ControlNet.")
+            self.hack_batchhijack(params)
+            self.hack_cn()
+    def restore(self):
+        if self.cn_script is not None:
+            logger.info(f"Restoring ControlNet.")
+            self.restore_batchhijack()
+            self.restore_cn()

extensions/sd-webui-animatediff/scripts/animatediff_i2ibatch.py ADDED Viewed

	@@ -0,0 +1,309 @@

+from pathlib import Path
+from types import MethodType
+import os
+import cv2
+import numpy as np
+import torch
+import hashlib
+from PIL import Image, ImageOps, UnidentifiedImageError
+from modules import processing, shared, scripts, img2img, devices, masking, sd_samplers, images
+from modules.processing import (StableDiffusionProcessingImg2Img,
+                                process_images,
+                                create_binary_mask,
+                                create_random_tensors,
+                                images_tensor_to_samples,
+                                setup_color_correction,
+                                opt_f)
+from modules.shared import opts
+from modules.sd_samplers_common import images_tensor_to_samples, approximation_indexes
+from scripts.animatediff_logger import logger_animatediff as logger
+class AnimateDiffI2IBatch:
+    original_img2img_process_batch = None
+    def hack(self):
+        # TODO: PR this hack to A1111
+        if AnimateDiffI2IBatch.original_img2img_process_batch is not None:
+            logger.info("Hacking i2i-batch is already done.")
+            return
+        logger.info("Hacking i2i-batch.")
+        AnimateDiffI2IBatch.original_img2img_process_batch = img2img.process_batch
+        original_img2img_process_batch = AnimateDiffI2IBatch.original_img2img_process_batch
+        def hacked_i2i_init(self, all_prompts, all_seeds, all_subseeds): # only hack this when i2i-batch with batch mask
+            self.image_cfg_scale: float = self.image_cfg_scale if shared.sd_model.cond_stage_key == "edit" else None
+            self.sampler = sd_samplers.create_sampler(self.sampler_name, self.sd_model)
+            crop_regions = []
+            paste_to = []
+            masks_for_overlay = []
+            image_masks = self.image_mask
+            for idx, image_mask in enumerate(image_masks):
+                # image_mask is passed in as RGBA by Gradio to support alpha masks,
+                # but we still want to support binary masks.
+                image_mask = create_binary_mask(image_mask)
+                if self.inpainting_mask_invert:
+                    image_mask = ImageOps.invert(image_mask)
+                if self.mask_blur_x > 0:
+                    np_mask = np.array(image_mask)
+                    kernel_size = 2 * int(2.5 * self.mask_blur_x + 0.5) + 1
+                    np_mask = cv2.GaussianBlur(np_mask, (kernel_size, 1), self.mask_blur_x)
+                    image_mask = Image.fromarray(np_mask)
+                if self.mask_blur_y > 0:
+                    np_mask = np.array(image_mask)
+                    kernel_size = 2 * int(2.5 * self.mask_blur_y + 0.5) + 1
+                    np_mask = cv2.GaussianBlur(np_mask, (1, kernel_size), self.mask_blur_y)
+                    image_mask = Image.fromarray(np_mask)
+                if self.inpaint_full_res:
+                    masks_for_overlay.append(image_mask)
+                    mask = image_mask.convert('L')
+                    crop_region = masking.get_crop_region(np.array(mask), self.inpaint_full_res_padding)
+                    crop_region = masking.expand_crop_region(crop_region, self.width, self.height, mask.width, mask.height)
+                    crop_regions.append(crop_region)
+                    x1, y1, x2, y2 = crop_region
+                    mask = mask.crop(crop_region)
+                    image_mask = images.resize_image(2, mask, self.width, self.height)
+                    paste_to.append((x1, y1, x2-x1, y2-y1))
+                else:
+                    image_mask = images.resize_image(self.resize_mode, image_mask, self.width, self.height)
+                    np_mask = np.array(image_mask)
+                    np_mask = np.clip((np_mask.astype(np.float32)) * 2, 0, 255).astype(np.uint8)
+                    masks_for_overlay.append(Image.fromarray(np_mask))
+                image_masks[idx] = image_mask
+            self.mask_for_overlay = masks_for_overlay[0] # only for saving purpose
+            if paste_to:
+                self.paste_to = paste_to[0]
+                self._animatediff_paste_to_full = paste_to
+            self.overlay_images = []
+            add_color_corrections = opts.img2img_color_correction and self.color_corrections is None
+            if add_color_corrections:
+                self.color_corrections = []
+            imgs = []
+            for idx, img in enumerate(self.init_images):
+                latent_mask = (self.latent_mask[idx] if isinstance(self.latent_mask, list) else self.latent_mask) if self.latent_mask is not None else image_masks[idx]
+                # Save init image
+                if opts.save_init_img:
+                    self.init_img_hash = hashlib.md5(img.tobytes()).hexdigest()
+                    images.save_image(img, path=opts.outdir_init_images, basename=None, forced_filename=self.init_img_hash, save_to_dirs=False)
+                image = images.flatten(img, opts.img2img_background_color)
+                if not crop_regions and self.resize_mode != 3:
+                    image = images.resize_image(self.resize_mode, image, self.width, self.height)
+                if image_masks:
+                    image_masked = Image.new('RGBa', (image.width, image.height))
+                    image_masked.paste(image.convert("RGBA").convert("RGBa"), mask=ImageOps.invert(masks_for_overlay[idx].convert('L')))
+                    self.overlay_images.append(image_masked.convert('RGBA'))
+                # crop_region is not None if we are doing inpaint full res
+                if crop_regions:
+                    image = image.crop(crop_regions[idx])
+                    image = images.resize_image(2, image, self.width, self.height)
+                if image_masks:
+                    if self.inpainting_fill != 1:
+                        image = masking.fill(image, latent_mask)
+                if add_color_corrections:
+                    self.color_corrections.append(setup_color_correction(image))
+                image = np.array(image).astype(np.float32) / 255.0
+                image = np.moveaxis(image, 2, 0)
+                imgs.append(image)
+            if len(imgs) == 1:
+                batch_images = np.expand_dims(imgs[0], axis=0).repeat(self.batch_size, axis=0)
+                if self.overlay_images is not None:
+                    self.overlay_images = self.overlay_images * self.batch_size
+                if self.color_corrections is not None and len(self.color_corrections) == 1:
+                    self.color_corrections = self.color_corrections * self.batch_size
+            elif len(imgs) <= self.batch_size:
+                self.batch_size = len(imgs)
+                batch_images = np.array(imgs)
+            else:
+                raise RuntimeError(f"bad number of images passed: {len(imgs)}; expecting {self.batch_size} or less")
+            image = torch.from_numpy(batch_images)
+            image = image.to(shared.device, dtype=devices.dtype_vae)
+            if opts.sd_vae_encode_method != 'Full':
+                self.extra_generation_params['VAE Encoder'] = opts.sd_vae_encode_method
+            self.init_latent = images_tensor_to_samples(image, approximation_indexes.get(opts.sd_vae_encode_method), self.sd_model)
+            devices.torch_gc()
+            if self.resize_mode == 3:
+                self.init_latent = torch.nn.functional.interpolate(self.init_latent, size=(self.height // opt_f, self.width // opt_f), mode="bilinear")
+            if image_masks is not None:
+                def process_letmask(init_mask):
+                    # init_mask = latent_mask
+                    latmask = init_mask.convert('RGB').resize((self.init_latent.shape[3], self.init_latent.shape[2]))
+                    latmask = np.moveaxis(np.array(latmask, dtype=np.float32), 2, 0) / 255
+                    latmask = latmask[0]
+                    latmask = np.around(latmask)
+                    return np.tile(latmask[None], (4, 1, 1))
+                if self.latent_mask is not None and not isinstance(self.latent_mask, list):
+                    latmask = process_letmask(self.latent_mask)
+                else:
+                    if isinstance(self.latent_mask, list):
+                        latmask = [process_letmask(x) for x in self.latent_mask]
+                    else:
+                        latmask = [process_letmask(x) for x in image_masks]
+                    latmask = np.stack(latmask, axis=0)
+                self.mask = torch.asarray(1.0 - latmask).to(shared.device).type(self.sd_model.dtype)
+                self.nmask = torch.asarray(latmask).to(shared.device).type(self.sd_model.dtype)
+                # this needs to be fixed to be done in sample() using actual seeds for batches
+                if self.inpainting_fill == 2:
+                    self.init_latent = self.init_latent * self.mask + create_random_tensors(self.init_latent.shape[1:], all_seeds[0:self.init_latent.shape[0]]) * self.nmask
+                elif self.inpainting_fill == 3:
+                    self.init_latent = self.init_latent * self.mask
+            self.image_conditioning = self.img2img_image_conditioning(image * 2 - 1, self.init_latent, image_masks) # let's ignore this image_masks which is related to inpaint model with different arch
+        def hacked_img2img_process_batch_hijack(
+                p: StableDiffusionProcessingImg2Img, input_dir: str, output_dir: str, inpaint_mask_dir: str,
+                args, to_scale=False, scale_by=1.0, use_png_info=False, png_info_props=None, png_info_dir=None):
+            if p.scripts:
+                for script in p.scripts.alwayson_scripts:
+                    if script.title().lower() == "animatediff":
+                        ad_arg = p.script_args[script.args_from]
+                        ad_enabled = ad_arg.get('enable', False) if isinstance(ad_arg, dict) else getattr(ad_arg, 'enable', False)
+                        if ad_enabled:
+                            p._animatediff_i2i_batch = 1 # i2i-batch mode, ordinary
+            if not hasattr(p, '_animatediff_i2i_batch'):
+                return original_img2img_process_batch(p, input_dir, output_dir, inpaint_mask_dir, args, to_scale, scale_by, use_png_info, png_info_props, png_info_dir)
+            output_dir = output_dir.strip()
+            processing.fix_seed(p)
+            images = list(shared.walk_files(input_dir, allowed_extensions=(".png", ".jpg", ".jpeg", ".webp", ".tif", ".tiff")))
+            is_inpaint_batch = False
+            if inpaint_mask_dir:
+                inpaint_masks = shared.listfiles(inpaint_mask_dir)
+                is_inpaint_batch = bool(inpaint_masks)
+                if is_inpaint_batch:
+                    assert len(inpaint_masks) == 1 or len(inpaint_masks) == len(images), 'The number of masks must be 1 or equal to the number of images.'
+                    logger.info(f"\n[i2i batch] Inpaint batch is enabled. {len(inpaint_masks)} masks found.")
+                    if len(inpaint_masks) > 1: # batch mask
+                        p.init = MethodType(hacked_i2i_init, p)
+            logger.info(f"[i2i batch] Will process {len(images)} images, creating {p.n_iter} new videos.")
+            # extract "default" params to use in case getting png info fails
+            prompt = p.prompt
+            negative_prompt = p.negative_prompt
+            seed = p.seed
+            cfg_scale = p.cfg_scale
+            sampler_name = p.sampler_name
+            steps = p.steps
+            frame_images = []
+            frame_masks = []
+            for i, image in enumerate(images):
+                try:
+                    img = Image.open(image)
+                except UnidentifiedImageError as e:
+                    print(e)
+                    continue
+                # Use the EXIF orientation of photos taken by smartphones.
+                img = ImageOps.exif_transpose(img)
+                if to_scale:
+                    p.width = int(img.width * scale_by)
+                    p.height = int(img.height * scale_by)
+                frame_images.append(img)
+                image_path = Path(image)
+                if is_inpaint_batch:
+                    if len(inpaint_masks) == 1:
+                        mask_image_path = inpaint_masks[0]
+                        p.image_mask = Image.open(mask_image_path)
+                    else:
+                        # try to find corresponding mask for an image using index matching
+                        mask_image_path = inpaint_masks[i]
+                        frame_masks.append(Image.open(mask_image_path))
+                    mask_image = Image.open(mask_image_path)
+                    p.image_mask = mask_image
+            if use_png_info:
+                try:
+                    info_img = frame_images[0]
+                    if png_info_dir:
+                        info_img_path = os.path.join(png_info_dir, os.path.basename(image))
+                        info_img = Image.open(info_img_path)
+                    from modules import images as imgutil
+                    from modules.generation_parameters_copypaste import parse_generation_parameters
+                    geninfo, _ = imgutil.read_info_from_image(info_img)
+                    parsed_parameters = parse_generation_parameters(geninfo)
+                    parsed_parameters = {k: v for k, v in parsed_parameters.items() if k in (png_info_props or {})}
+                except Exception:
+                    parsed_parameters = {}
+                p.prompt = prompt + (" " + parsed_parameters["Prompt"] if "Prompt" in parsed_parameters else "")
+                p.negative_prompt = negative_prompt + (" " + parsed_parameters["Negative prompt"] if "Negative prompt" in parsed_parameters else "")
+                p.seed = int(parsed_parameters.get("Seed", seed))
+                p.cfg_scale = float(parsed_parameters.get("CFG scale", cfg_scale))
+                p.sampler_name = parsed_parameters.get("Sampler", sampler_name)
+                p.steps = int(parsed_parameters.get("Steps", steps))
+            p.init_images = frame_images
+            if len(frame_masks) > 0:
+                p.image_mask = frame_masks
+            proc = scripts.scripts_img2img.run(p, *args) # we should not support this, but just leave it here
+            if proc is None:
+                if output_dir:
+                    p.outpath_samples = output_dir
+                    p.override_settings['save_to_dirs'] = False
+                    if p.n_iter > 1 or p.batch_size > 1:
+                        p.override_settings['samples_filename_pattern'] = f'{image_path.stem}-[generation_number]'
+                    else:
+                        p.override_settings['samples_filename_pattern'] = f'{image_path.stem}'
+                return process_images(p)
+            else:
+                logger.warn("Warning: you are using an unsupported external script. AnimateDiff may not work properly.")
+        img2img.process_batch = hacked_img2img_process_batch_hijack
+    def cap_init_image(self, p: StableDiffusionProcessingImg2Img, params):
+        if params.enable and isinstance(p, StableDiffusionProcessingImg2Img) and hasattr(p, '_animatediff_i2i_batch'):
+            if len(p.init_images) > params.video_length:
+                p.init_images = p.init_images[:params.video_length]
+                if p.image_mask and isinstance(p.image_mask, list) and len(p.image_mask) > params.video_length:
+                    p.image_mask = p.image_mask[:params.video_length]
+            if len(p.init_images) < params.video_length:
+                params.video_length = len(p.init_images)
+            if len(p.init_images) < params.batch_size:
+                params.batch_size = len(p.init_images)
+animatediff_i2ibatch = AnimateDiffI2IBatch()

extensions/sd-webui-animatediff/scripts/animatediff_infotext.py ADDED Viewed

	@@ -0,0 +1,35 @@

+import os
+from modules.paths import data_path
+from modules.processing import StableDiffusionProcessing, StableDiffusionProcessingImg2Img
+from scripts.animatediff_ui import AnimateDiffProcess
+from scripts.animatediff_logger import logger_animatediff as logger
+def update_infotext(p: StableDiffusionProcessing, params: AnimateDiffProcess):
+    if p.extra_generation_params is not None:
+        p.extra_generation_params["AnimateDiff"] = params.get_dict(isinstance(p, StableDiffusionProcessingImg2Img))
+def write_params_txt(info: str):
+    with open(os.path.join(data_path, "params.txt"), "w", encoding="utf8") as file:
+        file.write(info)
+def infotext_pasted(infotext, results):
+    for k, v in results.items():
+        if not k.startswith("AnimateDiff"):
+            continue
+        assert isinstance(v, str), f"Expect string but got {v}."
+        try:
+            for items in v.split(', '):
+                field, value = items.split(': ')
+                results[f"AnimateDiff {field}"] = value
+        except Exception:
+            logger.warn(
+                f"Failed to parse infotext, legacy format infotext is no longer supported:\n{v}"
+            )
+        break

extensions/sd-webui-animatediff/scripts/animatediff_infv2v.py ADDED Viewed

	@@ -0,0 +1,322 @@

+from typing import List
+import numpy as np
+import torch
+from modules import prompt_parser, devices, sd_samplers_common, shared
+from modules.shared import opts, state
+from modules.script_callbacks import CFGDenoiserParams, cfg_denoiser_callback
+from modules.script_callbacks import CFGDenoisedParams, cfg_denoised_callback
+from modules.script_callbacks import AfterCFGCallbackParams, cfg_after_cfg_callback
+from modules.sd_samplers_cfg_denoiser import CFGDenoiser, catenate_conds, subscript_cond, pad_cond
+from scripts.animatediff_logger import logger_animatediff as logger
+from scripts.animatediff_ui import AnimateDiffProcess
+from scripts.animatediff_prompt import AnimateDiffPromptSchedule
+class AnimateDiffInfV2V:
+    cfg_original_forward = None
+    def __init__(self, p, prompt_scheduler: AnimateDiffPromptSchedule):
+        try:
+            from scripts.external_code import find_cn_script
+            self.cn_script = find_cn_script(p.scripts)
+        except:
+            self.cn_script = None
+        self.prompt_scheduler = prompt_scheduler
+    # Returns fraction that has denominator that is a power of 2
+    @staticmethod
+    def ordered_halving(val):
+        # get binary value, padded with 0s for 64 bits
+        bin_str = f"{val:064b}"
+        # flip binary value, padding included
+        bin_flip = bin_str[::-1]
+        # convert binary to int
+        as_int = int(bin_flip, 2)
+        # divide by 1 << 64, equivalent to 2**64, or 18446744073709551616,
+        # or b10000000000000000000000000000000000000000000000000000000000000000 (1 with 64 zero's)
+        final = as_int / (1 << 64)
+        return final
+    # Generator that returns lists of latent indeces to diffuse on
+    @staticmethod
+    def uniform(
+        step: int = ...,
+        video_length: int = 0,
+        batch_size: int = 16,
+        stride: int = 1,
+        overlap: int = 4,
+        loop_setting: str = 'R-P',
+    ):
+        if video_length <= batch_size:
+            yield list(range(batch_size))
+            return
+        closed_loop = (loop_setting == 'A')
+        stride = min(stride, int(np.ceil(np.log2(video_length / batch_size))) + 1)
+        for context_step in 1 << np.arange(stride):
+            pad = int(round(video_length * AnimateDiffInfV2V.ordered_halving(step)))
+            both_close_loop = False
+            for j in range(
+                int(AnimateDiffInfV2V.ordered_halving(step) * context_step) + pad,
+                video_length + pad + (0 if closed_loop else -overlap),
+                (batch_size * context_step - overlap),
+            ):
+                if loop_setting == 'N' and context_step == 1:
+                    current_context = [e % video_length for e in range(j, j + batch_size * context_step, context_step)]
+                    first_context = [e % video_length for e in range(0, batch_size * context_step, context_step)]
+                    last_context = [e % video_length for e in range(video_length - batch_size * context_step, video_length, context_step)]
+                    def get_unsorted_index(lst):
+                        for i in range(1, len(lst)):
+                            if lst[i] < lst[i-1]:
+                                return i
+                        return None
+                    unsorted_index = get_unsorted_index(current_context)
+                    if unsorted_index is None:
+                        yield current_context
+                    elif both_close_loop: # last and this context are close loop
+                        both_close_loop = False
+                        yield first_context
+                    elif unsorted_index < batch_size - overlap: # only this context is close loop
+                        yield last_context
+                        yield first_context
+                    else: # this and next context are close loop
+                        both_close_loop = True
+                        yield last_context
+                else:
+                    yield [e % video_length for e in range(j, j + batch_size * context_step, context_step)]
+    def hack(self, params: AnimateDiffProcess):
+        if AnimateDiffInfV2V.cfg_original_forward is not None:
+            logger.info("CFGDenoiser already hacked")
+            return
+        logger.info(f"Hacking CFGDenoiser forward function.")
+        AnimateDiffInfV2V.cfg_original_forward = CFGDenoiser.forward
+        cn_script = self.cn_script
+        prompt_scheduler = self.prompt_scheduler
+        def mm_cn_select(context: List[int]):
+            # take control images for current context.
+            if cn_script and cn_script.latest_network:
+                from scripts.hook import ControlModelType
+                for control in cn_script.latest_network.control_params:
+                    if control.control_model_type not in [ControlModelType.IPAdapter, ControlModelType.Controlllite]:
+                        if control.hint_cond.shape[0] > len(context):
+                            control.hint_cond_backup = control.hint_cond
+                            control.hint_cond = control.hint_cond[context]
+                        control.hint_cond = control.hint_cond.to(device=devices.get_device_for("controlnet"))
+                        if control.hr_hint_cond is not None:
+                            if control.hr_hint_cond.shape[0] > len(context):
+                                control.hr_hint_cond_backup = control.hr_hint_cond
+                                control.hr_hint_cond = control.hr_hint_cond[context]
+                            control.hr_hint_cond = control.hr_hint_cond.to(device=devices.get_device_for("controlnet"))
+                    # IPAdapter and Controlllite are always on CPU.
+                    elif control.control_model_type == ControlModelType.IPAdapter and control.control_model.image_emb.shape[0] > len(context):
+                        control.control_model.image_emb_backup = control.control_model.image_emb
+                        control.control_model.image_emb = control.control_model.image_emb[context]
+                        control.control_model.uncond_image_emb_backup = control.control_model.uncond_image_emb
+                        control.control_model.uncond_image_emb = control.control_model.uncond_image_emb[context]
+                    elif control.control_model_type == ControlModelType.Controlllite:
+                        for module in control.control_model.modules.values():
+                            if module.cond_image.shape[0] > len(context):
+                                module.cond_image_backup = module.cond_image
+                                module.set_cond_image(module.cond_image[context])
+        def mm_cn_restore(context: List[int]):
+            # restore control images for next context
+            if cn_script and cn_script.latest_network:
+                from scripts.hook import ControlModelType
+                for control in cn_script.latest_network.control_params:
+                    if control.control_model_type not in [ControlModelType.IPAdapter, ControlModelType.Controlllite]:
+                        if getattr(control, "hint_cond_backup", None) is not None:
+                            control.hint_cond_backup[context] = control.hint_cond.to(device="cpu")
+                            control.hint_cond = control.hint_cond_backup
+                        if control.hr_hint_cond is not None and getattr(control, "hr_hint_cond_backup", None) is not None:
+                            control.hr_hint_cond_backup[context] = control.hr_hint_cond.to(device="cpu")
+                            control.hr_hint_cond = control.hr_hint_cond_backup
+                    elif control.control_model_type == ControlModelType.IPAdapter and getattr(control.control_model, "image_emb_backup", None) is not None:
+                        control.control_model.image_emb = control.control_model.image_emb_backup
+                        control.control_model.uncond_image_emb = control.control_model.uncond_image_emb_backup
+                    elif control.control_model_type == ControlModelType.Controlllite:
+                        for module in control.control_model.modules.values():
+                            if getattr(module, "cond_image_backup", None) is not None:
+                                module.set_cond_image(module.cond_image_backup)
+        def mm_sd_forward(self, x_in, sigma_in, cond_in, image_cond_in, make_condition_dict):
+            x_out = torch.zeros_like(x_in)
+            for context in AnimateDiffInfV2V.uniform(self.step, params.video_length, params.batch_size, params.stride, params.overlap, params.closed_loop):
+                if shared.opts.batch_cond_uncond:
+                    _context = context + [c + params.video_length for c in context]
+                else:
+                    _context = context
+                mm_cn_select(_context)
+                out = self.inner_model(
+                    x_in[_context], sigma_in[_context],
+                    cond=make_condition_dict(
+                        cond_in[_context] if not isinstance(cond_in, dict) else {k: v[_context] for k, v in cond_in.items()},
+                        image_cond_in[_context]))
+                x_out = x_out.to(dtype=out.dtype)
+                x_out[_context] = out
+                mm_cn_restore(_context)
+            return x_out
+        def mm_cfg_forward(self, x, sigma, uncond, cond, cond_scale, s_min_uncond, image_cond):
+            if state.interrupted or state.skipped:
+                raise sd_samplers_common.InterruptedException
+            if sd_samplers_common.apply_refiner(self):
+                cond = self.sampler.sampler_extra_args['cond']
+                uncond = self.sampler.sampler_extra_args['uncond']
+            # at self.image_cfg_scale == 1.0 produced results for edit model are the same as with normal sampling,
+            # so is_edit_model is set to False to support AND composition.
+            is_edit_model = shared.sd_model.cond_stage_key == "edit" and self.image_cfg_scale is not None and self.image_cfg_scale != 1.0
+            conds_list, tensor = prompt_parser.reconstruct_multicond_batch(cond, self.step)
+            uncond = prompt_parser.reconstruct_cond_batch(uncond, self.step)
+            assert not is_edit_model or all(len(conds) == 1 for conds in conds_list), "AND is not supported for InstructPix2Pix checkpoint (unless using Image CFG scale = 1.0)"
+            if self.mask_before_denoising and self.mask is not None:
+                x = self.init_latent * self.mask + self.nmask * x
+            batch_size = len(conds_list)
+            repeats = [len(conds_list[i]) for i in range(batch_size)]
+            if shared.sd_model.model.conditioning_key == "crossattn-adm":
+                image_uncond = torch.zeros_like(image_cond) # this should not be supported.
+                make_condition_dict = lambda c_crossattn, c_adm: {"c_crossattn": [c_crossattn], "c_adm": c_adm}
+            else:
+                image_uncond = image_cond
+                if isinstance(uncond, dict):
+                    make_condition_dict = lambda c_crossattn, c_concat: {**c_crossattn, "c_concat": [c_concat]}
+                else:
+                    make_condition_dict = lambda c_crossattn, c_concat: {"c_crossattn": [c_crossattn], "c_concat": [c_concat]}
+            if not is_edit_model:
+                x_in = torch.cat([torch.stack([x[i] for _ in range(n)]) for i, n in enumerate(repeats)] + [x])
+                sigma_in = torch.cat([torch.stack([sigma[i] for _ in range(n)]) for i, n in enumerate(repeats)] + [sigma])
+                image_cond_in = torch.cat([torch.stack([image_cond[i] for _ in range(n)]) for i, n in enumerate(repeats)] + [image_uncond])
+            else:
+                x_in = torch.cat([torch.stack([x[i] for _ in range(n)]) for i, n in enumerate(repeats)] + [x] + [x])
+                sigma_in = torch.cat([torch.stack([sigma[i] for _ in range(n)]) for i, n in enumerate(repeats)] + [sigma] + [sigma])
+                image_cond_in = torch.cat([torch.stack([image_cond[i] for _ in range(n)]) for i, n in enumerate(repeats)] + [image_uncond] + [torch.zeros_like(self.init_latent)])
+            denoiser_params = CFGDenoiserParams(x_in, image_cond_in, sigma_in, state.sampling_step, state.sampling_steps, tensor, uncond)
+            cfg_denoiser_callback(denoiser_params)
+            x_in = denoiser_params.x
+            image_cond_in = denoiser_params.image_cond
+            sigma_in = denoiser_params.sigma
+            tensor = denoiser_params.text_cond
+            uncond = denoiser_params.text_uncond
+            skip_uncond = False
+            # alternating uncond allows for higher thresholds without the quality loss normally expected from raising it
+            if self.step % 2 and s_min_uncond > 0 and sigma[0] < s_min_uncond and not is_edit_model:
+                skip_uncond = True
+                x_in = x_in[:-batch_size]
+                sigma_in = sigma_in[:-batch_size]
+            self.padded_cond_uncond = False
+            if shared.opts.pad_cond_uncond and tensor.shape[1] != uncond.shape[1]:
+                empty = shared.sd_model.cond_stage_model_empty_prompt
+                num_repeats = (tensor.shape[1] - uncond.shape[1]) // empty.shape[1]
+                if num_repeats < 0:
+                    tensor = pad_cond(tensor, -num_repeats, empty)
+                    self.padded_cond_uncond = True
+                elif num_repeats > 0:
+                    uncond = pad_cond(uncond, num_repeats, empty)
+                    self.padded_cond_uncond = True
+            if tensor.shape[1] == uncond.shape[1] or skip_uncond:
+                prompt_closed_loop = (params.video_length > params.batch_size) and (params.closed_loop in ['R+P', 'A']) # hook
+                tensor = prompt_scheduler.multi_cond(tensor, prompt_closed_loop) # hook
+                if is_edit_model:
+                    cond_in = catenate_conds([tensor, uncond, uncond])
+                elif skip_uncond:
+                    cond_in = tensor
+                else:
+                    cond_in = catenate_conds([tensor, uncond])
+                if shared.opts.batch_cond_uncond:
+                    x_out = mm_sd_forward(self, x_in, sigma_in, cond_in, image_cond_in, make_condition_dict) # hook
+                else:
+                    x_out = torch.zeros_like(x_in)
+                    for batch_offset in range(0, x_out.shape[0], batch_size):
+                        a = batch_offset
+                        b = a + batch_size
+                        x_out[a:b] = mm_sd_forward(self, x_in[a:b], sigma_in[a:b], subscript_cond(cond_in, a, b), subscript_cond(image_cond_in, a, b), make_condition_dict) # hook
+            else:
+                x_out = torch.zeros_like(x_in)
+                batch_size = batch_size*2 if shared.opts.batch_cond_uncond else batch_size
+                for batch_offset in range(0, tensor.shape[0], batch_size):
+                    a = batch_offset
+                    b = min(a + batch_size, tensor.shape[0])
+                    if not is_edit_model:
+                        c_crossattn = subscript_cond(tensor, a, b)
+                    else:
+                        c_crossattn = torch.cat([tensor[a:b]], uncond)
+                    x_out[a:b] = self.inner_model(x_in[a:b], sigma_in[a:b], cond=make_condition_dict(c_crossattn, image_cond_in[a:b]))
+                if not skip_uncond:
+                    x_out[-uncond.shape[0]:] = self.inner_model(x_in[-uncond.shape[0]:], sigma_in[-uncond.shape[0]:], cond=make_condition_dict(uncond, image_cond_in[-uncond.shape[0]:]))
+            denoised_image_indexes = [x[0][0] for x in conds_list]
+            if skip_uncond:
+                fake_uncond = torch.cat([x_out[i:i+1] for i in denoised_image_indexes])
+                x_out = torch.cat([x_out, fake_uncond])  # we skipped uncond denoising, so we put cond-denoised image to where the uncond-denoised image should be
+            denoised_params = CFGDenoisedParams(x_out, state.sampling_step, state.sampling_steps, self.inner_model)
+            cfg_denoised_callback(denoised_params)
+            devices.test_for_nans(x_out, "unet")
+            if is_edit_model:
+                denoised = self.combine_denoised_for_edit_model(x_out, cond_scale)
+            elif skip_uncond:
+                denoised = self.combine_denoised(x_out, conds_list, uncond, 1.0)
+            else:
+                denoised = self.combine_denoised(x_out, conds_list, uncond, cond_scale)
+            if not self.mask_before_denoising and self.mask is not None:
+                denoised = self.init_latent * self.mask + self.nmask * denoised
+            self.sampler.last_latent = self.get_pred_x0(torch.cat([x_in[i:i + 1] for i in denoised_image_indexes]), torch.cat([x_out[i:i + 1] for i in denoised_image_indexes]), sigma)
+            if opts.live_preview_content == "Prompt":
+                preview = self.sampler.last_latent
+            elif opts.live_preview_content == "Negative prompt":
+                preview = self.get_pred_x0(x_in[-uncond.shape[0]:], x_out[-uncond.shape[0]:], sigma)
+            else:
+                preview = self.get_pred_x0(torch.cat([x_in[i:i+1] for i in denoised_image_indexes]), torch.cat([denoised[i:i+1] for i in denoised_image_indexes]), sigma)
+            sd_samplers_common.store_latent(preview)
+            after_cfg_callback_params = AfterCFGCallbackParams(denoised, state.sampling_step, state.sampling_steps)
+            cfg_after_cfg_callback(after_cfg_callback_params)
+            denoised = after_cfg_callback_params.x
+            self.step += 1
+            return denoised
+        CFGDenoiser.forward = mm_cfg_forward
+    def restore(self):
+        if AnimateDiffInfV2V.cfg_original_forward is None:
+            logger.info("CFGDenoiser already restored.")
+            return
+        logger.info(f"Restoring CFGDenoiser forward function.")
+        CFGDenoiser.forward = AnimateDiffInfV2V.cfg_original_forward
+        AnimateDiffInfV2V.cfg_original_forward = None

extensions/sd-webui-animatediff/scripts/animatediff_latent.py ADDED Viewed

	@@ -0,0 +1,84 @@

+import numpy as np
+import torch
+from modules import images, shared
+from modules.devices import device, dtype_vae, torch_gc
+from modules.processing import StableDiffusionProcessingImg2Img
+from modules.sd_samplers_common import (approximation_indexes,
+                                        images_tensor_to_samples)
+from scripts.animatediff_logger import logger_animatediff as logger
+from scripts.animatediff_ui import AnimateDiffProcess
+class AnimateDiffI2VLatent:
+    def randomize(
+        self, p: StableDiffusionProcessingImg2Img, params: AnimateDiffProcess
+    ):
+        # Get init_alpha
+        init_alpha = [
+            1 - pow(i, params.latent_power) / params.latent_scale
+            for i in range(params.video_length)
+        ]
+        logger.info(f"Randomizing init_latent according to {init_alpha}.")
+        init_alpha = torch.tensor(init_alpha, dtype=torch.float32, device=device)[
+            :, None, None, None
+        ]
+        init_alpha[init_alpha < 0] = 0
+        if params.last_frame is not None:
+            last_frame = params.last_frame
+            if type(last_frame) == str:
+                from modules.api.api import decode_base64_to_image
+                last_frame = decode_base64_to_image(last_frame)
+            # Get last_alpha
+            last_alpha = [
+                1 - pow(i, params.latent_power_last) / params.latent_scale_last
+                for i in range(params.video_length)
+            ]
+            last_alpha.reverse()
+            logger.info(f"Randomizing last_latent according to {last_alpha}.")
+            last_alpha = torch.tensor(last_alpha, dtype=torch.float32, device=device)[
+                :, None, None, None
+            ]
+            last_alpha[last_alpha < 0] = 0
+            # Normalize alpha
+            sum_alpha = init_alpha + last_alpha
+            mask_alpha = sum_alpha > 1
+            scaling_factor = 1 / sum_alpha[mask_alpha]
+            init_alpha[mask_alpha] *= scaling_factor
+            last_alpha[mask_alpha] *= scaling_factor
+            init_alpha[0] = 1
+            init_alpha[-1] = 0
+            last_alpha[0] = 0
+            last_alpha[-1] = 1
+            # Calculate last_latent
+            if p.resize_mode != 3:
+                last_frame = images.resize_image(
+                    p.resize_mode, last_frame, p.width, p.height
+                )
+                last_frame = np.array(last_frame).astype(np.float32) / 255.0
+                last_frame = np.moveaxis(last_frame, 2, 0)[None, ...]
+            last_frame = torch.from_numpy(last_frame).to(device).to(dtype_vae)
+            last_latent = images_tensor_to_samples(
+                last_frame,
+                approximation_indexes.get(shared.opts.sd_vae_encode_method),
+                p.sd_model,
+            )
+            torch_gc()
+            if p.resize_mode == 3:
+                opt_f = 8
+                last_latent = torch.nn.functional.interpolate(
+                    last_latent,
+                    size=(p.height // opt_f, p.width // opt_f),
+                    mode="bilinear",
+                )
+            # Modify init_latent
+            p.init_latent = (
+                p.init_latent * init_alpha
+                + last_latent * last_alpha
+                + p.rng.next() * (1 - init_alpha - last_alpha)
+            )
+        else:
+            p.init_latent = p.init_latent * init_alpha + p.rng.next() * (1 - init_alpha)

extensions/sd-webui-animatediff/scripts/animatediff_lcm.py ADDED Viewed

	@@ -0,0 +1,137 @@

+# TODO: remove this file when LCM is merged to A1111
+import torch
+from k_diffusion import utils, sampling
+from k_diffusion.external import DiscreteEpsDDPMDenoiser
+from k_diffusion.sampling import default_noise_sampler, trange
+from modules import shared, sd_samplers_cfg_denoiser, sd_samplers_kdiffusion
+from scripts.animatediff_logger import logger_animatediff as logger
+class LCMCompVisDenoiser(DiscreteEpsDDPMDenoiser):
+    def __init__(self, model):
+        timesteps = 1000
+        beta_start = 0.00085
+        beta_end = 0.012
+        betas = torch.linspace(beta_start**0.5, beta_end**0.5, timesteps, dtype=torch.float32) ** 2
+        alphas = 1.0 - betas
+        alphas_cumprod = torch.cumprod(alphas, dim=0)
+        original_timesteps = 50     # LCM Original Timesteps (default=50, for current version of LCM)
+        self.skip_steps = timesteps // original_timesteps
+        alphas_cumprod_valid = torch.zeros((original_timesteps), dtype=torch.float32, device=model.device)
+        for x in range(original_timesteps):
+            alphas_cumprod_valid[original_timesteps - 1 - x] = alphas_cumprod[timesteps - 1 - x * self.skip_steps]
+        super().__init__(model, alphas_cumprod_valid, quantize=None)
+    def get_sigmas(self, n=None, sgm=False):
+        if n is None:
+            return sampling.append_zero(self.sigmas.flip(0))
+        start = self.sigma_to_t(self.sigma_max)
+        end = self.sigma_to_t(self.sigma_min)
+        if sgm:
+            t = torch.linspace(start, end, n + 1, device=shared.sd_model.device)[:-1]
+        else:
+            t = torch.linspace(start, end, n, device=shared.sd_model.device)
+        return sampling.append_zero(self.t_to_sigma(t))
+    def sigma_to_t(self, sigma, quantize=None):
+        log_sigma = sigma.log()
+        dists = log_sigma - self.log_sigmas[:, None]
+        return dists.abs().argmin(dim=0).view(sigma.shape) * self.skip_steps + (self.skip_steps - 1)
+    def t_to_sigma(self, timestep):
+        t = torch.clamp(((timestep - (self.skip_steps - 1)) / self.skip_steps).float(), min=0, max=(len(self.sigmas) - 1))
+        return super().t_to_sigma(t)
+    def get_eps(self, *args, **kwargs):
+        return self.inner_model.apply_model(*args, **kwargs)
+    def get_scaled_out(self, sigma, output, input):
+        sigma_data = 0.5
+        scaled_timestep = utils.append_dims(self.sigma_to_t(sigma), output.ndim) * 10.0
+        c_skip = sigma_data**2 / (scaled_timestep**2 + sigma_data**2)
+        c_out = scaled_timestep / (scaled_timestep**2 + sigma_data**2) ** 0.5
+        return c_out * output + c_skip * input
+    def forward(self, input, sigma, **kwargs):
+        c_out, c_in = [utils.append_dims(x, input.ndim) for x in self.get_scalings(sigma)]
+        eps = self.get_eps(input * c_in, self.sigma_to_t(sigma), **kwargs)
+        return self.get_scaled_out(sigma, input + eps * c_out, input)
+def sample_lcm(model, x, sigmas, extra_args=None, callback=None, disable=None, noise_sampler=None):
+    extra_args = {} if extra_args is None else extra_args
+    noise_sampler = default_noise_sampler(x) if noise_sampler is None else noise_sampler
+    s_in = x.new_ones([x.shape[0]])
+    for i in trange(len(sigmas) - 1, disable=disable):
+        denoised = model(x, sigmas[i] * s_in, **extra_args)
+        if callback is not None:
+            callback({'x': x, 'i': i, 'sigma': sigmas[i], 'sigma_hat': sigmas[i], 'denoised': denoised})
+        x = denoised
+        if sigmas[i + 1] > 0:
+            x += sigmas[i + 1] * noise_sampler(sigmas[i], sigmas[i + 1])
+    return x
+class CFGDenoiserLCM(sd_samplers_cfg_denoiser.CFGDenoiser):
+    @property
+    def inner_model(self):
+        if self.model_wrap is None:
+            denoiser = LCMCompVisDenoiser
+            self.model_wrap = denoiser(shared.sd_model)
+        return self.model_wrap
+class LCMSampler(sd_samplers_kdiffusion.KDiffusionSampler):
+    def __init__(self, funcname, sd_model, options=None):
+        super().__init__(funcname, sd_model, options)
+        self.model_wrap_cfg = CFGDenoiserLCM(self)
+        self.model_wrap = self.model_wrap_cfg.inner_model
+class AnimateDiffLCM:
+    lcm_ui_injected = False
+    @staticmethod
+    def hack_kdiff_ui():
+        if shared.opts.data.get("animatediff_disable_lcm", False):
+            return
+        if AnimateDiffLCM.lcm_ui_injected:
+            logger.info(f"LCM UI already injected.")
+            return
+        logger.info(f"Injecting LCM to UI.")
+        from modules import sd_samplers, sd_samplers_common
+        samplers_lcm = [('LCM', sample_lcm, ['k_lcm'], {})]
+        samplers_data_lcm = [
+            sd_samplers_common.SamplerData(label, lambda model, funcname=funcname: LCMSampler(funcname, model), aliases, options)
+            for label, funcname, aliases, options in samplers_lcm
+        ]
+        sd_samplers.all_samplers.extend(samplers_data_lcm)
+        sd_samplers.all_samplers_map = {x.name: x for x in sd_samplers.all_samplers}
+        sd_samplers.set_samplers()
+        AnimateDiffLCM.lcm_ui_injected = True

extensions/sd-webui-animatediff/scripts/animatediff_logger.py ADDED Viewed

	@@ -0,0 +1,41 @@

+import copy
+import logging
+import sys
+from modules import shared
+class ColoredFormatter(logging.Formatter):
+    COLORS = {
+        "DEBUG": "\033[0;36m",  # CYAN
+        "INFO": "\033[0;32m",  # GREEN
+        "WARNING": "\033[0;33m",  # YELLOW
+        "ERROR": "\033[0;31m",  # RED
+        "CRITICAL": "\033[0;37;41m",  # WHITE ON RED
+        "RESET": "\033[0m",  # RESET COLOR
+    }
+    def format(self, record):
+        colored_record = copy.copy(record)
+        levelname = colored_record.levelname
+        seq = self.COLORS.get(levelname, self.COLORS["RESET"])
+        colored_record.levelname = f"{seq}{levelname}{self.COLORS['RESET']}"
+        return super().format(colored_record)
+# Create a new logger
+logger_animatediff = logging.getLogger("AnimateDiff")
+logger_animatediff.propagate = False
+# Add handler if we don't have one.
+if not logger_animatediff.handlers:
+    handler = logging.StreamHandler(sys.stdout)
+    handler.setFormatter(
+        ColoredFormatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+    )
+    logger_animatediff.addHandler(handler)
+# Configure logger
+loglevel_string = getattr(shared.cmd_opts, "animatediff_loglevel", "INFO")
+loglevel = getattr(logging, loglevel_string.upper(), None)
+logger_animatediff.setLevel(loglevel)

extensions/sd-webui-animatediff/scripts/animatediff_lora.py ADDED Viewed

	@@ -0,0 +1,84 @@

+import os
+import re
+import sys
+from modules import sd_models, shared
+from modules.paths import extensions_builtin_dir
+from scripts.animatediff_logger import logger_animatediff as logger
+sys.path.append(f"{extensions_builtin_dir}/Lora")
+class AnimateDiffLora:
+    original_load_network = None
+    def __init__(self, v2: bool):
+        self.v2 = v2
+    def hack(self):
+        if not self.v2:
+            return
+        if AnimateDiffLora.original_load_network is not None:
+            logger.info("AnimateDiff LoRA already hacked")
+            return
+        logger.info("Hacking LoRA module to support motion LoRA")
+        import network
+        import networks
+        AnimateDiffLora.original_load_network = networks.load_network
+        original_load_network = AnimateDiffLora.original_load_network
+        def mm_load_network(name, network_on_disk):
+            def convert_mm_name_to_compvis(key):
+                sd_module_key, _, network_part = re.split(r'(_lora\.)', key)
+                sd_module_key = sd_module_key.replace("processor.", "").replace("to_out", "to_out.0")
+                return sd_module_key, 'lora_' + network_part
+            net = network.Network(name, network_on_disk)
+            net.mtime = os.path.getmtime(network_on_disk.filename)
+            sd = sd_models.read_state_dict(network_on_disk.filename)
+            if 'motion_modules' in list(sd.keys())[0]:
+                logger.info(f"Loading motion LoRA {name} from {network_on_disk.filename}")
+                matched_networks = {}
+                for key_network, weight in sd.items():
+                    key, network_part = convert_mm_name_to_compvis(key_network)
+                    sd_module = shared.sd_model.network_layer_mapping.get(key, None)
+                    assert sd_module is not None, f"Failed to find sd module for key {key}."
+                    if key not in matched_networks:
+                        matched_networks[key] = network.NetworkWeights(
+                            network_key=key_network, sd_key=key, w={}, sd_module=sd_module)
+                    matched_networks[key].w[network_part] = weight
+                for key, weights in matched_networks.items():
+                    net_module = networks.module_types[0].create_module(net, weights)
+                    assert net_module is not None, "Failed to create motion module LoRA"
+                    net.modules[key] = net_module
+                return net
+            else:
+                del sd
+                return original_load_network(name, network_on_disk)
+        networks.load_network = mm_load_network
+    def restore(self):
+        if not self.v2:
+            return
+        if AnimateDiffLora.original_load_network is None:
+            logger.info("AnimateDiff LoRA already restored")
+            return
+        logger.info("Restoring hacked LoRA")
+        import networks
+        networks.load_network = AnimateDiffLora.original_load_network
+        AnimateDiffLora.original_load_network = None

extensions/sd-webui-animatediff/scripts/animatediff_mm.py ADDED Viewed

	@@ -0,0 +1,204 @@

+import gc
+import os
+import torch
+from einops import rearrange
+from modules import hashes, shared, sd_models, devices
+from modules.devices import cpu, device, torch_gc
+from motion_module import MotionWrapper, MotionModuleType
+from scripts.animatediff_logger import logger_animatediff as logger
+class AnimateDiffMM:
+    mm_injected = False
+    def __init__(self):
+        self.mm: MotionWrapper = None
+        self.script_dir = None
+        self.prev_alpha_cumprod = None
+        self.gn32_original_forward = None
+    def set_script_dir(self, script_dir):
+        self.script_dir = script_dir
+    def get_model_dir(self):
+        model_dir = shared.opts.data.get("animatediff_model_path", os.path.join(self.script_dir, "model"))
+        if not model_dir:
+            model_dir = os.path.join(self.script_dir, "model")
+        return model_dir
+    def _load(self, model_name):
+        model_path = os.path.join(self.get_model_dir(), model_name)
+        if not os.path.isfile(model_path):
+            raise RuntimeError("Please download models manually.")
+        if self.mm is None or self.mm.mm_name != model_name:
+            logger.info(f"Loading motion module {model_name} from {model_path}")
+            model_hash = hashes.sha256(model_path, f"AnimateDiff/{model_name}")
+            mm_state_dict = sd_models.read_state_dict(model_path)
+            model_type = MotionModuleType.get_mm_type(mm_state_dict)
+            logger.info(f"Guessed {model_name} architecture: {model_type}")
+            self.mm = MotionWrapper(model_name, model_hash, model_type)
+            missed_keys = self.mm.load_state_dict(mm_state_dict)
+            logger.warn(f"Missing keys {missed_keys}")
+        self.mm.to(device).eval()
+        if not shared.cmd_opts.no_half:
+            self.mm.half()
+            if getattr(devices, "fp8", False):
+                for module in self.mm.modules():
+                    if isinstance(module, (torch.nn.Conv2d, torch.nn.Linear)):
+                        module.to(torch.float8_e4m3fn)
+    def inject(self, sd_model, model_name="mm_sd_v15.ckpt"):
+        if AnimateDiffMM.mm_injected:
+            logger.info("Motion module already injected. Trying to restore.")
+            self.restore(sd_model)
+        unet = sd_model.model.diffusion_model
+        self._load(model_name)
+        inject_sdxl = sd_model.is_sdxl or self.mm.is_xl
+        sd_ver = "SDXL" if sd_model.is_sdxl else "SD1.5"
+        assert sd_model.is_sdxl == self.mm.is_xl, f"Motion module incompatible with SD. You are using {sd_ver} with {self.mm.mm_type}."
+        if self.mm.is_v2:
+            logger.info(f"Injecting motion module {model_name} into {sd_ver} UNet middle block.")
+            unet.middle_block.insert(-1, self.mm.mid_block.motion_modules[0])
+        elif self.mm.enable_gn_hack():
+            logger.info(f"Hacking {sd_ver} GroupNorm32 forward function.")
+            if self.mm.is_hotshot:
+                from sgm.modules.diffusionmodules.util import GroupNorm32
+            else:
+                from ldm.modules.diffusionmodules.util import GroupNorm32
+            self.gn32_original_forward = GroupNorm32.forward
+            gn32_original_forward = self.gn32_original_forward
+            def groupnorm32_mm_forward(self, x):
+                x = rearrange(x, "(b f) c h w -> b c f h w", b=2)
+                x = gn32_original_forward(self, x)
+                x = rearrange(x, "b c f h w -> (b f) c h w", b=2)
+                return x
+            GroupNorm32.forward = groupnorm32_mm_forward
+        logger.info(f"Injecting motion module {model_name} into {sd_ver} UNet input blocks.")
+        for mm_idx, unet_idx in enumerate([1, 2, 4, 5, 7, 8, 10, 11]):
+            if inject_sdxl and mm_idx >= 6:
+                break
+            mm_idx0, mm_idx1 = mm_idx // 2, mm_idx % 2
+            mm_inject = getattr(self.mm.down_blocks[mm_idx0], "temporal_attentions" if self.mm.is_hotshot else "motion_modules")[mm_idx1]
+            unet.input_blocks[unet_idx].append(mm_inject)
+        logger.info(f"Injecting motion module {model_name} into {sd_ver} UNet output blocks.")
+        for unet_idx in range(12):
+            if inject_sdxl and unet_idx >= 9:
+                break
+            mm_idx0, mm_idx1 = unet_idx // 3, unet_idx % 3
+            mm_inject = getattr(self.mm.up_blocks[mm_idx0], "temporal_attentions" if self.mm.is_hotshot else "motion_modules")[mm_idx1]
+            if unet_idx % 3 == 2 and unet_idx != (8 if self.mm.is_xl else 11):
+                unet.output_blocks[unet_idx].insert(-1, mm_inject)
+            else:
+                unet.output_blocks[unet_idx].append(mm_inject)
+        self._set_ddim_alpha(sd_model)
+        self._set_layer_mapping(sd_model)
+        AnimateDiffMM.mm_injected = True
+        logger.info(f"Injection finished.")
+    def restore(self, sd_model):
+        if not AnimateDiffMM.mm_injected:
+            logger.info("Motion module already removed.")
+            return
+        inject_sdxl = sd_model.is_sdxl or self.mm.is_xl
+        sd_ver = "SDXL" if sd_model.is_sdxl else "SD1.5"
+        self._restore_ddim_alpha(sd_model)
+        unet = sd_model.model.diffusion_model
+        logger.info(f"Removing motion module from {sd_ver} UNet input blocks.")
+        for unet_idx in [1, 2, 4, 5, 7, 8, 10, 11]:
+            if inject_sdxl and unet_idx >= 9:
+                break
+            unet.input_blocks[unet_idx].pop(-1)
+        logger.info(f"Removing motion module from {sd_ver} UNet output blocks.")
+        for unet_idx in range(12):
+            if inject_sdxl and unet_idx >= 9:
+                break
+            if unet_idx % 3 == 2 and unet_idx != (8 if self.mm.is_xl else 11):
+                unet.output_blocks[unet_idx].pop(-2)
+            else:
+                unet.output_blocks[unet_idx].pop(-1)
+        if self.mm.is_v2:
+            logger.info(f"Removing motion module from {sd_ver} UNet middle block.")
+            unet.middle_block.pop(-2)
+        elif self.mm.enable_gn_hack():
+            logger.info(f"Restoring {sd_ver} GroupNorm32 forward function.")
+            if self.mm.is_hotshot:
+                from sgm.modules.diffusionmodules.util import GroupNorm32
+            else:
+                from ldm.modules.diffusionmodules.util import GroupNorm32
+            GroupNorm32.forward = self.gn32_original_forward
+            self.gn32_original_forward = None
+        AnimateDiffMM.mm_injected = False
+        logger.info(f"Removal finished.")
+        if shared.cmd_opts.lowvram:
+            self.unload()
+    def _set_ddim_alpha(self, sd_model):
+        logger.info(f"Setting DDIM alpha.")
+        beta_start = 0.00085
+        beta_end = 0.020 if self.mm.is_adxl else 0.012
+        if self.mm.is_adxl:
+            betas = torch.linspace(beta_start**0.5, beta_end**0.5, 1000, dtype=torch.float32, device=device) ** 2
+        else:
+            betas = torch.linspace(
+                beta_start,
+                beta_end,
+                1000 if sd_model.is_sdxl else sd_model.num_timesteps,
+                dtype=torch.float32,
+                device=device,
+            )
+        alphas = 1.0 - betas
+        alphas_cumprod = torch.cumprod(alphas, dim=0)
+        self.prev_alpha_cumprod = sd_model.alphas_cumprod
+        sd_model.alphas_cumprod = alphas_cumprod
+    def _set_layer_mapping(self, sd_model):
+        if hasattr(sd_model, 'network_layer_mapping'):
+            for name, module in self.mm.named_modules():
+                sd_model.network_layer_mapping[name] = module
+                module.network_layer_name = name
+    def _restore_ddim_alpha(self, sd_model):
+        logger.info(f"Restoring DDIM alpha.")
+        sd_model.alphas_cumprod = self.prev_alpha_cumprod
+        self.prev_alpha_cumprod = None
+    def unload(self):
+        logger.info("Moving motion module to CPU")
+        if self.mm is not None:
+            self.mm.to(cpu)
+        torch_gc()
+        gc.collect()
+    def remove(self):
+        logger.info("Removing motion module from any memory")
+        del self.mm
+        self.mm = None
+        torch_gc()
+        gc.collect()
+mm_animatediff = AnimateDiffMM()

extensions/sd-webui-animatediff/scripts/animatediff_output.py ADDED Viewed

	@@ -0,0 +1,361 @@

+import base64
+import datetime
+from pathlib import Path
+import imageio.v3 as imageio
+import numpy as np
+from PIL import Image, PngImagePlugin
+import PIL.features
+import piexif
+from modules import images, shared
+from modules.processing import Processed, StableDiffusionProcessing
+from scripts.animatediff_logger import logger_animatediff as logger
+from scripts.animatediff_ui import AnimateDiffProcess
+class AnimateDiffOutput:
+    def output(self, p: StableDiffusionProcessing, res: Processed, params: AnimateDiffProcess):
+        video_paths = []
+        logger.info("Merging images into GIF.")
+        date = datetime.datetime.now().strftime('%Y-%m-%d')
+        output_dir = Path(f"{p.outpath_samples}/AnimateDiff/{date}")
+        output_dir.mkdir(parents=True, exist_ok=True)
+        step = params.video_length if params.video_length > params.batch_size else params.batch_size
+        for i in range(res.index_of_first_image, len(res.images), step):
+            # frame interpolation replaces video_list with interpolated frames
+            # so make a copy instead of a slice (reference), to avoid modifying res
+            frame_list = [image.copy() for image in res.images[i : i + params.video_length]]
+            seq = images.get_next_sequence_number(output_dir, "")
+            filename_suffix = f"-{params.request_id}" if params.request_id else ""
+            filename = f"{seq:05}-{res.all_seeds[(i-res.index_of_first_image)]}{filename_suffix}"
+            video_path_prefix = output_dir / filename
+            frame_list = self._add_reverse(params, frame_list)
+            frame_list = self._interp(p, params, frame_list, filename)
+            video_paths += self._save(params, frame_list, video_path_prefix, res, i)
+        if len(video_paths) == 0:
+            return
+        res.images = video_paths if not p.is_api else (self._encode_video_to_b64(video_paths) + (frame_list if 'Frame' in params.format else []))
+    def _add_reverse(self, params: AnimateDiffProcess, frame_list: list):
+        if params.video_length <= params.batch_size and params.closed_loop in ['A']:
+            frame_list_reverse = frame_list[::-1]
+            if len(frame_list_reverse) > 0:
+                frame_list_reverse.pop(0)
+            if len(frame_list_reverse) > 0:
+                frame_list_reverse.pop(-1)
+            return frame_list + frame_list_reverse
+        return frame_list
+    def _interp(
+        self,
+        p: StableDiffusionProcessing,
+        params: AnimateDiffProcess,
+        frame_list: list,
+        filename: str
+    ):
+        if params.interp not in ['FILM']:
+            return frame_list
+        try:
+            from deforum_helpers.frame_interpolation import (
+                calculate_frames_to_add, check_and_download_film_model)
+            from film_interpolation.film_inference import run_film_interp_infer
+        except ImportError:
+            logger.error("Deforum not found. Please install: https://github.com/deforum-art/deforum-for-automatic1111-webui.git")
+            return frame_list
+        import glob
+        import os
+        import shutil
+        import modules.paths as ph
+        # load film model
+        deforum_models_path = ph.models_path + '/Deforum'
+        film_model_folder = os.path.join(deforum_models_path,'film_interpolation')
+        film_model_name = 'film_net_fp16.pt'
+        film_model_path = os.path.join(film_model_folder, film_model_name)
+        check_and_download_film_model('film_net_fp16.pt', film_model_folder)
+        film_in_between_frames_count = calculate_frames_to_add(len(frame_list), params.interp_x)
+        # save original frames to tmp folder for deforum input
+        tmp_folder = f"{p.outpath_samples}/AnimateDiff/tmp"
+        input_folder = f"{tmp_folder}/input"
+        os.makedirs(input_folder, exist_ok=True)
+        for tmp_seq, frame in enumerate(frame_list):
+            imageio.imwrite(f"{input_folder}/{tmp_seq:05}.png", frame)
+        # deforum saves output frames to tmp/{filename}
+        save_folder = f"{tmp_folder}/{filename}"
+        os.makedirs(save_folder, exist_ok=True)
+        run_film_interp_infer(
+            model_path = film_model_path,
+            input_folder = input_folder,
+            save_folder = save_folder,
+            inter_frames = film_in_between_frames_count)
+        # load deforum output frames and replace video_list
+        interp_frame_paths = sorted(glob.glob(os.path.join(save_folder, '*.png')))
+        frame_list = []
+        for f in interp_frame_paths:
+            with Image.open(f) as img:
+                img.load()
+                frame_list.append(img)
+        # if saving PNG, enforce saving to custom folder
+        if "PNG" in params.format:
+            params.force_save_to_custom = True
+        # remove tmp folder
+        try: shutil.rmtree(tmp_folder)
+        except OSError as e: print(f"Error: {e}")
+        return frame_list
+    def _save(
+        self,
+        params: AnimateDiffProcess,
+        frame_list: list,
+        video_path_prefix: Path,
+        res: Processed,
+        index: int,
+    ):
+        video_paths = []
+        video_array = [np.array(v) for v in frame_list]
+        infotext = res.infotexts[index]
+        s3_enable =shared.opts.data.get("animatediff_s3_enable", False)
+        use_infotext = shared.opts.enable_pnginfo and infotext is not None
+        if "PNG" in params.format and (shared.opts.data.get("animatediff_save_to_custom", False) or getattr(params, "force_save_to_custom", False)):
+            video_path_prefix.mkdir(exist_ok=True, parents=True)
+            for i, frame in enumerate(frame_list):
+                png_filename = video_path_prefix/f"{i:05}.png"
+                png_info = PngImagePlugin.PngInfo()
+                png_info.add_text('parameters', infotext)
+                imageio.imwrite(png_filename, frame, pnginfo=png_info)
+        if "GIF" in params.format:
+            video_path_gif = str(video_path_prefix) + ".gif"
+            video_paths.append(video_path_gif)
+            if shared.opts.data.get("animatediff_optimize_gif_palette", False):
+                try:
+                    import av
+                except ImportError:
+                    from launch import run_pip
+                    run_pip(
+                        "install imageio[pyav]",
+                        "sd-webui-animatediff GIF palette optimization requirement: imageio[pyav]",
+                    )
+                imageio.imwrite(
+                    video_path_gif, video_array, plugin='pyav', fps=params.fps,
+                    codec='gif', out_pixel_format='pal8',
+                    filter_graph=(
+                        {
+                            "split": ("split", ""),
+                            "palgen": ("palettegen", ""),
+                            "paluse": ("paletteuse", ""),
+                            "scale": ("scale", f"{frame_list[0].width}:{frame_list[0].height}")
+                        },
+                        [
+                            ("video_in", "scale", 0, 0),
+                            ("scale", "split", 0, 0),
+                            ("split", "palgen", 1, 0),
+                            ("split", "paluse", 0, 0),
+                            ("palgen", "paluse", 0, 1),
+                            ("paluse", "video_out", 0, 0),
+                        ]
+                    )
+                )
+                # imageio[pyav].imwrite doesn't support comment parameter
+                if use_infotext:
+                    try:
+                        import exiftool
+                    except ImportError:
+                        from launch import run_pip
+                        run_pip(
+                            "install PyExifTool",
+                            "sd-webui-animatediff GIF palette optimization requirement: PyExifTool",
+                        )
+                        import exiftool
+                    finally:
+                        try:
+                            exif_tool = exiftool.ExifTool()
+                            with exif_tool:
+                                escaped_infotext = infotext.replace('\n', r'\n')
+                                exif_tool.execute("-overwrite_original", f"-Comment={escaped_infotext}", video_path_gif)
+                        except FileNotFoundError:
+                            logger.warn(
+                                "exiftool not found, required for infotext with optimized GIF palette, try: apt install libimage-exiftool-perl or https://exiftool.org/"
+                            )
+            else:
+                imageio.imwrite(
+                    video_path_gif,
+                    video_array,
+                    plugin='pillow',
+                    duration=(1000 / params.fps),
+                    loop=params.loop_number,
+                    comment=(infotext if use_infotext else "")
+                )
+            if shared.opts.data.get("animatediff_optimize_gif_gifsicle", False):
+                self._optimize_gif(video_path_gif)
+        if "MP4" in params.format:
+            video_path_mp4 = str(video_path_prefix) + ".mp4"
+            video_paths.append(video_path_mp4)
+            try:
+                import av
+            except ImportError:
+                from launch import run_pip
+                run_pip(
+                    "install pyav",
+                    "sd-webui-animatediff MP4 save requirement: PyAV",
+                )
+                import av
+            options = {
+                "crf": str(shared.opts.data.get("animatediff_mp4_crf", 23))
+            }
+            preset = shared.opts.data.get("animatediff_mp4_preset", "")
+            if preset != "": options["preset"] = preset
+            tune = shared.opts.data.get("animatediff_mp4_tune", "")
+            if tune != "": options["tune"] = tune
+            output = av.open(video_path_mp4, "w")
+            logger.info(f"Saving {video_path_mp4}")
+            if use_infotext:
+                output.metadata["Comment"] = infotext
+            stream = output.add_stream('libx264', params.fps, options=options)
+            stream.width = frame_list[0].width
+            stream.height = frame_list[0].height
+            for img in video_array:
+                frame = av.VideoFrame.from_ndarray(img)
+                packet = stream.encode(frame)
+                output.mux(packet)
+            packet = stream.encode(None)
+            output.mux(packet)
+            output.close()
+        if "TXT" in params.format and res.images[index].info is not None:
+            video_path_txt = str(video_path_prefix) + ".txt"
+            with open(video_path_txt, "w", encoding="utf8") as file:
+                file.write(f"{infotext}\n")
+        if "WEBP" in params.format:
+            if PIL.features.check('webp_anim'):
+                video_path_webp = str(video_path_prefix) + ".webp"
+                video_paths.append(video_path_webp)
+                exif_bytes = b''
+                if use_infotext:
+                    exif_bytes = piexif.dump({
+                        "Exif":{
+                            piexif.ExifIFD.UserComment:piexif.helper.UserComment.dump(infotext, encoding="unicode")
+                        }})
+                lossless = shared.opts.data.get("animatediff_webp_lossless", False)
+                quality = shared.opts.data.get("animatediff_webp_quality", 80)
+                logger.info(f"Saving {video_path_webp} with lossless={lossless} and quality={quality}")
+                imageio.imwrite(video_path_webp, video_array, plugin='pillow',
+                    duration=int(1 / params.fps * 1000), loop=params.loop_number,
+                    lossless=lossless, quality=quality, exif=exif_bytes
+                )
+                # see additional Pillow WebP options at https://pillow.readthedocs.io/en/stable/handbook/image-file-formats.html#webp
+            else:
+                logger.warn("WebP animation in Pillow requires system WebP library v0.5.0 or later")
+        if "WEBM" in params.format:
+            video_path_webm = str(video_path_prefix) + ".webm"
+            video_paths.append(video_path_webm)
+            logger.info(f"Saving {video_path_webm}")
+            with imageio.imopen(video_path_webm, "w", plugin="pyav") as file:
+                if use_infotext:
+                    file.container_metadata["Title"] = infotext
+                    file.container_metadata["Comment"] = infotext
+                file.write(video_array, codec="vp9", fps=params.fps)
+        if s3_enable:
+            for video_path in video_paths: self._save_to_s3_stroge(video_path)
+        return video_paths
+    def _optimize_gif(self, video_path: str):
+        try:
+            import pygifsicle
+        except ImportError:
+            from launch import run_pip
+            run_pip(
+                "install pygifsicle",
+                "sd-webui-animatediff GIF optimization requirement: pygifsicle",
+            )
+            import pygifsicle
+        finally:
+            try:
+                pygifsicle.optimize(video_path)
+            except FileNotFoundError:
+                logger.warn("gifsicle not found, required for optimized GIFs, try: apt install gifsicle")
+    def _encode_video_to_b64(self, paths):
+        videos = []
+        for v_path in paths:
+            with open(v_path, "rb") as video_file:
+                videos.append(base64.b64encode(video_file.read()).decode("utf-8"))
+        return videos
+    def _install_requirement_if_absent(self,lib):
+        import launch
+        if not launch.is_installed(lib):
+            launch.run_pip(f"install {lib}", f"animatediff requirement: {lib}")
+    def _exist_bucket(self,s3_client,bucketname):
+        try:
+            s3_client.head_bucket(Bucket=bucketname)
+            return True
+        except ClientError as e:
+            if e.response['Error']['Code'] == '404':
+                return False
+            else:
+                raise
+    def _save_to_s3_stroge(self ,file_path):
+        """
+        put object to object storge
+        :type bucketname: string
+        :param bucketname: will save to this 'bucket' , access_key and secret_key must have permissions to save
+        :type file  : file
+        :param file : the local file
+        """
+        self._install_requirement_if_absent('boto3')
+        import boto3
+        from botocore.exceptions import ClientError
+        import os
+        host = shared.opts.data.get("animatediff_s3_host", '127.0.0.1')
+        port = shared.opts.data.get("animatediff_s3_port", '9001')
+        access_key = shared.opts.data.get("animatediff_s3_access_key", '')
+        secret_key = shared.opts.data.get("animatediff_s3_secret_key", '')
+        bucket = shared.opts.data.get("animatediff_s3_storge_bucket", '')
+        client = boto3.client(
+                service_name='s3',
+                aws_access_key_id = access_key,
+                aws_secret_access_key = secret_key,
+                endpoint_url=f'http://{host}:{port}',
+                )
+        if not os.path.exists(file_path): return
+        date = datetime.datetime.now().strftime('%Y-%m-%d')
+        if not self._exist_bucket(client,bucket):
+            client.create_bucket(Bucket=bucket)
+        filename = os.path.split(file_path)[1]
+        targetpath = f"{date}/{filename}"
+        client.upload_file(file_path, bucket,  targetpath)
+        logger.info(f"{file_path} saved to s3 in bucket: {bucket}")
+        return f"http://{host}:{port}/{bucket}/{targetpath}"

extensions/sd-webui-animatediff/scripts/animatediff_prompt.py ADDED Viewed

	@@ -0,0 +1,143 @@

+import re
+import torch
+from modules.processing import StableDiffusionProcessing, Processed
+from scripts.animatediff_logger import logger_animatediff as logger
+from scripts.animatediff_infotext import write_params_txt
+class AnimateDiffPromptSchedule:
+    def __init__(self):
+        self.prompt_map = None
+        self.original_prompt = None
+    def save_infotext_img(self, p: StableDiffusionProcessing):
+        if self.prompt_map is not None:
+            p.prompts = [self.original_prompt for _ in range(p.batch_size)]
+    def save_infotext_txt(self, res: Processed):
+        if self.prompt_map is not None:
+            parts = res.info.split('\nNegative prompt: ', 1)
+            if len(parts) > 1:
+                res.info = f"{self.original_prompt}\nNegative prompt: {parts[1]}"
+                for i in range(len(res.infotexts)):
+                    parts = res.infotexts[i].split('\nNegative prompt: ', 1)
+                    if len(parts) > 1:
+                        res.infotexts[i] = f"{self.original_prompt}\nNegative prompt: {parts[1]}"
+                write_params_txt(res.info)
+    def parse_prompt(self, p: StableDiffusionProcessing):
+        if type(p.prompt) is not str:
+            logger.warn("prompt is not str, cannot support prompt map")
+            return
+        lines = p.prompt.strip().split('\n')
+        data = {
+            'head_prompts': [],
+            'mapp_prompts': {},
+            'tail_prompts': []
+        }
+        mode = 'head'
+        for line in lines:
+            if mode == 'head':
+                if re.match(r'^\d+:', line):
+                    mode = 'mapp'
+                else:
+                    data['head_prompts'].append(line)
+            if mode == 'mapp':
+                match = re.match(r'^(\d+): (.+)$', line)
+                if match:
+                    frame, prompt = match.groups()
+                    data['mapp_prompts'][int(frame)] = prompt
+                else:
+                    mode = 'tail'
+            if mode == 'tail':
+                data['tail_prompts'].append(line)
+        if data['mapp_prompts']:
+            logger.info("You are using prompt travel.")
+            self.prompt_map = {}
+            prompt_list = []
+            last_frame = 0
+            current_prompt = ''
+            for frame, prompt in data['mapp_prompts'].items():
+                prompt_list += [current_prompt for _ in range(last_frame, frame)]
+                last_frame = frame
+                current_prompt = f"{', '.join(data['head_prompts'])}, {prompt}, {', '.join(data['tail_prompts'])}"
+                self.prompt_map[frame] = current_prompt
+            prompt_list += [current_prompt for _ in range(last_frame, p.batch_size)]
+            assert len(prompt_list) == p.batch_size, f"prompt_list length {len(prompt_list)} != batch_size {p.batch_size}"
+            self.original_prompt = p.prompt
+            p.prompt = prompt_list * p.n_iter
+    def single_cond(self, center_frame, video_length: int, cond: torch.Tensor, closed_loop = False):
+        if closed_loop:
+            key_prev = list(self.prompt_map.keys())[-1]
+            key_next = list(self.prompt_map.keys())[0]
+        else:
+            key_prev = list(self.prompt_map.keys())[0]
+            key_next = list(self.prompt_map.keys())[-1]
+        for p in self.prompt_map.keys():
+            if p > center_frame:
+                key_next = p
+                break
+            key_prev = p
+        dist_prev = center_frame - key_prev
+        if dist_prev < 0:
+            dist_prev += video_length
+        dist_next = key_next - center_frame
+        if dist_next < 0:
+            dist_next += video_length
+        if key_prev == key_next or dist_prev + dist_next == 0:
+            return cond[key_prev] if isinstance(cond, torch.Tensor) else {k: v[key_prev] for k, v in cond.items()}
+        rate = dist_prev / (dist_prev + dist_next)
+        if isinstance(cond, torch.Tensor):
+            return AnimateDiffPromptSchedule.slerp(cond[key_prev], cond[key_next], rate)
+        else: # isinstance(cond, dict)
+            return {
+                k: AnimateDiffPromptSchedule.slerp(v[key_prev], v[key_next], rate)
+                for k, v in cond.items()
+            }
+    def multi_cond(self, cond: torch.Tensor, closed_loop = False):
+        if self.prompt_map is None:
+            return cond
+        cond_list = [] if isinstance(cond, torch.Tensor) else {k: [] for k in cond.keys()}
+        for i in range(cond.shape[0]):
+            single_cond = self.single_cond(i, cond.shape[0], cond, closed_loop)
+            if isinstance(cond, torch.Tensor):
+                cond_list.append(single_cond)
+            else:
+                for k, v in single_cond.items():
+                    cond_list[k].append(v)
+        if isinstance(cond, torch.Tensor):
+            return torch.stack(cond_list).to(cond.dtype).to(cond.device)
+        else:
+            return {k: torch.stack(v).to(cond[k].dtype).to(cond[k].device) for k, v in cond_list.items()}
+    @staticmethod
+    def slerp(
+        v0: torch.Tensor, v1: torch.Tensor, t: float, DOT_THRESHOLD: float = 0.9995
+    ) -> torch.Tensor:
+        u0 = v0 / v0.norm()
+        u1 = v1 / v1.norm()
+        dot = (u0 * u1).sum()
+        if dot.abs() > DOT_THRESHOLD:
+            return (1.0 - t) * v0 + t * v1
+        omega = dot.acos()
+        return (((1.0 - t) * omega).sin() * v0 + (t * omega).sin() * v1) / omega.sin()

extensions/sd-webui-animatediff/scripts/animatediff_ui.py ADDED Viewed

	@@ -0,0 +1,349 @@

+import os
+import cv2
+import gradio as gr
+from modules import shared
+from modules.processing import StableDiffusionProcessing
+from scripts.animatediff_mm import mm_animatediff as motion_module
+from scripts.animatediff_i2ibatch import animatediff_i2ibatch
+from scripts.animatediff_lcm import AnimateDiffLCM
+class ToolButton(gr.Button, gr.components.FormComponent):
+    """Small button with single emoji as text, fits inside gradio forms"""
+    def __init__(self, **kwargs):
+        super().__init__(variant="tool", **kwargs)
+    def get_block_name(self):
+        return "button"
+class AnimateDiffProcess:
+    def __init__(
+        self,
+        model="mm_sd_v15_v2.ckpt",
+        enable=False,
+        video_length=0,
+        fps=8,
+        loop_number=0,
+        closed_loop='R-P',
+        batch_size=16,
+        stride=1,
+        overlap=-1,
+        format=["GIF", "PNG"],
+        interp='Off',
+        interp_x=10,
+        video_source=None,
+        video_path='',
+        latent_power=1,
+        latent_scale=32,
+        last_frame=None,
+        latent_power_last=1,
+        latent_scale_last=32,
+        request_id = '',
+    ):
+        self.model = model
+        self.enable = enable
+        self.video_length = video_length
+        self.fps = fps
+        self.loop_number = loop_number
+        self.closed_loop = closed_loop
+        self.batch_size = batch_size
+        self.stride = stride
+        self.overlap = overlap
+        self.format = format
+        self.interp = interp
+        self.interp_x = interp_x
+        self.video_source = video_source
+        self.video_path = video_path
+        self.latent_power = latent_power
+        self.latent_scale = latent_scale
+        self.last_frame = last_frame
+        self.latent_power_last = latent_power_last
+        self.latent_scale_last = latent_scale_last
+        self.request_id = request_id
+    def get_list(self, is_img2img: bool):
+        list_var = list(vars(self).values())[:-1]
+        if is_img2img:
+            animatediff_i2ibatch.hack()
+        else:
+            list_var = list_var[:-5]
+        return list_var
+    def get_dict(self, is_img2img: bool):
+        infotext = {
+            "enable": self.enable,
+            "model": self.model,
+            "video_length": self.video_length,
+            "fps": self.fps,
+            "loop_number": self.loop_number,
+            "closed_loop": self.closed_loop,
+            "batch_size": self.batch_size,
+            "stride": self.stride,
+            "overlap": self.overlap,
+            "interp": self.interp,
+            "interp_x": self.interp_x,
+        }
+        if self.request_id:
+            infotext['request_id'] = self.request_id
+        if motion_module.mm is not None and motion_module.mm.mm_hash is not None:
+            infotext['mm_hash'] = motion_module.mm.mm_hash[:8]
+        if is_img2img:
+            infotext.update({
+                "latent_power": self.latent_power,
+                "latent_scale": self.latent_scale,
+                "latent_power_last": self.latent_power_last,
+                "latent_scale_last": self.latent_scale_last,
+            })
+        infotext_str = ', '.join(f"{k}: {v}" for k, v in infotext.items())
+        return infotext_str
+    def _check(self):
+        assert (
+            self.video_length >= 0 and self.fps > 0
+        ), "Video length and FPS should be positive."
+        assert not set(["GIF", "MP4", "PNG", "WEBP", "WEBM"]).isdisjoint(
+            self.format
+        ), "At least one saving format should be selected."
+    def set_p(self, p: StableDiffusionProcessing):
+        self._check()
+        if self.video_length < self.batch_size:
+            p.batch_size = self.batch_size
+        else:
+            p.batch_size = self.video_length
+        if self.video_length == 0:
+            self.video_length = p.batch_size
+            self.video_default = True
+        else:
+            self.video_default = False
+        if self.overlap == -1:
+            self.overlap = self.batch_size // 4
+        if "PNG" not in self.format or shared.opts.data.get("animatediff_save_to_custom", False):
+            p.do_not_save_samples = True
+class AnimateDiffUiGroup:
+    txt2img_submit_button = None
+    img2img_submit_button = None
+    def __init__(self):
+        self.params = AnimateDiffProcess()
+    def render(self, is_img2img: bool, model_dir: str):
+        if not os.path.isdir(model_dir):
+            os.mkdir(model_dir)
+        elemid_prefix = "img2img-ad-" if is_img2img else "txt2img-ad-"
+        model_list = [f for f in os.listdir(model_dir) if f != ".gitkeep"]
+        with gr.Accordion("AnimateDiff", open=False):
+            gr.Markdown(value="Please click [this link](https://github.com/continue-revolution/sd-webui-animatediff#webui-parameters) to read the documentation of each parameter.")
+            with gr.Row():
+                def refresh_models(*inputs):
+                    new_model_list = [
+                        f for f in os.listdir(model_dir) if f != ".gitkeep"
+                    ]
+                    dd = inputs[0]
+                    if dd in new_model_list:
+                        selected = dd
+                    elif len(new_model_list) > 0:
+                        selected = new_model_list[0]
+                    else:
+                        selected = None
+                    return gr.Dropdown.update(choices=new_model_list, value=selected)
+                with gr.Row():
+                    self.params.model = gr.Dropdown(
+                        choices=model_list,
+                        value=(self.params.model if self.params.model in model_list else None),
+                        label="Motion module",
+                        type="value",
+                        elem_id=f"{elemid_prefix}motion-module",
+                    )
+                    refresh_model = ToolButton(value="\U0001f504")
+                    refresh_model.click(refresh_models, self.params.model, self.params.model)
+                self.params.format = gr.CheckboxGroup(
+                    choices=["GIF", "MP4", "WEBP", "WEBM", "PNG", "TXT"],
+                    label="Save format",
+                    type="value",
+                    elem_id=f"{elemid_prefix}save-format",
+                    value=self.params.format,
+                )
+            with gr.Row():
+                self.params.enable = gr.Checkbox(
+                    value=self.params.enable, label="Enable AnimateDiff",
+                    elem_id=f"{elemid_prefix}enable"
+                )
+                self.params.video_length = gr.Number(
+                    minimum=0,
+                    value=self.params.video_length,
+                    label="Number of frames",
+                    precision=0,
+                    elem_id=f"{elemid_prefix}video-length",
+                )
+                self.params.fps = gr.Number(
+                    value=self.params.fps, label="FPS", precision=0,
+                    elem_id=f"{elemid_prefix}fps"
+                )
+                self.params.loop_number = gr.Number(
+                    minimum=0,
+                    value=self.params.loop_number,
+                    label="Display loop number",
+                    precision=0,
+                    elem_id=f"{elemid_prefix}loop-number",
+                )
+            with gr.Row():
+                self.params.closed_loop = gr.Radio(
+                    choices=["N", "R-P", "R+P", "A"],
+                    value=self.params.closed_loop,
+                    label="Closed loop",
+                    elem_id=f"{elemid_prefix}closed-loop",
+                )
+                self.params.batch_size = gr.Slider(
+                    minimum=1,
+                    maximum=32,
+                    value=self.params.batch_size,
+                    label="Context batch size",
+                    step=1,
+                    precision=0,
+                    elem_id=f"{elemid_prefix}batch-size",
+                )
+                self.params.stride = gr.Number(
+                    minimum=1,
+                    value=self.params.stride,
+                    label="Stride",
+                    precision=0,
+                    elem_id=f"{elemid_prefix}stride",
+                )
+                self.params.overlap = gr.Number(
+                    minimum=-1,
+                    value=self.params.overlap,
+                    label="Overlap",
+                    precision=0,
+                    elem_id=f"{elemid_prefix}overlap",
+                )
+            with gr.Row():
+                self.params.interp = gr.Radio(
+                    choices=["Off", "FILM"],
+                    label="Frame Interpolation",
+                    elem_id=f"{elemid_prefix}interp-choice",
+                    value=self.params.interp
+                )
+                self.params.interp_x = gr.Number(
+                    value=self.params.interp_x, label="Interp X", precision=0,
+                    elem_id=f"{elemid_prefix}interp-x"
+                )
+            self.params.video_source = gr.Video(
+                value=self.params.video_source,
+                label="Video source",
+            )
+            def update_fps(video_source):
+                if video_source is not None and video_source != '':
+                    cap = cv2.VideoCapture(video_source)
+                    fps = int(cap.get(cv2.CAP_PROP_FPS))
+                    cap.release()
+                    return fps
+                else:
+                    return int(self.params.fps.value)
+            self.params.video_source.change(update_fps, inputs=self.params.video_source, outputs=self.params.fps)
+            def update_frames(video_source):
+                if video_source is not None and video_source != '':
+                    cap = cv2.VideoCapture(video_source)
+                    frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+                    cap.release()
+                    return frames
+                else:
+                    return int(self.params.video_length.value)
+            self.params.video_source.change(update_frames, inputs=self.params.video_source, outputs=self.params.video_length)
+            self.params.video_path = gr.Textbox(
+                value=self.params.video_path,
+                label="Video path",
+                elem_id=f"{elemid_prefix}video-path"
+            )
+            if is_img2img:
+                with gr.Row():
+                    self.params.latent_power = gr.Slider(
+                        minimum=0.1,
+                        maximum=10,
+                        value=self.params.latent_power,
+                        step=0.1,
+                        label="Latent power",
+                        elem_id=f"{elemid_prefix}latent-power",
+                    )
+                    self.params.latent_scale = gr.Slider(
+                        minimum=1,
+                        maximum=128,
+                        value=self.params.latent_scale,
+                        label="Latent scale",
+                        elem_id=f"{elemid_prefix}latent-scale"
+                    )
+                    self.params.latent_power_last = gr.Slider(
+                        minimum=0.1,
+                        maximum=10,
+                        value=self.params.latent_power_last,
+                        step=0.1,
+                        label="Optional latent power for last frame",
+                        elem_id=f"{elemid_prefix}latent-power-last",
+                    )
+                    self.params.latent_scale_last = gr.Slider(
+                        minimum=1,
+                        maximum=128,
+                        value=self.params.latent_scale_last,
+                        label="Optional latent scale for last frame",
+                        elem_id=f"{elemid_prefix}latent-scale-last"
+                    )
+                self.params.last_frame = gr.Image(
+                    label="Optional last frame. Leave it blank if you do not need one.",
+                    type="pil",
+                )
+            with gr.Row():
+                unload = gr.Button(value="Move motion module to CPU (default if lowvram)")
+                remove = gr.Button(value="Remove motion module from any memory")
+                unload.click(fn=motion_module.unload)
+                remove.click(fn=motion_module.remove)
+        return self.register_unit(is_img2img)
+    def register_unit(self, is_img2img: bool):
+        unit = gr.State(value=AnimateDiffProcess)
+        (
+            AnimateDiffUiGroup.img2img_submit_button
+            if is_img2img
+            else AnimateDiffUiGroup.txt2img_submit_button
+        ).click(
+            fn=AnimateDiffProcess,
+            inputs=self.params.get_list(is_img2img),
+            outputs=unit,
+            queue=False,
+        )
+        return unit
+    @staticmethod
+    def on_after_component(component, **_kwargs):
+        elem_id = getattr(component, "elem_id", None)
+        if elem_id == "txt2img_generate":
+            AnimateDiffUiGroup.txt2img_submit_button = component
+            return
+        if elem_id == "img2img_generate":
+            AnimateDiffUiGroup.img2img_submit_button = component
+            return
+    @staticmethod
+    def on_before_ui():
+        AnimateDiffLCM.hack_kdiff_ui()