fix: make reboot routes awaitable (#1045 )

fix: harden model metadata and preview routes (#1045 )
Refs #1045
2026-09-29 12:23:08 +08:00 · 2026-09-29 12:14:30 +08:00 · 2026-09-29 11:33:08 +08:00 · 2026-09-21 15:31:43 +08:00 · 2026-09-20 12:07:55 +08:00 · 2026-09-20 12:04:39 +08:00
169 changed files with 31975 additions and 19966 deletions
@@ -7,15 +7,36 @@ on:
    paths:
      - "pyproject.toml"

+permissions:
+  issues: write
+  contents: write
+
 jobs:
  publish-node:
    name: Publish Custom Node to registry
    runs-on: ubuntu-latest
+    if: ${{ github.repository_owner == 'yolain' }}
    steps:
      - name: Check out code
        uses: actions/checkout@v4
+      - name: Extract version from pyproject.toml
+        id: version
+        run: |
+          VERSION=$(grep -E '^\s*version\s*=' pyproject.toml | head -1 | sed -E 's/.*version\s*=\s*"([^"]+)".*/\1/')
+          if [ -z "$VERSION" ]; then
+            echo "ERROR: Could not extract version from pyproject.toml" >&2
+            exit 1
+          fi
+          echo "version=$VERSION" >> $GITHUB_OUTPUT
+          echo "Extracted version: $VERSION"
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: v${{ steps.version.outputs.version }}
+          generate_release_notes: true
      - name: Publish Custom Node
-        uses: Comfy-Org/publish-node-action@main
+        uses: Comfy-Org/publish-node-action@v1
        with:
          ## Add your own personal access token to your Github Repository secrets and reference it here.
-          personal_access_token: ${{ secrets.REGISTRY_ACCESS_TOKEN }}
+          personal_access_token: ${{ secrets.REGISTRY_ACCESS_TOKEN }}
@@ -9,10 +9,15 @@ workflow/**
 autocomplete/**
 web_beta/**
 web_version/dev/**
-ComfyUI-Easy-Use-Frontend/
 docs/**
 .vscode/
+.vs/
 .idea/
+.claude/**
 mmb-preset.custom.txt
 config.yaml
-node.tar.gz
+node.tar.gz
+.codex
+
+.cursorrules
+tools/ComfyUI-Easy-Use.json
@@ -0,0 +1,4 @@
+[submodule "ComfyUI-Easy-Use-Frontend"]
+	path = ComfyUI-Easy-Use-Frontend
+	url = https://github.com/yolain/ComfyUI-Easy-Use-Frontend.git
+    branch = main
@@ -2,7 +2,7 @@

 <div align="center">
 <a href="https://space.bilibili.com/1840885116">视频介绍</a> |
-文档 (康明孙) | 
+<a href="https://docs.easyuse.yolain.com">文档</a> | 
 <a href="https://github.com/yolain/ComfyUI-Yolain-Workflows">工作流合集</a> |
 <a href="#%EF%B8%8F-donation">捐助</a> 
 <br><br>
@@ -19,7 +19,7 @@
 - 增加了预采样参数配置的节点，可与采样节点分离，更方便预览。
 - 支持通配符与Lora的提示词节点，如需使用Lora Block Weight用法，需先保证自定义节点包中安装了 [ComfyUI-Inspire-Pack](https://github.com/ltdrdata/ComfyUI-Inspire-Pack)
 - 可多选的风格化提示词选择器，默认是Fooocus的样式json，可自定义json放在styles底下，samples文件夹里可放预览图(名称和name一致,图片文件名如有空格需转为下划线'_')
- 加载器可开启A1111提示词风格模式，可重现与webui生成近乎相同的图像，需先安装 [ComfyUI_smZNodes](https://github.com/shiimizu/ComfyUI_smZNodes)
+- 加载器可开启A1111提示词风格模式，可重现与webui生成近乎相同的图像
 - 可使用`easy latentNoisy`或`easy preSamplingNoiseIn`节点实现对潜空间的噪声注入
 - 简化 SD1.x、SD2.x、SDXL、SVD、Zero123等流程 
 - 简化 Stable Cascade [示例参考](https://github.com/yolain/ComfyUI-Yolain-Workflows?tab=readme-ov-file#1-13-stable-cascade)
@@ -39,6 +39,7 @@
 - 支持 kolors 模型
 - 支持 flux 模型
 - 支持 惰性条件判断（ifElse）和 for循环
+- 支持 Anima 与 Krea2 diffusion 模型，可通过 `easy diffusionModelLoader` 加载（需显式选择文本编码器与 VAE），并使用 `easy XYInputs: DiffusionModel` 进行 XY 对比

 ## 👨🏻‍🔧 安装

@@ -52,6 +53,108 @@ git clone https://github.com/yolain/ComfyUI-Easy-Use

 ## 📜 更新日志

+**v1.4.1**
+
+- 修复 `easy saveText` 将文本输出限制在输出目录 #1032
+
+**v1.4.0**
+
+- 添加 `easy tableEditor` 节点 - 用于编辑和显示表格数据的节点
+- 修复 `easy showAnything` 在最新版 ComfyUI 前端无法工作的问题
+- 修复 `easy multiAnglePrompt` 设置保存失败的问题
+- 修复 `easy detailer` 在子图中无法工作的问题
+- 修复新版 ComfyUI 前端中"刷新节点"功能连接线丢失的问题
+- 使用原生 `VAEDecodeTiled` 进行分块解码（支持 Qwen Image VAE）
+- 修复 `easy forLoopStart` - 允许 `total=0` 以防止不必要的循环执行
+- 修复 `easy preSampling` - `samplerCustomSettings.ip2p` 中 `vae`/`pixels` 现在是可选的
+- 修复 `easy pixart` ControlNet 包装器 - 使用 `pe_interpolation` 替代已移除的 `lewei_scale`
+- 修复 `easy promptConcat` - 当输入为列表时的 TypeError 问题
+- 使用专用 RNG 进行全局种子生成
+- 修复 `easy imageDetailTransfer` - 多帧蒙版在通道广播时崩溃
+- 修复 Windows 环境下 PrimeVue 对话框遮罩未清除的问题
+- 修复 `LockedMeta` 对象 TypeError（`object of type 'LockedMeta' has no len()`）
+- 增强 `easy simpleMath` `evaluate_formula` 以处理列表输入
+- 修复 `loraStack`/`controlnetStack` - 禁用时不再清除上游堆栈
+- 修复 XYPlot 在 `Seeds++ Batch` 和元组 X/Y 输入时崩溃的问题
+- 回滚循环节点到 v1 版本
+- 修复 `easy NodesMap` - 避免递归组引用
+- 修复 `easy CleanVRAM` 清理顺序并正确清除 Easy-Use 缓存
+- 指定文件读取的 UTF-8 编码
+- 移除不必要的 print 语句
+
+**v1.3.6**
+
+- 恢复 `easy showAnything` 对于列表类型的支持（但一些情况下展示庞大数据时仍会导致ComfyUI崩溃） 
+- 修复自定义小部件以支持子图和 Nodes 2.0 #942
+- 添加 `easy multiAngle` 节点
+- 将 `prompt.py` 转换为 V3 Schema
+- 修复 `easy humanSegmentation` 错误
+- 添加 `easy stringJoinLines`、`easy stringToIntList`、`easy simpleMath`
+- 修复 `easy ifElse` 和 `easy anythingIndexSwitch` 在某些环境下失败的问题
+
+**v1.3.5**
+
+- 修复`isNone`
+- 将`preview_rescale`添加到`easy imageChooser`
+- 修复小部件隐藏#910
+- 将 max 参数添加到 `wildcardsPromptMatrix` 偏移量 #909
+- 修复子图节点上的标题框样式
+- 在 `easypromptLine` 上添加 `remove_empty_lines`
+
+**v1.3.4**
+
+- 修复 `easy seedList` 最大值 #879
+- 为xyplot添加controlnet input #877
+- 为 `easy indexAnything` 支持 `反向索引` 
+
+**v1.3.3**
+
+- 删除CSS类名称`gird-cols-1` #859
+- 修复锁定种子在 `easy promptAwait` 中不起作用
+- 重命名节点图
+- 修复`easy ImageChooser`输出错误类型 #845
+
+**v1.3.2**
+
+- 改造 `easy imageChooser` 节点以兼容 frontend>=v1.24.2, 解决方案参考自 [Comfyui_LG_Tools](https://github.com/LAOGOU-666/Comfyui_LG_Tools)
+- 改造 `easy stylesSelector` 节点, 你可在 [other styles files](https://github.com/yolain/EasyUse-Styles-Templates) 下载到 `styles` 文件夹下
+- 改造 `easy humanSegmentation` 节点
+- 修复 `easy makeImageForICLora` 节点.
+- 添加 `easy joycaption3API` 节点
+- 添加 `easy promptAwait` 节点
+
+**v1.3.1**
+
+- 重写 drawNodeWidget 修复组节点预览的问题.
+- 更新了一些 XYPlot 的功能 by [mekinney](https://github.com/mekinney)
+- 添加 `easy seedList` 节点 (它对循环节点有用)
+
+**v1.3.0**
+
+- 将循环节点设置为最大输入和输出数量为20
+- 添加 `uniform width` 方式到 `easy makeImageForICLora`
+- 增加 `wildcardsPromptMatrix` 通配符提示词矩阵，由 [Rosmeowtis](https://github.com/Rosmeowtis) 贡献
+
+**v1.2.9**
+
+- 修复 Imagechooser 会导致工作流处理取消
+- 修复 brushnet tensor(640) 错误
+- 修复v1.6.0前端之后无法隐藏小部件的bug
+- 修复图像选择器无法选择图像
+- 修复ContextMenu Monkey修补以影响自定义脚本（PYSSSS）节点
+
+**v1.2.8**
+
+- 修复了一些BUG (😹)
+- 增加了多语言目录
+
+**v1.2.7**
+
+- 优化管理节点组显示
+- 在 `easy imageRemBg` 上添加 `ben2`
+- 添加 joyCaption2 API版节点（ https://github.com/siliconflow/BizyAir ）
+- 使用一种新的方式在 loader 中显示模型缩略图（支持 diffusion_models、lors、checkpoints）
+
 **v1.2.6**

 - 修复了在缺少自定义节点时缺少 “红色框框” 样式的问题。
@@ -151,7 +254,8 @@ git clone https://github.com/yolain/ComfyUI-Easy-Use
 - 增加 `easy imageCount` - 图像数量
 - 增加 `easy textSwitch` - 文字切换

-**v1.1.5**
+<details>
+<summary><b>v1.1.5</b></summary>

 - 重写 `easy cleanGPUUsed` - 可强制清理comfyUI的模型显存占用
 - 增加 `easy humanSegmentation` - 多类分割、人像分割
@@ -160,8 +264,10 @@ git clone https://github.com/yolain/ComfyUI-Easy-Use
 - 增加 `easy ipadapterApplyFromParams`
 - 增加 `easy imageInterrogator` - 图像反推
 - 增加 `easy stableDiffusion3API` - 简易的Stable Diffusion 3 多账号API节点
+</details>

-**v1.1.4**
+<details>
+<summary><b>v1.1.4</b></summary>

 - 增加 `easy imageChooser` - 从[cg-image-picker](https://github.com/chrisgoringe/cg-image-picker)简化的图片选择器
 - 增加 `easy preSamplingCustom` - 自定义预采样，可支持cosXL-edit
@@ -169,8 +275,10 @@ git clone https://github.com/yolain/ComfyUI-Easy-Use
 - 增加 在Loaders上右键菜单可查看 checkpoints、lora 信息
 - 修复 `easy preSamplingNoiseIn`、`easy latentNoisy`、`east Unsampler` 以兼容ComfyUI Revision>=2098 [0542088e] 以上版本
 - 修复 FooocusInpaint修改ModelPatcher计算权重引发的问题，理应在生成model后重置ModelPatcher为默认值
+</details>

-**v1.1.3**
+<details>
+<summary><b>v1.1.3</b></summary>

 - `easy ipadapterApply` 增加 **COMPOSITION** 预置项
 - 增加 对[ResAdapter](https://huggingface.co/jiaxiangc/res-adapter) lora模型 的加载支持
@@ -179,6 +287,7 @@ git clone https://github.com/yolain/ComfyUI-Easy-Use
 - 增加 `easy promptConcat`
 - `easy wildcards` 增加 **multiline_mode**属性 
 - 增加 当节点需要下载模型时，若huggingface连接超时，会切换至镜像地址下载模型
+</details>

 <details>
 <summary><b>v1.1.2</b></summary>
@@ -199,7 +308,7 @@ git clone https://github.com/yolain/ComfyUI-Easy-Use
 </details>

 <details>
-<summary><b>v1.1.1/b></summary>
+<summary><b>v1.1.1</b></summary>

 - 修复首次添加含seed的节点且当前模式为control_before_generate时，seed为0的问题
 - `easy preSamplingAdvanced` 增加 **return_with_leftover_noise**
@@ -472,18 +581,23 @@ git clone https://github.com/yolain/ComfyUI-Easy-Use

 [ComfyUI_ExtraModels](https://github.com/city96/ComfyUI_ExtraModels) - DiT架构相关节点（Pixart、混元DiT等）

-## ☕️ Donation
+## 免责声明
+
+本开源项目及其内容按 “原样 ”提供，不作任何明示或暗示的保证，包括但不限于适销性、特定用途适用性和非侵权保证。在任何情况下，作者或其他版权所有者均不对因本软件或本软件的使用或其他交易而产生、引起或与之相关的任何索赔、损害或其他责任承担责任，无论是合同诉讼、侵权诉讼还是其他诉讼。
+
+用户应自行负责确保在使用本软件或发布由本软件生成的内容时，遵守所在司法管辖区的所有适用法律和法规。作者和版权所有者不对用户在其各自所在地违反法律或法规的行为负责。
+
+## ☕️ 投喂

 **Comfyui-Easy-Use** 是一个 GPL 许可的开源项目。为了项目取得更好、可持续的发展，我希望能够获得更多的支持。 如果我的自定义节点为您的一天增添了价值，请考虑喝杯咖啡来进一步补充能量！ 💖感谢您的支持，每一杯咖啡都是我创作的动力！

 - [BiliBili充电](https://space.bilibili.com/1840885116)
- [爱发电](https://afdian.com/a/yolain)
 - [Wechat/Alipay](https://github.com/user-attachments/assets/803469bd-ed6a-4fab-932d-50e5088a2d03)

 感谢您的捐助，我将用这些费用来租用 GPU 或购买其他 GPT 服务，以便更好地调试和完善 ComfyUI-Easy-Use 功能

-##  🌟Stargazers
+##  🌟大富大贵的人儿

-My gratitude extends to the generous souls who bestow a star. Your support is much appreciated!
+我对那些慷慨的赐予一颗星的人表示感谢。非常感谢您的支持！

 [![Stargazers repo roster for @yolain/ComfyUI-Easy-Use](https://reporoster.com/stars/yolain/ComfyUI-Easy-Use)](https://github.com/yolain/ComfyUI-Easy-Use/stargazers)
@@ -2,7 +2,7 @@

 <div align="center">
 <a href="https://space.bilibili.com/1840885116">Video Tutorial</a> |
-Docs (Cooming Soon) | 
+<a href="https://docs.easyuse.yolain.com">Docs</a> | 
 <a href="https://github.com/yolain/ComfyUI-Yolain-Workflows">Workflow Collection</a> |
 <a href="#%EF%B8%8F-donation">Donation</a> 
 <br><br>
@@ -12,29 +12,30 @@ Docs (Cooming Soon) |

 **ComfyUI-Easy-Use** is an efficiency custom nodes integration package, which is extended on the basis of [TinyTerraNodes](https://github.com/TinyTerra/ComfyUI_tinyterraNodes). It has been integrated and optimized for many popular awesome custom nodes to achieve the purpose of faster and more convenient use of ComfyUI. While ensuring the degree of freedom, it restores the ultimate smooth image production experience that belongs to Stable Diffusion.

-## 👨🏻‍🎨 Introduce
+## 👨🏻‍🎨 Introduction

- Inspire by [tinyterraNodes](https://github.com/TinyTerra/ComfyUI_tinyterraNodes), which greatly reduces the time cost of tossing workflows。
+- Inspired by [tinyterraNodes](https://github.com/TinyTerra/ComfyUI_tinyterraNodes), which greatly reduces the time cost of tossing workflows。
 - UI interface beautification, the first time you install the user, if you need to use the UI theme, please switch the theme in Settings -> Color Palette and refresh page.
- Added a node for pre-sampling parameter configuration, which can be separated from the sampling node for easier previewing
- Wildcards and lora's are supported, for Lora Block Weight usage, ensure that the custom node package has the [ComfyUI-Inspire-Pack](https://github.com/ltdrdata/ComfyUI-Inspire-Pack)
- Multi-selectable styled cue word selector, default is Fooocus style json, custom json can be placed under styles, samples folder can be placed in the preview image (name and name consistent, image file name such as spaces need to be converted to underscores '_')
- The loader enables the A1111 prompt mode, which reproduces nearly identical images to those generated by webui, and needs to be installed [ComfyUI_smZNodes](https://github.com/shiimizu/ComfyUI_smZNodes) first. 
- Noise injection into the latent space can be achieved using the `easy latentNoisy` or `easy preSamplingNoiseIn` node
- Simplified processes for SD1.x, SD2.x, SDXL, SVD, Zero123, etc. [Example](https://github.com/yolain/ComfyUI-Easy-Use?tab=readme-ov-file#StableDiffusion)
- Simplified Stable Cascade [Example](https://github.com/yolain/ComfyUI-Easy-Use?tab=readme-ov-file#StableCascade)
+- Added a node for pre-sampling parameter configuration, which can be separated from the sampling node for easier previewing.
+- Wildcards and lora's are supported, for Lora Block Weight usage, ensure that the custom node package has the [ComfyUI-Inspire-Pack](https://github.com/ltdrdata/ComfyUI-Inspire-Pack).
+- Multi-selectable styled cue word selector, default is Fooocus style json, custom json can be placed under styles, samples folder can be placed in the preview image (name and name consistent, image file name such as spaces need to be converted to underscores '_').
+- The loader enables the A1111 prompt mode, which reproduces nearly identical images to those generated by webui. 
+- Noise injection into the latent space can be achieved using the `easy latentNoisy` or `easy preSamplingNoiseIn` node.
+- Simplified processes for SD1.x, SD2.x, SDXL, SVD, Zero123, etc. [Example](https://github.com/yolain/ComfyUI-Easy-Use?tab=readme-ov-file#StableDiffusion).
+- Simplified Stable Cascade [Example](https://github.com/yolain/ComfyUI-Easy-Use?tab=readme-ov-file#StableCascade).
 - Simplified Layer Diffuse [Example](https://github.com/yolain/ComfyUI-Easy-Use?tab=readme-ov-file#LayerDiffusion)，The first time you use it you may need to run `pip install -r requirements.txt` to install the required dependencies.
- Simplified InstantID [Example](https://github.com/yolain/ComfyUI-Easy-Use?tab=readme-ov-file#InstantID), You need to make sure that the custom node package has the [ComfyUI_InstantID](https://github.com/cubiq/ComfyUI_InstantID)
- Extending the usability of XYplot
- Fooocus Inpaint integration
+- Simplified InstantID [Example](https://github.com/yolain/ComfyUI-Easy-Use?tab=readme-ov-file#InstantID), You need to make sure that the custom node package has the [ComfyUI_InstantID](https://github.com/cubiq/ComfyUI_InstantID).
+- Extending the usability of XYplot.
+- Fooocus Inpaint integration.
 - Integration of common logical calculations, conversion of types, display of all types, etc.
- Background removal nodes for the RMBG-1.4 model supporting BriaAI, [BriaAI Guide](https://huggingface.co/briaai/RMBG-1.4)
- Forcibly cleared the memory usage of the comfy UI model are supported
- Stable Diffusion 3 multi-account API nodes are supported
- Support SD3's model
- Support Kolors‘s model
- Support Flux's model
- Support lazy if else and for loops
+- Background removal nodes for the RMBG-1.4 model supporting BriaAI, [BriaAI Guide](https://huggingface.co/briaai/RMBG-1.4).
+- Forcibly cleared the memory usage of the comfy UI model are supported.
+- Stable Diffusion 3 multi-account API nodes are supported.
+- Support SD3's model.
+- Support Kolors‘s model.
+- Support Flux's model.
+- Support lazy if else and for loops.
+- Support Anima and Krea2 diffusion models with `easy diffusionModelLoader` and `easy XYInputs: DiffusionModel`. The loader requires an explicit text encoder and VAE selection.

 ## 👨🏻‍🔧 Installation
 Clone the repo into the **custom_nodes** directory and install the requirements:
@@ -47,6 +48,108 @@ Double-click install.bat to install the required dependencies

 ## 📜 Changelog

+**v1.4.1**
+
+- Fix `easy saveText` to confine text outputs to output directory #1032
+
+**v1.4.0**
+
+- Add `easy tableEditor` node - A node for editing and displaying table data
+- Fix `easy showAnything` not working on latest ComfyUI frontend
+- Fix `easy multiAnglePrompt` settings failed to save
+- Fix `easy detailer` not working in subgraphs
+- Fix connection lines missing from "Refresh Nodes" feature in new ComfyUI frontend
+- Use native `VAEDecodeTiled` for tiled decode (Qwen Image VAE support)
+- Fix `easy forLoopStart` - allow `total=0` to prevent unnecessary loop execution
+- Fix `easy preSampling` - `vae`/`pixels` now optional on `samplerCustomSettings.ip2p`
+- Fix `easy pixart` ControlNet wrappers - use `pe_interpolation` instead of removed `lewei_scale`
+- Fix `easy promptConcat` - TypeError when an input is a list
+- Use a dedicated RNG for global seed generation
+- Fix `easy imageDetailTransfer` - multi-frame masks crash on channel broadcast
+- Fix PrimeVue dialog overlay not being cleared in Windows environment
+- Fix `LockedMeta` object TypeError (`object of type 'LockedMeta' has no len()`)
+- Enhance `easy simpleMath` `evaluate_formula` to handle list inputs
+- Fix `loraStack`/`controlnetStack` - disable no longer erases upstream stack
+- Fix XYPlot crashes in `Seeds++ Batch` and tuple X/Y inputs
+- Rollback cycle node to version v1
+- Fix `easy NodesMap` - avoid recursive group refs
+- Fix `easy CleanVRAM` teardown ordering and clear Easy-Use cache properly
+- Specify UTF-8 encoding for file reads
+- Remove unnecessary print statements
+
+**v1.3.6**
+
+- Restored `easy showAnything` support for list types (but displaying large data in some cases may still cause ComfyUI to crash)
+- Fix custom widgets to support subgraph and Nodes 2.0 #942
+- Add `easy multiAngle` node
+- Convert `prompt.py` to V3 Schema
+- Fix `easy humanSegmentation` error
+- Add `easy stringJoinLines`，`easy stringToIntList`, `easy simpleMath`
+- Fix `easy ifElse` and `easy anythingIndexSwitch` fails in certain environments
+
+**v1.3.5**
+
+- Fix `isNone`
+- Add `preview_rescale` to `easy imageChooser`
+- Fix widget hidden #910
+- Add max parameter to `wildcardsPromptMatrix` offset #909
+- Fix title box style on subgraph node
+- Add `remove_empty_lines` on `easy promptLine`
+
+**v1.3.4**
+
+- Fix `easy seedList` max_num #879
+- Add controlnet input to xyplot #877
+- Support `nagative indexing` for `easy indexAnything`
+
+**v1.3.3**
+
+- Removed the definition of the CSS class name gird-cols-1 #859
+- Fix lock seed not working in `easy promptAwait`
+- Rename the nodes map
+- Fix `easy imageChooser` output error type #845
+
+**v1.3.2**
+
+- Revamp `easy imageChooser` node to adapt frontend>=v1.24.2, solution referenced from [Comfyui_LG_Tools](https://github.com/LAOGOU-666/Comfyui_LG_Tools)
+- Revamp `easy stylesSelector` node, and you can download [other styles files](https://github.com/yolain/EasyUse-Styles-Templates) to the `styles` folder
+- Revamp `easy humanSegmentation` node
+- Fix `easy makeImageForICLora` node issue, that occurred when the heights of two images were the same during image stitching on.
+- Add `easy joycaption3API` node
+- Add `easy promptAwait` node
+
+**v1.3.1**
+
+- Rewrite drawNodeWidget and fix the GroupNode preview issue.
+- Updated some features of XYPlot  by [mekinney](https://github.com/mekinney)
+- Add `easy seedList` node (It's useful for in loops)
+
+**v1.3.0**
+
+- Set loop nodes maximum number of inputs and outputs to 20
+- Add `uniform width` method to `easy makeImageForICLora`
+- Add `wildcardsPromptMatrix` Node by [Rosmeowtis](https://github.com/Rosmeowtis)
+
+**v1.2.9**
+
+- Fix ImageChooser causes workflow processing to cancel
+- Fix brushnet tensor(640) error
+- Fix widgets not hidden after v1.6.0 frontend
+- Fix image chooser can not select images
+- Fix contextMenu monkey patching to affect custom scripts (pysssss) nodes
+
+**v1.2.8**
+
+- Added the multi-language catalog 
+- Fix CLIP vision model download URLs for IPAdapter and DynamiCrafter
+- Improve error handling for model downloads with clearer error messages and better handling of download failures
+
+**v1.2.7**
+
+- Optimize display of the node maps
+- Added `ben2` on `easy imageRemBg`
+- Using a new way to display the models thumbnails in the loaders (supported diffusion_models、lors、checkpoints)
+
 **v1.2.6**

 - Fix missing the "Red Rect" styles when you are missing custom nodes.
@@ -141,7 +244,8 @@ Double-click install.bat to install the required dependencies
 - Added `easy imageCount` - Get Image Count
 - Added `easy textSwitch` - Text Switch

-**v1.1.5**
+<details>
+<summary><b>v1.1.5</b></summary>

 - Rewrite `easy cleanGPUUsed` - the memory usage of the comfyUI can to be cleared
 - Added `easy humanSegmentation` - Human Part Segmentation
@@ -150,16 +254,19 @@ Double-click install.bat to install the required dependencies
 - Added `easy ipadapterApplyFromParams`
 - Added `easy imageInterrogator` - Image To Prompt
 - Added `easy stableDiffusion3API` - Easy Stable Diffusion 3 Multiple accounts API Node
+</details>

-**v1.1.4**
+<details>
+<summary><b>v1.1.4</b></summary>

 - Added `easy preSamplingCustom` - Custom-PreSampling, can be supported cosXL-edit
 - Added `easy ipadapterStyleComposition`
 - Added the right-click menu to view checkpoints and lora information in all Loaders
 - Fixed `easy preSamplingNoiseIn`、`easy latentNoisy`、`east Unsampler` compatible with ComfyUI Revision>=2098 [0542088e] or later
- 
+</details>

-**v1.1.3**
+<details>
+<summary><b>v1.1.3</b></summary>

 - `easy ipadapterApply` Added **COMPOSITION** preset
 - Supported [ResAdapter](https://huggingface.co/jiaxiangc/res-adapter) when load ResAdapter lora
@@ -167,6 +274,7 @@ Double-click install.bat to install the required dependencies
 - Added `easy promptReplace`
 - Added `easy promptConcat`
 - `easy wildcards` Added **multiline_mode**  
+</details>

 <details>
 <summary><b>v1.1.2</b></summary>
@@ -325,7 +433,6 @@ Double-click install.bat to install the required dependencies
 - `easy XYInputs ModelMergeBlocks` Values can be imported from CSV files
 - Fixed `easy pipeToBasicPipe` Bug

-
 - Removed `easy imageRemBg`
 - Remove the introductory diagram and workflow files from the package to reduce the package size
 - Replaced the font file used in the generation of XY diagrams
@@ -456,6 +563,12 @@ Disclaimer: Opened source was not easy. I have a lot of respect for the contribu

 [ComfyUI_ExtraModels](https://github.com/city96/ComfyUI_ExtraModels) - DiT custom nodes

+## Disclaimer
+
+This software is provided “as is,” without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose, and non-infringement. In no event shall the authors or copyright holders be liable for any claim, damages, or other liability, whether in an action of contract, tort, or otherwise, arising from, out of, or in connection with the software or the use or other dealings in the software.
+
+Users are solely responsible for ensuring that their use of this software complies with all applicable laws and regulations in the jurisdiction where they use the software or publish content generated by it. The authors and copyright holders are not responsible for any violations of laws or regulations by users in their respective locations.
+
 ## ☕️ Donation

 **Comfyui-Easy-Use** is an GPL-licensed open source project. In order to achieve better and sustainable development of the project, i expect to gain more backers. <br>
@@ -463,16 +576,11 @@ If my custom nodes has added value to your day, consider indulging in a coffee t
 💖You can support me in any of the following ways:

 - [BiliBili](https://space.bilibili.com/1840885116)
- [Afdian](https://afdian.com/a/yolain)
 - [Wechat / Alipay](https://github.com/user-attachments/assets/803469bd-ed6a-4fab-932d-50e5088a2d03)
- 🪙 Wallet Address:
-  - ETH: 0x01f7CEd3245CaB3891A0ec8f528178db352EaC74
-  - USDT(tron): TP3AnJXkAzfebL2GKmFAvQvXgsxzivweV6
-
-（This is a newly created wallet, and if it receives sponsorship, I'll use it to rent GPUs or other GPT services for better debugging and refinement of ComfyUI-Easy-Use features.）

 ##  🌟Stargazers

 My gratitude extends to the generous souls who bestow a star. Your support is much appreciated!

-[![Stargazers repo roster for @yolain/ComfyUI-Easy-Use](https://reporoster.com/stars/yolain/ComfyUI-Easy-Use)](https://github.com/yolain/ComfyUI-Easy-Use/stargazers)
+[![Stargazers repo roster for @yolain/ComfyUI-Easy-Use](https://reporoster.com/stars/yolain/ComfyUI-Easy-Use)](https://github.com/yolain/ComfyUI-Easy-Use/stargazers)
+
@@ -1,30 +1,37 @@
-__version__ = "1.2.6"
+__version__ = "1.4.1"

 import yaml
+import json
 import os
 import folder_paths
 import importlib
-from pathlib import Path

-node_list = [
-    "server",
-    "api",
-    "easyNodes",
-    "image",
-    "logic"
-]
+cwd_path = os.path.dirname(os.path.realpath(__file__))
+comfy_path = folder_paths.base_path

 NODE_CLASS_MAPPINGS = {}
 NODE_DISPLAY_NAME_MAPPINGS = {}

-for module_name in node_list:
-    imported_module = importlib.import_module(".py.{}".format(module_name), __name__)
+try:
+    import comfy.supported_models as _supported_models
+    _HAS_DIFFUSION_XY_SUPPORT = (
+        hasattr(_supported_models, "Anima")
+        and hasattr(_supported_models, "Krea2")
+    )
+except Exception:
+    _HAS_DIFFUSION_XY_SUPPORT = False
+
+if not _HAS_DIFFUSION_XY_SUPPORT:
+    print("[ComfyUI-Easy-Use] Anima/Krea2 XY nodes need comfy.supported_models.Anima and Krea2")
+
+importlib.import_module('.py.routes', __name__)
+importlib.import_module('.py.server', __name__)
+nodes_list = ["util", "seed", "prompt", "loaders", "adapter", "inpaint", "preSampling", "samplers", "fix", "pipe", "xyplot", "image", "logic", "api", "deprecated"]
+for module_name in nodes_list:
+    imported_module = importlib.import_module(".py.nodes.{}".format(module_name), __name__)
    NODE_CLASS_MAPPINGS = {**NODE_CLASS_MAPPINGS, **imported_module.NODE_CLASS_MAPPINGS}
    NODE_DISPLAY_NAME_MAPPINGS = {**NODE_DISPLAY_NAME_MAPPINGS, **imported_module.NODE_DISPLAY_NAME_MAPPINGS}

-cwd_path = os.path.dirname(os.path.realpath(__file__))
-comfy_path = folder_paths.base_path
-
 #Wildcards
 from .py.libs.wildcards import read_wildcard_dict
 wildcards_path = os.path.join(os.path.dirname(__file__), "wildcards")
@@ -66,22 +73,7 @@ if not os.path.exists(example_path):
        json.dump(data, f, indent=4, ensure_ascii=False)


-# Model thumbnails
-from .py.libs.add_resources import add_static_resource
-from .py.libs.model import easyModelManager
-model_config = easyModelManager().models_config
-for model in model_config:
-    paths = folder_paths.get_folder_paths(model)
-    for path in paths:
-        if not Path(path).exists():
-            continue
-        add_static_resource(path, path, limit=True)
-
-# get comfyui revision
-from .py.libs.utils import compare_revision
-
-new_frontend_revision = 2546
-web_default_version = 'v2' if compare_revision(new_frontend_revision) else 'v1'
+web_default_version = 'v2'
 # web directory
 config_path = os.path.join(cwd_path, "config.yaml")
 if os.path.isfile(config_path):
@@ -0,0 +1,31 @@
+{
+  "settingsCategories": {
+    "Hotkeys": "Hotkeys",
+    "Nodes": "Nodes",
+    "NodesMap": "NodesMap",
+    "StylesSelector": "StylesSelector"
+  },
+  "nodeCategories": {
+    "Util": "Util",
+    "Seed": "Seed",
+    "Prompt": "Prompt",
+    "Loaders": "Loaders",
+    "Adapter": "Adapter",
+    "Inpaint": "Inpaint",
+    "PreSampling": "PreSampling",
+    "Sampler": "Sampler",
+    "Fix": "Fix",
+    "Pipe": "Pipe",
+    "XY Inputs": "XY Inputs",
+    "Image": "Image",
+    "Segmentation": "Segmentation",
+    "\uD83D\uDEAB Deprecated": "\uD83D\uDEAB Deprecated",
+    "Type": "Type",
+    "Math": "Math",
+    "Switch": "Switch",
+    "Index Switch": "Index Switch",
+    "While Loop": "While Loop",
+    "For Loop": "For Loop",
+    "LoadImage": "Load Image"
+  }
+}
@@ -0,0 +1,67 @@
+{
+  "EasyUse_Hotkeys_AddGroup": {
+    "name": "Enable Shift+g to add the selected nodes to a group",
+    "tooltip": "From v1.2.39, you can use Ctrl+g instead"
+  },
+  "EasyUse_Hotkeys_cleanVRAMUsed": {
+    "name": "Enable Shift+r to unload model and node cache"
+  },
+  "EasyUse_Hotkeys_toggleNodesMap": {
+    "name": "Enable Shift+m to toggle nodes map"
+  },
+  "EasyUse_Hotkeys_AlignSelectedNodes": {
+    "name": "Enable Shift+Up/Down/Left/Right and Shift+Ctrl+Alt+Left/Right to align selected nodes",
+    "tooltip": "Shift+Up/Down/Left/Right can align selected nodes, Shift+Ctrl+Alt+Left/Right can distribute nodes horizontally/vertically"
+  },
+  "EasyUse_Hotkeys_NormalizeSelectedNodes": {
+    "name": "Enable Shift+Ctrl+Left/Right to normalize selected nodes",
+    "tooltip": "Enable Shift+Ctrl+Left to normalize width and Shift+Ctrl+Right to normalize height"
+  },
+  "EasyUse_Hotkeys_NodesTemplate": {
+    "name": "Enable Alt+1~9 to paste node templates into the workflow"
+  },
+  "EasyUse_Hotkeys_JumpNearestNodes": {
+    "name": "Enable Up/Down/Left/Right to jump to the nearest node"
+  },
+  "EasyUse_ContextMenu_SubDirectories": {
+    "name": "Enable automatic nesting of subdirectories in the context menu"
+  },
+  "EasyUse_ContextMenu_ModelsThumbnails": {
+    "name": "Enable model preview thumbnails"
+  },
+  "EasyUse_ContextMenu_NodesSort": {
+    "name": "Enable A~Z sorting of new nodes in the context menu"
+  },
+  "EasyUse_ContextMenu_QuickOptions": {
+    "name": "Use three quick buttons in the context menu",
+    "options": {
+      "At the forefront": "At the forefront",
+      "At the end": "At the end",
+      "Disable": "Disable"
+    }
+  },
+  "EasyUse_Nodes_Runtime": {
+    "name": "Enable node runtime display"
+  },
+  "EasyUse_Nodes_ChainGetSet": {
+    "name": "Enable chaining of get and set points with the parent node"
+  },
+  "EasyUse_NodesMap_Sorting": {
+    "name": "Manage nodes group sorting mode",
+    "tooltip": "Automatically sort by default. If set to manual, groups can be drag and dropped and the order will be saved.",
+    "options": {
+      "Auto sorting": "Auto sorting",
+      "Manual drag&drop sorting": "Manual drag&drop sorting"
+    }
+  },
+  "EasyUse_NodesMap_DisplayNodeID": {
+    "name": "Enable node ID display"
+  },
+  "EasyUse_NodesMap_DisplayGroupOnly": {
+    "name": "Show groups only"
+  },
+  "EasyUse_NodesMap_Enable": {
+    "name": "Enable Group Map",
+    "tooltip": "You need to refresh the page to update successfully"
+  }
+}
@@ -0,0 +1,30 @@
+{
+  "settingsCategories": {
+    "Hotkeys": "Raccourcis",
+    "Nodes": "Nœuds",
+    "NodesMap": "Carte des nœuds"
+  },
+  "nodeCategories": {
+    "Util": "Utilitaire",
+    "Seed": "Graine",
+    "Prompt": "Prompt",
+    "Loaders": "Chargeurs",
+    "Adapter": "Adaptateur",
+    "Inpaint": "Retouche",
+    "PreSampling": "Pré-échantillonnage",
+    "Sampler": "Échantillonneur",
+    "Fix": "Correction",
+    "Pipe": "Pipeline",
+    "XY Inputs": "Entrées XY",
+    "Image": "Image",
+    "Segmentation": "Segmentation",
+    "\uD83D\uDEAB Deprecated": "\uD83D\uDEAB Obsolète",
+    "Type": "Type",
+    "Math": "Mathématiques",
+    "Switch": "Interrupteur",
+    "Index Switch": "Interrupteur d'index",
+    "While Loop": "Boucle While",
+    "For Loop": "Boucle For",
+    "LoadImage": "Charger l'image"
+  }
+}
@@ -0,0 +1,67 @@
+{
+  "EasyUse_Hotkeys_AddGroup": {
+    "name": "Activer Shift+g pour ajouter les nœuds sélectionnés à un groupe",
+    "tooltip": "Depuis la v1.2.39, vous pouvez utiliser Ctrl+g à la place"
+  },
+  "EasyUse_Hotkeys_cleanVRAMUsed": {
+    "name": "Activer Shift+r pour décharger le cache du modèle et des nœuds"
+  },
+  "EasyUse_Hotkeys_toggleNodesMap": {
+    "name": "Activer Shift+m pour basculer la carte des nœuds"
+  },
+  "EasyUse_Hotkeys_AlignSelectedNodes": {
+    "name": "Activer Shift+Up/Down/Left/Right et Shift+Ctrl+Alt+Left/Right pour aligner les nœuds sélectionnés",
+    "tooltip": "Shift+Up/Down/Left/Right peut aligner les nœuds sélectionnés, Shift+Ctrl+Alt+Left/Right peut les répartir horizontalement/verticalement"
+  },
+  "EasyUse_Hotkeys_NormalizeSelectedNodes": {
+    "name": "Activer Shift+Ctrl+Left/Right pour normaliser les nœuds sélectionnés",
+    "tooltip": "Activer Shift+Ctrl+Left pour normaliser la largeur et Shift+Ctrl+Right pour normaliser la hauteur"
+  },
+  "EasyUse_Hotkeys_NodesTemplate": {
+    "name": "Activer Alt+1~9 pour coller les modèles de nœuds dans le workflow"
+  },
+  "EasyUse_Hotkeys_JumpNearestNodes": {
+    "name": "Activer Up/Down/Left/Right pour passer au nœud le plus proche"
+  },
+  "EasyUse_ContextMenu_SubDirectories": {
+    "name": "Activer l'imbrication automatique des sous-répertoires dans le menu contextuel"
+  },
+  "EasyUse_ContextMenu_ModelsThumbnails": {
+    "name": "Activer les vignettes d'aperçu du modèle"
+  },
+  "EasyUse_ContextMenu_NodesSort": {
+    "name": "Activer le tri A~Z des nouveaux nœuds dans le menu contextuel"
+  },
+  "EasyUse_ContextMenu_QuickOptions": {
+    "name": "Utiliser trois boutons rapides dans le menu contextuel",
+    "options": {
+      "At the forefront": "À l'avant-plan",
+      "At the end": "À la fin",
+      "Disable": "Désactiver"
+    }
+  },
+  "EasyUse_Nodes_Runtime": {
+    "name": "Activer l'affichage du temps d'exécution des nœuds"
+  },
+  "EasyUse_Nodes_ChainGetSet": {
+    "name": "Activer le chaînage des points get et set avec le nœud parent"
+  },
+  "EasyUse_NodesMap_Sorting": {
+    "name": "Gérer le mode de tri des groupes de nœuds",
+    "tooltip": "Tri automatique par défaut. Si défini sur manuel, les groupes peuvent être glissés-déposés et l'ordre sera sauvegardé.",
+    "options": {
+      "Auto sorting": "Tri automatique",
+      "Manual drag&drop sorting": "Tri manuel par glisser-déposer"
+    }
+  },
+  "EasyUse_NodesMap_DisplayNodeID": {
+    "name": "Activer l'affichage de l'ID du nœud"
+  },
+  "EasyUse_NodesMap_DisplayGroupOnly": {
+    "name": "Afficher uniquement les groupes"
+  },
+  "EasyUse_NodesMap_Enable": {
+    "name": "Activer la carte des groupes",
+    "tooltip": "Vous devez actualiser la page pour mettre à jour"
+  }
+}
@@ -0,0 +1,30 @@
+{
+  "settingsCategories": {
+    "Hotkeys": "ショートカットキー",
+    "Nodes": "ノード",
+    "NodesMap": "ノードマップ"
+  },
+  "nodeCategories": {
+    "Util": "ユーティリティ",
+    "Seed": "シード",
+    "Prompt": "プロンプト",
+    "Loaders": "ローダー",
+    "Adapter": "アダプター",
+    "Inpaint": "インペイント",
+    "PreSampling": "プリサンプリング",
+    "Sampler": "サンプラー",
+    "Fix": "フィックス",
+    "Pipe": "パイプ",
+    "XY Inputs": "XY入力",
+    "Image": "画像",
+    "Segmentation": "セグメンテーション",
+    "\uD83D\uDEAB Deprecated": "🚫 非推奨",
+    "Type": "タイプ",
+    "Math": "数学",
+    "Switch": "スイッチ",
+    "Index Switch": "インデックススイッチ",
+    "While Loop": "Whileループ",
+    "For Loop": "Forループ",
+    "LoadImage": "画像読み込み"
+  }
+}
@@ -0,0 +1,67 @@
+{
+  "EasyUse_Hotkeys_AddGroup": {
+    "name": "Shift+gを使用して選択したノードをグループに追加する",
+    "tooltip": "v1.2.39以降、Ctrl+gが使用できます"
+  },
+  "EasyUse_Hotkeys_cleanVRAMUsed": {
+    "name": "Shift+rを使用してモデルおよびノードキャッシュをアンロードする"
+  },
+  "EasyUse_Hotkeys_toggleNodesMap": {
+    "name": "Shift+mを使用してノードマップを表示/非表示にします"
+  },
+  "EasyUse_Hotkeys_AlignSelectedNodes": {
+    "name": "Shift+上/下/左/右およびShift+Ctrl+Alt+左/右を使用して選択したノードを整列する",
+    "tooltip": "Shift+上/下/左/右で選択したノードを整列し、Shift+Ctrl+Alt+左/右で水平方向/垂直方向に分布させる"
+  },
+  "EasyUse_Hotkeys_NormalizeSelectedNodes": {
+    "name": "Shift+Ctrl+左/右を使用して選択したノードのサイズを正規化する",
+    "tooltip": "Shift+Ctrl+左で幅を、Shift+Ctrl+右で高さを正規化する"
+  },
+  "EasyUse_Hotkeys_NodesTemplate": {
+    "name": "Alt+1~9を使用してワークフローにノードテンプレートを貼り付ける"
+  },
+  "EasyUse_Hotkeys_JumpNearestNodes": {
+    "name": "上/下/左/右を使用して最も近いノードにジャンプする"
+  },
+  "EasyUse_ContextMenu_SubDirectories": {
+    "name": "コンテキストメニューでサブディレクトリを自動でネストする"
+  },
+  "EasyUse_ContextMenu_ModelsThumbnails": {
+    "name": "モデルプレビューサムネイルを有効にする"
+  },
+  "EasyUse_ContextMenu_NodesSort": {
+    "name": "コンテキストメニューで新規ノードをA~Z順に並べ替える"
+  },
+  "EasyUse_ContextMenu_QuickOptions": {
+    "name": "コンテキストメニューで3つのクイックボタンを使用する",
+    "options": {
+      "At the forefront": "最前面に",
+      "At the end": "最後に",
+      "Disable": "無効"
+    }
+  },
+  "EasyUse_Nodes_Runtime": {
+    "name": "ノードの実行時間表示を有効にする"
+  },
+  "EasyUse_Nodes_ChainGetSet": {
+    "name": "親ノードと取得/設定ポイントを連結することを有効にする"
+  },
+  "EasyUse_NodesMap_Sorting": {
+    "name": "ノードグループの並べ替えモードを管理する",
+    "tooltip": "デフォルトで自動的に並べ替えます。マニュアルに設定した場合、グループをドラッグアンドドロップで並べ替え、順序が保存されます。",
+    "options": {
+      "Auto sorting": "自動並べ替え",
+      "Manual drag&drop sorting": "手動ドラッグアンドドロップによる並べ替え"
+    }
+  },
+  "EasyUse_NodesMap_DisplayNodeID": {
+    "name": "ノードIDの表示を有効にする"
+  },
+  "EasyUse_NodesMap_DisplayGroupOnly": {
+    "name": "グループのみ表示する"
+  },
+  "EasyUse_NodesMap_Enable": {
+    "name": "グループマップを有効にする",
+    "tooltip": "ページを更新する必要があります"
+  }
+}
@@ -0,0 +1,30 @@
+{
+  "settingsCategories": {
+    "Hotkeys": "단축키",
+    "Nodes": "노드",
+    "NodesMap": "노드 맵"
+  },
+  "nodeCategories": {
+    "Util": "유틸",
+    "Seed": "시드",
+    "Prompt": "프롬프트",
+    "Loaders": "로더",
+    "Adapter": "어댑터",
+    "Inpaint": "인페인트",
+    "PreSampling": "사전 샘플링",
+    "Sampler": "샘플러",
+    "Fix": "픽스",
+    "Pipe": "파이프",
+    "XY Inputs": "XY 입력",
+    "Image": "이미지",
+    "Segmentation": "분할",
+    "\uD83D\uDEAB Deprecated": "\uD83D\uDEAB 사용 중단",
+    "Type": "유형",
+    "Math": "수학",
+    "Switch": "스위치",
+    "Index Switch": "인덱스 스위치",
+    "While Loop": "while 루프",
+    "For Loop": "for 루프",
+    "LoadImage": "이미지 로드"
+  }
+}
@@ -0,0 +1,67 @@
+{
+  "EasyUse_Hotkeys_AddGroup": {
+    "name": "Shift+g 를 사용하여 선택된 노드를 그룹에 추가합니다",
+    "tooltip": "v1.2.39부터는 Ctrl+g 를 사용할 수 있습니다"
+  },
+  "EasyUse_Hotkeys_cleanVRAMUsed": {
+    "name": "Shift+r 를 사용하여 모델 및 노드 캐시를 언로드합니다"
+  },
+  "EasyUse_Hotkeys_toggleNodesMap": {
+    "name": "Shift+m 를 사용하여 노드 맵을 전환합니다"
+  },
+  "EasyUse_Hotkeys_AlignSelectedNodes": {
+    "name": "Shift+Up/Down/Left/Right 와 Shift+Ctrl+Alt+Left/Right 를 사용하여 선택된 노드를 정렬합니다",
+    "tooltip": "Shift+Up/Down/Left/Right 는 선택된 노드를 정렬하며, Shift+Ctrl+Alt+Left/Right 는 노드를 수평/수직으로 분배합니다"
+  },
+  "EasyUse_Hotkeys_NormalizeSelectedNodes": {
+    "name": "Shift+Ctrl+Left/Right 를 사용하여 선택된 노드를 정규화합니다",
+    "tooltip": "Shift+Ctrl+Left 는 너비를, Shift+Ctrl+Right 는 높이를 정규화합니다"
+  },
+  "EasyUse_Hotkeys_NodesTemplate": {
+    "name": "Alt+1~9 를 사용하여 워크플로우에 노드 템플릿을 붙여넣습니다"
+  },
+  "EasyUse_Hotkeys_JumpNearestNodes": {
+    "name": "Up/Down/Left/Right 를 사용하여 가장 가까운 노드로 이동합니다"
+  },
+  "EasyUse_ContextMenu_SubDirectories": {
+    "name": "컨텍스트 메뉴에서 자동으로 하위 디렉토리를 중첩합니다"
+  },
+  "EasyUse_ContextMenu_ModelsThumbnails": {
+    "name": "모델 미리보기 썸네일을 활성화합니다"
+  },
+  "EasyUse_ContextMenu_NodesSort": {
+    "name": "컨텍스트 메뉴에서 새로운 노드를 A~Z 순으로 정렬합니다"
+  },
+  "EasyUse_ContextMenu_QuickOptions": {
+    "name": "컨텍스트 메뉴에 3개의 빠른 옵션 버튼을 사용합니다",
+    "options": {
+      "At the forefront": "앞쪽에",
+      "At the end": "뒤쪽에",
+      "Disable": "비활성화"
+    }
+  },
+  "EasyUse_Nodes_Runtime": {
+    "name": "노드 실행 시간 표시를 활성화합니다"
+  },
+  "EasyUse_Nodes_ChainGetSet": {
+    "name": "부모 노드와 연결된 get/ set 포인트 체이닝을 활성화합니다"
+  },
+  "EasyUse_NodesMap_Sorting": {
+    "name": "노드 그룹 정렬 모드를 관리합니다",
+    "tooltip": "기본값은 자동 정렬입니다. 수동으로 설정하면 그룹을 드래그 앤 드롭할 수 있으며 순서가 저장됩니다.",
+    "options": {
+      "Auto sorting": "자동 정렬",
+      "Manual drag&drop sorting": "수동 드래그 앤 드롭 정렬"
+    }
+  },
+  "EasyUse_NodesMap_DisplayNodeID": {
+    "name": "노드 ID 표시를 활성화합니다"
+  },
+  "EasyUse_NodesMap_DisplayGroupOnly": {
+    "name": "그룹만 표시합니다"
+  },
+  "EasyUse_NodesMap_Enable": {
+    "name": "그룹 맵을 활성화합니다",
+    "tooltip": "업데이트를 위해 페이지를 새로고침해야 합니다"
+  }
+}
@@ -0,0 +1,30 @@
+{
+  "settingsCategories": {
+    "Hotkeys": "Горячие клавиши",
+    "Nodes": "Узлы",
+    "NodesMap": "Карта узлов"
+  },
+  "nodeCategories": {
+    "Util": "Утилиты",
+    "Seed": "Сид",
+    "Prompt": "Подсказка",
+    "Loaders": "Загрузчики",
+    "Adapter": "Адаптер",
+    "Inpaint": "Ретушь",
+    "PreSampling": "Предвыборка",
+    "Sampler": "Сэмплер",
+    "Fix": "Исправление",
+    "Pipe": "Конвейер",
+    "XY Inputs": "Ввод XY",
+    "Image": "Изображение",
+    "Segmentation": "Сегментация",
+    "\uD83D\uDEAB Deprecated": "\uD83D\uDEAB Устарело",
+    "Type": "Тип",
+    "Math": "Математика",
+    "Switch": "Переключатель",
+    "Index Switch": "Переключатель индексов",
+    "While Loop": "Цикл while",
+    "For Loop": "Цикл for",
+    "LoadImage": "Загрузка изображения"
+  }
+}
@@ -0,0 +1,67 @@
+{
+  "EasyUse_Hotkeys_AddGroup": {
+    "name": "Включить Shift+g для добавления выделенных узлов в группу",
+    "tooltip": "Начиная с версии v1.2.39, можно использовать Ctrl+g"
+  },
+  "EasyUse_Hotkeys_cleanVRAMUsed": {
+    "name": "Включить Shift+r для выгрузки модели и кэша узлов"
+  },
+  "EasyUse_Hotkeys_toggleNodesMap": {
+    "name": "Включить Shift+m для переключения карты узлов"
+  },
+  "EasyUse_Hotkeys_AlignSelectedNodes": {
+    "name": "Включить Shift+Стрелки для выравнивания выделенных узлов и Shift+Ctrl+Alt+Стрелки для распределения узлов по горизонтали/вертикали",
+    "tooltip": "Shift+Стрелки выравнивают выделенные узлы, Shift+Ctrl+Alt+Стрелки распределяют узлы по горизонтали/вертикали"
+  },
+  "EasyUse_Hotkeys_NormalizeSelectedNodes": {
+    "name": "Включить Shift+Ctrl+Стрелки для нормализации выделенных узлов",
+    "tooltip": "Включить Shift+Ctrl+Лево для нормализации ширины и Shift+Ctrl+Право для нормализации высоты"
+  },
+  "EasyUse_Hotkeys_NodesTemplate": {
+    "name": "Включить Alt+1~9 для вставки шаблонов узлов в рабочий процесс"
+  },
+  "EasyUse_Hotkeys_JumpNearestNodes": {
+    "name": "Включить Стрелки для перехода к ближайшему узлу"
+  },
+  "EasyUse_ContextMenu_SubDirectories": {
+    "name": "Включить автоматическое вложение подкаталогов в контекстном меню"
+  },
+  "EasyUse_ContextMenu_ModelsThumbnails": {
+    "name": "Включить превью миниатюр моделей"
+  },
+  "EasyUse_ContextMenu_NodesSort": {
+    "name": "Включить A~Z сортировку новых узлов в контекстном меню"
+  },
+  "EasyUse_ContextMenu_QuickOptions": {
+    "name": "Использовать три быстрых кнопки в контекстном меню",
+    "options": {
+      "At the forefront": "В начале",
+      "At the end": "В конце",
+      "Disable": "Отключено"
+    }
+  },
+  "EasyUse_Nodes_Runtime": {
+    "name": "Включить отображение времени выполнения узлов"
+  },
+  "EasyUse_Nodes_ChainGetSet": {
+    "name": "Включить связывание точек получения и установки с родительским узлом"
+  },
+  "EasyUse_NodesMap_Sorting": {
+    "name": "Управление режимом сортировки групп узлов",
+    "tooltip": "По умолчанию автоматическая сортировка. При ручном режиме группы можно перемещать методом перетаскивания, и порядок будет сохранён.",
+    "options": {
+      "Auto sorting": "Автоматическая сортировка",
+      "Manual drag&drop sorting": "Ручная сортировка перетаскиванием"
+    }
+  },
+  "EasyUse_NodesMap_DisplayNodeID": {
+    "name": "Включить отображение ID узлов"
+  },
+  "EasyUse_NodesMap_DisplayGroupOnly": {
+    "name": "Показывать только группы"
+  },
+  "EasyUse_NodesMap_Enable": {
+    "name": "Включить карту групп",
+    "tooltip": "Необходимо обновить страницу для успешного обновления"
+  }
+}
@@ -0,0 +1,33 @@
+{
+  "settingsCategories": {
+    "Hotkeys": "快捷键",
+    "Nodes": "节点相关",
+    "NodesMap": "管理节点组",
+    "StylesSelector": "样式选择器",
+    "MultiAngle": "摄影机多角度提示词"
+  },
+  "nodeCategories": {
+    "Util": "工具",
+    "Seed": "随机种",
+    "Prompt": "提示词",
+    "Loaders": "模型加载器",
+    "Adapter": "模型适配器",
+    "Inpaint": "内补重绘",
+    "PreSampling": "预采样参数",
+    "Sampler": "采样器",
+    "Fix": "修复相关",
+    "Pipe": "节点束",
+    "XY Inputs": "XY图表输入项",
+    "Image": "图像",
+    "Segmentation": "分割",
+    "Logic": "逻辑",
+    "\uD83D\uDEAB Deprecated": "\uD83D\uDEAB 已弃用",
+    "Type": "类型",
+    "Math": "数学计算",
+    "Switch": "开关",
+    "Index Switch": "索引开关",
+    "While Loop": "While循环",
+    "For Loop": "For循环",
+    "LoadImage": "加载图像"
+  }
+}
@@ -0,0 +1,86 @@
+{
+  "EasyUse_Hotkeys_AddGroup": {
+    "name": "启用 Shift+g 键将选中的节点添加一个组",
+    "tooltip": "从v1.2.39开始，可以使用Ctrl+g代替"
+  },
+  "EasyUse_Hotkeys_cleanVRAMUsed": {
+    "name": "启用 Shift+r 键卸载模型和节点缓存"
+  },
+  "EasyUse_Hotkeys_toggleNodesMap": {
+    "name": "启用 Shift+m 键显隐管理节点组"
+  },
+  "EasyUse_Hotkeys_AlignSelectedNodes": {
+    "name": "启用 Shift+上/下/左/右 和 Shift+Ctrl+Alt+左/右 键对齐选中的节点",
+    "tooltip": "Shift+上/下/左/右 可以对齐选中的节点, Shift+Ctrl+Alt+左/右 可以水平/垂直分布节点"
+  },
+  "EasyUse_Hotkeys_NormalizeSelectedNodes": {
+    "name": "启用 Shift+Ctrl+左/右 键规范化选中的节点",
+    "tooltip": "启用 Shift+Ctrl+左 键规范化宽度和 Shift+Ctrl+右 键规范化高度"
+  },
+  "EasyUse_Hotkeys_NodesTemplate": {
+    "name": "启用 Alt+1~9 从节点模板粘贴到工作流中"
+  },
+  "EasyUse_Hotkeys_JumpNearestNodes": {
+    "name": "启用 上/下/左/右 键跳转到最近的前后节点"
+  },
+  "EasyUse_ContextMenu_SubDirectories": {
+    "name": "启用上下文菜单自动嵌套子目录"
+  },
+  "EasyUse_ContextMenu_ModelsThumbnails": {
+    "name": "启动模型预览图显示"
+  },
+  "EasyUse_ContextMenu_NodesSort": {
+    "name": "启用右键菜单中新建节点A~Z排序"
+  },
+  "EasyUse_ContextMenu_QuickOptions": {
+    "name": "在右键菜单中使用三个快捷按钮",
+    "options": {
+      "At the forefront": "在最前面",
+      "At the end": "在最后面",
+      "Disable": "禁用"
+    }
+  },
+  "EasyUse_Nodes_Runtime": {
+    "name": "启动节点运行时间显示"
+  },
+  "EasyUse_Nodes_ChainGetSet": {
+    "name": "启用将获取点和设置点与父节点链在一起"
+  },
+  "EasyUse_NodesMap_Sorting": {
+    "name": "管理节点组排序模式",
+    "tooltip": "默认自动排序，如果设置为手动，组可以拖放并保存排序结果。",
+    "options": {
+        "Auto sorting": "自动排序",
+        "Manual drag&drop sorting": "手动拖拽排序"
+    }
+  },
+  "EasyUse_NodesMap_DisplayNodeID": {
+    "name": "启用节点ID显示"
+  },
+  "EasyUse_NodesMap_DisplayGroupOnly": {
+    "name": "仅显示组"
+  },
+  "EasyUse_NodesMap_Enable": {
+    "name": "启用管理节点组",
+    "tooltip": "您需要刷新页面以成功更新"
+  },
+  "EasyUse_StylesSelector_DisplayType": {
+    "name": "样式选择器显示类型",
+    "tooltip": "样式选择器显示类型，如果设置为“网格”，则显示为网格，如果设置为“列表”，则显示为列表",
+    "options": {
+      "Grid": "网格",
+      "List": "列表"
+    }
+  },
+  "EasyUse_MultiAngle_InvertRotate": {
+    "name": "启用反转旋转模式",
+    "tooltip": "在多角度节点中启用反转旋转模式，使旋转方向与大多数3D软件一致"
+  },
+  "EasyUse_MultiAngle_HollowMode": {
+    "name": "启用多角度镂空展示模式",
+    "tooltip": "在多角度节点中启用镂空展示模式，可以更直观地查看相机角度"
+  },
+  "EasyUse_MultiAngle_AddAnglePrompt": {
+    "name": "启用添加多角度提示词"
+  }
+}
@@ -31,7 +31,4 @@ add_folder_path_and_extensions("mediapipe", [os.path.join(model_path, "mediapipe
 add_folder_path_and_extensions("inpaint", [os.path.join(model_path, "inpaint")], folder_paths.supported_pt_extensions)
 add_folder_path_and_extensions("prompt_generator", [os.path.join(model_path, "prompt_generator")], folder_paths.supported_pt_extensions)
 add_folder_path_and_extensions("t5", [os.path.join(model_path, "t5")], folder_paths.supported_pt_extensions)
-add_folder_path_and_extensions("llm", [os.path.join(model_path, "LLM")], folder_paths.supported_pt_extensions)
-
-add_folder_path_and_extensions("checkpoints_thumb", [os.path.join(model_path, "checkpoints")], image_suffixs)
-add_folder_path_and_extensions("loras_thumb", [os.path.join(model_path, "loras")], image_suffixs)
+add_folder_path_and_extensions("llm", [os.path.join(model_path, "LLM")], folder_paths.supported_pt_extensions)
@@ -0,0 +1,6 @@
+from .libs.loader import easyLoader
+from .libs.sampler import easySampler
+
+sampler = easySampler()
+easyCache = easyLoader()
+
@@ -193,6 +193,9 @@ REMBG_MODELS = {
    },
    "RMBG-2.0": {
        "model_url": "briaai/RMBG-2.0"
+    },
+    "BEN2": {
+        "model_url": "https://huggingface.co/PramaLLC/BEN2/resolve/main/BEN2_Base.pth"
    }
 }

@@ -333,7 +336,7 @@ IPADAPTER_CLIPVISION_MODELS = {
        "model_url": "https://huggingface.co/openai/clip-vit-large-patch14-336/resolve/main/pytorch_model.bin"
    },
    "clip-vit-h-14-laion2B-s32B-b79K":{
-        "model_url": "https://huggingface.co/laion/CLIP-ViT-H-14-laion2B-s32B-b79K/resolve/main/open_clip_pytorch_model.safetensors"
+        "model_url": "https://huggingface.co/laion/CLIP-ViT-H-14-laion2B-s32B-b79K/resolve/main/open_clip_model.safetensors"
    },
    "sigclip_vision_patch14_384":{
        "model_url": "https://huggingface.co/Comfy-Org/sigclip_vision_384/resolve/main/sigclip_vision_patch14_384.safetensors"
@@ -347,7 +350,7 @@ DYNAMICRAFTER_MODELS = {
        "model_url": "https://huggingface.co/ExponentialML/DynamiCrafterUNet/resolve/main/dynamicrafter_unet_512.safetensors",
        "vae_url": "https://huggingface.co/stabilityai/sd-vae-ft-mse-original/resolve/main/vae-ft-mse-840000-ema-pruned.safetensors",
        "clip_url": "https://huggingface.co/stabilityai/stable-diffusion-2-1/resolve/main/text_encoder/model.safetensors",
-        "clip_vision_url": "https://huggingface.co/laion/CLIP-ViT-H-14-laion2B-s32B-b79K/resolve/main/open_clip_pytorch_model.safetensors",
+        "clip_vision_url": "https://huggingface.co/laion/CLIP-ViT-H-14-laion2B-s32B-b79K/resolve/main/open_clip_model.safetensors",
    },
    "dynamicrafter_unet_512_interp (2.98GB)": {
        "model_url": "https://huggingface.co/ExponentialML/DynamiCrafterUNet/resolve/main/dynamicrafter_unet_512_interp.safetensors"
@@ -367,6 +370,15 @@ HUMANPARSING_MODELS = {
    },
    "human-parts":{
        "model_url":"https://huggingface.co/Metal3d/deeplabv3p-resnet50-human/resolve/main/deeplabv3p-resnet50-human.onnx",
+    },
+    "segformer_b3_clothes":{
+        "model_name": "sayeed99/segformer_b3_clothes",
+    },
+    "segformer_b3_fashion":{
+        "model_name": "sayeed99/segformer-b3-fashion",
+    },
+    "face_parsing":{
+        "model_name": "jonathandinu/face-parsing"
    }
 }

@@ -376,4 +388,38 @@ MEDIAPIPE_MODELS = {
    "selfie_multiclass_256x256": {
        "model_url": "https://huggingface.co/yolain/selfie_multiclass_256x256/resolve/main/selfie_multiclass_256x256.tflite"
    }
-}
+}
+
+
+#prompt template
+PROMPT_TEMPLATE = {
+    "prefix": ["Detailed photo of", "Amateur photo of", "Flicker 2008 photo of", "Fantastic artwork of",
+               "Vintage photograph of", "Unreal 5 render of", "Surrealist painting of",
+               "Professional advertising design of"],
+    "subject": ["a man", "a woman", "a young man", "a young woman", "a handsome man", "a beautiful woman", "a monster", "a toy", "a product", "a buddha", "a dog", "a cat"],
+    "action": ["looking at viewer", "looking away", "looking up", "looking down", "looking back", "open mouth", "half-closed mouth", "closed mouth", "open eyes", "half-closed eyes", "closed eyes", "wink", "standing", "sitting", "lying", "walking", "running", "adjusting hair", "waving", "hand on hip", "crossed arms", "smile", "sad", "angry", "sleepy", "tired", "expressionless"],
+    "clothes": ["underwear", "clothed", "casual", "dress", "swimsuit", "uniform", "bikini", "one-piece swimsuit", "shirt", "blouse", "sweater", "hoodie", "jeans", "pants", "shorts", "skirt", "vest", "coat", "trenchoat", "jacket", "short dress", "long dress", "off-shoulder", "backless", "hairbow", "hair ribbon", "hair tie", "hairband", "cap", "beanie",  "bucket hat", "sun hat", "straw hat", "rice hat", "witch hat", "crown", "chain necklace", "tooth necklace", "choker", "pendant", "bracelet", "watch", "ring", "earring", "anklet", "belt", "scarf", "gloves", "mittens", "socks", "stockings", "tights", "leggings", "boots", "sneakers", "heels", "sandals", "flip-flops", "slippers", "loafers", "mules", "oxfords", "brogues", "derbies", "monk shoes", "chelsea boots", "combat boots", "riding boots", "rain boots", "wedge heels", "platform heels", "stilettos", "block heels", "kitten heels", "moccasins", "espadrilles", "pumps", "flats", "ballet flats", "mary janes", "slingbacks", "peep-toe", "mule sandals", "gladiator sandals", "thong sandals", "slide sandals", "espadrille sandals", "wedge sandals", "platform sandals", "ankle boots", "knee-high boots", "over-the-knee boots", "thigh-high boots", "wellington boots", "chukka boots", "desert boots", "chelsea boots", "hiking boots", "work boots", "snow boots", "rain boots", "riding boots", "cowboy boots", "combat boots", "biker boots", "duck boots", "military boots", "western boots", "ankle strap heels", "block heels", "chunky heels", "cone heels", "kitten heels", "platform heels", "pumps", "slingback heels", "stiletto heels", "wedge heels", "mules", "slingbacks", "slides", "thong sandals", "gladiator sandals", "espadrilles", "wedge sandals", "platform sandals", "ankle boots", "knee-high boots", "over-the-knee boots", "thigh-high boots", "wellington boots", "chukka boots", "desert boots", "chelsea boots", "hiking boots", "work boots", "snow boots", "rain boots", "riding boots", "cowboy boots", "combat boots", "biker boots", "duck boots", "military boots", "western boots", "ankle strap heels", "block heels" ],
+    "environment": ["sunshine from window", "neon night, city", "sunset over sea", "golden time", "sci-fi RGB glowing, cyberpunk", "natural lighting", "warm atmosphere, at home, bedroom", "magic lit", "evil, gothic, in a cave", "light and shadow", "shadow from window", "soft studio lighting", "home atmosphere, cozy bedroom illumination", "neon, Wong Kar-wai, warm", "moonlight through curtains", "stormy sky lighting", "underwater glow, deep sea", "foggy forest at dawn", "golden hour in a meadow", "rainbow reflections, neon", "cozy candlelight", "apocalyptic, smoky atmosphere", "red glow, emergency lights", "mystical glow, enchanted forest", "campfire light", "harsh, industrial lighting", "sunrise in the mountains", "evening glow in the desert", "moonlight in a dark alley", "golden glow at a fairground", "midnight in the forest", "purple and pink hues at twilight", "foggy morning, muted light", "candle-lit room, rustic vibe", "fluorescent office lighting", "lightning flash in storm", "night, cozy warm light from fireplace", "ethereal glow, magical forest", "dusky evening on a beach", "afternoon light filtering through trees", "blue neon light, urban street", "red and blue police lights in rain", "aurora borealis glow, arctic landscape", "sunrise through foggy mountains", "golden hour on a city skyline", "mysterious twilight, heavy mist", "early morning rays, forest clearing", "colorful lantern light at festival", "soft glow through stained glass", "harsh spotlight in dark room", "mellow evening glow on a lake", "crystal reflections in a cave", "vibrant autumn lighting in a forest", "gentle snowfall at dusk", "hazy light of a winter morning", "soft, diffused foggy glow", "underwater luminescence", "rain-soaked reflections in city lights", "golden sunlight streaming through trees", "fireflies lighting up a summer night", "glowing embers from a forge", "dim candlelight in a gothic castle", "midnight sky with bright starlight", "warm sunset in a rural village", "flickering light in a haunted house", "desert sunset with mirage-like glow", "golden beams piercing through storm clouds"],
+    "background": ["cars and people", "a cozy bed and a lamp", "a forest clearing with mist", "a bustling marketplace", "a quiet beach at dusk", "an old, cobblestone street", "a futuristic cityscape", "a tranquil lake with mountains", "a mysterious cave entrance", "bookshelves and plants in the background", "an ancient temple in ruins", "tall skyscrapers and neon signs", "a starry sky over a desert", "a bustling café", "rolling hills and farmland", "a modern living room with a fireplace", "an abandoned warehouse", "a picturesque mountain range", "a starry night sky", "the interior of a futuristic spaceship", "the cluttered workshop of an inventor", "the glowing embers of a bonfire", "a misty lake surrounded by trees", "an ornate palace hall", "a busy street market", "a vast desert landscape", "a peaceful library corner", "bustling train station", "a mystical, enchanted forest", "an underwater reef with colorful fish", "a quiet rural village", "a sandy beach with palm trees", "a vibrant coral reef, teeming with life", "snow-capped mountains in distance", "a stormy ocean, waves crashing", "a rustic barn in open fields", "a futuristic lab with glowing screens", "a dark, abandoned castle", "the ruins of an ancient civilization", "a bustling urban street in rain", "an elegant grand ballroom", "a sprawling field of wildflowers", "a dense jungle with sunlight filtering through", "a dimly lit, vintage bar", "an ice cave with sparkling crystals", "a serene riverbank at sunset", "a narrow alley with graffiti walls", "a peaceful zen garden with koi pond", "a high-tech control room", "a quiet mountain village at dawn", "a lighthouse on a rocky coast", "a rainy street with flickering lights", "a frozen lake with ice formations", "an abandoned theme park", "a small fishing village on a pier", "rolling sand dunes in a desert", "a dense forest with towering redwoods", "a snowy cabin in the mountains", "a mystical cave with bioluminescent plants", "a castle courtyard under moonlight", "a bustling open-air night market", "an old train station with steam", "a tranquil waterfall surrounded by trees", "a vineyard in the countryside", "a quaint medieval village", "a bustling harbor with boats", "a high-tech futuristic mall", "a lush tropical rainforest"],
+    "nsfw": ["nude", "breast", "small breast", "middle breast", "large breast", "nipples", "clothes lift", "pussy juice trail", "pussy juice puddle", "small testicles", "medium testicles", "large testicles", "disembodied penis", "cum on body", "cum inside", "cum outside", "fingering", "handjob", "fellatio", "licking penis", "paizuri",  "doggystyle", "cowgirl", "reversed cowgirl", "piledriver", "suspended congress", "full nelson",],
+}
+
+NEW_SCHEDULERS = ['align_your_steps', 'gits']
+
+DIFFUSION_MODEL_XY_DEFAULTS = {
+    "anima": {
+        "clip_name": "qwen_3_06b_base.safetensors",
+        "clip_type": "anima",
+        "vae_name": "qwen_image_vae.safetensors",
+    },
+    "krea2": {
+        "clip_name": "Huihui-Qwen3-VL-4B-Instruct-abliterated-fp8_scaled.safetensors",
+        "clip_type": "krea2",
+        "vae_name": "qwen_image_vae.safetensors",
+    },
+}
+
+DIFFUSION_MODEL_CLIP_TYPES = {
+    "anima": "anima",
+    "krea2": "krea2",
+}
@@ -1,334 +0,0 @@
-#credit to ExponentialML for this module
-#from https://github.com/ExponentialML/ComfyUI_Native_DynamiCrafter
-import os
-import torch
-import comfy
-
-from einops import rearrange
-from comfy import model_base, model_management
-from .lvdm.modules.networks.openaimodel3d import UNetModel as DynamiCrafterUNetModel
-
-from .utils.model_utils import DynamiCrafterBase, DYNAMICRAFTER_CONFIG, load_image_proj_dict, load_dynamicrafter_dict, get_image_proj_model
-
-class DynamiCrafter:
-
-    def __init__(self):
-        self.model_patcher = None
-
-    # There is probably a better way to do this, but with the apply_model callback, this seems necessary.
-    # The model gets wrapped around a CFG Denoiser class, and handles the conditioning parts there.
-    # We cannot access it, so we must find the conditioning according to how ComfyUI handles it.
-    def get_conditioning_pair(self, c_crossattn, use_cfg: bool):
-        if not use_cfg:
-            return c_crossattn
-
-        conditioning_group = []
-
-        for i in range(c_crossattn.shape[0]):
-            # Get the positive and negative conditioning.
-            positive_idx = i + 1
-            negative_idx = i
-
-            if positive_idx >= c_crossattn.shape[0]:
-                break
-
-            if not torch.equal(c_crossattn[[positive_idx]], c_crossattn[[negative_idx]]):
-                conditioning_group = [
-                    c_crossattn[[positive_idx]],
-                    c_crossattn[[negative_idx]]
-                ]
-                break
-
-        if len(conditioning_group) == 0:
-            raise ValueError("Could not get the appropriate conditioning group.")
-
-        return torch.cat(conditioning_group)
-
-    # apply_model, {"input": input_x, "timestep": timestep_, "c": c, "cond_or_uncond": cond_or_uncond}
-    def _forward(self, *args):
-        transformer_options = self.model_patcher.model_options['transformer_options']
-        conditioning = transformer_options['conditioning']
-
-        apply_model = args[0]
-
-        # forward_dict
-        fd = args[1]
-
-        x, t, model_in_kwargs, _ = fd['input'], fd['timestep'], fd['c'], fd['cond_or_uncond']
-
-        c_crossattn = model_in_kwargs.pop("c_crossattn")
-        c_concat = conditioning['c_concat']
-        num_video_frames = conditioning['num_video_frames']
-        fs = conditioning['fs']
-
-        original_num_frames = num_video_frames
-
-        # Better way to determine if we're using CFG
-        # The cond batch will always be num_frames >= 2 since we're doing video,
-        # so we need get this condition differently here.
-        if x.shape[0] > num_video_frames:
-            num_video_frames *= 2
-            batch_size = 2
-            use_cfg = True
-        else:
-            use_cfg = False
-            batch_size = 1
-
-        if use_cfg:
-            c_concat = torch.cat([c_concat] * 2)
-
-        self.validate_forwardable_latent(x, c_concat, num_video_frames, use_cfg)
-
-        x_in, c_concat = map(lambda xc: rearrange(xc, '(b t) c h w -> b c t h w', b=batch_size), (x, c_concat))
-
-        # We always assume video, so there will always be batched conditionings.
-        c_crossattn = self.get_conditioning_pair(c_crossattn, use_cfg)
-        c_crossattn = c_crossattn[:2] if use_cfg else c_crossattn[:1]
-        context_in = c_crossattn
-
-        img_embs = conditioning['image_emb']
-
-        if use_cfg:
-            img_emb_uncond = conditioning['image_emb_uncond']
-            img_embs = torch.cat([img_embs, img_emb_uncond])
-
-        fs = torch.cat([fs] * x_in.shape[0])
-
-        outs = []
-        for i in range(batch_size):
-            model_in_kwargs['transformer_options']['cond_idx'] = i
-            x_out = apply_model(
-                x_in[[i]],
-                t=torch.cat([t[:1]]),
-                context_in=context_in[[i]],
-                c_crossattn=c_crossattn,
-                cc_concat=c_concat[[i]],  # "cc" is to handle naming conflict with apply_model wrapper.
-                # We want to handle this in the UNet forward.
-                num_video_frames=num_video_frames // 2 if batch_size > 1 else num_video_frames,
-                img_emb=img_embs[[i]],
-                fs=fs[[i]],
-                **model_in_kwargs
-            )
-            outs.append(x_out)
-
-        x_out = torch.cat(list(reversed(outs)))
-        x_out = rearrange(x_out, 'b c t h w -> (b t) c h w')
-
-        return x_out
-
-    def assign_forward_args(
-            self,
-            model,
-            c_concat,
-            image_emb,
-            image_emb_uncond,
-            fs,
-            frames,
-    ):
-        model.model_options['transformer_options']['conditioning'] = {
-            "c_concat": c_concat,
-            "image_emb": image_emb,
-            'image_emb_uncond': image_emb_uncond,
-            "fs": fs,
-            "num_video_frames": frames,
-        }
-
-    def validate_forwardable_latent(self, latent, c_concat, num_video_frames, use_cfg):
-        check_no_cfg = latent.shape[0] != num_video_frames
-        check_with_cfg = latent.shape[0] != (num_video_frames * 2)
-
-        latent_batch_size = latent.shape[0] if not use_cfg else latent.shape[0] // 2
-        num_frames = num_video_frames if not use_cfg else num_video_frames // 2
-
-        if all([check_no_cfg, check_with_cfg]):
-            raise ValueError(
-                "Please make sure your latent inputs match the number of frames in the DynamiCrafter Processor."
-                f"Got a latent batch size of ({latent_batch_size}) with number of frames being ({num_frames})."
-            )
-
-        latent_h, latent_w = latent.shape[-2:]
-        c_concat_h, c_concat_w = c_concat.shape[-2:]
-
-        if not all([latent_h == c_concat_h, latent_w == c_concat_w]):
-            raise ValueError(
-                "Please make sure that your input latent and image frames are the same height and width.",
-                f"Image Size: {c_concat_w * 8}, {c_concat_h * 8}, Latent Size: {latent_h * 8}, {latent_w * 8}"
-            )
-
-    def process_image_conditioning(
-            self,
-            model,
-            clip_vision,
-            vae,
-            image_proj_model,
-            images,
-            use_interpolate,
-            fps: int,
-            frames: int,
-            scale_latents: bool
-    ):
-        self.model_patcher = model
-        encoded_latent = vae.encode(images[:, :, :, :3])
-
-        encoded_image = clip_vision.encode_image(images[:1])['last_hidden_state']
-        image_emb = image_proj_model(encoded_image)
-
-        encoded_image_uncond = clip_vision.encode_image(torch.zeros_like(images)[:1])['last_hidden_state']
-        image_emb_uncond = image_proj_model(encoded_image_uncond)
-
-        c_concat = encoded_latent
-
-        if scale_latents:
-            vae_process_input = vae.process_input
-            vae.process_input = lambda image: (image - .5) * 2
-            c_concat = vae.encode(images[:, :, :, :3])
-            vae.process_input = vae_process_input
-            c_concat = model.model.process_latent_in(c_concat) * 1.3
-        else:
-            c_concat = model.model.process_latent_in(c_concat)
-
-        fs = torch.tensor([fps], dtype=torch.long, device=model_management.intermediate_device())
-
-        model.set_model_unet_function_wrapper(self._forward)
-
-        used_interpolate_processing = False
-
-        if use_interpolate and frames > 16:
-            raise ValueError(
-                "When using interpolation mode, the maximum amount of frames are 16."
-                "If you're doing long video generation, consider using the last frame\
-                     from the first generation for the next one (autoregressive)."
-            )
-        if encoded_latent.shape[0] == 1:
-            c_concat = torch.cat([c_concat] * frames, dim=0)[:frames]
-
-            if use_interpolate:
-                mask = torch.zeros_like(c_concat)
-                mask[:1] = c_concat[:1]
-                c_concat = mask
-
-                used_interpolate_processing = True
-        else:
-            if use_interpolate and c_concat.shape[0] in [2, 3]:
-                input_frame_count = c_concat.shape[0]
-
-                # We're just padding to the same type an size of the concat
-                masked_frames = torch.zeros_like(torch.cat([c_concat[:1]] * frames))[:frames]
-
-                # Start frame
-                masked_frames[:1] = c_concat[:1]
-
-                end_frame_idx = -1
-
-                # TODO
-                speed = 1.0
-                if speed < 1.0:
-                    possible_speeds = list(torch.linspace(0, 1.0, c_concat.shape[0]))
-                    speed_from_frames = enumerate(possible_speeds)
-                    speed_idx = min(speed_from_frames, key=lambda n: n[1] - speed)[0]
-                    end_frame_idx = speed_idx
-
-                # End frame
-                masked_frames[-1:] = c_concat[[end_frame_idx]]
-
-                # Possible middle frame, but not working at the moment.
-                if input_frame_count == 3:
-                    middle_idx = masked_frames.shape[0] // 2
-                    middle_idx_frame = c_concat.shape[0] // 2
-                    masked_frames[[middle_idx]] = c_concat[[middle_idx_frame]]
-
-                c_concat = masked_frames
-                used_interpolate_processing = True
-
-                print(f"Using interpolation mode with {input_frame_count} frames.")
-
-            if c_concat.shape[0] < frames and not used_interpolate_processing:
-                print(
-                    "Multiple images found, but interpolation mode is unset. Using the first frame as condition.",
-                )
-                c_concat = torch.cat([c_concat[:1]] * frames)
-
-        c_concat = c_concat[:frames]
-
-        if encoded_latent.shape[0] == 1:
-            encoded_latent = torch.cat([encoded_latent] * frames)[:frames]
-
-        if encoded_latent.shape[0] < frames and encoded_latent.shape[0] != 1:
-            encoded_latent = torch.cat(
-                [encoded_latent] + [encoded_latent[-1:]] * abs(encoded_latent.shape[0] - frames)
-            )[:frames]
-
-        # We could store this as a state in this Node Class Instance, but to prevent any weird edge cases,
-        # this should always be passed through the 'stateless' way, and let ComfyUI handle the transformer_options state.
-        self.assign_forward_args(model, c_concat, image_emb, image_emb_uncond, fs, frames)
-
-        return (model, {"samples": torch.zeros_like(c_concat)}, {"samples": encoded_latent},)
-
-
-    # Loader for the DynamiCrafter model.
-    def load_model_sicts(self, model_path: str):
-        model_state_dict = comfy.utils.load_torch_file(model_path)
-        dynamicrafter_dict = load_dynamicrafter_dict(model_state_dict)
-        image_proj_dict = load_image_proj_dict(model_state_dict)
-
-        return dynamicrafter_dict, image_proj_dict
-
-    def get_prediction_type(self, is_eps: bool, model_config):
-        if not is_eps and "image_cross_attention_scale_learnable" in model_config.unet_config.keys():
-            model_config.unet_config["image_cross_attention_scale_learnable"] = False
-
-        return model_base.ModelType.EPS if is_eps else model_base.ModelType.V_PREDICTION
-
-    def handle_model_management(self, dynamicrafter_dict: dict, model_config):
-        parameters = comfy.utils.calculate_parameters(dynamicrafter_dict, "model.diffusion_model.")
-        load_device = model_management.get_torch_device()
-        unet_dtype = model_management.unet_dtype(
-            model_params=parameters,
-            supported_dtypes=model_config.supported_inference_dtypes
-        )
-        manual_cast_dtype = model_management.unet_manual_cast(
-            unet_dtype,
-            load_device,
-            model_config.supported_inference_dtypes
-        )
-        model_config.set_inference_dtype(unet_dtype, manual_cast_dtype)
-        inital_load_device = model_management.unet_inital_load_device(parameters, unet_dtype)
-        offload_device = model_management.unet_offload_device()
-
-        return load_device, inital_load_device
-
-    def check_leftover_keys(self, state_dict: dict):
-        left_over = state_dict.keys()
-        if len(left_over) > 0:
-            print("left over keys:", left_over)
-
-    def load_dynamicrafter(self, model_path):
-
-        if os.path.exists(model_path):
-            dynamicrafter_dict, image_proj_dict = self.load_model_sicts(model_path)
-            model_config = DynamiCrafterBase(DYNAMICRAFTER_CONFIG)
-
-            dynamicrafter_dict, is_eps = model_config.process_dict_version(state_dict=dynamicrafter_dict)
-
-            MODEL_TYPE = self.get_prediction_type(is_eps, model_config)
-            load_device, inital_load_device = self.handle_model_management(dynamicrafter_dict, model_config)
-
-            model = model_base.BaseModel(
-                model_config,
-                model_type=MODEL_TYPE,
-                device=inital_load_device,
-                unet_model=DynamiCrafterUNetModel
-            )
-
-            image_proj_model = get_image_proj_model(image_proj_dict)
-            model.load_model_weights(dynamicrafter_dict, "model.diffusion_model.")
-            self.check_leftover_keys(dynamicrafter_dict)
-
-            model_patcher = comfy.model_patcher.ModelPatcher(
-                model,
-                load_device=load_device,
-                offload_device=model_management.unet_offload_device(),
-                current_device=inital_load_device
-            )
-
-        return (model_patcher, image_proj_model,)
@@ -1,102 +0,0 @@
-# adopted from
-# https://github.com/openai/improved-diffusion/blob/main/improved_diffusion/gaussian_diffusion.py
-# and
-# https://github.com/lucidrains/denoising-diffusion-pytorch/blob/7706bdfc6f527f58d33f84b7b522e61e6e3164b3/denoising_diffusion_pytorch/denoising_diffusion_pytorch.py
-# and
-# https://github.com/openai/guided-diffusion/blob/0ba878e517b276c45d1195eb29f6f5f72659a05b/guided_diffusion/nn.py
-#
-# thanks!
-
-import torch.nn as nn
-import comfy.ops
-ops = comfy.ops.disable_weight_init
-
-from ..utils.utils import instantiate_from_config
-
-def disabled_train(self, mode=True):
-    """Overwrite model.train with this function to make sure train/eval mode
-    does not change anymore."""
-    return self
-
-def zero_module(module):
-    """
-    Zero out the parameters of a module and return it.
-    """
-    for p in module.parameters():
-        p.detach().zero_()
-    return module
-
-def scale_module(module, scale):
-    """
-    Scale the parameters of a module and return it.
-    """
-    for p in module.parameters():
-        p.detach().mul_(scale)
-    return module
-
-
-def conv_nd(dims, *args, **kwargs):
-    """
-    Create a 1D, 2D, or 3D convolution module.
-    """
-    if dims == 1:
-        return nn.Conv1d(*args, **kwargs)
-    elif dims == 2:
-        return ops.Conv2d(*args, **kwargs)
-    elif dims == 3:
-        return ops.Conv3d(*args, **kwargs)
-    raise ValueError(f"unsupported dimensions: {dims}")
-
-
-def linear(*args, **kwargs):
-    """
-    Create a linear module.
-    """
-    return ops.Linear(*args, **kwargs)
-
-
-def avg_pool_nd(dims, *args, **kwargs):
-    """
-    Create a 1D, 2D, or 3D average pooling module.
-    """
-    if dims == 1:
-        return nn.AvgPool1d(*args, **kwargs)
-    elif dims == 2:
-        return nn.AvgPool2d(*args, **kwargs)
-    elif dims == 3:
-        return nn.AvgPool3d(*args, **kwargs)
-    raise ValueError(f"unsupported dimensions: {dims}")
-
-
-def nonlinearity(type='silu'):
-    if type == 'silu':
-        return nn.SiLU()
-    elif type == 'leaky_relu':
-        return nn.LeakyReLU()
-
-
-class GroupNormSpecific(ops.GroupNorm):
-    def forward(self, x):
-        return super().forward(x.float()).type(x.dtype)
-
-
-def normalization(channels, num_groups=32, dtype=None, device=None):
-    """
-    Make a standard normalization layer.
-    :param channels: number of input channels.
-    :return: an nn.Module for normalization.
-    """
-    return GroupNormSpecific(num_groups, channels, dtype=dtype, device=device)
-
-
-class HybridConditioner(nn.Module):
-
-    def __init__(self, c_concat_config, c_crossattn_config):
-        super().__init__()
-        self.concat_conditioner = instantiate_from_config(c_concat_config)
-        self.crossattn_conditioner = instantiate_from_config(c_crossattn_config)
-
-    def forward(self, c_concat, c_crossattn):
-        c_concat = self.concat_conditioner(c_concat)
-        c_crossattn = self.crossattn_conditioner(c_crossattn)
-        return {'c_concat': [c_concat], 'c_crossattn': [c_crossattn]}
@@ -1,94 +0,0 @@
-import math
-from inspect import isfunction
-import torch
-from torch import nn
-import torch.distributed as dist
-
-
-def gather_data(data, return_np=True):
-    ''' gather data from multiple processes to one list '''
-    data_list = [torch.zeros_like(data) for _ in range(dist.get_world_size())]
-    dist.all_gather(data_list, data)  # gather not supported with NCCL
-    if return_np:
-        data_list = [data.cpu().numpy() for data in data_list]
-    return data_list
-
-def autocast(f):
-    def do_autocast(*args, **kwargs):
-        with torch.cuda.amp.autocast(enabled=True,
-                                     dtype=torch.get_autocast_gpu_dtype(),
-                                     cache_enabled=torch.is_autocast_cache_enabled()):
-            return f(*args, **kwargs)
-    return do_autocast
-
-
-def extract_into_tensor(a, t, x_shape):
-    b, *_ = t.shape
-    out = a.gather(-1, t)
-    return out.reshape(b, *((1,) * (len(x_shape) - 1)))
-
-
-def noise_like(shape, device, repeat=False):
-    repeat_noise = lambda: torch.randn((1, *shape[1:]), device=device).repeat(shape[0], *((1,) * (len(shape) - 1)))
-    noise = lambda: torch.randn(shape, device=device)
-    return repeat_noise() if repeat else noise()
-
-
-def default(val, d):
-    if exists(val):
-        return val
-    return d() if isfunction(d) else d
-
-def exists(val):
-    return val is not None
-
-def identity(*args, **kwargs):
-    return nn.Identity()
-
-def uniq(arr):
-    return{el: True for el in arr}.keys()
-
-def mean_flat(tensor):
-    """
-    Take the mean over all non-batch dimensions.
-    """
-    return tensor.mean(dim=list(range(1, len(tensor.shape))))
-
-def ismap(x):
-    if not isinstance(x, torch.Tensor):
-        return False
-    return (len(x.shape) == 4) and (x.shape[1] > 3)
-
-def isimage(x):
-    if not isinstance(x,torch.Tensor):
-        return False
-    return (len(x.shape) == 4) and (x.shape[1] == 3 or x.shape[1] == 1)
-
-def max_neg_value(t):
-    return -torch.finfo(t.dtype).max
-
-def shape_to_str(x):
-    shape_str = "x".join([str(x) for x in x.shape])
-    return shape_str
-
-def init_(tensor):
-    dim = tensor.shape[-1]
-    std = 1 / math.sqrt(dim)
-    tensor.uniform_(-std, std)
-    return tensor
-
-ckpt = torch.utils.checkpoint.checkpoint
-def checkpoint(func, inputs, params, flag):
-    """
-    Evaluate a function without caching intermediate activations, allowing for
-    reduced memory at the expense of extra compute in the backward pass.
-    :param func: the function to evaluate.
-    :param inputs: the argument sequence to pass to `func`.
-    :param params: a sequence of parameters `func` depends on but does not
-                   explicitly take as arguments.
-    :param flag: if False, disable gradient checkpointing.
-    """
-    if flag:
-        return ckpt(func, *inputs, use_reentrant=False)
-    else:
-        return func(*inputs)
@@ -1,95 +0,0 @@
-import torch
-import numpy as np
-
-
-class AbstractDistribution:
-    def sample(self):
-        raise NotImplementedError()
-
-    def mode(self):
-        raise NotImplementedError()
-
-
-class DiracDistribution(AbstractDistribution):
-    def __init__(self, value):
-        self.value = value
-
-    def sample(self):
-        return self.value
-
-    def mode(self):
-        return self.value
-
-
-class DiagonalGaussianDistribution(object):
-    def __init__(self, parameters, deterministic=False):
-        self.parameters = parameters
-        self.mean, self.logvar = torch.chunk(parameters, 2, dim=1)
-        self.logvar = torch.clamp(self.logvar, -30.0, 20.0)
-        self.deterministic = deterministic
-        self.std = torch.exp(0.5 * self.logvar)
-        self.var = torch.exp(self.logvar)
-        if self.deterministic:
-            self.var = self.std = torch.zeros_like(self.mean).to(device=self.parameters.device)
-
-    def sample(self, noise=None):
-        if noise is None:
-            noise = torch.randn(self.mean.shape)
-        
-        x = self.mean + self.std * noise.to(device=self.parameters.device)
-        return x
-
-    def kl(self, other=None):
-        if self.deterministic:
-            return torch.Tensor([0.])
-        else:
-            if other is None:
-                return 0.5 * torch.sum(torch.pow(self.mean, 2)
-                                       + self.var - 1.0 - self.logvar,
-                                       dim=[1, 2, 3])
-            else:
-                return 0.5 * torch.sum(
-                    torch.pow(self.mean - other.mean, 2) / other.var
-                    + self.var / other.var - 1.0 - self.logvar + other.logvar,
-                    dim=[1, 2, 3])
-
-    def nll(self, sample, dims=[1,2,3]):
-        if self.deterministic:
-            return torch.Tensor([0.])
-        logtwopi = np.log(2.0 * np.pi)
-        return 0.5 * torch.sum(
-            logtwopi + self.logvar + torch.pow(sample - self.mean, 2) / self.var,
-            dim=dims)
-
-    def mode(self):
-        return self.mean
-
-
-def normal_kl(mean1, logvar1, mean2, logvar2):
-    """
-    source: https://github.com/openai/guided-diffusion/blob/27c20a8fab9cb472df5d6bdd6c8d11c8f430b924/guided_diffusion/losses.py#L12
-    Compute the KL divergence between two gaussians.
-    Shapes are automatically broadcasted, so batches can be compared to
-    scalars, among other use cases.
-    """
-    tensor = None
-    for obj in (mean1, logvar1, mean2, logvar2):
-        if isinstance(obj, torch.Tensor):
-            tensor = obj
-            break
-    assert tensor is not None, "at least one argument must be a Tensor"
-
-    # Force variances to be Tensors. Broadcasting helps convert scalars to
-    # Tensors, but it does not work for torch.exp().
-    logvar1, logvar2 = [
-        x if isinstance(x, torch.Tensor) else torch.tensor(x).to(tensor)
-        for x in (logvar1, logvar2)
-    ]
-
-    return 0.5 * (
-        -1.0
-        + logvar2
-        - logvar1
-        + torch.exp(logvar1 - logvar2)
-        + ((mean1 - mean2) ** 2) * torch.exp(-logvar2)
-    )
@@ -1,76 +0,0 @@
-import torch
-from torch import nn
-
-
-class LitEma(nn.Module):
-    def __init__(self, model, decay=0.9999, use_num_upates=True):
-        super().__init__()
-        if decay < 0.0 or decay > 1.0:
-            raise ValueError('Decay must be between 0 and 1')
-
-        self.m_name2s_name = {}
-        self.register_buffer('decay', torch.tensor(decay, dtype=torch.float32))
-        self.register_buffer('num_updates', torch.tensor(0,dtype=torch.int) if use_num_upates
-                             else torch.tensor(-1,dtype=torch.int))
-
-        for name, p in model.named_parameters():
-            if p.requires_grad:
-                #remove as '.'-character is not allowed in buffers
-                s_name = name.replace('.','')
-                self.m_name2s_name.update({name:s_name})
-                self.register_buffer(s_name,p.clone().detach().data)
-
-        self.collected_params = []
-
-    def forward(self,model):
-        decay = self.decay
-
-        if self.num_updates >= 0:
-            self.num_updates += 1
-            decay = min(self.decay,(1 + self.num_updates) / (10 + self.num_updates))
-
-        one_minus_decay = 1.0 - decay
-
-        with torch.no_grad():
-            m_param = dict(model.named_parameters())
-            shadow_params = dict(self.named_buffers())
-
-            for key in m_param:
-                if m_param[key].requires_grad:
-                    sname = self.m_name2s_name[key]
-                    shadow_params[sname] = shadow_params[sname].type_as(m_param[key])
-                    shadow_params[sname].sub_(one_minus_decay * (shadow_params[sname] - m_param[key]))
-                else:
-                    assert not key in self.m_name2s_name
-
-    def copy_to(self, model):
-        m_param = dict(model.named_parameters())
-        shadow_params = dict(self.named_buffers())
-        for key in m_param:
-            if m_param[key].requires_grad:
-                m_param[key].data.copy_(shadow_params[self.m_name2s_name[key]].data)
-            else:
-                assert not key in self.m_name2s_name
-
-    def store(self, parameters):
-        """
-        Save the current parameters for restoring later.
-        Args:
-          parameters: Iterable of `torch.nn.Parameter`; the parameters to be
-            temporarily stored.
-        """
-        self.collected_params = [param.clone() for param in parameters]
-
-    def restore(self, parameters):
-        """
-        Restore the parameters stored with the `store` method.
-        Useful to validate the model with EMA parameters without affecting the
-        original optimization process. Store the parameters before the
-        `copy_to` method. After validation (or model saving), use this to
-        restore the former parameters.
-        Args:
-          parameters: Iterable of `torch.nn.Parameter`; the parameters to be
-            updated with the stored parameters.
-        """
-        for c_param, param in zip(self.collected_params, parameters):
-            param.data.copy_(c_param.data)
@@ -1,219 +0,0 @@
-import os
-from contextlib import contextmanager
-import torch
-import numpy as np
-from einops import rearrange
-import torch.nn.functional as F
-import pytorch_lightning as pl
-from ...modules.networks.ae_modules import Encoder, Decoder
-from ...distributions import DiagonalGaussianDistribution
-from utils.utils import instantiate_from_config
-
-
-class AutoencoderKL(pl.LightningModule):
-    def __init__(self,
-                 ddconfig,
-                 lossconfig,
-                 embed_dim,
-                 ckpt_path=None,
-                 ignore_keys=[],
-                 image_key="image",
-                 colorize_nlabels=None,
-                 monitor=None,
-                 test=False,
-                 logdir=None,
-                 input_dim=4,
-                 test_args=None,
-                 ):
-        super().__init__()
-        self.image_key = image_key
-        self.encoder = Encoder(**ddconfig)
-        self.decoder = Decoder(**ddconfig)
-        self.loss = instantiate_from_config(lossconfig)
-        assert ddconfig["double_z"]
-        self.quant_conv = torch.nn.Conv2d(2*ddconfig["z_channels"], 2*embed_dim, 1)
-        self.post_quant_conv = torch.nn.Conv2d(embed_dim, ddconfig["z_channels"], 1)
-        self.embed_dim = embed_dim
-        self.input_dim = input_dim
-        self.test = test
-        self.test_args = test_args
-        self.logdir = logdir
-        if colorize_nlabels is not None:
-            assert type(colorize_nlabels)==int
-            self.register_buffer("colorize", torch.randn(3, colorize_nlabels, 1, 1))
-        if monitor is not None:
-            self.monitor = monitor
-        if ckpt_path is not None:
-            self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys)
-        if self.test:
-            self.init_test()
-    
-    def init_test(self,):
-        self.test = True
-        save_dir = os.path.join(self.logdir, "test")
-        if 'ckpt' in self.test_args:
-            ckpt_name = os.path.basename(self.test_args.ckpt).split('.ckpt')[0] + f'_epoch{self._cur_epoch}'
-            self.root = os.path.join(save_dir, ckpt_name)
-        else:
-            self.root = save_dir
-        if 'test_subdir' in self.test_args:
-            self.root = os.path.join(save_dir, self.test_args.test_subdir)
-
-        self.root_zs = os.path.join(self.root, "zs")
-        self.root_dec = os.path.join(self.root, "reconstructions")
-        self.root_inputs = os.path.join(self.root, "inputs")
-        os.makedirs(self.root, exist_ok=True)
-
-        if self.test_args.save_z:
-            os.makedirs(self.root_zs, exist_ok=True)
-        if self.test_args.save_reconstruction:
-            os.makedirs(self.root_dec, exist_ok=True)
-        if self.test_args.save_input:
-            os.makedirs(self.root_inputs, exist_ok=True)
-        assert(self.test_args is not None)
-        self.test_maximum = getattr(self.test_args, 'test_maximum', None) 
-        self.count = 0
-        self.eval_metrics = {}
-        self.decodes = []
-        self.save_decode_samples = 2048
-
-    def init_from_ckpt(self, path, ignore_keys=list()):
-        sd = torch.load(path, map_location="cpu")
-        try:
-            self._cur_epoch = sd['epoch']
-            sd = sd["state_dict"]
-        except:
-            self._cur_epoch = 'null'
-        keys = list(sd.keys())
-        for k in keys:
-            for ik in ignore_keys:
-                if k.startswith(ik):
-                    print("Deleting key {} from state_dict.".format(k))
-                    del sd[k]
-        self.load_state_dict(sd, strict=False)
-        # self.load_state_dict(sd, strict=True)
-        print(f"Restored from {path}")
-
-    def encode(self, x, **kwargs):
-        
-        h = self.encoder(x)
-        moments = self.quant_conv(h)
-        posterior = DiagonalGaussianDistribution(moments)
-        return posterior
-
-    def decode(self, z, **kwargs):
-        z = self.post_quant_conv(z)
-        dec = self.decoder(z)
-        return dec
-
-    def forward(self, input, sample_posterior=True):
-        posterior = self.encode(input)
-        if sample_posterior:
-            z = posterior.sample()
-        else:
-            z = posterior.mode()
-        dec = self.decode(z)
-        return dec, posterior
-
-    def get_input(self, batch, k):
-        x = batch[k]
-        if x.dim() == 5 and self.input_dim == 4:
-            b,c,t,h,w = x.shape
-            self.b = b
-            self.t = t 
-            x = rearrange(x, 'b c t h w -> (b t) c h w')
-
-        return x
-
-    def training_step(self, batch, batch_idx, optimizer_idx):
-        inputs = self.get_input(batch, self.image_key)
-        reconstructions, posterior = self(inputs)
-
-        if optimizer_idx == 0:
-            # train encoder+decoder+logvar
-            aeloss, log_dict_ae = self.loss(inputs, reconstructions, posterior, optimizer_idx, self.global_step,
-                                            last_layer=self.get_last_layer(), split="train")
-            self.log("aeloss", aeloss, prog_bar=True, logger=True, on_step=True, on_epoch=True)
-            self.log_dict(log_dict_ae, prog_bar=False, logger=True, on_step=True, on_epoch=False)
-            return aeloss
-
-        if optimizer_idx == 1:
-            # train the discriminator
-            discloss, log_dict_disc = self.loss(inputs, reconstructions, posterior, optimizer_idx, self.global_step,
-                                                last_layer=self.get_last_layer(), split="train")
-
-            self.log("discloss", discloss, prog_bar=True, logger=True, on_step=True, on_epoch=True)
-            self.log_dict(log_dict_disc, prog_bar=False, logger=True, on_step=True, on_epoch=False)
-            return discloss
-
-    def validation_step(self, batch, batch_idx):
-        inputs = self.get_input(batch, self.image_key)
-        reconstructions, posterior = self(inputs)
-        aeloss, log_dict_ae = self.loss(inputs, reconstructions, posterior, 0, self.global_step,
-                                        last_layer=self.get_last_layer(), split="val")
-
-        discloss, log_dict_disc = self.loss(inputs, reconstructions, posterior, 1, self.global_step,
-                                            last_layer=self.get_last_layer(), split="val")
-
-        self.log("val/rec_loss", log_dict_ae["val/rec_loss"])
-        self.log_dict(log_dict_ae)
-        self.log_dict(log_dict_disc)
-        return self.log_dict
-    
-    def configure_optimizers(self):
-        lr = self.learning_rate
-        opt_ae = torch.optim.Adam(list(self.encoder.parameters())+
-                                  list(self.decoder.parameters())+
-                                  list(self.quant_conv.parameters())+
-                                  list(self.post_quant_conv.parameters()),
-                                  lr=lr, betas=(0.5, 0.9))
-        opt_disc = torch.optim.Adam(self.loss.discriminator.parameters(),
-                                    lr=lr, betas=(0.5, 0.9))
-        return [opt_ae, opt_disc], []
-
-    def get_last_layer(self):
-        return self.decoder.conv_out.weight
-
-    @torch.no_grad()
-    def log_images(self, batch, only_inputs=False, **kwargs):
-        log = dict()
-        x = self.get_input(batch, self.image_key)
-        x = x.to(self.device)
-        if not only_inputs:
-            xrec, posterior = self(x)
-            if x.shape[1] > 3:
-                # colorize with random projection
-                assert xrec.shape[1] > 3
-                x = self.to_rgb(x)
-                xrec = self.to_rgb(xrec)
-            log["samples"] = self.decode(torch.randn_like(posterior.sample()))
-            log["reconstructions"] = xrec
-        log["inputs"] = x
-        return log
-
-    def to_rgb(self, x):
-        assert self.image_key == "segmentation"
-        if not hasattr(self, "colorize"):
-            self.register_buffer("colorize", torch.randn(3, x.shape[1], 1, 1).to(x))
-        x = F.conv2d(x, weight=self.colorize)
-        x = 2.*(x-x.min())/(x.max()-x.min()) - 1.
-        return x
-
-class IdentityFirstStage(torch.nn.Module):
-    def __init__(self, *args, vq_interface=False, **kwargs):
-        self.vq_interface = vq_interface  # TODO: Should be true by default but check to not break older stuff
-        super().__init__()
-
-    def encode(self, x, *args, **kwargs):
-        return x
-
-    def decode(self, x, *args, **kwargs):
-        return x
-
-    def quantize(self, x, *args, **kwargs):
-        if self.vq_interface:
-            return x, None, [None, None, None]
-        return x
-
-    def forward(self, x, *args, **kwargs):
-        return x
@@ -1,762 +0,0 @@
-"""
-wild mixture of
-https://github.com/openai/improved-diffusion/blob/e94489283bb876ac1477d5dd7709bbbd2d9902ce/improved_diffusion/gaussian_diffusion.py
-https://github.com/lucidrains/denoising-diffusion-pytorch/blob/7706bdfc6f527f58d33f84b7b522e61e6e3164b3/denoising_diffusion_pytorch/denoising_diffusion_pytorch.py
-https://github.com/CompVis/taming-transformers
-- merci
-"""
-
-from functools import partial
-from contextlib import contextmanager
-import numpy as np
-from tqdm import tqdm
-from einops import rearrange, repeat
-import logging
-mainlogger = logging.getLogger('mainlogger')
-import torch
-import torch.nn as nn
-from torchvision.utils import make_grid
-
-from ...utils.utils import instantiate_from_config
-from ..ema import LitEma
-from ..distributions import DiagonalGaussianDistribution
-from ..models.utils_diffusion import make_beta_schedule, rescale_zero_terminal_snr
-from ..basics import disabled_train
-from ..common import (
-    extract_into_tensor,
-    noise_like,
-    exists,
-    default
-)
-
-__conditioning_keys__ = {'concat': 'c_concat',
-                         'crossattn': 'c_crossattn',
-                         'adm': 'y'}
-
-class DDPM(nn.Module):
-    # classic DDPM with Gaussian diffusion, in image space
-    def __init__(self,
-                 unet_config,
-                 timesteps=1000,
-                 beta_schedule="linear",
-                 loss_type="l2",
-                 ckpt_path=None,
-                 ignore_keys=[],
-                 load_only_unet=False,
-                 monitor=None,
-                 use_ema=True,
-                 first_stage_key="image",
-                 image_size=256,
-                 channels=3,
-                 log_every_t=100,
-                 clip_denoised=True,
-                 linear_start=1e-4,
-                 linear_end=2e-2,
-                 cosine_s=8e-3,
-                 given_betas=None,
-                 original_elbo_weight=0.,
-                 v_posterior=0.,  # weight for choosing posterior variance as sigma = (1-v) * beta_tilde + v * beta
-                 l_simple_weight=1.,
-                 conditioning_key=None,
-                 parameterization="eps",  # all assuming fixed variance schedules
-                 scheduler_config=None,
-                 use_positional_encodings=False,
-                 learn_logvar=False,
-                 logvar_init=0.,
-                 rescale_betas_zero_snr=False,
-                 ):
-        super().__init__()
-        assert parameterization in ["eps", "x0", "v"], 'currently only supporting "eps" and "x0" and "v"'
-        self.parameterization = parameterization
-        mainlogger.info(f"{self.__class__.__name__}: Running in {self.parameterization}-prediction mode")
-        self.cond_stage_model = None
-        self.clip_denoised = clip_denoised
-        self.log_every_t = log_every_t
-        self.first_stage_key = first_stage_key
-        self.channels = channels
-        self.temporal_length = unet_config.params.temporal_length
-        self.image_size = image_size  # try conv?
-        if isinstance(self.image_size, int):
-            self.image_size = [self.image_size, self.image_size]
-        self.use_positional_encodings = use_positional_encodings
-        self.model = DiffusionWrapper(unet_config, conditioning_key)
-        #count_params(self.model, verbose=True)
-        self.use_ema = use_ema
-        self.rescale_betas_zero_snr = rescale_betas_zero_snr
-        if self.use_ema:
-            self.model_ema = LitEma(self.model)
-            mainlogger.info(f"Keeping EMAs of {len(list(self.model_ema.buffers()))}.")
-
-        self.use_scheduler = scheduler_config is not None
-        if self.use_scheduler:
-            self.scheduler_config = scheduler_config
-
-        self.v_posterior = v_posterior
-        self.original_elbo_weight = original_elbo_weight
-        self.l_simple_weight = l_simple_weight
-
-        if monitor is not None:
-            self.monitor = monitor
-        if ckpt_path is not None:
-            self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys, only_model=load_only_unet)
-
-        self.register_schedule(given_betas=given_betas, beta_schedule=beta_schedule, timesteps=timesteps,
-                               linear_start=linear_start, linear_end=linear_end, cosine_s=cosine_s)
-
-        self.loss_type = loss_type
-
-        self.learn_logvar = learn_logvar
-        self.logvar = torch.full(fill_value=logvar_init, size=(self.num_timesteps,))
-        if self.learn_logvar:
-            self.logvar = nn.Parameter(self.logvar, requires_grad=True)
-
-    def register_schedule(self, given_betas=None, beta_schedule="linear", timesteps=1000,
-                          linear_start=1e-4, linear_end=2e-2, cosine_s=8e-3):
-        if exists(given_betas):
-            betas = given_betas
-        else:
-            betas = make_beta_schedule(beta_schedule, timesteps, linear_start=linear_start, linear_end=linear_end,
-                                       cosine_s=cosine_s)
-        if self.rescale_betas_zero_snr:
-            betas = rescale_zero_terminal_snr(betas)
-        
-        alphas = 1. - betas
-        alphas_cumprod = np.cumprod(alphas, axis=0)
-        alphas_cumprod_prev = np.append(1., alphas_cumprod[:-1])
-
-        timesteps, = betas.shape
-        self.num_timesteps = int(timesteps)
-        self.linear_start = linear_start
-        self.linear_end = linear_end
-        assert alphas_cumprod.shape[0] == self.num_timesteps, 'alphas have to be defined for each timestep'
-
-        to_torch = partial(torch.tensor, dtype=torch.float32)
-
-        self.register_buffer('betas', to_torch(betas))
-        self.register_buffer('alphas_cumprod', to_torch(alphas_cumprod))
-        self.register_buffer('alphas_cumprod_prev', to_torch(alphas_cumprod_prev))
-
-        # calculations for diffusion q(x_t | x_{t-1}) and others
-        self.register_buffer('sqrt_alphas_cumprod', to_torch(np.sqrt(alphas_cumprod)))
-        self.register_buffer('sqrt_one_minus_alphas_cumprod', to_torch(np.sqrt(1. - alphas_cumprod)))
-        self.register_buffer('log_one_minus_alphas_cumprod', to_torch(np.log(1. - alphas_cumprod)))
-
-        if self.parameterization != 'v':
-            self.register_buffer('sqrt_recip_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod)))
-            self.register_buffer('sqrt_recipm1_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod - 1)))
-        else:
-            self.register_buffer('sqrt_recip_alphas_cumprod', torch.zeros_like(to_torch(alphas_cumprod)))
-            self.register_buffer('sqrt_recipm1_alphas_cumprod', torch.zeros_like(to_torch(alphas_cumprod)))
-
-        # calculations for posterior q(x_{t-1} | x_t, x_0)
-        posterior_variance = (1 - self.v_posterior) * betas * (1. - alphas_cumprod_prev) / (
-                    1. - alphas_cumprod) + self.v_posterior * betas
-        # above: equal to 1. / (1. / (1. - alpha_cumprod_tm1) + alpha_t / beta_t)
-        self.register_buffer('posterior_variance', to_torch(posterior_variance))
-        # below: log calculation clipped because the posterior variance is 0 at the beginning of the diffusion chain
-        self.register_buffer('posterior_log_variance_clipped', to_torch(np.log(np.maximum(posterior_variance, 1e-20))))
-        self.register_buffer('posterior_mean_coef1', to_torch(
-            betas * np.sqrt(alphas_cumprod_prev) / (1. - alphas_cumprod)))
-        self.register_buffer('posterior_mean_coef2', to_torch(
-            (1. - alphas_cumprod_prev) * np.sqrt(alphas) / (1. - alphas_cumprod)))
-
-        if self.parameterization == "eps":
-            lvlb_weights = self.betas ** 2 / (
-                        2 * self.posterior_variance * to_torch(alphas) * (1 - self.alphas_cumprod))
-        elif self.parameterization == "x0":
-            lvlb_weights = 0.5 * np.sqrt(torch.Tensor(alphas_cumprod)) / (2. * 1 - torch.Tensor(alphas_cumprod))
-        elif self.parameterization == "v":
-            lvlb_weights = torch.ones_like(self.betas ** 2 / (
-                    2 * self.posterior_variance * to_torch(alphas) * (1 - self.alphas_cumprod)))
-        else:
-            raise NotImplementedError("mu not supported")
-        # TODO how to choose this term
-        lvlb_weights[0] = lvlb_weights[1]
-        self.register_buffer('lvlb_weights', lvlb_weights, persistent=False)
-        assert not torch.isnan(self.lvlb_weights).all()
-
-    @contextmanager
-    def ema_scope(self, context=None):
-        if self.use_ema:
-            self.model_ema.store(self.model.parameters())
-            self.model_ema.copy_to(self.model)
-            if context is not None:
-                mainlogger.info(f"{context}: Switched to EMA weights")
-        try:
-            yield None
-        finally:
-            if self.use_ema:
-                self.model_ema.restore(self.model.parameters())
-                if context is not None:
-                    mainlogger.info(f"{context}: Restored training weights")
-
-    def init_from_ckpt(self, path, ignore_keys=list(), only_model=False):
-        sd = torch.load(path, map_location="cpu")
-        if "state_dict" in list(sd.keys()):
-            sd = sd["state_dict"]
-        keys = list(sd.keys())
-        for k in keys:
-            for ik in ignore_keys:
-                if k.startswith(ik):
-                    mainlogger.info("Deleting key {} from state_dict.".format(k))
-                    del sd[k]
-        missing, unexpected = self.load_state_dict(sd, strict=False) if not only_model else self.model.load_state_dict(
-            sd, strict=False)
-        mainlogger.info(f"Restored from {path} with {len(missing)} missing and {len(unexpected)} unexpected keys")
-        if len(missing) > 0:
-            mainlogger.info(f"Missing Keys: {missing}")
-        if len(unexpected) > 0:
-            mainlogger.info(f"Unexpected Keys: {unexpected}")
-
-    def q_mean_variance(self, x_start, t):
-        """
-        Get the distribution q(x_t | x_0).
-        :param x_start: the [N x C x ...] tensor of noiseless inputs.
-        :param t: the number of diffusion steps (minus 1). Here, 0 means one step.
-        :return: A tuple (mean, variance, log_variance), all of x_start's shape.
-        """
-        mean = (extract_into_tensor(self.sqrt_alphas_cumprod, t, x_start.shape) * x_start)
-        variance = extract_into_tensor(1.0 - self.alphas_cumprod, t, x_start.shape)
-        log_variance = extract_into_tensor(self.log_one_minus_alphas_cumprod, t, x_start.shape)
-        return mean, variance, log_variance
-
-    def predict_start_from_noise(self, x_t, t, noise):
-        return (
-                extract_into_tensor(self.sqrt_recip_alphas_cumprod, t, x_t.shape) * x_t -
-                extract_into_tensor(self.sqrt_recipm1_alphas_cumprod, t, x_t.shape) * noise
-        )
-
-    def predict_start_from_z_and_v(self, x_t, t, v):
-        # self.register_buffer('sqrt_alphas_cumprod', to_torch(np.sqrt(alphas_cumprod)))
-        # self.register_buffer('sqrt_one_minus_alphas_cumprod', to_torch(np.sqrt(1. - alphas_cumprod)))
-        return (
-                extract_into_tensor(self.sqrt_alphas_cumprod, t, x_t.shape) * x_t -
-                extract_into_tensor(self.sqrt_one_minus_alphas_cumprod, t, x_t.shape) * v
-        )
-
-    def predict_eps_from_z_and_v(self, x_t, t, v):
-        return (
-                extract_into_tensor(self.sqrt_alphas_cumprod, t, x_t.shape) * v +
-                extract_into_tensor(self.sqrt_one_minus_alphas_cumprod, t, x_t.shape) * x_t
-        )
-
-    def q_posterior(self, x_start, x_t, t):
-        posterior_mean = (
-                extract_into_tensor(self.posterior_mean_coef1, t, x_t.shape) * x_start +
-                extract_into_tensor(self.posterior_mean_coef2, t, x_t.shape) * x_t
-        )
-        posterior_variance = extract_into_tensor(self.posterior_variance, t, x_t.shape)
-        posterior_log_variance_clipped = extract_into_tensor(self.posterior_log_variance_clipped, t, x_t.shape)
-        return posterior_mean, posterior_variance, posterior_log_variance_clipped
-
-    def p_mean_variance(self, x, t, clip_denoised: bool):
-        model_out = self.model(x, t)
-        if self.parameterization == "eps":
-            x_recon = self.predict_start_from_noise(x, t=t, noise=model_out)
-        elif self.parameterization == "x0":
-            x_recon = model_out
-        if clip_denoised:
-            x_recon.clamp_(-1., 1.)
-
-        model_mean, posterior_variance, posterior_log_variance = self.q_posterior(x_start=x_recon, x_t=x, t=t)
-        return model_mean, posterior_variance, posterior_log_variance
-
-    @torch.no_grad()
-    def p_sample(self, x, t, clip_denoised=True, repeat_noise=False):
-        b, *_, device = *x.shape, x.device
-        model_mean, _, model_log_variance = self.p_mean_variance(x=x, t=t, clip_denoised=clip_denoised)
-        noise = noise_like(x.shape, device, repeat_noise)
-        # no noise when t == 0
-        nonzero_mask = (1 - (t == 0).float()).reshape(b, *((1,) * (len(x.shape) - 1)))
-        return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise
-
-    @torch.no_grad()
-    def p_sample_loop(self, shape, return_intermediates=False):
-        device = self.betas.device
-        b = shape[0]
-        img = torch.randn(shape, device=device)
-        intermediates = [img]
-        for i in tqdm(reversed(range(0, self.num_timesteps)), desc='Sampling t', total=self.num_timesteps):
-            img = self.p_sample(img, torch.full((b,), i, device=device, dtype=torch.long),
-                                clip_denoised=self.clip_denoised)
-            if i % self.log_every_t == 0 or i == self.num_timesteps - 1:
-                intermediates.append(img)
-        if return_intermediates:
-            return img, intermediates
-        return img
-
-    @torch.no_grad()
-    def sample(self, batch_size=16, return_intermediates=False):
-        image_size = self.image_size
-        channels = self.channels
-        return self.p_sample_loop((batch_size, channels, image_size, image_size),
-                                  return_intermediates=return_intermediates)
-
-    def q_sample(self, x_start, t, noise=None):
-        noise = default(noise, lambda: torch.randn_like(x_start))
-        return (extract_into_tensor(self.sqrt_alphas_cumprod, t, x_start.shape) * x_start +
-                extract_into_tensor(self.sqrt_one_minus_alphas_cumprod, t, x_start.shape) * noise)
-
-    def get_v(self, x, noise, t):
-        return (
-                extract_into_tensor(self.sqrt_alphas_cumprod, t, x.shape) * noise -
-                extract_into_tensor(self.sqrt_one_minus_alphas_cumprod, t, x.shape) * x
-        )
-
-    def get_input(self, batch, k):
-        x = batch[k]
-        x = x.to(memory_format=torch.contiguous_format).float()
-        return x
-
-    def _get_rows_from_list(self, samples):
-        n_imgs_per_row = len(samples)
-        denoise_grid = rearrange(samples, 'n b c h w -> b n c h w')
-        denoise_grid = rearrange(denoise_grid, 'b n c h w -> (b n) c h w')
-        denoise_grid = make_grid(denoise_grid, nrow=n_imgs_per_row)
-        return denoise_grid
-
-    @torch.no_grad()
-    def log_images(self, batch, N=8, n_row=2, sample=True, return_keys=None, **kwargs):
-        log = dict()
-        x = self.get_input(batch, self.first_stage_key)
-        N = min(x.shape[0], N)
-        n_row = min(x.shape[0], n_row)
-        x = x.to(self.device)[:N]
-        log["inputs"] = x
-
-        # get diffusion row
-        diffusion_row = list()
-        x_start = x[:n_row]
-
-        for t in range(self.num_timesteps):
-            if t % self.log_every_t == 0 or t == self.num_timesteps - 1:
-                t = repeat(torch.tensor([t]), '1 -> b', b=n_row)
-                t = t.to(self.device).long()
-                noise = torch.randn_like(x_start)
-                x_noisy = self.q_sample(x_start=x_start, t=t, noise=noise)
-                diffusion_row.append(x_noisy)
-
-        log["diffusion_row"] = self._get_rows_from_list(diffusion_row)
-
-        if sample:
-            # get denoise row
-            with self.ema_scope("Plotting"):
-                samples, denoise_row = self.sample(batch_size=N, return_intermediates=True)
-
-            log["samples"] = samples
-            log["denoise_row"] = self._get_rows_from_list(denoise_row)
-
-        if return_keys:
-            if np.intersect1d(list(log.keys()), return_keys).shape[0] == 0:
-                return log
-            else:
-                return {key: log[key] for key in return_keys}
-        return log
-
-
-class LatentDiffusion(DDPM):
-    """main class"""
-    def __init__(self,
-                 first_stage_config,
-                 cond_stage_config,
-                 num_timesteps_cond=None,
-                 cond_stage_key="caption",
-                 cond_stage_trainable=False,
-                 cond_stage_forward=None,
-                 conditioning_key=None,
-                 uncond_prob=0.2,
-                 uncond_type="empty_seq",
-                 scale_factor=1.0,
-                 scale_by_std=False,
-                 encoder_type="2d",
-                 only_model=False,
-                 noise_strength=0,
-                 use_dynamic_rescale=False,
-                 base_scale=0.7,
-                 turning_step=400,
-                 loop_video=False,
-                 fps_condition_type='fs',
-                 perframe_ae=False,
-                 *args, **kwargs):
-        self.num_timesteps_cond = default(num_timesteps_cond, 1)
-        self.scale_by_std = scale_by_std
-        assert self.num_timesteps_cond <= kwargs['timesteps']
-        # for backwards compatibility after implementation of DiffusionWrapper
-        ckpt_path = kwargs.pop("ckpt_path", None)
-        ignore_keys = kwargs.pop("ignore_keys", [])
-        conditioning_key = default(conditioning_key, 'crossattn')
-        super().__init__(conditioning_key=conditioning_key, *args, **kwargs)
-
-        self.cond_stage_trainable = cond_stage_trainable
-        self.cond_stage_key = cond_stage_key
-        self.noise_strength = noise_strength
-        self.use_dynamic_rescale = use_dynamic_rescale
-        self.loop_video = loop_video
-        self.fps_condition_type = fps_condition_type
-        self.perframe_ae = perframe_ae
-        try:
-            self.num_downs = len(first_stage_config.params.ddconfig.ch_mult) - 1
-        except:
-            self.num_downs = 0
-        if not scale_by_std:
-            self.scale_factor = scale_factor
-        else:
-            self.register_buffer('scale_factor', torch.tensor(scale_factor))
-
-        if use_dynamic_rescale:
-            scale_arr1 = np.linspace(1.0, base_scale, turning_step)
-            scale_arr2 = np.full(self.num_timesteps, base_scale)
-            scale_arr = np.concatenate((scale_arr1, scale_arr2))
-            to_torch = partial(torch.tensor, dtype=torch.float32)
-            self.register_buffer('scale_arr', to_torch(scale_arr))
-
-        self.instantiate_first_stage(first_stage_config)
-        self.instantiate_cond_stage(cond_stage_config)
-        self.first_stage_config = first_stage_config
-        self.cond_stage_config = cond_stage_config        
-        self.clip_denoised = False
-
-        self.cond_stage_forward = cond_stage_forward
-        self.encoder_type = encoder_type
-        assert(encoder_type in ["2d", "3d"])
-        self.uncond_prob = uncond_prob
-        self.classifier_free_guidance = True if uncond_prob > 0 else False
-        assert(uncond_type in ["zero_embed", "empty_seq"])
-        self.uncond_type = uncond_type
-
-        self.restarted_from_ckpt = False
-        if ckpt_path is not None:
-            self.init_from_ckpt(ckpt_path, ignore_keys, only_model=only_model)
-            self.restarted_from_ckpt = True
-                
-
-    def make_cond_schedule(self, ):
-        self.cond_ids = torch.full(size=(self.num_timesteps,), fill_value=self.num_timesteps - 1, dtype=torch.long)
-        ids = torch.round(torch.linspace(0, self.num_timesteps - 1, self.num_timesteps_cond)).long()
-        self.cond_ids[:self.num_timesteps_cond] = ids
-
-    def instantiate_first_stage(self, config):
-        model = instantiate_from_config(config)
-        self.first_stage_model = model.eval()
-        self.first_stage_model.train = disabled_train
-        for param in self.first_stage_model.parameters():
-            param.requires_grad = False
-
-    def instantiate_cond_stage(self, config):
-        if not self.cond_stage_trainable:
-            model = instantiate_from_config(config)
-            self.cond_stage_model = model.eval()
-            self.cond_stage_model.train = disabled_train
-            for param in self.cond_stage_model.parameters():
-                param.requires_grad = False
-        else:
-            model = instantiate_from_config(config)
-            self.cond_stage_model = model
-    
-    def get_learned_conditioning(self, c):
-        if self.cond_stage_forward is None:
-            if hasattr(self.cond_stage_model, 'encode') and callable(self.cond_stage_model.encode):
-                c = self.cond_stage_model.encode(c)
-                if isinstance(c, DiagonalGaussianDistribution):
-                    c = c.mode()
-            else:
-                c = self.cond_stage_model(c)
-        else:
-            assert hasattr(self.cond_stage_model, self.cond_stage_forward)
-            c = getattr(self.cond_stage_model, self.cond_stage_forward)(c)
-        return c
-
-    def get_first_stage_encoding(self, encoder_posterior, noise=None):
-        if isinstance(encoder_posterior, DiagonalGaussianDistribution):
-            z = encoder_posterior.sample(noise=noise)
-        elif isinstance(encoder_posterior, torch.Tensor):
-            z = encoder_posterior
-        else:
-            raise NotImplementedError(f"encoder_posterior of type '{type(encoder_posterior)}' not yet implemented")
-        return self.scale_factor * z
-   
-    @torch.no_grad()
-    def encode_first_stage(self, x):
-        if self.encoder_type == "2d" and x.dim() == 5:
-            b, _, t, _, _ = x.shape
-            x = rearrange(x, 'b c t h w -> (b t) c h w')
-            reshape_back = True
-        else:
-            reshape_back = False
-        
-        ## consume more GPU memory but faster
-        if not self.perframe_ae:
-            encoder_posterior = self.first_stage_model.encode(x)
-            results = self.get_first_stage_encoding(encoder_posterior).detach()
-        else:  ## consume less GPU memory but slower
-            results = []
-            for index in range(x.shape[0]):
-                frame_batch = self.first_stage_model.encode(x[index:index+1,:,:,:])
-                frame_result = self.get_first_stage_encoding(frame_batch).detach()
-                results.append(frame_result)
-            results = torch.cat(results, dim=0)
-
-        if reshape_back:
-            results = rearrange(results, '(b t) c h w -> b c t h w', b=b,t=t)
-        
-        return results
-    
-    def decode_core(self, z, **kwargs):
-        if self.encoder_type == "2d" and z.dim() == 5:
-            b, _, t, _, _ = z.shape
-            z = rearrange(z, 'b c t h w -> (b t) c h w')
-            reshape_back = True
-        else:
-            reshape_back = False
-            
-        if not self.perframe_ae:    
-            z = 1. / self.scale_factor * z
-            results = self.first_stage_model.decode(z, **kwargs)
-        else:
-            results = []
-            for index in range(z.shape[0]):
-                frame_z = 1. / self.scale_factor * z[index:index+1,:,:,:]
-                frame_result = self.first_stage_model.decode(frame_z, **kwargs)
-                results.append(frame_result)
-            results = torch.cat(results, dim=0)
-
-        if reshape_back:
-            results = rearrange(results, '(b t) c h w -> b c t h w', b=b,t=t)
-        return results
-
-    @torch.no_grad()
-    def decode_first_stage(self, z, **kwargs):
-        return self.decode_core(z, **kwargs)
-
-    # same as above but without decorator
-    def differentiable_decode_first_stage(self, z, **kwargs):
-        return self.decode_core(z, **kwargs)
-    
-    def forward(self, x, c, **kwargs):
-        t = torch.randint(0, self.num_timesteps, (x.shape[0],), device=self.device).long()
-        if self.use_dynamic_rescale:
-            x = x * extract_into_tensor(self.scale_arr, t, x.shape)
-        return self.p_losses(x, c, t, **kwargs)
-
-    def apply_model(self, x_noisy, t, cond, **kwargs):
-        if isinstance(cond, dict):
-            # hybrid case, cond is exptected to be a dict
-            pass
-        else:
-            if not isinstance(cond, list):
-                cond = [cond]
-            key = 'c_concat' if self.model.conditioning_key == 'concat' else 'c_crossattn'
-            cond = {key: cond}
-
-        x_recon = self.model(x_noisy, t, **cond, **kwargs)
-
-        if isinstance(x_recon, tuple):
-            return x_recon[0]
-        else:
-            return x_recon
-
-    def _get_denoise_row_from_list(self, samples, desc=''):
-        denoise_row = []
-        for zd in tqdm(samples, desc=desc):
-            denoise_row.append(self.decode_first_stage(zd.to(self.device)))
-        n_log_timesteps = len(denoise_row)
-
-        denoise_row = torch.stack(denoise_row)  # n_log_timesteps, b, C, H, W
-        
-        if denoise_row.dim() == 5:
-            denoise_grid = rearrange(denoise_row, 'n b c h w -> b n c h w')
-            denoise_grid = rearrange(denoise_grid, 'b n c h w -> (b n) c h w')
-            denoise_grid = make_grid(denoise_grid, nrow=n_log_timesteps)
-        elif denoise_row.dim() == 6:
-            # video, grid_size=[n_log_timesteps*bs, t]
-            video_length = denoise_row.shape[3]
-            denoise_grid = rearrange(denoise_row, 'n b c t h w -> b n c t h w')
-            denoise_grid = rearrange(denoise_grid, 'b n c t h w -> (b n) c t h w')
-            denoise_grid = rearrange(denoise_grid, 'n c t h w -> (n t) c h w')
-            denoise_grid = make_grid(denoise_grid, nrow=video_length)
-        else:
-            raise ValueError
-
-        return denoise_grid
-
-
-    def p_mean_variance(self, x, c, t, clip_denoised: bool, return_x0=False, score_corrector=None, corrector_kwargs=None, **kwargs):
-        t_in = t
-        model_out = self.apply_model(x, t_in, c, **kwargs)
-
-        if score_corrector is not None:
-            assert self.parameterization == "eps"
-            model_out = score_corrector.modify_score(self, model_out, x, t, c, **corrector_kwargs)
-
-        if self.parameterization == "eps":
-            x_recon = self.predict_start_from_noise(x, t=t, noise=model_out)
-        elif self.parameterization == "x0":
-            x_recon = model_out
-        else:
-            raise NotImplementedError()
-
-        if clip_denoised:
-            x_recon.clamp_(-1., 1.)
-
-        model_mean, posterior_variance, posterior_log_variance = self.q_posterior(x_start=x_recon, x_t=x, t=t)
-
-        if return_x0:
-            return model_mean, posterior_variance, posterior_log_variance, x_recon
-        else:
-            return model_mean, posterior_variance, posterior_log_variance
-
-    @torch.no_grad()
-    def p_sample(self, x, c, t, clip_denoised=False, repeat_noise=False, return_x0=False, \
-                 temperature=1., noise_dropout=0., score_corrector=None, corrector_kwargs=None, **kwargs):
-        b, *_, device = *x.shape, x.device
-        outputs = self.p_mean_variance(x=x, c=c, t=t, clip_denoised=clip_denoised, return_x0=return_x0, \
-                                       score_corrector=score_corrector, corrector_kwargs=corrector_kwargs, **kwargs)
-        if return_x0:
-            model_mean, _, model_log_variance, x0 = outputs
-        else:
-            model_mean, _, model_log_variance = outputs
-
-        noise = noise_like(x.shape, device, repeat_noise) * temperature
-        if noise_dropout > 0.:
-            noise = torch.nn.functional.dropout(noise, p=noise_dropout)
-        # no noise when t == 0
-        nonzero_mask = (1 - (t == 0).float()).reshape(b, *((1,) * (len(x.shape) - 1)))
-
-        if return_x0:
-            return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise, x0
-        else:
-            return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise
-
-    @torch.no_grad()
-    def p_sample_loop(self, cond, shape, return_intermediates=False, x_T=None, verbose=True, callback=None, \
-                      timesteps=None, mask=None, x0=None, img_callback=None, start_T=None, log_every_t=None, **kwargs):
-
-        if not log_every_t:
-            log_every_t = self.log_every_t
-        device = self.betas.device
-        b = shape[0]        
-        # sample an initial noise
-        if x_T is None:
-            img = torch.randn(shape, device=device)
-        else:
-            img = x_T
-
-        intermediates = [img]
-        if timesteps is None:
-            timesteps = self.num_timesteps
-        if start_T is not None:
-            timesteps = min(timesteps, start_T)
-
-        iterator = tqdm(reversed(range(0, timesteps)), desc='Sampling t', total=timesteps) if verbose else reversed(range(0, timesteps))
-
-        if mask is not None:
-            assert x0 is not None
-            assert x0.shape[2:3] == mask.shape[2:3]  # spatial size has to match
-
-        for i in iterator:
-            ts = torch.full((b,), i, device=device, dtype=torch.long)
-            if self.shorten_cond_schedule:
-                assert self.model.conditioning_key != 'hybrid'
-                tc = self.cond_ids[ts].to(cond.device)
-                cond = self.q_sample(x_start=cond, t=tc, noise=torch.randn_like(cond))
-
-            img = self.p_sample(img, cond, ts, clip_denoised=self.clip_denoised, **kwargs)
-            if mask is not None:
-                img_orig = self.q_sample(x0, ts)
-                img = img_orig * mask + (1. - mask) * img
-
-            if i % log_every_t == 0 or i == timesteps - 1:
-                intermediates.append(img)
-            if callback: callback(i)
-            if img_callback: img_callback(img, i)
-
-        if return_intermediates:
-            return img, intermediates
-        return img
-
-
-class LatentVisualDiffusion(LatentDiffusion):
-    def __init__(self, img_cond_stage_config, image_proj_stage_config, freeze_embedder=True, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self._init_embedder(img_cond_stage_config, freeze_embedder)
-        self.image_proj_model = instantiate_from_config(image_proj_stage_config)
-
-    def _init_embedder(self, config, freeze=True):
-        embedder = instantiate_from_config(config)
-        if freeze:
-            self.embedder = embedder.eval()
-            self.embedder.train = disabled_train
-            for param in self.embedder.parameters():
-                param.requires_grad = False
-
-
-class DiffusionWrapper(nn.Module):
-    def __init__(self, diff_model_config, conditioning_key):
-        super().__init__()
-        self.diffusion_model = instantiate_from_config(diff_model_config)
-        self.conditioning_key = conditioning_key
-
-    def forward(self, x, t, c_concat: list = None, c_crossattn: list = None,
-                c_adm=None, s=None, mask=None, **kwargs):
-        # temporal_context = fps is foNone
-        if self.conditioning_key is None:
-            out = self.diffusion_model(x, t)
-        elif self.conditioning_key == 'concat':
-            xc = torch.cat([x] + c_concat, dim=1)
-            out = self.diffusion_model(xc, t, **kwargs)
-        elif self.conditioning_key == 'crossattn':
-            cc = torch.cat(c_crossattn, 1)
-            out = self.diffusion_model(x, t, context=cc, **kwargs)
-        elif self.conditioning_key == 'hybrid':
-            ## it is just right [b,c,t,h,w]: concatenate in channel dim
-            xc = torch.cat([x] + c_concat, dim=1)
-            cc = torch.cat(c_crossattn, 1)
-            out = self.diffusion_model(xc, t, context=cc, **kwargs)
-        elif self.conditioning_key == 'resblockcond':
-            cc = c_crossattn[0]
-            out = self.diffusion_model(x, t, context=cc)
-        elif self.conditioning_key == 'adm':
-            cc = c_crossattn[0]
-            out = self.diffusion_model(x, t, y=cc)
-        elif self.conditioning_key == 'hybrid-adm':
-            assert c_adm is not None
-            xc = torch.cat([x] + c_concat, dim=1)
-            cc = torch.cat(c_crossattn, 1)
-            out = self.diffusion_model(xc, t, context=cc, y=c_adm, **kwargs)
-        elif self.conditioning_key == 'hybrid-time':
-            assert s is not None
-            xc = torch.cat([x] + c_concat, dim=1)
-            cc = torch.cat(c_crossattn, 1)
-            out = self.diffusion_model(xc, t, context=cc, s=s)
-        elif self.conditioning_key == 'concat-time-mask':
-            # assert s is not None
-            xc = torch.cat([x] + c_concat, dim=1)
-            out = self.diffusion_model(xc, t, context=None, s=s, mask=mask)
-        elif self.conditioning_key == 'concat-adm-mask':
-            # assert s is not None
-            if c_concat is not None:
-                xc = torch.cat([x] + c_concat, dim=1)
-            else:
-                xc = x
-            out = self.diffusion_model(xc, t, context=None, y=s, mask=mask)
-        elif self.conditioning_key == 'hybrid-adm-mask':
-            cc = torch.cat(c_crossattn, 1)
-            if c_concat is not None:
-                xc = torch.cat([x] + c_concat, dim=1)
-            else:
-                xc = x
-            out = self.diffusion_model(xc, t, context=cc, y=s, mask=mask)
-        elif self.conditioning_key == 'hybrid-time-adm': # adm means y, e.g., class index
-            # assert s is not None
-            assert c_adm is not None
-            xc = torch.cat([x] + c_concat, dim=1)
-            cc = torch.cat(c_crossattn, 1)
-            out = self.diffusion_model(xc, t, context=cc, s=s, y=c_adm)
-        elif self.conditioning_key == 'crossattn-adm':
-            assert c_adm is not None
-            cc = torch.cat(c_crossattn, 1)
-            out = self.diffusion_model(x, t, context=cc, y=c_adm)
-        else:
-            raise NotImplementedError()
-
-        return out
@@ -1,317 +0,0 @@
-import numpy as np
-from tqdm import tqdm
-import torch
-from ..models.utils_diffusion import make_ddim_sampling_parameters, make_ddim_timesteps, rescale_noise_cfg
-from ..common import noise_like
-from ..common import extract_into_tensor
-import copy
-
-
-class DDIMSampler(object):
-    def __init__(self, model, schedule="linear", **kwargs):
-        super().__init__()
-        self.model = model
-        self.ddpm_num_timesteps = model.num_timesteps
-        self.schedule = schedule
-        self.counter = 0
-
-    def register_buffer(self, name, attr):
-        if type(attr) == torch.Tensor:
-            if attr.device != torch.device("cuda"):
-                attr = attr.to(torch.device("cuda"))
-        setattr(self, name, attr)
-
-    def make_schedule(self, ddim_num_steps, ddim_discretize="uniform", ddim_eta=0., verbose=True):
-        self.ddim_timesteps = make_ddim_timesteps(ddim_discr_method=ddim_discretize, num_ddim_timesteps=ddim_num_steps,
-                                                  num_ddpm_timesteps=self.ddpm_num_timesteps,verbose=verbose)
-        alphas_cumprod = self.model.alphas_cumprod
-        assert alphas_cumprod.shape[0] == self.ddpm_num_timesteps, 'alphas have to be defined for each timestep'
-        to_torch = lambda x: x.clone().detach().to(torch.float32).to(self.model.device)
-
-        if self.model.use_dynamic_rescale:
-            self.ddim_scale_arr = self.model.scale_arr[self.ddim_timesteps]
-            self.ddim_scale_arr_prev = torch.cat([self.ddim_scale_arr[0:1], self.ddim_scale_arr[:-1]])
-
-        self.register_buffer('betas', to_torch(self.model.betas))
-        self.register_buffer('alphas_cumprod', to_torch(alphas_cumprod))
-        self.register_buffer('alphas_cumprod_prev', to_torch(self.model.alphas_cumprod_prev))
-
-        # calculations for diffusion q(x_t | x_{t-1}) and others
-        self.register_buffer('sqrt_alphas_cumprod', to_torch(np.sqrt(alphas_cumprod.cpu())))
-        self.register_buffer('sqrt_one_minus_alphas_cumprod', to_torch(np.sqrt(1. - alphas_cumprod.cpu())))
-        self.register_buffer('log_one_minus_alphas_cumprod', to_torch(np.log(1. - alphas_cumprod.cpu())))
-        self.register_buffer('sqrt_recip_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod.cpu())))
-        self.register_buffer('sqrt_recipm1_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod.cpu() - 1)))
-
-        # ddim sampling parameters
-        ddim_sigmas, ddim_alphas, ddim_alphas_prev = make_ddim_sampling_parameters(alphacums=alphas_cumprod.cpu(),
-                                                                                   ddim_timesteps=self.ddim_timesteps,
-                                                                                   eta=ddim_eta,verbose=verbose)
-        self.register_buffer('ddim_sigmas', ddim_sigmas)
-        self.register_buffer('ddim_alphas', ddim_alphas)
-        self.register_buffer('ddim_alphas_prev', ddim_alphas_prev)
-        self.register_buffer('ddim_sqrt_one_minus_alphas', np.sqrt(1. - ddim_alphas))
-        sigmas_for_original_sampling_steps = ddim_eta * torch.sqrt(
-            (1 - self.alphas_cumprod_prev) / (1 - self.alphas_cumprod) * (
-                        1 - self.alphas_cumprod / self.alphas_cumprod_prev))
-        self.register_buffer('ddim_sigmas_for_original_num_steps', sigmas_for_original_sampling_steps)
-
-    @torch.no_grad()
-    def sample(self,
-               S,
-               batch_size,
-               shape,
-               conditioning=None,
-               callback=None,
-               normals_sequence=None,
-               img_callback=None,
-               quantize_x0=False,
-               eta=0.,
-               mask=None,
-               x0=None,
-               temperature=1.,
-               noise_dropout=0.,
-               score_corrector=None,
-               corrector_kwargs=None,
-               verbose=True,
-               schedule_verbose=False,
-               x_T=None,
-               log_every_t=100,
-               unconditional_guidance_scale=1.,
-               unconditional_conditioning=None,
-               precision=None,
-               fs=None,
-               timestep_spacing='uniform', #uniform_trailing for starting from last timestep
-               guidance_rescale=0.0,
-               **kwargs
-               ):
-        
-        # check condition bs
-        if conditioning is not None:
-            if isinstance(conditioning, dict):
-                try:
-                    cbs = conditioning[list(conditioning.keys())[0]].shape[0]
-                except:
-                    cbs = conditioning[list(conditioning.keys())[0]][0].shape[0]
-
-                if cbs != batch_size:
-                    print(f"Warning: Got {cbs} conditionings but batch-size is {batch_size}")
-            else:
-                if conditioning.shape[0] != batch_size:
-                    print(f"Warning: Got {conditioning.shape[0]} conditionings but batch-size is {batch_size}")
-
-        self.make_schedule(ddim_num_steps=S, ddim_discretize=timestep_spacing, ddim_eta=eta, verbose=schedule_verbose)
-        
-        # make shape
-        if len(shape) == 3:
-            C, H, W = shape
-            size = (batch_size, C, H, W)
-        elif len(shape) == 4:
-            C, T, H, W = shape
-            size = (batch_size, C, T, H, W)
-
-        samples, intermediates = self.ddim_sampling(conditioning, size,
-                                                    callback=callback,
-                                                    img_callback=img_callback,
-                                                    quantize_denoised=quantize_x0,
-                                                    mask=mask, x0=x0,
-                                                    ddim_use_original_steps=False,
-                                                    noise_dropout=noise_dropout,
-                                                    temperature=temperature,
-                                                    score_corrector=score_corrector,
-                                                    corrector_kwargs=corrector_kwargs,
-                                                    x_T=x_T,
-                                                    log_every_t=log_every_t,
-                                                    unconditional_guidance_scale=unconditional_guidance_scale,
-                                                    unconditional_conditioning=unconditional_conditioning,
-                                                    verbose=verbose,
-                                                    precision=precision,
-                                                    fs=fs,
-                                                    guidance_rescale=guidance_rescale,
-                                                    **kwargs)
-        return samples, intermediates
-
-    @torch.no_grad()
-    def ddim_sampling(self, cond, shape,
-                      x_T=None, ddim_use_original_steps=False,
-                      callback=None, timesteps=None, quantize_denoised=False,
-                      mask=None, x0=None, img_callback=None, log_every_t=100,
-                      temperature=1., noise_dropout=0., score_corrector=None, corrector_kwargs=None,
-                      unconditional_guidance_scale=1., unconditional_conditioning=None, verbose=True,precision=None,fs=None,guidance_rescale=0.0,
-                      **kwargs):
-        device = self.model.betas.device        
-        b = shape[0]
-        if x_T is None:
-            img = torch.randn(shape, device=device)
-        else:
-            img = x_T
-        if precision is not None:
-            if precision == 16:
-                img = img.to(dtype=torch.float16)
-
-        if timesteps is None:
-            timesteps = self.ddpm_num_timesteps if ddim_use_original_steps else self.ddim_timesteps
-        elif timesteps is not None and not ddim_use_original_steps:
-            subset_end = int(min(timesteps / self.ddim_timesteps.shape[0], 1) * self.ddim_timesteps.shape[0]) - 1
-            timesteps = self.ddim_timesteps[:subset_end]
-            
-        intermediates = {'x_inter': [img], 'pred_x0': [img]}
-        time_range = reversed(range(0,timesteps)) if ddim_use_original_steps else np.flip(timesteps)
-        total_steps = timesteps if ddim_use_original_steps else timesteps.shape[0]
-        if verbose:
-            iterator = tqdm(time_range, desc='DDIM Sampler', total=total_steps)
-        else:
-            iterator = time_range
-
-        clean_cond = kwargs.pop("clean_cond", False)
-
-        # cond_copy, unconditional_conditioning_copy = copy.deepcopy(cond), copy.deepcopy(unconditional_conditioning)
-        for i, step in enumerate(iterator):
-            index = total_steps - i - 1
-            ts = torch.full((b,), step, device=device, dtype=torch.long)
-
-            ## use mask to blend noised original latent (img_orig) & new sampled latent (img)
-            if mask is not None:
-                assert x0 is not None
-                if clean_cond:
-                    img_orig = x0
-                else:
-                    img_orig = self.model.q_sample(x0, ts)  # TODO: deterministic forward pass? <ddim inversion>
-                img = img_orig * mask + (1. - mask) * img # keep original & modify use img
-
-
-
-
-            outs = self.p_sample_ddim(img, cond, ts, index=index, use_original_steps=ddim_use_original_steps,
-                                      quantize_denoised=quantize_denoised, temperature=temperature,
-                                      noise_dropout=noise_dropout, score_corrector=score_corrector,
-                                      corrector_kwargs=corrector_kwargs,
-                                      unconditional_guidance_scale=unconditional_guidance_scale,
-                                      unconditional_conditioning=unconditional_conditioning,
-                                      mask=mask,x0=x0,fs=fs,guidance_rescale=guidance_rescale,
-                                      **kwargs)
-            
-
-            img, pred_x0 = outs
-            if callback: callback(i)
-            if img_callback: img_callback(pred_x0, i)
-
-            if index % log_every_t == 0 or index == total_steps - 1:
-                intermediates['x_inter'].append(img)
-                intermediates['pred_x0'].append(pred_x0)
-
-        return img, intermediates
-
-    @torch.no_grad()
-    def p_sample_ddim(self, x, c, t, index, repeat_noise=False, use_original_steps=False, quantize_denoised=False,
-                      temperature=1., noise_dropout=0., score_corrector=None, corrector_kwargs=None,
-                      unconditional_guidance_scale=1., unconditional_conditioning=None,
-                      uc_type=None, conditional_guidance_scale_temporal=None,mask=None,x0=None,guidance_rescale=0.0,**kwargs):
-        b, *_, device = *x.shape, x.device
-        if x.dim() == 5:
-            is_video = True
-        else:
-            is_video = False
-
-        if unconditional_conditioning is None or unconditional_guidance_scale == 1.:
-            model_output = self.model.apply_model(x, t, c, **kwargs) # unet denoiser
-        else:
-            ### do_classifier_free_guidance
-            if isinstance(c, torch.Tensor) or isinstance(c, dict):
-                e_t_cond = self.model.apply_model(x, t, c, **kwargs)
-                e_t_uncond = self.model.apply_model(x, t, unconditional_conditioning, **kwargs)
-            else:
-                raise NotImplementedError
-
-            model_output = e_t_uncond + unconditional_guidance_scale * (e_t_cond - e_t_uncond)
-
-            if guidance_rescale > 0.0:
-                model_output = rescale_noise_cfg(model_output, e_t_cond, guidance_rescale=guidance_rescale)
-
-        if self.model.parameterization == "v":
-            e_t = self.model.predict_eps_from_z_and_v(x, t, model_output)
-        else:
-            e_t = model_output
-
-        if score_corrector is not None:
-            assert self.model.parameterization == "eps", 'not implemented'
-            e_t = score_corrector.modify_score(self.model, e_t, x, t, c, **corrector_kwargs)
-
-        alphas = self.model.alphas_cumprod if use_original_steps else self.ddim_alphas
-        alphas_prev = self.model.alphas_cumprod_prev if use_original_steps else self.ddim_alphas_prev
-        sqrt_one_minus_alphas = self.model.sqrt_one_minus_alphas_cumprod if use_original_steps else self.ddim_sqrt_one_minus_alphas
-        # sigmas = self.model.ddim_sigmas_for_original_num_steps if use_original_steps else self.ddim_sigmas
-        sigmas = self.ddim_sigmas_for_original_num_steps if use_original_steps else self.ddim_sigmas
-        # select parameters corresponding to the currently considered timestep
-        
-        if is_video:
-            size = (b, 1, 1, 1, 1)
-        else:
-            size = (b, 1, 1, 1)
-        a_t = torch.full(size, alphas[index], device=device)
-        a_prev = torch.full(size, alphas_prev[index], device=device)
-        sigma_t = torch.full(size, sigmas[index], device=device)
-        sqrt_one_minus_at = torch.full(size, sqrt_one_minus_alphas[index],device=device)
-
-        # current prediction for x_0
-        if self.model.parameterization != "v":
-            pred_x0 = (x - sqrt_one_minus_at * e_t) / a_t.sqrt()
-        else:
-            pred_x0 = self.model.predict_start_from_z_and_v(x, t, model_output)
-        
-        if self.model.use_dynamic_rescale:
-            scale_t = torch.full(size, self.ddim_scale_arr[index], device=device)
-            prev_scale_t = torch.full(size, self.ddim_scale_arr_prev[index], device=device)
-            rescale = (prev_scale_t / scale_t)
-            pred_x0 *= rescale
-
-        if quantize_denoised:
-            pred_x0, _, *_ = self.model.first_stage_model.quantize(pred_x0)
-        # direction pointing to x_t
-        dir_xt = (1. - a_prev - sigma_t**2).sqrt() * e_t
-
-        noise = sigma_t * noise_like(x.shape, device, repeat_noise) * temperature
-        if noise_dropout > 0.:
-            noise = torch.nn.functional.dropout(noise, p=noise_dropout)
-    
-        x_prev = a_prev.sqrt() * pred_x0 + dir_xt + noise
-
-        return x_prev, pred_x0
-
-    @torch.no_grad()
-    def decode(self, x_latent, cond, t_start, unconditional_guidance_scale=1.0, unconditional_conditioning=None,
-               use_original_steps=False, callback=None):
-
-        timesteps = np.arange(self.ddpm_num_timesteps) if use_original_steps else self.ddim_timesteps
-        timesteps = timesteps[:t_start]
-
-        time_range = np.flip(timesteps)
-        total_steps = timesteps.shape[0]
-        print(f"Running DDIM Sampling with {total_steps} timesteps")
-
-        iterator = tqdm(time_range, desc='Decoding image', total=total_steps)
-        x_dec = x_latent
-        for i, step in enumerate(iterator):
-            index = total_steps - i - 1
-            ts = torch.full((x_latent.shape[0],), step, device=x_latent.device, dtype=torch.long)
-            x_dec, _ = self.p_sample_ddim(x_dec, cond, ts, index=index, use_original_steps=use_original_steps,
-                                          unconditional_guidance_scale=unconditional_guidance_scale,
-                                          unconditional_conditioning=unconditional_conditioning)
-            if callback: callback(i)
-        return x_dec
-
-    @torch.no_grad()
-    def stochastic_encode(self, x0, t, use_original_steps=False, noise=None):
-        # fast, but does not allow for exact reconstruction
-        # t serves as an index to gather the correct alphas
-        if use_original_steps:
-            sqrt_alphas_cumprod = self.sqrt_alphas_cumprod
-            sqrt_one_minus_alphas_cumprod = self.sqrt_one_minus_alphas_cumprod
-        else:
-            sqrt_alphas_cumprod = torch.sqrt(self.ddim_alphas)
-            sqrt_one_minus_alphas_cumprod = self.ddim_sqrt_one_minus_alphas
-
-        if noise is None:
-            noise = torch.randn_like(x0)
-        return (extract_into_tensor(sqrt_alphas_cumprod, t, x0.shape) * x0 +
-                extract_into_tensor(sqrt_one_minus_alphas_cumprod, t, x0.shape) * noise)
@@ -1,323 +0,0 @@
-import numpy as np
-from tqdm import tqdm
-import torch
-from ...models.utils_diffusion import make_ddim_sampling_parameters, make_ddim_timesteps, rescale_noise_cfg
-from ..common import noise_like
-from ..common import extract_into_tensor
-import copy
-
-
-class DDIMSampler(object):
-    def __init__(self, model, schedule="linear", **kwargs):
-        super().__init__()
-        self.model = model
-        self.ddpm_num_timesteps = model.num_timesteps
-        self.schedule = schedule
-        self.counter = 0
-
-    def register_buffer(self, name, attr):
-        if type(attr) == torch.Tensor:
-            if attr.device != torch.device("cuda"):
-                attr = attr.to(torch.device("cuda"))
-        setattr(self, name, attr)
-
-    def make_schedule(self, ddim_num_steps, ddim_discretize="uniform", ddim_eta=0., verbose=True):
-        self.ddim_timesteps = make_ddim_timesteps(ddim_discr_method=ddim_discretize, num_ddim_timesteps=ddim_num_steps,
-                                                  num_ddpm_timesteps=self.ddpm_num_timesteps,verbose=verbose)
-        alphas_cumprod = self.model.alphas_cumprod
-        assert alphas_cumprod.shape[0] == self.ddpm_num_timesteps, 'alphas have to be defined for each timestep'
-        to_torch = lambda x: x.clone().detach().to(torch.float32).to(self.model.device)
-
-        if self.model.use_dynamic_rescale:
-            self.ddim_scale_arr = self.model.scale_arr[self.ddim_timesteps]
-            self.ddim_scale_arr_prev = torch.cat([self.ddim_scale_arr[0:1], self.ddim_scale_arr[:-1]])
-
-        self.register_buffer('betas', to_torch(self.model.betas))
-        self.register_buffer('alphas_cumprod', to_torch(alphas_cumprod))
-        self.register_buffer('alphas_cumprod_prev', to_torch(self.model.alphas_cumprod_prev))
-
-        # calculations for diffusion q(x_t | x_{t-1}) and others
-        self.register_buffer('sqrt_alphas_cumprod', to_torch(np.sqrt(alphas_cumprod.cpu())))
-        self.register_buffer('sqrt_one_minus_alphas_cumprod', to_torch(np.sqrt(1. - alphas_cumprod.cpu())))
-        self.register_buffer('log_one_minus_alphas_cumprod', to_torch(np.log(1. - alphas_cumprod.cpu())))
-        self.register_buffer('sqrt_recip_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod.cpu())))
-        self.register_buffer('sqrt_recipm1_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod.cpu() - 1)))
-
-        # ddim sampling parameters
-        ddim_sigmas, ddim_alphas, ddim_alphas_prev = make_ddim_sampling_parameters(alphacums=alphas_cumprod.cpu(),
-                                                                                   ddim_timesteps=self.ddim_timesteps,
-                                                                                   eta=ddim_eta,verbose=verbose)
-        self.register_buffer('ddim_sigmas', ddim_sigmas)
-        self.register_buffer('ddim_alphas', ddim_alphas)
-        self.register_buffer('ddim_alphas_prev', ddim_alphas_prev)
-        self.register_buffer('ddim_sqrt_one_minus_alphas', np.sqrt(1. - ddim_alphas))
-        sigmas_for_original_sampling_steps = ddim_eta * torch.sqrt(
-            (1 - self.alphas_cumprod_prev) / (1 - self.alphas_cumprod) * (
-                        1 - self.alphas_cumprod / self.alphas_cumprod_prev))
-        self.register_buffer('ddim_sigmas_for_original_num_steps', sigmas_for_original_sampling_steps)
-
-    @torch.no_grad()
-    def sample(self,
-               S,
-               batch_size,
-               shape,
-               conditioning=None,
-               callback=None,
-               normals_sequence=None,
-               img_callback=None,
-               quantize_x0=False,
-               eta=0.,
-               mask=None,
-               x0=None,
-               temperature=1.,
-               noise_dropout=0.,
-               score_corrector=None,
-               corrector_kwargs=None,
-               verbose=True,
-               schedule_verbose=False,
-               x_T=None,
-               log_every_t=100,
-               unconditional_guidance_scale=1.,
-               unconditional_conditioning=None,
-               precision=None,
-               fs=None,
-               timestep_spacing='uniform', #uniform_trailing for starting from last timestep
-               guidance_rescale=0.0,
-               # this has to come in the same format as the conditioning, # e.g. as encoded tokens, ...
-               **kwargs
-               ):
-        
-        # check condition bs
-        if conditioning is not None:
-            if isinstance(conditioning, dict):
-                try:
-                    cbs = conditioning[list(conditioning.keys())[0]].shape[0]
-                except:
-                    cbs = conditioning[list(conditioning.keys())[0]][0].shape[0]
-
-                if cbs != batch_size:
-                    print(f"Warning: Got {cbs} conditionings but batch-size is {batch_size}")
-            else:
-                if conditioning.shape[0] != batch_size:
-                    print(f"Warning: Got {conditioning.shape[0]} conditionings but batch-size is {batch_size}")
-
-        # print('==> timestep_spacing: ', timestep_spacing, guidance_rescale)
-        self.make_schedule(ddim_num_steps=S, ddim_discretize=timestep_spacing, ddim_eta=eta, verbose=schedule_verbose)
-        
-        # make shape
-        if len(shape) == 3:
-            C, H, W = shape
-            size = (batch_size, C, H, W)
-        elif len(shape) == 4:
-            C, T, H, W = shape
-            size = (batch_size, C, T, H, W)
-        # print(f'Data shape for DDIM sampling is {size}, eta {eta}')
-        
-        samples, intermediates = self.ddim_sampling(conditioning, size,
-                                                    callback=callback,
-                                                    img_callback=img_callback,
-                                                    quantize_denoised=quantize_x0,
-                                                    mask=mask, x0=x0,
-                                                    ddim_use_original_steps=False,
-                                                    noise_dropout=noise_dropout,
-                                                    temperature=temperature,
-                                                    score_corrector=score_corrector,
-                                                    corrector_kwargs=corrector_kwargs,
-                                                    x_T=x_T,
-                                                    log_every_t=log_every_t,
-                                                    unconditional_guidance_scale=unconditional_guidance_scale,
-                                                    unconditional_conditioning=unconditional_conditioning,
-                                                    verbose=verbose,
-                                                    precision=precision,
-                                                    fs=fs,
-                                                    guidance_rescale=guidance_rescale,
-                                                    **kwargs)
-        return samples, intermediates
-
-    @torch.no_grad()
-    def ddim_sampling(self, cond, shape,
-                      x_T=None, ddim_use_original_steps=False,
-                      callback=None, timesteps=None, quantize_denoised=False,
-                      mask=None, x0=None, img_callback=None, log_every_t=100,
-                      temperature=1., noise_dropout=0., score_corrector=None, corrector_kwargs=None,
-                      unconditional_guidance_scale=1., unconditional_conditioning=None, verbose=True,precision=None,fs=None,guidance_rescale=0.0,
-                      **kwargs):
-        device = self.model.betas.device        
-        b = shape[0]
-        if x_T is None:
-            img = torch.randn(shape, device=device)
-        else:
-            img = x_T
-        if precision is not None:
-            if precision == 16:
-                img = img.to(dtype=torch.float16)
-
-        
-        if timesteps is None:
-            timesteps = self.ddpm_num_timesteps if ddim_use_original_steps else self.ddim_timesteps
-        elif timesteps is not None and not ddim_use_original_steps:
-            subset_end = int(min(timesteps / self.ddim_timesteps.shape[0], 1) * self.ddim_timesteps.shape[0]) - 1
-            timesteps = self.ddim_timesteps[:subset_end]
-            
-        intermediates = {'x_inter': [img], 'pred_x0': [img]}
-        time_range = reversed(range(0,timesteps)) if ddim_use_original_steps else np.flip(timesteps)
-        total_steps = timesteps if ddim_use_original_steps else timesteps.shape[0]
-        if verbose:
-            iterator = tqdm(time_range, desc='DDIM Sampler', total=total_steps)
-        else:
-            iterator = time_range
-
-        clean_cond = kwargs.pop("clean_cond", False)
-
-        # cond_copy, unconditional_conditioning_copy = copy.deepcopy(cond), copy.deepcopy(unconditional_conditioning)
-        for i, step in enumerate(iterator):
-            index = total_steps - i - 1
-            ts = torch.full((b,), step, device=device, dtype=torch.long)
-
-            ## use mask to blend noised original latent (img_orig) & new sampled latent (img)
-            if mask is not None:
-                assert x0 is not None
-                if clean_cond:
-                    img_orig = x0
-                else:
-                    img_orig = self.model.q_sample(x0, ts)  # TODO: deterministic forward pass? <ddim inversion>
-                img = img_orig * mask + (1. - mask) * img # keep original & modify use img
-
-
-
-
-            outs = self.p_sample_ddim(img, cond, ts, index=index, use_original_steps=ddim_use_original_steps,
-                                      quantize_denoised=quantize_denoised, temperature=temperature,
-                                      noise_dropout=noise_dropout, score_corrector=score_corrector,
-                                      corrector_kwargs=corrector_kwargs,
-                                      unconditional_guidance_scale=unconditional_guidance_scale,
-                                      unconditional_conditioning=unconditional_conditioning,
-                                      mask=mask,x0=x0,fs=fs,guidance_rescale=guidance_rescale,
-                                      **kwargs)
-            
-
-
-            img, pred_x0 = outs
-            if callback: callback(i)
-            if img_callback: img_callback(pred_x0, i)
-
-            if index % log_every_t == 0 or index == total_steps - 1:
-                intermediates['x_inter'].append(img)
-                intermediates['pred_x0'].append(pred_x0)
-
-        return img, intermediates
-
-    @torch.no_grad()
-    def p_sample_ddim(self, x, c, t, index, repeat_noise=False, use_original_steps=False, quantize_denoised=False,
-                      temperature=1., noise_dropout=0., score_corrector=None, corrector_kwargs=None,
-                      unconditional_guidance_scale=1., unconditional_conditioning=None,
-                      uc_type=None, cfg_img=None,mask=None,x0=None,guidance_rescale=0.0, **kwargs):
-        b, *_, device = *x.shape, x.device
-        if x.dim() == 5:
-            is_video = True
-        else:
-            is_video = False
-        if cfg_img is None:
-            cfg_img = unconditional_guidance_scale
-
-        unconditional_conditioning_img_nonetext = kwargs['unconditional_conditioning_img_nonetext']
-
-        
-        if unconditional_conditioning is None or unconditional_guidance_scale == 1.:
-            model_output = self.model.apply_model(x, t, c, **kwargs) # unet denoiser
-        else:
-            ### with unconditional condition
-            e_t_cond = self.model.apply_model(x, t, c, **kwargs)
-            e_t_uncond = self.model.apply_model(x, t, unconditional_conditioning, **kwargs)
-            e_t_uncond_img = self.model.apply_model(x, t, unconditional_conditioning_img_nonetext, **kwargs)
-            # text cfg
-            model_output = e_t_uncond + cfg_img * (e_t_uncond_img - e_t_uncond) + unconditional_guidance_scale * (e_t_cond - e_t_uncond_img)
-            if guidance_rescale > 0.0:
-                model_output = rescale_noise_cfg(model_output, e_t_cond, guidance_rescale=guidance_rescale)
-        
-        if self.model.parameterization == "v":
-            e_t = self.model.predict_eps_from_z_and_v(x, t, model_output)
-        else:
-            e_t = model_output
-
-        if score_corrector is not None:
-            assert self.model.parameterization == "eps", 'not implemented'
-            e_t = score_corrector.modify_score(self.model, e_t, x, t, c, **corrector_kwargs)
-
-        alphas = self.model.alphas_cumprod if use_original_steps else self.ddim_alphas
-        alphas_prev = self.model.alphas_cumprod_prev if use_original_steps else self.ddim_alphas_prev
-        sqrt_one_minus_alphas = self.model.sqrt_one_minus_alphas_cumprod if use_original_steps else self.ddim_sqrt_one_minus_alphas
-        sigmas = self.ddim_sigmas_for_original_num_steps if use_original_steps else self.ddim_sigmas
-        # select parameters corresponding to the currently considered timestep
-        
-        if is_video:
-            size = (b, 1, 1, 1, 1)
-        else:
-            size = (b, 1, 1, 1)
-        a_t = torch.full(size, alphas[index], device=device)
-        a_prev = torch.full(size, alphas_prev[index], device=device)
-        sigma_t = torch.full(size, sigmas[index], device=device)
-        sqrt_one_minus_at = torch.full(size, sqrt_one_minus_alphas[index],device=device)
-
-        # current prediction for x_0
-        if self.model.parameterization != "v":
-            pred_x0 = (x - sqrt_one_minus_at * e_t) / a_t.sqrt()
-        else:
-            pred_x0 = self.model.predict_start_from_z_and_v(x, t, model_output)
-        
-        if self.model.use_dynamic_rescale:
-            scale_t = torch.full(size, self.ddim_scale_arr[index], device=device)
-            prev_scale_t = torch.full(size, self.ddim_scale_arr_prev[index], device=device)
-            rescale = (prev_scale_t / scale_t)
-            pred_x0 *= rescale
-
-        if quantize_denoised:
-            pred_x0, _, *_ = self.model.first_stage_model.quantize(pred_x0)
-        # direction pointing to x_t
-        dir_xt = (1. - a_prev - sigma_t**2).sqrt() * e_t
-
-        noise = sigma_t * noise_like(x.shape, device, repeat_noise) * temperature
-        if noise_dropout > 0.:
-            noise = torch.nn.functional.dropout(noise, p=noise_dropout)
-    
-        x_prev = a_prev.sqrt() * pred_x0 + dir_xt + noise
-
-        return x_prev, pred_x0
-
-    @torch.no_grad()
-    def decode(self, x_latent, cond, t_start, unconditional_guidance_scale=1.0, unconditional_conditioning=None,
-               use_original_steps=False, callback=None):
-
-        timesteps = np.arange(self.ddpm_num_timesteps) if use_original_steps else self.ddim_timesteps
-        timesteps = timesteps[:t_start]
-
-        time_range = np.flip(timesteps)
-        total_steps = timesteps.shape[0]
-        print(f"Running DDIM Sampling with {total_steps} timesteps")
-
-        iterator = tqdm(time_range, desc='Decoding image', total=total_steps)
-        x_dec = x_latent
-        for i, step in enumerate(iterator):
-            index = total_steps - i - 1
-            ts = torch.full((x_latent.shape[0],), step, device=x_latent.device, dtype=torch.long)
-            x_dec, _ = self.p_sample_ddim(x_dec, cond, ts, index=index, use_original_steps=use_original_steps,
-                                          unconditional_guidance_scale=unconditional_guidance_scale,
-                                          unconditional_conditioning=unconditional_conditioning)
-            if callback: callback(i)
-        return x_dec
-
-    @torch.no_grad()
-    def stochastic_encode(self, x0, t, use_original_steps=False, noise=None):
-        # fast, but does not allow for exact reconstruction
-        # t serves as an index to gather the correct alphas
-        if use_original_steps:
-            sqrt_alphas_cumprod = self.sqrt_alphas_cumprod
-            sqrt_one_minus_alphas_cumprod = self.sqrt_one_minus_alphas_cumprod
-        else:
-            sqrt_alphas_cumprod = torch.sqrt(self.ddim_alphas)
-            sqrt_one_minus_alphas_cumprod = self.ddim_sqrt_one_minus_alphas
-
-        if noise is None:
-            noise = torch.randn_like(x0)
-        return (extract_into_tensor(sqrt_alphas_cumprod, t, x0.shape) * x0 +
-                extract_into_tensor(sqrt_one_minus_alphas_cumprod, t, x0.shape) * noise)
@@ -1 +0,0 @@
-from .sampler import UniPCSampler
@@ -1,79 +0,0 @@
-"""SAMPLING ONLY."""
-
-import torch
-
-from .uni_pc import NoiseScheduleVP, model_wrapper, UniPC
-
-class UniPCSampler(object):
-    def __init__(self, model, **kwargs):
-        super().__init__()
-        self.model = model
-        to_torch = lambda x: x.clone().detach().to(torch.float32).to(model.device)
-        self.register_buffer('alphas_cumprod', to_torch(model.alphas_cumprod))
-
-    def register_buffer(self, name, attr):
-        if type(attr) == torch.Tensor:
-            if attr.device != torch.device("cuda"):
-                attr = attr.to(torch.device("cuda"))
-        setattr(self, name, attr)
-
-    @torch.no_grad()
-    def sample(self,
-               S,
-               batch_size,
-               shape,
-               conditioning=None,
-               callback=None,
-               normals_sequence=None,
-               img_callback=None,
-               quantize_x0=False,
-               eta=0.,
-               mask=None,
-               x0=None,
-               temperature=1.,
-               noise_dropout=0.,
-               score_corrector=None,
-               corrector_kwargs=None,
-               verbose=True,
-               x_T=None,
-               log_every_t=100,
-               unconditional_guidance_scale=1.,
-               unconditional_conditioning=None,
-               # this has to come in the same format as the conditioning, # e.g. as encoded tokens, ...
-               **kwargs
-               ):
-        if conditioning is not None:
-            if isinstance(conditioning, dict):
-                cbs = conditioning[list(conditioning.keys())[0]].shape[0]
-                if cbs != batch_size:
-                    print(f"Warning: Got {cbs} conditionings but batch-size is {batch_size}")
-            else:
-                if conditioning.shape[0] != batch_size:
-                    print(f"Warning: Got {conditioning.shape[0]} conditionings but batch-size is {batch_size}")
-
-        # sampling
-        C, F, H, W = shape
-        size = (batch_size, C, H, W)
-
-        device = self.model.betas.device
-        if x_T is None:
-            img = torch.randn(size, device=device)
-        else:
-            img = x_T
-
-        ns = NoiseScheduleVP('discrete', alphas_cumprod=self.alphas_cumprod)
-
-        model_fn = model_wrapper(
-            lambda x, t, c: self.model.apply_model(x, t, c),
-            ns,
-            model_type="noise",
-            guidance_type="classifier-free",
-            condition=conditioning,
-            unconditional_condition=unconditional_conditioning,
-            guidance_scale=unconditional_guidance_scale,
-        )
-
-        uni_pc = UniPC(model_fn, ns, predict_x0=True, thresholding=False)
-        x = uni_pc.sample(img, steps=S, skip_type="time_uniform", method="multistep", order=3, lower_order_final=True)
-
-        return x.to(device), None
@@ -1,808 +0,0 @@
-import torch
-import torch.nn.functional as F
-import math
-
-
-class NoiseScheduleVP:
-    def __init__(
-            self,
-            schedule='discrete',
-            betas=None,
-            alphas_cumprod=None,
-            continuous_beta_0=0.1,
-            continuous_beta_1=20.,
-        ):
-        """Create a wrapper class for the forward SDE (VP type).
-
-        ***
-        Update: We support discrete-time diffusion models by implementing a picewise linear interpolation for log_alpha_t.
-                We recommend to use schedule='discrete' for the discrete-time diffusion models, especially for high-resolution images.
-        ***
-
-        The forward SDE ensures that the condition distribution q_{t|0}(x_t | x_0) = N ( alpha_t * x_0, sigma_t^2 * I ).
-        We further define lambda_t = log(alpha_t) - log(sigma_t), which is the half-logSNR (described in the DPM-Solver paper).
-        Therefore, we implement the functions for computing alpha_t, sigma_t and lambda_t. For t in [0, T], we have:
-
-            log_alpha_t = self.marginal_log_mean_coeff(t)
-            sigma_t = self.marginal_std(t)
-            lambda_t = self.marginal_lambda(t)
-
-        Moreover, as lambda(t) is an invertible function, we also support its inverse function:
-
-            t = self.inverse_lambda(lambda_t)
-
-        ===============================================================
-
-        We support both discrete-time DPMs (trained on n = 0, 1, ..., N-1) and continuous-time DPMs (trained on t in [t_0, T]).
-
-        1. For discrete-time DPMs:
-
-            For discrete-time DPMs trained on n = 0, 1, ..., N-1, we convert the discrete steps to continuous time steps by:
-                t_i = (i + 1) / N
-            e.g. for N = 1000, we have t_0 = 1e-3 and T = t_{N-1} = 1.
-            We solve the corresponding diffusion ODE from time T = 1 to time t_0 = 1e-3.
-
-            Args:
-                betas: A `torch.Tensor`. The beta array for the discrete-time DPM. (See the original DDPM paper for details)
-                alphas_cumprod: A `torch.Tensor`. The cumprod alphas for the discrete-time DPM. (See the original DDPM paper for details)
-
-            Note that we always have alphas_cumprod = cumprod(betas). Therefore, we only need to set one of `betas` and `alphas_cumprod`.
-
-            **Important**:  Please pay special attention for the args for `alphas_cumprod`:
-                The `alphas_cumprod` is the \hat{alpha_n} arrays in the notations of DDPM. Specifically, DDPMs assume that
-                    q_{t_n | 0}(x_{t_n} | x_0) = N ( \sqrt{\hat{alpha_n}} * x_0, (1 - \hat{alpha_n}) * I ).
-                Therefore, the notation \hat{alpha_n} is different from the notation alpha_t in DPM-Solver. In fact, we have
-                    alpha_{t_n} = \sqrt{\hat{alpha_n}},
-                and
-                    log(alpha_{t_n}) = 0.5 * log(\hat{alpha_n}).
-
-
-        2. For continuous-time DPMs:
-
-            We support two types of VPSDEs: linear (DDPM) and cosine (improved-DDPM). The hyperparameters for the noise
-            schedule are the default settings in DDPM and improved-DDPM:
-
-            Args:
-                beta_min: A `float` number. The smallest beta for the linear schedule.
-                beta_max: A `float` number. The largest beta for the linear schedule.
-                cosine_s: A `float` number. The hyperparameter in the cosine schedule.
-                cosine_beta_max: A `float` number. The hyperparameter in the cosine schedule.
-                T: A `float` number. The ending time of the forward process.
-
-        ===============================================================
-
-        Args:
-            schedule: A `str`. The noise schedule of the forward SDE. 'discrete' for discrete-time DPMs,
-                    'linear' or 'cosine' for continuous-time DPMs.
-        Returns:
-            A wrapper object of the forward SDE (VP type).
-        
-        ===============================================================
-
-        Example:
-
-        # For discrete-time DPMs, given betas (the beta array for n = 0, 1, ..., N - 1):
-        >>> ns = NoiseScheduleVP('discrete', betas=betas)
-
-        # For discrete-time DPMs, given alphas_cumprod (the \hat{alpha_n} array for n = 0, 1, ..., N - 1):
-        >>> ns = NoiseScheduleVP('discrete', alphas_cumprod=alphas_cumprod)
-
-        # For continuous-time DPMs (VPSDE), linear schedule:
-        >>> ns = NoiseScheduleVP('linear', continuous_beta_0=0.1, continuous_beta_1=20.)
-
-        """
-
-        if schedule not in ['discrete', 'linear', 'cosine']:
-            raise ValueError("Unsupported noise schedule {}. The schedule needs to be 'discrete' or 'linear' or 'cosine'".format(schedule))
-
-        self.schedule = schedule
-        if schedule == 'discrete':
-            if betas is not None:
-                log_alphas = 0.5 * torch.log(1 - betas).cumsum(dim=0)
-            else:
-                assert alphas_cumprod is not None
-                log_alphas = 0.5 * torch.log(alphas_cumprod)
-            self.total_N = len(log_alphas)
-            self.T = 1.
-            self.t_array = torch.linspace(0., 1., self.total_N + 1)[1:].reshape((1, -1))
-            self.log_alpha_array = log_alphas.reshape((1, -1,))
-        else:
-            self.total_N = 1000
-            self.beta_0 = continuous_beta_0
-            self.beta_1 = continuous_beta_1
-            self.cosine_s = 0.008
-            self.cosine_beta_max = 999.
-            self.cosine_t_max = math.atan(self.cosine_beta_max * (1. + self.cosine_s) / math.pi) * 2. * (1. + self.cosine_s) / math.pi - self.cosine_s
-            self.cosine_log_alpha_0 = math.log(math.cos(self.cosine_s / (1. + self.cosine_s) * math.pi / 2.))
-            self.schedule = schedule
-            if schedule == 'cosine':
-                # For the cosine schedule, T = 1 will have numerical issues. So we manually set the ending time T.
-                # Note that T = 0.9946 may be not the optimal setting. However, we find it works well.
-                self.T = 0.9946
-            else:
-                self.T = 1.
-
-    def marginal_log_mean_coeff(self, t):
-        """
-        Compute log(alpha_t) of a given continuous-time label t in [0, T].
-        """
-        if self.schedule == 'discrete':
-            return interpolate_fn(t.reshape((-1, 1)), self.t_array.to(t.device), self.log_alpha_array.to(t.device)).reshape((-1))
-        elif self.schedule == 'linear':
-            return -0.25 * t ** 2 * (self.beta_1 - self.beta_0) - 0.5 * t * self.beta_0
-        elif self.schedule == 'cosine':
-            log_alpha_fn = lambda s: torch.log(torch.cos((s + self.cosine_s) / (1. + self.cosine_s) * math.pi / 2.))
-            log_alpha_t =  log_alpha_fn(t) - self.cosine_log_alpha_0
-            return log_alpha_t
-
-    def marginal_alpha(self, t):
-        """
-        Compute alpha_t of a given continuous-time label t in [0, T].
-        """
-        return torch.exp(self.marginal_log_mean_coeff(t))
-
-    def marginal_std(self, t):
-        """
-        Compute sigma_t of a given continuous-time label t in [0, T].
-        """
-        return torch.sqrt(1. - torch.exp(2. * self.marginal_log_mean_coeff(t)))
-
-    def marginal_lambda(self, t):
-        """
-        Compute lambda_t = log(alpha_t) - log(sigma_t) of a given continuous-time label t in [0, T].
-        """
-        log_mean_coeff = self.marginal_log_mean_coeff(t)
-        log_std = 0.5 * torch.log(1. - torch.exp(2. * log_mean_coeff))
-        return log_mean_coeff - log_std
-
-    def inverse_lambda(self, lamb):
-        """
-        Compute the continuous-time label t in [0, T] of a given half-logSNR lambda_t.
-        """
-        if self.schedule == 'linear':
-            tmp = 2. * (self.beta_1 - self.beta_0) * torch.logaddexp(-2. * lamb, torch.zeros((1,)).to(lamb))
-            Delta = self.beta_0**2 + tmp
-            return tmp / (torch.sqrt(Delta) + self.beta_0) / (self.beta_1 - self.beta_0)
-        elif self.schedule == 'discrete':
-            log_alpha = -0.5 * torch.logaddexp(torch.zeros((1,)).to(lamb.device), -2. * lamb)
-            t = interpolate_fn(log_alpha.reshape((-1, 1)), torch.flip(self.log_alpha_array.to(lamb.device), [1]), torch.flip(self.t_array.to(lamb.device), [1]))
-            return t.reshape((-1,))
-        else:
-            log_alpha = -0.5 * torch.logaddexp(-2. * lamb, torch.zeros((1,)).to(lamb))
-            t_fn = lambda log_alpha_t: torch.arccos(torch.exp(log_alpha_t + self.cosine_log_alpha_0)) * 2. * (1. + self.cosine_s) / math.pi - self.cosine_s
-            t = t_fn(log_alpha)
-            return t
-
-
-def model_wrapper(
-    model,
-    noise_schedule,
-    model_type="noise",
-    model_kwargs={},
-    guidance_type="uncond",
-    condition=None,
-    unconditional_condition=None,
-    guidance_scale=1.,
-    classifier_fn=None,
-    classifier_kwargs={},
-):
-    """Create a wrapper function for the noise prediction model.
-
-    DPM-Solver needs to solve the continuous-time diffusion ODEs. For DPMs trained on discrete-time labels, we need to
-    firstly wrap the model function to a noise prediction model that accepts the continuous time as the input.
-
-    We support four types of the diffusion model by setting `model_type`:
-
-        1. "noise": noise prediction model. (Trained by predicting noise).
-
-        2. "x_start": data prediction model. (Trained by predicting the data x_0 at time 0).
-
-        3. "v": velocity prediction model. (Trained by predicting the velocity).
-            The "v" prediction is derivation detailed in Appendix D of [1], and is used in Imagen-Video [2].
-
-            [1] Salimans, Tim, and Jonathan Ho. "Progressive distillation for fast sampling of diffusion models."
-                arXiv preprint arXiv:2202.00512 (2022).
-            [2] Ho, Jonathan, et al. "Imagen Video: High Definition Video Generation with Diffusion Models."
-                arXiv preprint arXiv:2210.02303 (2022).
-    
-        4. "score": marginal score function. (Trained by denoising score matching).
-            Note that the score function and the noise prediction model follows a simple relationship:
-            ```
-                noise(x_t, t) = -sigma_t * score(x_t, t)
-            ```
-
-    We support three types of guided sampling by DPMs by setting `guidance_type`:
-        1. "uncond": unconditional sampling by DPMs.
-            The input `model` has the following format:
-            ``
-                model(x, t_input, **model_kwargs) -> noise | x_start | v | score
-            ``
-
-        2. "classifier": classifier guidance sampling [3] by DPMs and another classifier.
-            The input `model` has the following format:
-            ``
-                model(x, t_input, **model_kwargs) -> noise | x_start | v | score
-            `` 
-
-            The input `classifier_fn` has the following format:
-            ``
-                classifier_fn(x, t_input, cond, **classifier_kwargs) -> logits(x, t_input, cond)
-            ``
-
-            [3] P. Dhariwal and A. Q. Nichol, "Diffusion models beat GANs on image synthesis,"
-                in Advances in Neural Information Processing Systems, vol. 34, 2021, pp. 8780-8794.
-
-        3. "classifier-free": classifier-free guidance sampling by conditional DPMs.
-            The input `model` has the following format:
-            ``
-                model(x, t_input, cond, **model_kwargs) -> noise | x_start | v | score
-            `` 
-            And if cond == `unconditional_condition`, the model output is the unconditional DPM output.
-
-            [4] Ho, Jonathan, and Tim Salimans. "Classifier-free diffusion guidance."
-                arXiv preprint arXiv:2207.12598 (2022).
-        
-
-    The `t_input` is the time label of the model, which may be discrete-time labels (i.e. 0 to 999)
-    or continuous-time labels (i.e. epsilon to T).
-
-    We wrap the model function to accept only `x` and `t_continuous` as inputs, and outputs the predicted noise:
-    ``
-        def model_fn(x, t_continuous) -> noise:
-            t_input = get_model_input_time(t_continuous)
-            return noise_pred(model, x, t_input, **model_kwargs)         
-    ``
-    where `t_continuous` is the continuous time labels (i.e. epsilon to T). And we use `model_fn` for DPM-Solver.
-
-    ===============================================================
-
-    Args:
-        model: A diffusion model with the corresponding format described above.
-        noise_schedule: A noise schedule object, such as NoiseScheduleVP.
-        model_type: A `str`. The parameterization type of the diffusion model.
-                    "noise" or "x_start" or "v" or "score".
-        model_kwargs: A `dict`. A dict for the other inputs of the model function.
-        guidance_type: A `str`. The type of the guidance for sampling.
-                    "uncond" or "classifier" or "classifier-free".
-        condition: A pytorch tensor. The condition for the guided sampling.
-                    Only used for "classifier" or "classifier-free" guidance type.
-        unconditional_condition: A pytorch tensor. The condition for the unconditional sampling.
-                    Only used for "classifier-free" guidance type.
-        guidance_scale: A `float`. The scale for the guided sampling.
-        classifier_fn: A classifier function. Only used for the classifier guidance.
-        classifier_kwargs: A `dict`. A dict for the other inputs of the classifier function.
-    Returns:
-        A noise prediction model that accepts the noised data and the continuous time as the inputs.
-    """
-
-    def get_model_input_time(t_continuous):
-        """
-        Convert the continuous-time `t_continuous` (in [epsilon, T]) to the model input time.
-        For discrete-time DPMs, we convert `t_continuous` in [1 / N, 1] to `t_input` in [0, 1000 * (N - 1) / N].
-        For continuous-time DPMs, we just use `t_continuous`.
-        """
-        if noise_schedule.schedule == 'discrete':
-            return (t_continuous - 1. / noise_schedule.total_N) * 1000.
-        else:
-            return t_continuous
-
-    def noise_pred_fn(x, t_continuous, cond=None):
-        if t_continuous.reshape((-1,)).shape[0] == 1:
-            t_continuous = t_continuous.expand((x.shape[0]))
-        t_input = get_model_input_time(t_continuous)
-        if cond is None:
-            output = model(x, t_input, None, **model_kwargs)
-        else:
-            output = model(x, t_input, cond, **model_kwargs)
-        if model_type == "noise":
-            return output
-        elif model_type == "x_start":
-            alpha_t, sigma_t = noise_schedule.marginal_alpha(t_continuous), noise_schedule.marginal_std(t_continuous)
-            dims = x.dim()
-            return (x - expand_dims(alpha_t, dims) * output) / expand_dims(sigma_t, dims)
-        elif model_type == "v":
-            alpha_t, sigma_t = noise_schedule.marginal_alpha(t_continuous), noise_schedule.marginal_std(t_continuous)
-            dims = x.dim()
-            return expand_dims(alpha_t, dims) * output + expand_dims(sigma_t, dims) * x
-        elif model_type == "score":
-            sigma_t = noise_schedule.marginal_std(t_continuous)
-            dims = x.dim()
-            return -expand_dims(sigma_t, dims) * output
-
-    def cond_grad_fn(x, t_input):
-        """
-        Compute the gradient of the classifier, i.e. nabla_{x} log p_t(cond | x_t).
-        """
-        with torch.enable_grad():
-            x_in = x.detach().requires_grad_(True)
-            log_prob = classifier_fn(x_in, t_input, condition, **classifier_kwargs)
-            return torch.autograd.grad(log_prob.sum(), x_in)[0]
-
-    def model_fn(x, t_continuous):
-        """
-        The noise predicition model function that is used for DPM-Solver.
-        """
-        if t_continuous.reshape((-1,)).shape[0] == 1:
-            t_continuous = t_continuous.expand((x.shape[0]))
-        if guidance_type == "uncond":
-            return noise_pred_fn(x, t_continuous)
-        elif guidance_type == "classifier":
-            assert classifier_fn is not None
-            t_input = get_model_input_time(t_continuous)
-            cond_grad = cond_grad_fn(x, t_input)
-            sigma_t = noise_schedule.marginal_std(t_continuous)
-            noise = noise_pred_fn(x, t_continuous)
-            return noise - guidance_scale * expand_dims(sigma_t, dims=cond_grad.dim()) * cond_grad
-        elif guidance_type == "classifier-free":
-            if guidance_scale == 1. or unconditional_condition is None:
-                return noise_pred_fn(x, t_continuous, cond=condition)
-            else:
-                x_in = torch.cat([x] * 2)
-                t_in = torch.cat([t_continuous] * 2)
-                c_in = torch.cat([unconditional_condition, condition])
-                noise_uncond, noise = noise_pred_fn(x_in, t_in, cond=c_in).chunk(2)
-                return noise_uncond + guidance_scale * (noise - noise_uncond)
-
-    assert model_type in ["noise", "x_start", "v"]
-    assert guidance_type in ["uncond", "classifier", "classifier-free"]
-    return model_fn
-
-
-class UniPC:
-    def __init__(
-        self,
-        model_fn,
-        noise_schedule,
-        predict_x0=True,
-        thresholding=False,
-        max_val=1.,
-        variant='bh1'
-    ):
-        """Construct a UniPC. 
-
-        We support both data_prediction and noise_prediction.
-        """
-        self.model = model_fn
-        self.noise_schedule = noise_schedule
-        self.variant = variant
-        self.predict_x0 = predict_x0
-        self.thresholding = thresholding
-        self.max_val = max_val
-        
-    def dynamic_thresholding_fn(self, x0, t=None):
-        """
-        The dynamic thresholding method. 
-        """
-        dims = x0.dim()
-        p = self.dynamic_thresholding_ratio
-        s = torch.quantile(torch.abs(x0).reshape((x0.shape[0], -1)), p, dim=1)
-        s = expand_dims(torch.maximum(s, self.thresholding_max_val * torch.ones_like(s).to(s.device)), dims)
-        x0 = torch.clamp(x0, -s, s) / s
-        return x0
-
-    def noise_prediction_fn(self, x, t):
-        """
-        Return the noise prediction model.
-        """
-        return self.model(x, t)
-
-    def data_prediction_fn(self, x, t):
-        """
-        Return the data prediction model (with thresholding).
-        """
-        noise = self.noise_prediction_fn(x, t)
-        dims = x.dim()
-        alpha_t, sigma_t = self.noise_schedule.marginal_alpha(t), self.noise_schedule.marginal_std(t)
-        x0 = (x - expand_dims(sigma_t, dims) * noise) / expand_dims(alpha_t, dims)
-        if self.thresholding:
-            p = 0.995   # A hyperparameter in the paper of "Imagen" [1].
-            s = torch.quantile(torch.abs(x0).reshape((x0.shape[0], -1)), p, dim=1)
-            s = expand_dims(torch.maximum(s, self.max_val * torch.ones_like(s).to(s.device)), dims)
-            x0 = torch.clamp(x0, -s, s) / s
-        return x0
-
-    def model_fn(self, x, t):
-        """
-        Convert the model to the noise prediction model or the data prediction model. 
-        """
-        if self.predict_x0:
-            return self.data_prediction_fn(x, t)
-        else:
-            return self.noise_prediction_fn(x, t)
-
-    def get_time_steps(self, skip_type, t_T, t_0, N, device):
-        """Compute the intermediate time steps for sampling.
-        """
-        if skip_type == 'logSNR':
-            lambda_T = self.noise_schedule.marginal_lambda(torch.tensor(t_T).to(device))
-            lambda_0 = self.noise_schedule.marginal_lambda(torch.tensor(t_0).to(device))
-            logSNR_steps = torch.linspace(lambda_T.cpu().item(), lambda_0.cpu().item(), N + 1).to(device)
-            return self.noise_schedule.inverse_lambda(logSNR_steps)
-        elif skip_type == 'time_uniform':
-            return torch.linspace(t_T, t_0, N + 1).to(device)
-        elif skip_type == 'time_quadratic':
-            t_order = 2
-            t = torch.linspace(t_T**(1. / t_order), t_0**(1. / t_order), N + 1).pow(t_order).to(device)
-            return t
-        else:
-            raise ValueError("Unsupported skip_type {}, need to be 'logSNR' or 'time_uniform' or 'time_quadratic'".format(skip_type))
-
-    def get_orders_and_timesteps_for_singlestep_solver(self, steps, order, skip_type, t_T, t_0, device):
-        """
-        Get the order of each step for sampling by the singlestep DPM-Solver.
-        """
-        if order == 3:
-            K = steps // 3 + 1
-            if steps % 3 == 0:
-                orders = [3,] * (K - 2) + [2, 1]
-            elif steps % 3 == 1:
-                orders = [3,] * (K - 1) + [1]
-            else:
-                orders = [3,] * (K - 1) + [2]
-        elif order == 2:
-            if steps % 2 == 0:
-                K = steps // 2
-                orders = [2,] * K
-            else:
-                K = steps // 2 + 1
-                orders = [2,] * (K - 1) + [1]
-        elif order == 1:
-            K = steps
-            orders = [1,] * steps
-        else:
-            raise ValueError("'order' must be '1' or '2' or '3'.")
-        if skip_type == 'logSNR':
-            # To reproduce the results in DPM-Solver paper
-            timesteps_outer = self.get_time_steps(skip_type, t_T, t_0, K, device)
-        else:
-            timesteps_outer = self.get_time_steps(skip_type, t_T, t_0, steps, device)[torch.cumsum(torch.tensor([0,] + orders), 0).to(device)]
-        return timesteps_outer, orders
-
-    def denoise_to_zero_fn(self, x, s):
-        """
-        Denoise at the final step, which is equivalent to solve the ODE from lambda_s to infty by first-order discretization. 
-        """
-        return self.data_prediction_fn(x, s)
-
-    def multistep_uni_pc_update(self, x, model_prev_list, t_prev_list, t, order, **kwargs):
-        if len(t.shape) == 0:
-            t = t.view(-1)
-        if 'bh' in self.variant:
-            return self.multistep_uni_pc_bh_update(x, model_prev_list, t_prev_list, t, order, **kwargs)
-        else:
-            assert self.variant == 'vary_coeff'
-            return self.multistep_uni_pc_vary_update(x, model_prev_list, t_prev_list, t, order, **kwargs)
-
-    def multistep_uni_pc_vary_update(self, x, model_prev_list, t_prev_list, t, order, use_corrector=True):
-        print(f'using unified predictor-corrector with order {order} (solver type: vary coeff)')
-        ns = self.noise_schedule
-        assert order <= len(model_prev_list)
-
-        # first compute rks
-        t_prev_0 = t_prev_list[-1]
-        lambda_prev_0 = ns.marginal_lambda(t_prev_0)
-        lambda_t = ns.marginal_lambda(t)
-        model_prev_0 = model_prev_list[-1]
-        sigma_prev_0, sigma_t = ns.marginal_std(t_prev_0), ns.marginal_std(t)
-        log_alpha_t = ns.marginal_log_mean_coeff(t)
-        alpha_t = torch.exp(log_alpha_t)
-
-        h = lambda_t - lambda_prev_0
-
-        rks = []
-        D1s = []
-        for i in range(1, order):
-            t_prev_i = t_prev_list[-(i + 1)]
-            model_prev_i = model_prev_list[-(i + 1)]
-            lambda_prev_i = ns.marginal_lambda(t_prev_i)
-            rk = (lambda_prev_i - lambda_prev_0) / h
-            rks.append(rk)
-            D1s.append((model_prev_i - model_prev_0) / rk)
-
-        rks.append(1.)
-        rks = torch.tensor(rks, device=x.device)
-
-        K = len(rks)
-        # build C matrix
-        C = []
-
-        col = torch.ones_like(rks)
-        for k in range(1, K + 1):
-            C.append(col)
-            col = col * rks / (k + 1) 
-        C = torch.stack(C, dim=1)
-
-        if len(D1s) > 0:
-            D1s = torch.stack(D1s, dim=1) # (B, K)
-            C_inv_p = torch.linalg.inv(C[:-1, :-1])
-            A_p = C_inv_p
-
-        if use_corrector:
-            print('using corrector')
-            C_inv = torch.linalg.inv(C)
-            A_c = C_inv
-
-        hh = -h if self.predict_x0 else h
-        h_phi_1 = torch.expm1(hh)
-        h_phi_ks = []
-        factorial_k = 1
-        h_phi_k = h_phi_1
-        for k in range(1, K + 2):
-            h_phi_ks.append(h_phi_k)
-            h_phi_k = h_phi_k / hh - 1 / factorial_k
-            factorial_k *= (k + 1)
-
-        model_t = None
-        if self.predict_x0:
-            x_t_ = (
-                sigma_t / sigma_prev_0 * x
-                - alpha_t * h_phi_1 * model_prev_0
-            )
-            # now predictor
-            x_t = x_t_
-            if len(D1s) > 0:
-                # compute the residuals for predictor
-                for k in range(K - 1):
-                    x_t = x_t - alpha_t * h_phi_ks[k + 1] * torch.einsum('bkchw,k->bchw', D1s, A_p[k])
-            # now corrector
-            if use_corrector:
-                model_t = self.model_fn(x_t, t)
-                D1_t = (model_t - model_prev_0)
-                x_t = x_t_
-                k = 0
-                for k in range(K - 1):
-                    x_t = x_t - alpha_t * h_phi_ks[k + 1] * torch.einsum('bkchw,k->bchw', D1s, A_c[k][:-1])
-                x_t = x_t - alpha_t * h_phi_ks[K] * (D1_t * A_c[k][-1])
-        else:
-            log_alpha_prev_0, log_alpha_t = ns.marginal_log_mean_coeff(t_prev_0), ns.marginal_log_mean_coeff(t)
-            x_t_ = (
-                (torch.exp(log_alpha_t - log_alpha_prev_0)) * x
-                - (sigma_t * h_phi_1) * model_prev_0
-            )
-            # now predictor
-            x_t = x_t_
-            if len(D1s) > 0:
-                # compute the residuals for predictor
-                for k in range(K - 1):
-                    x_t = x_t - sigma_t * h_phi_ks[k + 1] * torch.einsum('bkchw,k->bchw', D1s, A_p[k])
-            # now corrector
-            if use_corrector:
-                model_t = self.model_fn(x_t, t)
-                D1_t = (model_t - model_prev_0)
-                x_t = x_t_
-                k = 0
-                for k in range(K - 1):
-                    x_t = x_t - sigma_t * h_phi_ks[k + 1] * torch.einsum('bkchw,k->bchw', D1s, A_c[k][:-1])
-                x_t = x_t - sigma_t * h_phi_ks[K] * (D1_t * A_c[k][-1])
-        return x_t, model_t
-
-    def multistep_uni_pc_bh_update(self, x, model_prev_list, t_prev_list, t, order, x_t=None, use_corrector=True):
-        print(f'using unified predictor-corrector with order {order} (solver type: B(h))')
-        ns = self.noise_schedule
-        assert order <= len(model_prev_list)
-        dims = x.dim()
-
-        # first compute rks
-        t_prev_0 = t_prev_list[-1]
-        lambda_prev_0 = ns.marginal_lambda(t_prev_0)
-        lambda_t = ns.marginal_lambda(t)
-        model_prev_0 = model_prev_list[-1]
-        sigma_prev_0, sigma_t = ns.marginal_std(t_prev_0), ns.marginal_std(t)
-        log_alpha_prev_0, log_alpha_t = ns.marginal_log_mean_coeff(t_prev_0), ns.marginal_log_mean_coeff(t)
-        alpha_t = torch.exp(log_alpha_t)
-
-        h = lambda_t - lambda_prev_0
-
-        rks = []
-        D1s = []
-        for i in range(1, order):
-            t_prev_i = t_prev_list[-(i + 1)]
-            model_prev_i = model_prev_list[-(i + 1)]
-            lambda_prev_i = ns.marginal_lambda(t_prev_i)
-            rk = ((lambda_prev_i - lambda_prev_0) / h)[0]
-            rks.append(rk)
-            D1s.append((model_prev_i - model_prev_0) / rk)
-
-        rks.append(1.)
-        rks = torch.tensor(rks, device=x.device)
-
-        R = []
-        b = []
-
-        hh = -h[0] if self.predict_x0 else h[0]
-        h_phi_1 = torch.expm1(hh) # h\phi_1(h) = e^h - 1
-        h_phi_k = h_phi_1 / hh - 1
-
-        factorial_i = 1
-
-        if self.variant == 'bh1':
-            B_h = hh
-        elif self.variant == 'bh2':
-            B_h = torch.expm1(hh)
-        else:
-            raise NotImplementedError()
-            
-        for i in range(1, order + 1):
-            R.append(torch.pow(rks, i - 1))
-            b.append(h_phi_k * factorial_i / B_h)
-            factorial_i *= (i + 1)
-            h_phi_k = h_phi_k / hh - 1 / factorial_i 
-
-        R = torch.stack(R)
-        b = torch.tensor(b, device=x.device)
-
-        # now predictor
-        use_predictor = len(D1s) > 0 and x_t is None
-        if len(D1s) > 0:
-            D1s = torch.stack(D1s, dim=1) # (B, K)
-            if x_t is None:
-                # for order 2, we use a simplified version
-                if order == 2:
-                    rhos_p = torch.tensor([0.5], device=b.device)
-                else:
-                    rhos_p = torch.linalg.solve(R[:-1, :-1], b[:-1])
-        else:
-            D1s = None
-
-        if use_corrector:
-            print('using corrector')
-            # for order 1, we use a simplified version
-            if order == 1:
-                rhos_c = torch.tensor([0.5], device=b.device)
-            else:
-                rhos_c = torch.linalg.solve(R, b)
-
-        model_t = None
-        if self.predict_x0:
-            x_t_ = (
-                expand_dims(sigma_t / sigma_prev_0, dims) * x
-                - expand_dims(alpha_t * h_phi_1, dims)* model_prev_0
-            )
-
-            if x_t is None:
-                if use_predictor:
-                    pred_res = torch.einsum('k,bkchw->bchw', rhos_p, D1s)
-                else:
-                    pred_res = 0
-                x_t = x_t_ - expand_dims(alpha_t * B_h, dims) * pred_res
-
-            if use_corrector:
-                model_t = self.model_fn(x_t, t)
-                if D1s is not None:
-                    corr_res = torch.einsum('k,bkchw->bchw', rhos_c[:-1], D1s)
-                else:
-                    corr_res = 0
-                D1_t = (model_t - model_prev_0)
-                x_t = x_t_ - expand_dims(alpha_t * B_h, dims) * (corr_res + rhos_c[-1] * D1_t)
-        else:
-            x_t_ = (
-                expand_dims(torch.exp(log_alpha_t - log_alpha_prev_0), dims) * x
-                - expand_dims(sigma_t * h_phi_1, dims) * model_prev_0
-            )
-            if x_t is None:
-                if use_predictor:
-                    pred_res = torch.einsum('k,bkchw->bchw', rhos_p, D1s)
-                else:
-                    pred_res = 0
-                x_t = x_t_ - expand_dims(sigma_t * B_h, dims) * pred_res
-
-            if use_corrector:
-                model_t = self.model_fn(x_t, t)
-                if D1s is not None:
-                    corr_res = torch.einsum('k,bkchw->bchw', rhos_c[:-1], D1s)
-                else:
-                    corr_res = 0
-                D1_t = (model_t - model_prev_0)
-                x_t = x_t_ - expand_dims(sigma_t * B_h, dims) * (corr_res + rhos_c[-1] * D1_t)
-        return x_t, model_t
-
-
-    def sample(self, x, steps=20, t_start=None, t_end=None, order=3, skip_type='time_uniform',
-        method='singlestep', lower_order_final=True, denoise_to_zero=False, solver_type='dpm_solver',
-        atol=0.0078, rtol=0.05, corrector=False,
-    ):
-        t_0 = 1. / self.noise_schedule.total_N if t_end is None else t_end
-        t_T = self.noise_schedule.T if t_start is None else t_start
-        device = x.device
-        if method == 'multistep':
-            assert steps >= order
-            timesteps = self.get_time_steps(skip_type=skip_type, t_T=t_T, t_0=t_0, N=steps, device=device)
-            assert timesteps.shape[0] - 1 == steps
-            with torch.no_grad():
-                vec_t = timesteps[0].expand((x.shape[0]))
-                model_prev_list = [self.model_fn(x, vec_t)]
-                t_prev_list = [vec_t]
-                # Init the first `order` values by lower order multistep DPM-Solver.
-                for init_order in range(1, order):
-                    vec_t = timesteps[init_order].expand(x.shape[0])
-                    x, model_x = self.multistep_uni_pc_update(x, model_prev_list, t_prev_list, vec_t, init_order, use_corrector=True)
-                    if model_x is None:
-                        model_x = self.model_fn(x, vec_t)
-                    model_prev_list.append(model_x)
-                    t_prev_list.append(vec_t)
-                for step in range(order, steps + 1):
-                    vec_t = timesteps[step].expand(x.shape[0])
-                    if lower_order_final:
-                        step_order = min(order, steps + 1 - step)
-                    else:
-                        step_order = order
-                    print('this step order:', step_order)
-                    if step == steps:
-                        print('do not run corrector at the last step')
-                        use_corrector = False
-                    else:
-                        use_corrector = True
-                    x, model_x =  self.multistep_uni_pc_update(x, model_prev_list, t_prev_list, vec_t, step_order, use_corrector=use_corrector)
-                    for i in range(order - 1):
-                        t_prev_list[i] = t_prev_list[i + 1]
-                        model_prev_list[i] = model_prev_list[i + 1]
-                    t_prev_list[-1] = vec_t
-                    # We do not need to evaluate the final model value.
-                    if step < steps:
-                        if model_x is None:
-                            model_x = self.model_fn(x, vec_t)
-                        model_prev_list[-1] = model_x
-        else:
-            raise NotImplementedError()
-        if denoise_to_zero:
-            x = self.denoise_to_zero_fn(x, torch.ones((x.shape[0],)).to(device) * t_0)
-        return x
-
-
-#############################################################
-# other utility functions
-#############################################################
-
-def interpolate_fn(x, xp, yp):
-    """
-    A piecewise linear function y = f(x), using xp and yp as keypoints.
-    We implement f(x) in a differentiable way (i.e. applicable for autograd).
-    The function f(x) is well-defined for all x-axis. (For x beyond the bounds of xp, we use the outmost points of xp to define the linear function.)
-
-    Args:
-        x: PyTorch tensor with shape [N, C], where N is the batch size, C is the number of channels (we use C = 1 for DPM-Solver).
-        xp: PyTorch tensor with shape [C, K], where K is the number of keypoints.
-        yp: PyTorch tensor with shape [C, K].
-    Returns:
-        The function values f(x), with shape [N, C].
-    """
-    N, K = x.shape[0], xp.shape[1]
-    all_x = torch.cat([x.unsqueeze(2), xp.unsqueeze(0).repeat((N, 1, 1))], dim=2)
-    sorted_all_x, x_indices = torch.sort(all_x, dim=2)
-    x_idx = torch.argmin(x_indices, dim=2)
-    cand_start_idx = x_idx - 1
-    start_idx = torch.where(
-        torch.eq(x_idx, 0),
-        torch.tensor(1, device=x.device),
-        torch.where(
-            torch.eq(x_idx, K), torch.tensor(K - 2, device=x.device), cand_start_idx,
-        ),
-    )
-    end_idx = torch.where(torch.eq(start_idx, cand_start_idx), start_idx + 2, start_idx + 1)
-    start_x = torch.gather(sorted_all_x, dim=2, index=start_idx.unsqueeze(2)).squeeze(2)
-    end_x = torch.gather(sorted_all_x, dim=2, index=end_idx.unsqueeze(2)).squeeze(2)
-    start_idx2 = torch.where(
-        torch.eq(x_idx, 0),
-        torch.tensor(0, device=x.device),
-        torch.where(
-            torch.eq(x_idx, K), torch.tensor(K - 2, device=x.device), cand_start_idx,
-        ),
-    )
-    y_positions_expanded = yp.unsqueeze(0).expand(N, -1, -1)
-    start_y = torch.gather(y_positions_expanded, dim=2, index=start_idx2.unsqueeze(2)).squeeze(2)
-    end_y = torch.gather(y_positions_expanded, dim=2, index=(start_idx2 + 1).unsqueeze(2)).squeeze(2)
-    cand = start_y + (x - start_x) * (end_y - start_y) / (end_x - start_x)
-    return cand
-
-
-def expand_dims(v, dims):
-    """
-    Expand the tensor `v` to the dim `dims`.
-
-    Args:
-        `v`: a PyTorch tensor with shape [N].
-        `dim`: a `int`.
-    Returns:
-        a PyTorch tensor with shape [N, 1, 1, ..., 1] and the total dimension is `dims`.
-    """
-    return v[(...,) + (None,)*(dims - 1)]
@@ -1,158 +0,0 @@
-import math
-import numpy as np
-import torch
-import torch.nn.functional as F
-from einops import repeat
-
-
-def timestep_embedding(timesteps, dim, max_period=10000, repeat_only=False, dtype=None):
-    """
-    Create sinusoidal timestep embeddings.
-    :param timesteps: a 1-D Tensor of N indices, one per batch element.
-                      These may be fractional.
-    :param dim: the dimension of the output.
-    :param max_period: controls the minimum frequency of the embeddings.
-    :return: an [N x dim] Tensor of positional embeddings.
-    """
-    if not repeat_only:
-        half = dim // 2
-        freqs = torch.exp(
-            -math.log(max_period) * torch.arange(start=0, end=half, dtype=dtype) / half
-        ).to(device=timesteps.device)
-        args = timesteps[:, None].float() * freqs[None]
-        embedding = torch.cat([torch.cos(args), torch.sin(args)], dim=-1)
-        if dim % 2:
-            embedding = torch.cat([embedding, torch.zeros_like(embedding[:, :1])], dim=-1)
-    else:
-        embedding = repeat(timesteps, 'b -> b d', d=dim)
-    return embedding.to(dtype)
-
-
-def make_beta_schedule(schedule, n_timestep, linear_start=1e-4, linear_end=2e-2, cosine_s=8e-3):
-    if schedule == "linear":
-        betas = (
-                torch.linspace(linear_start ** 0.5, linear_end ** 0.5, n_timestep, dtype=torch.float64) ** 2
-        )
-
-    elif schedule == "cosine":
-        timesteps = (
-                torch.arange(n_timestep + 1, dtype=torch.float64) / n_timestep + cosine_s
-        )
-        alphas = timesteps / (1 + cosine_s) * np.pi / 2
-        alphas = torch.cos(alphas).pow(2)
-        alphas = alphas / alphas[0]
-        betas = 1 - alphas[1:] / alphas[:-1]
-        betas = np.clip(betas, a_min=0, a_max=0.999)
-
-    elif schedule == "sqrt_linear":
-        betas = torch.linspace(linear_start, linear_end, n_timestep, dtype=torch.float64)
-    elif schedule == "sqrt":
-        betas = torch.linspace(linear_start, linear_end, n_timestep, dtype=torch.float64) ** 0.5
-    else:
-        raise ValueError(f"schedule '{schedule}' unknown.")
-    return betas.numpy()
-
-
-def make_ddim_timesteps(ddim_discr_method, num_ddim_timesteps, num_ddpm_timesteps, verbose=True):
-    if ddim_discr_method == 'uniform':
-        c = num_ddpm_timesteps // num_ddim_timesteps
-        ddim_timesteps = np.asarray(list(range(0, num_ddpm_timesteps, c)))
-        steps_out = ddim_timesteps + 1
-    elif ddim_discr_method == 'uniform_trailing':
-        c = num_ddpm_timesteps / num_ddim_timesteps
-        ddim_timesteps = np.flip(np.round(np.arange(num_ddpm_timesteps, 0, -c))).astype(np.int64)
-        steps_out = ddim_timesteps - 1
-    elif ddim_discr_method == 'quad':
-        ddim_timesteps = ((np.linspace(0, np.sqrt(num_ddpm_timesteps * .8), num_ddim_timesteps)) ** 2).astype(int)
-        steps_out = ddim_timesteps + 1
-    else:
-        raise NotImplementedError(f'There is no ddim discretization method called "{ddim_discr_method}"')
-
-    # assert ddim_timesteps.shape[0] == num_ddim_timesteps
-    # add one to get the final alpha values right (the ones from first scale to data during sampling)
-    # steps_out = ddim_timesteps + 1
-    if verbose:
-        print(f'Selected timesteps for ddim sampler: {steps_out}')
-    return steps_out
-
-
-def make_ddim_sampling_parameters(alphacums, ddim_timesteps, eta, verbose=True):
-    # select alphas for computing the variance schedule
-    # print(f'ddim_timesteps={ddim_timesteps}, len_alphacums={len(alphacums)}')
-    alphas = alphacums[ddim_timesteps]
-    alphas_prev = np.asarray([alphacums[0]] + alphacums[ddim_timesteps[:-1]].tolist())
-
-    # according the the formula provided in https://arxiv.org/abs/2010.02502
-    sigmas = eta * np.sqrt((1 - alphas_prev) / (1 - alphas) * (1 - alphas / alphas_prev))
-    if verbose:
-        print(f'Selected alphas for ddim sampler: a_t: {alphas}; a_(t-1): {alphas_prev}')
-        print(f'For the chosen value of eta, which is {eta}, '
-              f'this results in the following sigma_t schedule for ddim sampler {sigmas}')
-    return sigmas, alphas, alphas_prev
-
-
-def betas_for_alpha_bar(num_diffusion_timesteps, alpha_bar, max_beta=0.999):
-    """
-    Create a beta schedule that discretizes the given alpha_t_bar function,
-    which defines the cumulative product of (1-beta) over time from t = [0,1].
-    :param num_diffusion_timesteps: the number of betas to produce.
-    :param alpha_bar: a lambda that takes an argument t from 0 to 1 and
-                      produces the cumulative product of (1-beta) up to that
-                      part of the diffusion process.
-    :param max_beta: the maximum beta to use; use values lower than 1 to
-                     prevent singularities.
-    """
-    betas = []
-    for i in range(num_diffusion_timesteps):
-        t1 = i / num_diffusion_timesteps
-        t2 = (i + 1) / num_diffusion_timesteps
-        betas.append(min(1 - alpha_bar(t2) / alpha_bar(t1), max_beta))
-    return np.array(betas)
-
-def rescale_zero_terminal_snr(betas):
-    """
-    Rescales betas to have zero terminal SNR Based on https://arxiv.org/pdf/2305.08891.pdf (Algorithm 1)
-
-    Args:
-        betas (`numpy.ndarray`):
-            the betas that the scheduler is being initialized with.
-
-    Returns:
-        `numpy.ndarray`: rescaled betas with zero terminal SNR
-    """
-    # Convert betas to alphas_bar_sqrt
-    alphas = 1.0 - betas
-    alphas_cumprod = np.cumprod(alphas, axis=0)
-    alphas_bar_sqrt = np.sqrt(alphas_cumprod)
-
-    # Store old values.
-    alphas_bar_sqrt_0 = alphas_bar_sqrt[0].copy()
-    alphas_bar_sqrt_T = alphas_bar_sqrt[-1].copy()
-
-    # Shift so the last timestep is zero.
-    alphas_bar_sqrt -= alphas_bar_sqrt_T
-
-    # Scale so the first timestep is back to the old value.
-    alphas_bar_sqrt *= alphas_bar_sqrt_0 / (alphas_bar_sqrt_0 - alphas_bar_sqrt_T)
-
-    # Convert alphas_bar_sqrt to betas
-    alphas_bar = alphas_bar_sqrt**2  # Revert sqrt
-    alphas = alphas_bar[1:] / alphas_bar[:-1]  # Revert cumprod
-    alphas = np.concatenate([alphas_bar[0:1], alphas])
-    betas = 1 - alphas
-
-    return betas
-
-
-def rescale_noise_cfg(noise_cfg, noise_pred_text, guidance_rescale=0.0):
-    """
-    Rescale `noise_cfg` according to `guidance_rescale`. Based on findings of [Common Diffusion Noise Schedules and
-    Sample Steps are Flawed](https://arxiv.org/pdf/2305.08891.pdf). See Section 3.4
-    """
-    std_text = noise_pred_text.std(dim=list(range(1, noise_pred_text.ndim)), keepdim=True)
-    std_cfg = noise_cfg.std(dim=list(range(1, noise_cfg.ndim)), keepdim=True)
-    # rescale the results from guidance (fixes overexposure)
-    noise_pred_rescaled = noise_cfg * (std_text / std_cfg)
-    # mix with the original results from guidance by factor guidance_rescale to avoid "plain looking" images
-    noise_cfg = guidance_rescale * noise_pred_rescaled + (1 - guidance_rescale) * noise_cfg
-    return noise_cfg
@@ -1,809 +0,0 @@
-import torch
-from torch import nn, einsum
-import torch.nn.functional as F
-from einops import rearrange, repeat
-from functools import partial
-from ..common import (
-    checkpoint,
-    exists,
-    default,
-)
-from ..basics import zero_module
-import comfy.ops
-ops = comfy.ops.disable_weight_init
-from comfy import model_management
-from comfy.ldm.modules.attention import optimized_attention, optimized_attention_masked
-
-if model_management.xformers_enabled():
-    import xformers
-    import xformers.ops
-    XFORMERS_IS_AVAILBLE = True
-else:
-    XFORMERS_IS_AVAILBLE = False
-
-class RelativePosition(nn.Module):
-    """ https://github.com/evelinehong/Transformer_Relative_Position_PyTorch/blob/master/relative_position.py """
-
-    def __init__(self, num_units, max_relative_position):
-        super().__init__()
-        self.num_units = num_units
-        self.max_relative_position = max_relative_position
-        self.embeddings_table = nn.Parameter(torch.Tensor(max_relative_position * 2 + 1, num_units))
-        nn.init.xavier_uniform_(self.embeddings_table)
-
-    def forward(self, length_q, length_k):
-        device = self.embeddings_table.device
-        range_vec_q = torch.arange(length_q, device=device)
-        range_vec_k = torch.arange(length_k, device=device)
-        distance_mat = range_vec_k[None, :] - range_vec_q[:, None]
-        distance_mat_clipped = torch.clamp(distance_mat, -self.max_relative_position, self.max_relative_position)
-        final_mat = distance_mat_clipped + self.max_relative_position
-        final_mat = final_mat.long()
-        embeddings = self.embeddings_table[final_mat]
-        return embeddings
-
-
-# TODO Add native Comfy optimized attention.
-class CrossAttention(nn.Module):
-
-    def __init__(
-                self, 
-                query_dim, 
-                context_dim=None, 
-                heads=8, 
-                dim_head=64, 
-                dropout=0., 
-                relative_position=False, 
-                temporal_length=None, 
-                video_length=None, 
-                image_cross_attention=False, 
-                image_cross_attention_scale=1.0, 
-                image_cross_attention_scale_learnable=False, 
-                text_context_len=77,
-                device=None,
-                dtype=None,
-                operations=ops
-            ):
-        super().__init__()
-        inner_dim = dim_head * heads
-        context_dim = default(context_dim, query_dim)
-        self.scale = dim_head**-0.5
-        self.heads = heads
-        self.dim_head = dim_head
-        self.to_q = operations.Linear(query_dim, inner_dim, bias=False, device=device, dtype=dtype)
-        self.to_k = operations.Linear(context_dim, inner_dim, bias=False, device=device, dtype=dtype) 
-        self.to_v = operations.Linear(context_dim, inner_dim, bias=False, device=device, dtype=dtype)
-
-        self.to_out = nn.Sequential(
-            operations.Linear(inner_dim, query_dim, device=device, dtype=dtype), 
-            nn.Dropout(dropout)
-        )
-        
-        self.relative_position = relative_position
-        if self.relative_position:
-            assert(temporal_length is not None)
-            self.relative_position_k = RelativePosition(num_units=dim_head, max_relative_position=temporal_length)
-            self.relative_position_v = RelativePosition(num_units=dim_head, max_relative_position=temporal_length)
-        else:
-            ## only used for spatial attention, while NOT for temporal attention
-            if XFORMERS_IS_AVAILBLE and temporal_length is None:
-                self.forward = self.efficient_forward
-            else:
-                self.forward = self.comfy_efficient_forward
-
-        self.video_length = video_length
-        self.image_cross_attention = image_cross_attention
-        self.image_cross_attention_scale = image_cross_attention_scale
-        self.text_context_len = text_context_len
-        self.image_cross_attention_scale_learnable = image_cross_attention_scale_learnable
-        if self.image_cross_attention:
-            self.to_k_ip = operations.Linear(context_dim, inner_dim, bias=False, device=device, dtype=dtype)
-            self.to_v_ip = operations.Linear(context_dim, inner_dim, bias=False, device=device, dtype=dtype)
-            if image_cross_attention_scale_learnable:
-                self.register_parameter('alpha', nn.Parameter(torch.tensor(0.)) )
-
-    def comfy_efficient_forward(self, x, context=None, mask=None, *args, **kwargs):
-        spatial_self_attn = (context is None)
-        k_ip, v_ip, out_ip = None, None, None
-
-        h = self.heads
-        q = self.to_q(x)
-        context = default(context, x)
-
-        if self.image_cross_attention and not spatial_self_attn:
-            context, context_image = context[:,:self.text_context_len,:], context[:,self.text_context_len:,:]
-            k = self.to_k(context)
-            v = self.to_v(context)
-            k_ip = self.to_k_ip(context_image)
-            v_ip = self.to_v_ip(context_image)
-        else:
-            if not spatial_self_attn:
-                context = context[:,:self.text_context_len,:]
-            k = self.to_k(context)
-            v = self.to_v(context)
-
-        out = optimized_attention(q, k, v, h)
-
-        if exists(mask):
-            ## feasible for causal attention mask only
-            out = optimized_attention_masked(q, k, v, h)
-
-        ## for image cross-attention
-        if k_ip is not None:
-            q = rearrange(q, 'b n (h d) -> (b h) n d', h=h)
-            k_ip, v_ip = map(lambda t: rearrange(t, 'b n (h d) -> (b h) n d', h=h), (k_ip, v_ip))
-            sim_ip =  torch.einsum('b i d, b j d -> b i j', q, k_ip) * self.scale
-            del k_ip
-            sim_ip = sim_ip.softmax(dim=-1)
-            out_ip = torch.einsum('b i j, b j d -> b i d', sim_ip, v_ip)
-            out_ip = rearrange(out_ip, '(b h) n d -> b n (h d)', h=h)
-
-        if out_ip is not None:
-            if self.image_cross_attention_scale_learnable:
-                out = out + self.image_cross_attention_scale * out_ip * (torch.tanh(self.alpha)+1)
-            else:
-                out = out + self.image_cross_attention_scale * out_ip
-
-        return self.to_out(out)
-            
-    def forward(self, x, context=None, mask=None):
-        spatial_self_attn = (context is None)
-        k_ip, v_ip, out_ip = None, None, None
-
-        h = self.heads
-        q = self.to_q(x)
-        context = default(context, x)
-
-        if self.image_cross_attention and not spatial_self_attn:
-            context, context_image = context[:,:self.text_context_len,:], context[:,self.text_context_len:,:]
-            k = self.to_k(context)
-            v = self.to_v(context)
-            k_ip = self.to_k_ip(context_image)
-            v_ip = self.to_v_ip(context_image)
-        else:
-
-            # Assumed Spatial Attention (b c h w)
-            if not spatial_self_attn:
-                context = context[:,:self.text_context_len,:]
-            k = self.to_k(context)
-            v = self.to_v(context)
-
-
-        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> (b h) n d', h=h), (q, k, v))
-
-        sim = torch.einsum('b i d, b j d -> b i j', q, k) * self.scale
-        if self.relative_position:
-            len_q, len_k, len_v = q.shape[1], k.shape[1], v.shape[1]
-            k2 = self.relative_position_k(len_q, len_k)
-            sim2 = einsum('b t d, t s d -> b t s', q, k2) * self.scale # TODO check 
-            sim += sim2
-        del k
-
-        if exists(mask):
-            ## feasible for causal attention mask only
-            max_neg_value = -torch.finfo(sim.dtype).max
-            mask = repeat(mask, 'b i j -> (b h) i j', h=h)
-            sim.masked_fill_(~(mask>0.5), max_neg_value)
-
-        # attention, what we cannot get enough of
-        sim = sim.softmax(dim=-1)
-
-        out = torch.einsum('b i j, b j d -> b i d', sim, v)
-        if self.relative_position:
-            v2 = self.relative_position_v(len_q, len_v)
-            out2 = einsum('b t s, t s d -> b t d', sim, v2) # TODO check
-            out += out2
-        out = rearrange(out, '(b h) n d -> b n (h d)', h=h)
-
-
-        ## for image cross-attention
-        if k_ip is not None:
-            k_ip, v_ip = map(lambda t: rearrange(t, 'b n (h d) -> (b h) n d', h=h), (k_ip, v_ip))
-            sim_ip =  torch.einsum('b i d, b j d -> b i j', q, k_ip) * self.scale
-            del k_ip
-            sim_ip = sim_ip.softmax(dim=-1)
-            out_ip = torch.einsum('b i j, b j d -> b i d', sim_ip, v_ip)
-            out_ip = rearrange(out_ip, '(b h) n d -> b n (h d)', h=h)
-
-
-        if out_ip is not None:
-            if self.image_cross_attention_scale_learnable:
-                out = out + self.image_cross_attention_scale * out_ip * (torch.tanh(self.alpha)+1)
-            else:
-                out = out + self.image_cross_attention_scale * out_ip
-        
-        return self.to_out(out)
-    
-    def efficient_forward(self, x, context=None, mask=None):
-        spatial_self_attn = (context is None)
-        k_ip, v_ip, out_ip = None, None, None
-
-        q = self.to_q(x)
-        context = default(context, x)
-
-        if self.image_cross_attention and not spatial_self_attn:
-            context, context_image = context[:,:self.text_context_len,:], context[:,self.text_context_len:,:]
-            k = self.to_k(context)
-            v = self.to_v(context)
-            k_ip = self.to_k_ip(context_image)
-            v_ip = self.to_v_ip(context_image)
-        else:
-            if not spatial_self_attn:
-                context = context[:,:self.text_context_len,:]
-            k = self.to_k(context)
-            v = self.to_v(context)
-
-        b, _, _ = q.shape
-        q, k, v = map(
-            lambda t: t.unsqueeze(3)
-            .reshape(b, t.shape[1], self.heads, self.dim_head)
-            .permute(0, 2, 1, 3)
-            .reshape(b * self.heads, t.shape[1], self.dim_head)
-            .contiguous(),
-            (q, k, v),
-        )
-        # actually compute the attention, what we cannot get enough of
-        out = xformers.ops.memory_efficient_attention(q, k, v, attn_bias=None, op=None)
-        
-        ## for image cross-attention
-        if k_ip is not None:
-            k_ip, v_ip = map(
-                lambda t: t.unsqueeze(3)
-                .reshape(b, t.shape[1], self.heads, self.dim_head)
-                .permute(0, 2, 1, 3)
-                .reshape(b * self.heads, t.shape[1], self.dim_head)
-                .contiguous(),
-                (k_ip, v_ip),
-            )
-            out_ip = xformers.ops.memory_efficient_attention(q, k_ip, v_ip, attn_bias=None, op=None)
-            out_ip = (
-                out_ip.unsqueeze(0)
-                .reshape(b, self.heads, out.shape[1], self.dim_head)
-                .permute(0, 2, 1, 3)
-                .reshape(b, out.shape[1], self.heads * self.dim_head)
-            )
-
-        if exists(mask):
-            raise NotImplementedError
-        out = (
-            out.unsqueeze(0)
-            .reshape(b, self.heads, out.shape[1], self.dim_head)
-            .permute(0, 2, 1, 3)
-            .reshape(b, out.shape[1], self.heads * self.dim_head)
-        )
-        if out_ip is not None:
-            if self.image_cross_attention_scale_learnable:
-                out = out + self.image_cross_attention_scale * out_ip * (torch.tanh(self.alpha)+1)
-            else:
-                out = out + self.image_cross_attention_scale * out_ip
-           
-        return self.to_out(out)
-
-
-class BasicTransformerBlock(nn.Module):
-
-    def __init__(
-        self, 
-        dim, 
-        n_heads, 
-        d_head, 
-        dropout=0., 
-        context_dim=None, 
-        gated_ff=True, 
-        checkpoint=True,
-        disable_self_attn=False, 
-        attention_cls=None, 
-        video_length=None, 
-        inner_dim=None,
-        image_cross_attention=False, 
-        image_cross_attention_scale=1.0, 
-        image_cross_attention_scale_learnable=False, 
-        switch_temporal_ca_to_sa=False,
-        text_context_len=77,
-        ff_in=None,
-        device=None,
-        dtype=None,
-        operations=ops
-    ):
-        super().__init__()
-        attn_cls = CrossAttention if attention_cls is None else attention_cls
-
-        self.ff_in = ff_in or inner_dim is not None
-        if self.ff_in:
-            self.norm_in = operations.LayerNorm(dim, dtype=dtype, device=device)
-            self.ff_in = FeedForward(
-                dim, 
-                dim_out=inner_dim, 
-                dropout=dropout, 
-                glu=gated_ff, 
-                dtype=dtype, 
-                device=device, 
-                operations=operations
-            )
-        if inner_dim is None:
-            inner_dim = dim
-
-        self.is_res = inner_dim == dim
-        self.disable_self_attn = disable_self_attn
-        self.attn1 = attn_cls(query_dim=dim, heads=n_heads, dim_head=d_head, dropout=dropout,
-            context_dim=None, device=device, dtype=dtype if self.disable_self_attn else None)
-        self.ff = FeedForward(dim, dropout=dropout, glu=gated_ff, device=device, dtype=dtype)
-        self.attn2 = attn_cls(
-            query_dim=dim, 
-            context_dim=context_dim, 
-            heads=n_heads, 
-            dim_head=d_head, 
-            dropout=dropout, 
-            video_length=video_length, 
-            image_cross_attention=image_cross_attention, 
-            image_cross_attention_scale=image_cross_attention_scale, 
-            image_cross_attention_scale_learnable=image_cross_attention_scale_learnable,
-            text_context_len=text_context_len,
-            device=device,
-            dtype=dtype
-        )
-        self.image_cross_attention = image_cross_attention
-
-        self.norm1 = operations.LayerNorm(dim, device=device, dtype=dtype)
-        self.norm2 = operations.LayerNorm(dim, device=device, dtype=dtype)
-        self.norm3 = operations.LayerNorm(dim, device=device, dtype=dtype)
-
-        self.n_heads = n_heads
-        self.d_head = d_head
-        self.checkpoint = checkpoint
-        self.switch_temporal_ca_to_sa = switch_temporal_ca_to_sa
-
-    def forward(self, x, context=None, mask=None, **kwargs):
-        ## implementation tricks: because checkpointing doesn't support non-tensor (e.g. None or scalar) arguments
-        input_tuple = (x,)      ## should not be (x), otherwise *input_tuple will decouple x into multiple arguments
-        if context is not None:
-            input_tuple = (x, context)
-        if mask is not None:
-            forward_mask = partial(self._forward, mask=mask)
-            return checkpoint(forward_mask, (x,), self.parameters(), self.checkpoint)
-        return checkpoint(self._forward, input_tuple, self.parameters(), self.checkpoint)
-
-
-    def _forward(self, x, context=None, mask=None, transformer_options={}):
-        extra_options = {}
-        block = transformer_options.get("block", None)
-        block_index = transformer_options.get("block_index", 0)
-        transformer_patches = {}
-        transformer_patches_replace = {}
-
-        for k in transformer_options:
-            if k == "patches":
-                transformer_patches = transformer_options[k]
-            elif k == "patches_replace":
-                transformer_patches_replace = transformer_options[k]
-            else:
-                extra_options[k] = transformer_options[k]
-
-        extra_options["n_heads"] = self.n_heads
-        extra_options["dim_head"] = self.d_head
-
-        if self.ff_in:
-            x_skip = x
-            x = self.ff_in(self.norm_in(x))
-            if self.is_res:
-                x += x_skip
-
-        n = self.norm1(x)
-        if self.disable_self_attn:
-            context_attn1 = context
-        else:
-            context_attn1 = None
-        value_attn1 = None
-
-        if "attn1_patch" in transformer_patches:
-            patch = transformer_patches["attn1_patch"]
-            if context_attn1 is None:
-                context_attn1 = n
-            value_attn1 = context_attn1
-            for p in patch:
-                n, context_attn1, value_attn1 = p(n, context_attn1, value_attn1, extra_options)
-
-        if block is not None:
-            transformer_block = (block[0], block[1], block_index)
-        else:
-            transformer_block = None
-        attn1_replace_patch = transformer_patches_replace.get("attn1", {})
-        block_attn1 = transformer_block
-        if block_attn1 not in attn1_replace_patch:
-            block_attn1 = block
-
-        if block_attn1 in attn1_replace_patch:
-            if context_attn1 is None:
-                context_attn1 = n
-                value_attn1 = n
-            n = self.attn1.to_q(n)
-            context_attn1 = self.attn1.to_k(context_attn1)
-            value_attn1 = self.attn1.to_v(value_attn1)
-            n = attn1_replace_patch[block_attn1](n, context_attn1, value_attn1, extra_options)
-            n = self.attn1.to_out(n)
-        else:
-            n = self.attn1(n, context=context_attn1, value=value_attn1)
-
-        if "attn1_output_patch" in transformer_patches:
-            patch = transformer_patches["attn1_output_patch"]
-            for p in patch:
-                n = p(n, extra_options)
-
-        x += n
-        if "middle_patch" in transformer_patches:
-            patch = transformer_patches["middle_patch"]
-            for p in patch:
-                x = p(x, extra_options)
-
-        if self.attn2 is not None:
-            n = self.norm2(x)
-            if self.switch_temporal_ca_to_sa:
-                context_attn2 = n
-            else:
-                context_attn2 = context
-            value_attn2 = None
-            if "attn2_patch" in transformer_patches:
-                patch = transformer_patches["attn2_patch"]
-                value_attn2 = context_attn2
-                for p in patch:
-                    n, context_attn2, value_attn2 = p(n, context_attn2, value_attn2, extra_options)
-
-            attn2_replace_patch = transformer_patches_replace.get("attn2", {})
-            block_attn2 = transformer_block
-            if block_attn2 not in attn2_replace_patch:
-                block_attn2 = block
-
-            if block_attn2 in attn2_replace_patch:
-                if value_attn2 is None:
-                    value_attn2 = context_attn2
-                n = self.attn2.to_q(n)
-                context_attn2 = self.attn2.to_k(context_attn2)
-                value_attn2 = self.attn2.to_v(value_attn2)
-                n = attn2_replace_patch[block_attn2](n, context_attn2, value_attn2, extra_options)
-                n = self.attn2.to_out(n)
-            else:
-                n = self.attn2(n, context=context_attn2, value=value_attn2)
-
-        if "attn2_output_patch" in transformer_patches:
-            patch = transformer_patches["attn2_output_patch"]
-            for p in patch:
-                n = p(n, extra_options)
-
-        x += n
-        if self.is_res:
-            x_skip = x
-        x = self.ff(self.norm3(x))
-        if self.is_res:
-            x += x_skip
-
-        return x
-
-
-class SpatialTransformer(nn.Module):
-    """
-    Transformer block for image-like data in spatial axis.
-    First, project the input (aka embedding)
-    and reshape to b, t, d.
-    Then apply standard transformer action.
-    Finally, reshape to image
-    NEW: use_linear for more efficiency instead of the 1x1 convs
-    """
-
-    def __init__(
-        self, 
-        in_channels, 
-        n_heads, 
-        d_head, 
-        depth=1, 
-        dropout=0., 
-        context_dim=None,
-        use_checkpoint=True, 
-        disable_self_attn=False, 
-        use_linear=False, 
-        video_length=None,
-        image_cross_attention=False, 
-        image_cross_attention_scale_learnable=False,
-        device=None,
-        dtype=None,
-        operations=ops
-    ):
-        super().__init__()
-        self.in_channels = in_channels
-        inner_dim = n_heads * d_head
-        self.norm = operations.GroupNorm(num_groups=32, num_channels=in_channels, eps=1e-6, affine=True, device=device, dtype=dtype)
-        if not use_linear:
-            self.proj_in = opeations.Conv2d(in_channels, inner_dim, kernel_size=1, stride=1, padding=0, device=device, dtype=dtype)
-        else:
-            self.proj_in = operations.Linear(in_channels, inner_dim, device=device, dtype=dtype)
-
-        attention_cls = None
-        self.transformer_blocks = nn.ModuleList([
-            BasicTransformerBlock(
-                inner_dim,
-                n_heads,
-                d_head,
-                dropout=dropout,
-                context_dim=context_dim,
-                disable_self_attn=disable_self_attn,
-                checkpoint=use_checkpoint,
-                attention_cls=attention_cls,
-                video_length=video_length,
-                image_cross_attention=image_cross_attention,
-                image_cross_attention_scale_learnable=image_cross_attention_scale_learnable,
-                device=device,
-                dtype=dtype
-                ) for d in range(depth)
-        ])
-        if not use_linear:
-            self.proj_out = zero_module(operations.Conv2d(inner_dim, in_channels, kernel_size=1, stride=1, padding=0, device=device, dtype=dtype))
-        else:
-            self.proj_out = zero_module(operations.Linear(inner_dim, in_channels, device=device, dtype=dtype))
-        self.use_linear = use_linear
-
-    def forward(self, x, context=None, transformer_options={}, **kwargs):
-        b, c, h, w = x.shape
-        x_in = x
-        x = self.norm(x)
-        if not self.use_linear:
-            x = self.proj_in(x)
-        x = rearrange(x, 'b c h w -> b (h w) c').contiguous()
-        if self.use_linear:
-            x = self.proj_in(x)
-        for i, block in enumerate(self.transformer_blocks):
-            transformer_options['block_index'] = i
-            x = block(x, context=context, **kwargs)
-        if self.use_linear:
-            x = self.proj_out(x)
-        x = rearrange(x, 'b (h w) c -> b c h w', h=h, w=w).contiguous()
-        if not self.use_linear:
-            x = self.proj_out(x)
-        return x + x_in
-    
-    
-class TemporalTransformer(nn.Module):
-    """
-    Transformer block for image-like data in temporal axis.
-    First, reshape to b, t, d.
-    Then apply standard transformer action.
-    Finally, reshape to image
-    """
-    def __init__(
-        self, 
-        in_channels, 
-        n_heads, 
-        d_head, 
-        depth=1, 
-        dropout=0., 
-        context_dim=None,
-        use_checkpoint=True, 
-        use_linear=False, 
-        only_self_att=True, 
-        causal_attention=False, 
-        causal_block_size=1,
-        relative_position=False, 
-        temporal_length=None,
-        device=None,
-        dtype=None,
-        operations=ops
-    ):
-        super().__init__()
-        self.only_self_att = only_self_att
-        self.relative_position = relative_position
-        self.causal_attention = causal_attention
-        self.causal_block_size = causal_block_size
-
-        if only_self_att:
-            context_dim = None
-            
-        self.in_channels = in_channels
-        inner_dim = n_heads * d_head
-        self.norm = operations.GroupNorm(num_groups=32, num_channels=in_channels, eps=1e-6, affine=True, device=device, dtype=dtype)
-        self.proj_in = nn.Conv1d(in_channels, inner_dim, kernel_size=1, stride=1, padding=0).to(device, dtype)
-        if not use_linear:
-            self.proj_in = nn.Conv1d(in_channels, inner_dim, kernel_size=1, stride=1, padding=0).to(device, dtype)
-        else:
-            self.proj_in = operations.Linear(in_channels, inner_dim, device=device, dtype=dtype)
-
-        if relative_position:
-            assert(temporal_length is not None)
-            attention_cls = partial(CrossAttention, relative_position=True, temporal_length=temporal_length, device=device, dtype=dtype)
-        else:
-            attention_cls = partial(CrossAttention, temporal_length=temporal_length, device=device, dtype=dtype)
-        if self.causal_attention:
-            assert(temporal_length is not None)
-            self.mask = torch.tril(torch.ones([1, temporal_length, temporal_length]))
-
-        if self.only_self_att:
-            context_dim = None
-        self.transformer_blocks = nn.ModuleList([
-            BasicTransformerBlock(
-                inner_dim,
-                n_heads,
-                d_head,
-                dropout=dropout,
-                context_dim=context_dim,
-                attention_cls=attention_cls,
-                checkpoint=use_checkpoint,
-                device=device,
-                dtype=dtype
-            ) for d in range(depth)
-        ])
-        if not use_linear:
-            self.proj_out = zero_module(nn.Conv1d(inner_dim, in_channels, kernel_size=1, stride=1, padding=0).to(device, dtype))
-        else:
-            self.proj_out = zero_module(operations.Linear(inner_dim, in_channels, device=device, dtype=dtype))
-        self.use_linear = use_linear
-
-    def forward(self, x, context=None):
-        b, c, t, h, w = x.shape
-        x_in = x
-        x = self.norm(x)
-        x = rearrange(x, 'b c t h w -> (b h w) c t').contiguous()
-        if not self.use_linear:
-            x = self.proj_in(x)
-        x = rearrange(x, 'bhw c t -> bhw t c').contiguous()
-        if self.use_linear:
-            x = self.proj_in(x)
-
-        temp_mask = None
-        if self.causal_attention:
-            # slice the from mask map
-            temp_mask = self.mask[:,:t,:t].to(x.device)
-
-        if temp_mask is not None:
-            mask = temp_mask.to(x.device)
-            mask = repeat(mask, 'l i j -> (l bhw) i j', bhw=b*h*w)
-        else:
-            mask = None
-
-        if self.only_self_att:
-            ## note: if no context is given, cross-attention defaults to self-attention
-            for i, block in enumerate(self.transformer_blocks):
-                x = block(x, mask=mask)
-            x = rearrange(x, '(b hw) t c -> b hw t c', b=b).contiguous()
-        else:
-            x = rearrange(x, '(b hw) t c -> b hw t c', b=b).contiguous()
-            context = rearrange(context, '(b t) l con -> b t l con', t=t).contiguous()
-            for i, block in enumerate(self.transformer_blocks):
-                # calculate each batch one by one (since number in shape could not greater then 65,535 for some package)
-                for j in range(b):
-                    context_j = repeat(
-                        context[j],
-                        't l con -> (t r) l con', r=(h * w) // t, t=t).contiguous()
-                    ## note: causal mask will not applied in cross-attention case
-                    x[j] = block(x[j], context=context_j)
-        
-        if self.use_linear:
-            x = self.proj_out(x)
-            x = rearrange(x, 'b (h w) t c -> b c t h w', h=h, w=w).contiguous()
-        if not self.use_linear:
-            x = rearrange(x, 'b hw t c -> (b hw) c t').contiguous()
-            x = self.proj_out(x)
-            x = rearrange(x, '(b h w) c t -> b c t h w', b=b, h=h, w=w).contiguous()
-
-        return x + x_in
-    
-
-class GEGLU(nn.Module):
-    def __init__(self, dim_in, dim_out, device=None, dtype=None, operations=ops):
-        super().__init__()
-        self.proj = operations.Linear(dim_in, dim_out * 2, device=device, dtype=dtype)
-
-    def forward(self, x):
-        x, gate = self.proj(x).chunk(2, dim=-1)
-        return x * F.gelu(gate)
-
-
-class FeedForward(nn.Module):
-    def __init__(self, dim, dim_out=None, mult=4, glu=False, dropout=0., device=None, dtype=None, operations=ops):
-        super().__init__()
-        inner_dim = int(dim * mult)
-        dim_out = default(dim_out, dim)
-        project_in = nn.Sequential(
-            operations.Linear(dim, inner_dim, device=device, dtype=dtype),
-            nn.GELU()
-        ) if not glu else GEGLU(dim, inner_dim)
-
-        self.net = nn.Sequential(
-            project_in,
-            nn.Dropout(dropout),
-            operations.Linear(inner_dim, dim_out, device=device, dtype=dtype)
-        )
-
-    def forward(self, x):
-        return self.net(x)
-
-
-class LinearAttention(nn.Module):
-    def __init__(self, dim, heads=4, dim_head=32, device=None, dtype=None, operations=ops):
-        super().__init__()
-        self.heads = heads
-        hidden_dim = dim_head * heads
-        self.to_qkv = operations.Conv2d(dim, hidden_dim * 3, 1, bias = False, device=device, dtype=dtype)
-        self.to_out = operations.Conv2d(hidden_dim, dim, 1, device=device, dtype=dtype)
-
-    def forward(self, x):
-        b, c, h, w = x.shape
-        qkv = self.to_qkv(x)
-        q, k, v = rearrange(qkv, 'b (qkv heads c) h w -> qkv b heads c (h w)', heads = self.heads, qkv=3)
-        k = k.softmax(dim=-1)  
-        context = torch.einsum('bhdn,bhen->bhde', k, v)
-        out = torch.einsum('bhde,bhdn->bhen', context, q)
-        out = rearrange(out, 'b heads c (h w) -> b (heads c) h w', heads=self.heads, h=h, w=w)
-        return self.to_out(out)
-
-
-class SpatialSelfAttention(nn.Module):
-    def __init__(self, in_channels, device=None, dtype=None, operations=ops):
-        super().__init__()
-        self.in_channels = in_channels
-
-        self.norm = operations.GroupNorm(
-            num_groups=32, 
-            num_channels=in_channels, 
-            eps=1e-6, 
-            affine=True, 
-            device=device, 
-            dtype=dtype
-        )
-        self.q = operations.Conv2d(
-                                in_channels,
-                                in_channels,
-                                kernel_size=1,
-                                stride=1,
-                                padding=0,
-                                device=device,
-                                dtype=dtype
-                            )
-        self.k = operations.Conv2d(
-                                in_channels,
-                                in_channels,
-                                kernel_size=1,
-                                stride=1,
-                                padding=0,
-                                device=device,
-                                dtype=dtype
-                            )
-        self.v = operations.Conv2d(
-                                in_channels,
-                                in_channels,
-                                kernel_size=1,
-                                stride=1,
-                                padding=0,
-                                device=device,
-                                dtype=dtype
-                            )
-        self.proj_out = operations.Conv2d(
-                                in_channels,
-                                in_channels,
-                                kernel_size=1,
-                                stride=1,
-                                padding=0,
-                                device=device,
-                                dtype=dtype
-                            )
-
-    def forward(self, x):
-        h_ = x
-        h_ = self.norm(h_)
-        q = self.q(h_)
-        k = self.k(h_)
-        v = self.v(h_)
-
-        # compute attention
-        b,c,h,w = q.shape
-        q = rearrange(q, 'b c h w -> b (h w) c')
-        k = rearrange(k, 'b c h w -> b c (h w)')
-        w_ = torch.einsum('bij,bjk->bik', q, k)
-
-        w_ = w_ * (int(c)**(-0.5))
-        w_ = torch.nn.functional.softmax(w_, dim=2)
-
-        # attend to values
-        v = rearrange(v, 'b c h w -> b c (h w)')
-        w_ = rearrange(w_, 'b i j -> b j i')
-        h_ = torch.einsum('bij,bjk->bik', v, w_)
-        h_ = rearrange(h_, 'b c (h w) -> b c h w', h=h)
-        h_ = self.proj_out(h_)
-
-        return x+h_
@@ -1,389 +0,0 @@
-import torch
-import torch.nn as nn
-import kornia
-import open_clip
-from torch.utils.checkpoint import checkpoint
-from transformers import T5Tokenizer, T5EncoderModel, CLIPTokenizer, CLIPTextModel
-from ..common import autocast
-from utils.utils import count_params
-
-
-class AbstractEncoder(nn.Module):
-    def __init__(self):
-        super().__init__()
-
-    def encode(self, *args, **kwargs):
-        raise NotImplementedError
-
-
-class IdentityEncoder(AbstractEncoder):
-    def encode(self, x):
-        return x
-
-
-class ClassEmbedder(nn.Module):
-    def __init__(self, embed_dim, n_classes=1000, key='class', ucg_rate=0.1):
-        super().__init__()
-        self.key = key
-        self.embedding = nn.Embedding(n_classes, embed_dim)
-        self.n_classes = n_classes
-        self.ucg_rate = ucg_rate
-
-    def forward(self, batch, key=None, disable_dropout=False):
-        if key is None:
-            key = self.key
-        # this is for use in crossattn
-        c = batch[key][:, None]
-        if self.ucg_rate > 0. and not disable_dropout:
-            mask = 1. - torch.bernoulli(torch.ones_like(c) * self.ucg_rate)
-            c = mask * c + (1 - mask) * torch.ones_like(c) * (self.n_classes - 1)
-            c = c.long()
-        c = self.embedding(c)
-        return c
-
-    def get_unconditional_conditioning(self, bs, device="cuda"):
-        uc_class = self.n_classes - 1  # 1000 classes --> 0 ... 999, one extra class for ucg (class 1000)
-        uc = torch.ones((bs,), device=device) * uc_class
-        uc = {self.key: uc}
-        return uc
-
-
-def disabled_train(self, mode=True):
-    """Overwrite model.train with this function to make sure train/eval mode
-    does not change anymore."""
-    return self
-
-
-class FrozenT5Embedder(AbstractEncoder):
-    """Uses the T5 transformer encoder for text"""
-
-    def __init__(self, version="google/t5-v1_1-large", device="cuda", max_length=77,
-                 freeze=True):  # others are google/t5-v1_1-xl and google/t5-v1_1-xxl
-        super().__init__()
-        self.tokenizer = T5Tokenizer.from_pretrained(version)
-        self.transformer = T5EncoderModel.from_pretrained(version)
-        self.device = device
-        self.max_length = max_length  # TODO: typical value?
-        if freeze:
-            self.freeze()
-
-    def freeze(self):
-        self.transformer = self.transformer.eval()
-        # self.train = disabled_train
-        for param in self.parameters():
-            param.requires_grad = False
-
-    def forward(self, text):
-        batch_encoding = self.tokenizer(text, truncation=True, max_length=self.max_length, return_length=True,
-                                        return_overflowing_tokens=False, padding="max_length", return_tensors="pt")
-        tokens = batch_encoding["input_ids"].to(self.device)
-        outputs = self.transformer(input_ids=tokens)
-
-        z = outputs.last_hidden_state
-        return z
-
-    def encode(self, text):
-        return self(text)
-
-
-class FrozenCLIPEmbedder(AbstractEncoder):
-    """Uses the CLIP transformer encoder for text (from huggingface)"""
-    LAYERS = [
-        "last",
-        "pooled",
-        "hidden"
-    ]
-
-    def __init__(self, version="openai/clip-vit-large-patch14", device="cuda", max_length=77,
-                 freeze=True, layer="last", layer_idx=None):  # clip-vit-base-patch32
-        super().__init__()
-        assert layer in self.LAYERS
-        self.tokenizer = CLIPTokenizer.from_pretrained(version)
-        self.transformer = CLIPTextModel.from_pretrained(version)
-        self.device = device
-        self.max_length = max_length
-        if freeze:
-            self.freeze()
-        self.layer = layer
-        self.layer_idx = layer_idx
-        if layer == "hidden":
-            assert layer_idx is not None
-            assert 0 <= abs(layer_idx) <= 12
-
-    def freeze(self):
-        self.transformer = self.transformer.eval()
-        # self.train = disabled_train
-        for param in self.parameters():
-            param.requires_grad = False
-
-    def forward(self, text):
-        batch_encoding = self.tokenizer(text, truncation=True, max_length=self.max_length, return_length=True,
-                                        return_overflowing_tokens=False, padding="max_length", return_tensors="pt")
-        tokens = batch_encoding["input_ids"].to(self.device)
-        outputs = self.transformer(input_ids=tokens, output_hidden_states=self.layer == "hidden")
-        if self.layer == "last":
-            z = outputs.last_hidden_state
-        elif self.layer == "pooled":
-            z = outputs.pooler_output[:, None, :]
-        else:
-            z = outputs.hidden_states[self.layer_idx]
-        return z
-
-    def encode(self, text):
-        return self(text)
-
-
-class ClipImageEmbedder(nn.Module):
-    def __init__(
-            self,
-            model,
-            jit=False,
-            device='cuda' if torch.cuda.is_available() else 'cpu',
-            antialias=True,
-            ucg_rate=0.
-    ):
-        super().__init__()
-        from clip import load as load_clip
-        self.model, _ = load_clip(name=model, device=device, jit=jit)
-
-        self.antialias = antialias
-
-        self.register_buffer('mean', torch.Tensor([0.48145466, 0.4578275, 0.40821073]), persistent=False)
-        self.register_buffer('std', torch.Tensor([0.26862954, 0.26130258, 0.27577711]), persistent=False)
-        self.ucg_rate = ucg_rate
-
-    def preprocess(self, x):
-        # normalize to [0,1]
-        x = kornia.geometry.resize(x, (224, 224),
-                                   interpolation='bicubic', align_corners=True,
-                                   antialias=self.antialias)
-        x = (x + 1.) / 2.
-        # re-normalize according to clip
-        x = kornia.enhance.normalize(x, self.mean, self.std)
-        return x
-
-    def forward(self, x, no_dropout=False):
-        # x is assumed to be in range [-1,1]
-        out = self.model.encode_image(self.preprocess(x))
-        out = out.to(x.dtype)
-        if self.ucg_rate > 0. and not no_dropout:
-            out = torch.bernoulli((1. - self.ucg_rate) * torch.ones(out.shape[0], device=out.device))[:, None] * out
-        return out
-
-
-class FrozenOpenCLIPEmbedder(AbstractEncoder):
-    """
-    Uses the OpenCLIP transformer encoder for text
-    """
-    LAYERS = [
-        # "pooled",
-        "last",
-        "penultimate"
-    ]
-
-    def __init__(self, arch="ViT-H-14", version="laion2b_s32b_b79k", device="cuda", max_length=77,
-                 freeze=True, layer="last"):
-        super().__init__()
-        assert layer in self.LAYERS
-        model, _, _ = open_clip.create_model_and_transforms(arch, device=torch.device('cpu'), pretrained=version)
-        del model.visual
-        self.model = model
-
-        self.device = device
-        self.max_length = max_length
-        if freeze:
-            self.freeze()
-        self.layer = layer
-        if self.layer == "last":
-            self.layer_idx = 0
-        elif self.layer == "penultimate":
-            self.layer_idx = 1
-        else:
-            raise NotImplementedError()
-
-    def freeze(self):
-        self.model = self.model.eval()
-        for param in self.parameters():
-            param.requires_grad = False
-
-    def forward(self, text):
-        tokens = open_clip.tokenize(text) ## all clip models use 77 as context length
-        z = self.encode_with_transformer(tokens.to(self.device))
-        return z
-
-    def encode_with_transformer(self, text):
-        x = self.model.token_embedding(text)  # [batch_size, n_ctx, d_model]
-        x = x + self.model.positional_embedding
-        x = x.permute(1, 0, 2)  # NLD -> LND
-        x = self.text_transformer_forward(x, attn_mask=self.model.attn_mask)
-        x = x.permute(1, 0, 2)  # LND -> NLD
-        x = self.model.ln_final(x)
-        return x
-
-    def text_transformer_forward(self, x: torch.Tensor, attn_mask=None):
-        for i, r in enumerate(self.model.transformer.resblocks):
-            if i == len(self.model.transformer.resblocks) - self.layer_idx:
-                break
-            if self.model.transformer.grad_checkpointing and not torch.jit.is_scripting():
-                x = checkpoint(r, x, attn_mask)
-            else:
-                x = r(x, attn_mask=attn_mask)
-        return x
-
-    def encode(self, text):
-        return self(text)
-
-
-class FrozenOpenCLIPImageEmbedder(AbstractEncoder):
-    """
-    Uses the OpenCLIP vision transformer encoder for images
-    """
-
-    def __init__(self, arch="ViT-H-14", version="laion2b_s32b_b79k", device="cuda", max_length=77,
-                 freeze=True, layer="pooled", antialias=True, ucg_rate=0.):
-        super().__init__()
-        model, _, _ = open_clip.create_model_and_transforms(arch, device=torch.device('cpu'),
-                                                            pretrained=version, )
-        del model.transformer
-        self.model = model
-        # self.mapper = torch.nn.Linear(1280, 1024)
-        self.device = device
-        self.max_length = max_length
-        if freeze:
-            self.freeze()
-        self.layer = layer
-        if self.layer == "penultimate":
-            raise NotImplementedError()
-            self.layer_idx = 1
-
-        self.antialias = antialias
-
-        self.register_buffer('mean', torch.Tensor([0.48145466, 0.4578275, 0.40821073]), persistent=False)
-        self.register_buffer('std', torch.Tensor([0.26862954, 0.26130258, 0.27577711]), persistent=False)
-        self.ucg_rate = ucg_rate
-
-    def preprocess(self, x):
-        # normalize to [0,1]
-        x = kornia.geometry.resize(x, (224, 224),
-                                   interpolation='bicubic', align_corners=True,
-                                   antialias=self.antialias)
-        x = (x + 1.) / 2.
-        # renormalize according to clip
-        x = kornia.enhance.normalize(x, self.mean, self.std)
-        return x
-
-    def freeze(self):
-        self.model = self.model.eval()
-        for param in self.model.parameters():
-            param.requires_grad = False
-    
-    @autocast
-    def forward(self, image, no_dropout=False):
-        z = self.encode_with_vision_transformer(image)
-        if self.ucg_rate > 0. and not no_dropout:
-            z = torch.bernoulli((1. - self.ucg_rate) * torch.ones(z.shape[0], device=z.device))[:, None] * z
-        return z
-
-    def encode_with_vision_transformer(self, img):
-        img = self.preprocess(img)
-        x = self.model.visual(img)
-        return x
-
-    def encode(self, text):
-        return self(text)
-
-class FrozenOpenCLIPImageEmbedderV2(AbstractEncoder):
-    """
-    Uses the OpenCLIP vision transformer encoder for images
-    """
-
-    def __init__(self, arch="ViT-H-14", version="laion2b_s32b_b79k", device="cuda",
-                 freeze=True, layer="pooled", antialias=True):
-        super().__init__()
-        model, _, _ = open_clip.create_model_and_transforms(arch, device=torch.device('cpu'),
-                                                            pretrained=version, )
-        del model.transformer
-        self.model = model
-        self.device = device
-
-        if freeze:
-            self.freeze()
-        self.layer = layer
-        if self.layer == "penultimate":
-            raise NotImplementedError()
-            self.layer_idx = 1
-
-        self.antialias = antialias
-
-        self.register_buffer('mean', torch.Tensor([0.48145466, 0.4578275, 0.40821073]), persistent=False)
-        self.register_buffer('std', torch.Tensor([0.26862954, 0.26130258, 0.27577711]), persistent=False)
-
-
-    def preprocess(self, x):
-        # normalize to [0,1]
-        x = kornia.geometry.resize(x, (224, 224),
-                                   interpolation='bicubic', align_corners=True,
-                                   antialias=self.antialias)
-        x = (x + 1.) / 2.
-        # renormalize according to clip
-        x = kornia.enhance.normalize(x, self.mean, self.std)
-        return x
-
-    def freeze(self):
-        self.model = self.model.eval()
-        for param in self.model.parameters():
-            param.requires_grad = False
-
-    def forward(self, image, no_dropout=False): 
-        ## image: b c h w
-        z = self.encode_with_vision_transformer(image)
-        return z
-
-    def encode_with_vision_transformer(self, x):
-        x = self.preprocess(x)
-
-        # to patches - whether to use dual patchnorm - https://arxiv.org/abs/2302.01327v1
-        if self.model.visual.input_patchnorm:
-            # einops - rearrange(x, 'b c (h p1) (w p2) -> b (h w) (c p1 p2)')
-            x = x.reshape(x.shape[0], x.shape[1], self.model.visual.grid_size[0], self.model.visual.patch_size[0], self.model.visual.grid_size[1], self.model.visual.patch_size[1])
-            x = x.permute(0, 2, 4, 1, 3, 5)
-            x = x.reshape(x.shape[0], self.model.visual.grid_size[0] * self.model.visual.grid_size[1], -1)
-            x = self.model.visual.patchnorm_pre_ln(x)
-            x = self.model.visual.conv1(x)
-        else:
-            x = self.model.visual.conv1(x)  # shape = [*, width, grid, grid]
-            x = x.reshape(x.shape[0], x.shape[1], -1)  # shape = [*, width, grid ** 2]
-            x = x.permute(0, 2, 1)  # shape = [*, grid ** 2, width]
-
-        # class embeddings and positional embeddings
-        x = torch.cat(
-            [self.model.visual.class_embedding.to(x.dtype) + torch.zeros(x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device),
-             x], dim=1)  # shape = [*, grid ** 2 + 1, width]
-        x = x + self.model.visual.positional_embedding.to(x.dtype)
-
-        # a patch_dropout of 0. would mean it is disabled and this function would do nothing but return what was passed in
-        x = self.model.visual.patch_dropout(x)
-        x = self.model.visual.ln_pre(x)
-
-        x = x.permute(1, 0, 2)  # NLD -> LND
-        x = self.model.visual.transformer(x)
-        x = x.permute(1, 0, 2)  # LND -> NLD
-
-        return x
-
-class FrozenCLIPT5Encoder(AbstractEncoder):
-    def __init__(self, clip_version="openai/clip-vit-large-patch14", t5_version="google/t5-v1_1-xl", device="cuda",
-                 clip_max_length=77, t5_max_length=77):
-        super().__init__()
-        self.clip_encoder = FrozenCLIPEmbedder(clip_version, device, max_length=clip_max_length)
-        self.t5_encoder = FrozenT5Embedder(t5_version, device, max_length=t5_max_length)
-        print(f"{self.clip_encoder.__class__.__name__} has {count_params(self.clip_encoder) * 1.e-6:.2f} M parameters, "
-              f"{self.t5_encoder.__class__.__name__} comes with {count_params(self.t5_encoder) * 1.e-6:.2f} M params.")
-
-    def encode(self, text):
-        return self(text)
-
-    def forward(self, text):
-        clip_z = self.clip_encoder.encode(text)
-        t5_z = self.t5_encoder.encode(text)
-        return [clip_z, t5_z]
@@ -1,145 +0,0 @@
-# modified from https://github.com/mlfoundations/open_flamingo/blob/main/open_flamingo/src/helpers.py
-# and https://github.com/lucidrains/imagen-pytorch/blob/main/imagen_pytorch/imagen_pytorch.py
-# and https://github.com/tencent-ailab/IP-Adapter/blob/main/ip_adapter/resampler.py
-import math
-import torch
-import torch.nn as nn
-
-
-class ImageProjModel(nn.Module):
-    """Projection Model"""
-    def __init__(self, cross_attention_dim=1024, clip_embeddings_dim=1024, clip_extra_context_tokens=4):
-        super().__init__()        
-        self.cross_attention_dim = cross_attention_dim
-        self.clip_extra_context_tokens = clip_extra_context_tokens
-        self.proj = nn.Linear(clip_embeddings_dim, self.clip_extra_context_tokens * cross_attention_dim)
-        self.norm = nn.LayerNorm(cross_attention_dim)
-        
-    def forward(self, image_embeds):
-        #embeds = image_embeds
-        embeds = image_embeds.type(list(self.proj.parameters())[0].dtype)
-        clip_extra_context_tokens = self.proj(embeds).reshape(-1, self.clip_extra_context_tokens, self.cross_attention_dim)
-        clip_extra_context_tokens = self.norm(clip_extra_context_tokens)
-        return clip_extra_context_tokens
-
-
-# FFN
-def FeedForward(dim, mult=4):
-    inner_dim = int(dim * mult)
-    return nn.Sequential(
-        nn.LayerNorm(dim),
-        nn.Linear(dim, inner_dim, bias=False),
-        nn.GELU(),
-        nn.Linear(inner_dim, dim, bias=False),
-    )
-    
-    
-def reshape_tensor(x, heads):
-    bs, length, width = x.shape
-    #(bs, length, width) --> (bs, length, n_heads, dim_per_head)
-    x = x.view(bs, length, heads, -1)
-    # (bs, length, n_heads, dim_per_head) --> (bs, n_heads, length, dim_per_head)
-    x = x.transpose(1, 2)
-    # (bs, n_heads, length, dim_per_head) --> (bs*n_heads, length, dim_per_head)
-    x = x.reshape(bs, heads, length, -1)
-    return x
-
-
-class PerceiverAttention(nn.Module):
-    def __init__(self, *, dim, dim_head=64, heads=8):
-        super().__init__()
-        self.scale = dim_head**-0.5
-        self.dim_head = dim_head
-        self.heads = heads
-        inner_dim = dim_head * heads
-
-        self.norm1 = nn.LayerNorm(dim)
-        self.norm2 = nn.LayerNorm(dim)
-
-        self.to_q = nn.Linear(dim, inner_dim, bias=False)
-        self.to_kv = nn.Linear(dim, inner_dim * 2, bias=False)
-        self.to_out = nn.Linear(inner_dim, dim, bias=False)
-
-
-    def forward(self, x, latents):
-        """
-        Args:
-            x (torch.Tensor): image features
-                shape (b, n1, D)
-            latent (torch.Tensor): latent features
-                shape (b, n2, D)
-        """
-        x = self.norm1(x)
-        latents = self.norm2(latents)
-        
-        b, l, _ = latents.shape
-
-        q = self.to_q(latents)
-        kv_input = torch.cat((x, latents), dim=-2)
-        k, v = self.to_kv(kv_input).chunk(2, dim=-1)
-        
-        q = reshape_tensor(q, self.heads)
-        k = reshape_tensor(k, self.heads)
-        v = reshape_tensor(v, self.heads)
-
-        # attention
-        scale = 1 / math.sqrt(math.sqrt(self.dim_head))
-        weight = (q * scale) @ (k * scale).transpose(-2, -1) # More stable with f16 than dividing afterwards
-        weight = torch.softmax(weight.float(), dim=-1).type(weight.dtype)
-        out = weight @ v
-        
-        out = out.permute(0, 2, 1, 3).reshape(b, l, -1)
-
-        return self.to_out(out)
-
-
-class Resampler(nn.Module):
-    def __init__(
-        self,
-        dim=1024,
-        depth=8,
-        dim_head=64,
-        heads=16,
-        num_queries=8,
-        embedding_dim=768,
-        output_dim=1024,
-        ff_mult=4,
-        video_length=None, # using frame-wise version or not
-    ):
-        super().__init__()
-        ## queries for a single frame / image
-        self.num_queries = num_queries 
-        self.video_length = video_length
-
-        ## <num_queries> queries for each frame
-        if video_length is not None: 
-            num_queries = num_queries * video_length
-
-        self.latents = nn.Parameter(torch.randn(1, num_queries, dim) / dim**0.5)
-        self.proj_in = nn.Linear(embedding_dim, dim)
-        self.proj_out = nn.Linear(dim, output_dim)
-        self.norm_out = nn.LayerNorm(output_dim)
-        
-        self.layers = nn.ModuleList([])
-        for _ in range(depth):
-            self.layers.append(
-                nn.ModuleList(
-                    [
-                        PerceiverAttention(dim=dim, dim_head=dim_head, heads=heads),
-                        FeedForward(dim=dim, mult=ff_mult),
-                    ]
-                )
-            )
-
-    def forward(self, x):
-        latents = self.latents.repeat(x.size(0), 1, 1) ## B (T L) C
-        x = self.proj_in(x)
-        
-        for attn, ff in self.layers:
-            latents = attn(x, latents) + latents
-            latents = ff(latents) + latents
-            
-        latents = self.proj_out(latents)
-        latents = self.norm_out(latents) # B L C or B (T L) C
-
-        return latents
@@ -1,822 +0,0 @@
-from functools import partial
-from abc import abstractmethod
-import torch
-import torch.nn as nn
-from einops import rearrange
-import torch.nn.functional as F
-from ...models.utils_diffusion import timestep_embedding
-from ...common import checkpoint
-from ...basics import (
-    zero_module,
-    conv_nd,
-    linear,
-    avg_pool_nd,
-    normalization
-)
-from ...modules.attention import SpatialTransformer, TemporalTransformer
-import comfy.ops
-import logging
-
-ops = comfy.ops.disable_weight_init
-
-class TimestepBlock(nn.Module):
-    """
-    Any module where forward() takes timestep embeddings as a second argument.
-    """
-    @abstractmethod
-    def forward(self, x, emb):
-        """
-        Apply the module to `x` given `emb` timestep embeddings.
-        """
-
-#This is needed because accelerate makes a copy of transformer_options which breaks "transformer_index"
-def forward_timestep_embed(ts, x, emb, context=None, batch_size=None, transformer_options={}):
-    for layer in ts:
-        if isinstance(layer, TimestepBlock):
-            x = layer(x, emb, batch_size=batch_size)
-        elif isinstance(layer, SpatialTransformer):
-            x = layer(x, context)
-            if "transformer_index" in transformer_options:
-                transformer_options["transformer_index"] += 1
-        elif isinstance(layer, TemporalTransformer):
-            x = rearrange(x, '(b f) c h w -> b c f h w', b=batch_size)
-            x = layer(x, context)
-            if "transformer_index" in transformer_options:
-                transformer_options["transformer_index"] += 1
-            x = rearrange(x, 'b c f h w -> (b f) c h w')
-        else:
-            x = layer(x)
-    return x
-
-class TimestepEmbedSequential(nn.Sequential, TimestepBlock):
-    """
-    A sequential module that passes timestep embeddings to the children that
-    support it as an extra input.
-    """
-
-    def forward(self, *args, **kwargs):
-        return forward_timestep_embed(self, *args, **kwargs)
-
-class Downsample(nn.Module):
-    """
-    A downsampling layer with an optional convolution.
-    :param channels: channels in the inputs and outputs.
-    :param use_conv: a bool determining if a convolution is applied.
-    :param dims: determines if the signal is 1D, 2D, or 3D. If 3D, then
-                 downsampling occurs in the inner-two dimensions.
-    """
-
-    def __init__(self, channels, use_conv, dims=2, out_channels=None, padding=1, dtype=None, device=None, operations=ops):
-        super().__init__()
-        self.channels = channels
-        self.out_channels = out_channels or channels
-        self.use_conv = use_conv
-        self.dims = dims
-        stride = 2 if dims != 3 else (1, 2, 2)
-        if use_conv:
-            self.op = operations.conv_nd(
-                dims, self.channels, self.out_channels, 3, stride=stride, padding=padding
-            )
-        else:
-            assert self.channels == self.out_channels
-            self.op = avg_pool_nd(dims, kernel_size=stride, stride=stride)
-
-    def forward(self, x):
-        assert x.shape[1] == self.channels
-        return self.op(x)
-
-class Upsample(nn.Module):
-    """
-    An upsampling layer with an optional convolution.
-    :param channels: channels in the inputs and outputs.
-    :param use_conv: a bool determining if a convolution is applied.
-    :param dims: determines if the signal is 1D, 2D, or 3D. If 3D, then
-                 upsampling occurs in the inner-two dimensions.
-    """
-
-    def __init__(self, channels, use_conv, dims=2, out_channels=None, padding=1, dtype=None, device=None, operations=ops):
-        super().__init__()
-        self.channels = channels
-        self.out_channels = out_channels or channels
-        self.use_conv = use_conv
-        self.dims = dims
-        if use_conv:
-            self.conv = operations.conv_nd(dims, self.channels, self.out_channels, 3, padding=padding, dtype=dtype, device=device)
-
-    def forward(self, x):
-        assert x.shape[1] == self.channels
-        if self.dims == 3:
-            x = F.interpolate(x, (x.shape[2], x.shape[3] * 2, x.shape[4] * 2), mode='nearest')
-        else:
-            x = F.interpolate(x, scale_factor=2, mode='nearest')
-        if self.use_conv:
-            x = self.conv(x)
-        return x
-
-class ResBlock(TimestepBlock):
-    """
-    A residual block that can optionally change the number of channels.
-    :param channels: the number of input channels.
-    :param emb_channels: the number of timestep embedding channels.
-    :param dropout: the rate of dropout.
-    :param out_channels: if specified, the number of out channels.
-    :param use_conv: if True and out_channels is specified, use a spatial
-        convolution instead of a smaller 1x1 convolution to change the
-        channels in the skip connection.
-    :param dims: determines if the signal is 1D, 2D, or 3D.
-    :param up: if True, use this block for upsampling.
-    :param down: if True, use this block for downsampling.
-    :param use_temporal_conv: if True, use the temporal convolution.
-    :param use_image_dataset: if True, the temporal parameters will not be optimized.
-    """
-
-    def __init__(
-        self,
-        channels,
-        emb_channels,
-        dropout,
-        out_channels=None,
-        use_scale_shift_norm=False,
-        dims=2,
-        use_checkpoint=False,
-        use_conv=False,
-        up=False,
-        down=False,
-        kernel_size=3,
-        use_temporal_conv=False,
-        tempspatial_aware=False,
-        dtype=None,
-        device=None,
-        operations=ops
-    ):
-        super().__init__()
-        self.channels = channels
-        self.emb_channels = emb_channels
-        self.dropout = dropout
-        self.out_channels = out_channels or channels
-        self.use_conv = use_conv
-        self.use_checkpoint = use_checkpoint
-        self.use_scale_shift_norm = use_scale_shift_norm
-        self.use_temporal_conv = use_temporal_conv
-
-        if isinstance(kernel_size, list):
-            padding =[k // 2 for k in kernel_size]
-        else:
-            padding = kernel_size // 2
-
-        # operations used in normalization function
-        self.in_layers = nn.Sequential(
-            normalization(channels, dtype=dtype, device=device),
-            nn.SiLU(),
-            operations.conv_nd(dims, channels, self.out_channels, 3, padding=1, dtype=dtype, device=device),
-        )
-
-        self.updown = up or down
-
-        if up:
-            self.h_upd = Upsample(channels, False, dims, dtype=dtype, device=device)
-            self.x_upd = Upsample(channels, False, dims, dtype=dtype, device=device)
-        elif down:
-            self.h_upd = Downsample(channels, False, dims, dtype=dtype, device=device)
-            self.x_upd = Downsample(channels, False, dims, dtype=dtype, device=device)
-        else:
-            self.h_upd = self.x_upd = nn.Identity()
-
-        self.emb_layers = nn.Sequential(
-            nn.SiLU(),
-            operations.Linear(
-                emb_channels,
-                2 * self.out_channels if use_scale_shift_norm else self.out_channels,
-                dtype=dtype,
-                device=device
-            ),
-        )
-        self.out_layers = nn.Sequential(
-            normalization(self.out_channels, dtype=dtype, device=device),
-            nn.SiLU(),
-            nn.Dropout(p=dropout),
-            zero_module(operations.Conv2d(self.out_channels, self.out_channels, 3, padding=1, dtype=dtype, device=device)),
-        )
-
-        if self.out_channels == channels:
-            self.skip_connection = nn.Identity()
-        elif use_conv:
-            self.skip_connection = operations.conv_nd(dims, channels, self.out_channels, 3, padding=1, dtype=dtype, device=device)
-        else:
-            self.skip_connection = operations.conv_nd(dims, channels, self.out_channels, 1, dtype=dtype, device=device)
-
-        if self.use_temporal_conv:
-            self.temopral_conv = TemporalConvBlock(
-                self.out_channels,
-                self.out_channels,
-                dropout=0.1,
-                spatial_aware=tempspatial_aware,
-                dtype=dtype,
-                device=device
-            )
-
-    def forward(self, x, emb, batch_size=None):
-        """
-        Apply the block to a Tensor, conditioned on a timestep embedding.
-        :param x: an [N x C x ...] Tensor of features.
-        :param emb: an [N x emb_channels] Tensor of timestep embeddings.
-        :return: an [N x C x ...] Tensor of outputs.
-        """
-        input_tuple = (x, emb)
-        if batch_size:
-            forward_batchsize = partial(self._forward, batch_size=batch_size)
-            return checkpoint(forward_batchsize, input_tuple, self.parameters(), self.use_checkpoint)
-        return checkpoint(self._forward, input_tuple, self.parameters(), self.use_checkpoint)
-
-    def _forward(self, x, emb, batch_size=None):
-        if self.updown:
-            in_rest, in_conv = self.in_layers[:-1], self.in_layers[-1]
-            h = in_rest(x)
-            h = self.h_upd(h)
-            x = self.x_upd(x)
-            h = in_conv(h)
-        else:
-            h = self.in_layers(x)
-        emb_out = self.emb_layers(emb).type(h.dtype)
-        while len(emb_out.shape) < len(h.shape):
-            emb_out = emb_out[..., None]
-        if self.use_scale_shift_norm:
-            out_norm, out_rest = self.out_layers[0], self.out_layers[1:]
-            scale, shift = torch.chunk(emb_out, 2, dim=1)
-            h = out_norm(h) * (1 + scale) + shift
-            h = out_rest(h)
-        else:
-            h = h + emb_out
-            h = self.out_layers(h)
-        h = self.skip_connection(x) + h
-
-        if self.use_temporal_conv and batch_size:
-            h = rearrange(h, '(b t) c h w -> b c t h w', b=batch_size)
-            h = self.temopral_conv(h)
-            h = rearrange(h, 'b c t h w -> (b t) c h w')
-        return h
-
-class TemporalConvBlock(nn.Module):
-    """
-    Adapted from modelscope: https://github.com/modelscope/modelscope/blob/master/modelscope/models/multi_modal/video_synthesis/unet_sd.py
-    """
-    def __init__(
-        self, 
-        in_channels, 
-        out_channels=None, 
-        dropout=0.0, 
-        spatial_aware=False, 
-        dtype=None, 
-        device=None, 
-        operations=ops
-    ):
-        super(TemporalConvBlock, self).__init__()
-        if out_channels is None:
-            out_channels = in_channels
-        self.in_channels = in_channels
-        self.out_channels = out_channels
-        th_kernel_shape = (3, 1, 1) if not spatial_aware else (3, 3, 1)
-        th_padding_shape = (1, 0, 0) if not spatial_aware else (1, 1, 0)
-        tw_kernel_shape = (3, 1, 1) if not spatial_aware else (3, 1, 3)
-        tw_padding_shape = (1, 0, 0) if not spatial_aware else (1, 0, 1)
-
-        # conv layers
-        self.conv1 = nn.Sequential(
-            operations.GroupNorm(32, in_channels, device=device, dtype=dtype), nn.SiLU(),
-            operations.Conv3d(in_channels, out_channels, th_kernel_shape, padding=th_padding_shape, device=device, dtype=dtype))
-        self.conv2 = nn.Sequential(
-            operations.GroupNorm(32, out_channels, device=device, dtype=dtype), nn.SiLU(), nn.Dropout(dropout),
-            operations.Conv3d(out_channels, in_channels, tw_kernel_shape, padding=tw_padding_shape, device=device, dtype=dtype))
-        self.conv3 = nn.Sequential(
-            operations.GroupNorm(32, out_channels, device=device, dtype=dtype), nn.SiLU(), nn.Dropout(dropout),
-            operations.Conv3d(out_channels, in_channels, th_kernel_shape, padding=th_padding_shape, device=device, dtype=dtype))
-        self.conv4 = nn.Sequential(
-            operations.GroupNorm(32, out_channels, device=device, dtype=dtype), nn.SiLU(), nn.Dropout(dropout),
-            operations.Conv3d(out_channels, in_channels, tw_kernel_shape, padding=tw_padding_shape, device=device, dtype=dtype))
-
-        # zero out the last layer params,so the conv block is identity
-        nn.init.zeros_(self.conv4[-1].weight)
-        nn.init.zeros_(self.conv4[-1].bias)
-
-    def forward(self, x):
-        identity = x
-        x = self.conv1(x)
-        x = self.conv2(x)
-        x = self.conv3(x)
-        x = self.conv4(x)
-
-        return identity + x
-
-def context_processor(context, t, img_emb=None, temporal_size=16, concat_only=False, disable_concat=False):
-    if disable_concat:
-        return context
-        
-    ## repeat t times for context [(b t) 77 768] & time embedding
-    ## check if we use per-frame image conditioning
-
-    if img_emb is not None:
-        context = torch.cat([context, img_emb.to(context.device, context.dtype)], dim=1)
-        
-    if concat_only:
-        return context
-
-    b, l_context, _ = context.shape
-    if l_context == 77 + t * temporal_size:
-        context_text, context_img = context[:,:77,:], context[:,77:,:]
-        context_text = context_text.repeat_interleave(repeats=t, dim=0)
-        context_img = rearrange(context_img, 'b (t l) c -> (b t) l c', t=t)
-        context = torch.cat([context_text, context_img], dim=1)
-    else:
-        context = context.repeat_interleave(repeats=t, dim=0)
-
-    return context
-
-def apply_control(h, control, name, cond_idx=None):
-    if control is not None and name in control and len(control[name]) > 0:
-        frames = h.shape[0]
-        ctrl = control[name].pop()
-        if ctrl is not None:    
-            try:
-                if cond_idx is not None and ctrl.shape[0] > frames:
-                    ctrl_frames_list = list(range(ctrl.shape[0]))
-                    ctrl_frames = len(ctrl_frames_list)
-
-                    idxs = (
-                        ctrl_frames_list[ctrl_frames // 2:] if cond_idx == 0 else \
-                            ctrl_frames_list[:ctrl_frames // 2]
-                    )
-                    
-                    ctrl = ctrl[idxs]
-
-                h += ctrl
-            except Exception as e:
-                if h.shape != ctrl.shape:
-                    logging.warning(
-                        "warning control could not be applied {} {}".format(h.shape, ctrl.shape)
-                    )
-                logging.warning(e)
-    return h
-
-class UNetModel(nn.Module):
-    """
-    The full UNet model with attention and timestep embedding.
-    :param in_channels: in_channels in the input Tensor.
-    :param model_channels: base channel count for the model.
-    :param out_channels: channels in the output Tensor.
-    :param num_res_blocks: number of residual blocks per downsample.
-    :param attention_resolutions: a collection of downsample rates at which
-        attention will take place. May be a set, list, or tuple.
-        For example, if this contains 4, then at 4x downsampling, attention
-        will be used.
-    :param dropout: the dropout probability.
-    :param channel_mult: channel multiplier for each level of the UNet.
-    :param conv_resample: if True, use learned convolutions for upsampling and
-        downsampling.
-    :param dims: determines if the signal is 1D, 2D, or 3D.
-    :param num_classes: if specified (as an int), then this model will be
-        class-conditional with `num_classes` classes.
-    :param use_checkpoint: use gradient checkpointing to reduce memory usage.
-    :param num_heads: the number of attention heads in each attention layer.
-    :param num_heads_channels: if specified, ignore num_heads and instead use
-                               a fixed channel width per attention head.
-    :param num_heads_upsample: works with num_heads to set a different number
-                               of heads for upsampling. Deprecated.
-    :param use_scale_shift_norm: use a FiLM-like conditioning mechanism.
-    :param resblock_updown: use residual blocks for up/downsampling.
-    :param use_new_attention_order: use a different attention pattern for potentially
-                                    increased efficiency.
-    """
-
-    def __init__(self,
-                 in_channels,
-                 model_channels,
-                 out_channels,
-                 num_res_blocks,
-                 attention_resolutions,
-                 dropout=0.0,
-                 channel_mult=(1, 2, 4, 8),
-                 conv_resample=True,
-                 dims=2,
-                 context_dim=None,
-                 use_scale_shift_norm=False,
-                 resblock_updown=False,
-                 num_heads=-1,
-                 num_head_channels=-1,
-                 transformer_depth=1,
-                 use_linear=False,
-                 use_checkpoint=False,
-                 temporal_conv=False,
-                 tempspatial_aware=False,
-                 temporal_attention=True,
-                 use_relative_position=True,
-                 use_causal_attention=False,
-                 temporal_length=None,
-                 use_fp16=False,
-                 addition_attention=False,
-                 temporal_selfatt_only=True,
-                 image_cross_attention=False,
-                 image_cross_attention_scale_learnable=False,
-                 default_fs=4,
-                 fs_condition=False,
-                 device=None,
-                 dtype=torch.float16,
-                 operations=ops
-                ):
-        super(UNetModel, self).__init__()
-        if num_heads == -1:
-            assert num_head_channels != -1, 'Either num_heads or num_head_channels has to be set'
-        if num_head_channels == -1:
-            assert num_heads != -1, 'Either num_heads or num_head_channels has to be set'
-
-        self.in_channels = in_channels
-        self.model_channels = model_channels
-        self.out_channels = out_channels
-        self.num_res_blocks = num_res_blocks
-        self.attention_resolutions = attention_resolutions
-        self.dropout = dropout
-        self.channel_mult = channel_mult
-        self.conv_resample = conv_resample
-        self.temporal_attention = temporal_attention
-        time_embed_dim = model_channels * 4
-        self.use_checkpoint = use_checkpoint
-        temporal_self_att_only = True
-        self.addition_attention = addition_attention
-        self.temporal_length = temporal_length
-        self.image_cross_attention = image_cross_attention
-        self.image_cross_attention_scale_learnable = image_cross_attention_scale_learnable
-        self.default_fs = default_fs
-        self.fs_condition = fs_condition
-        self.device = device
-        #self.dtype = dtype
-        self.dtype = torch.float32
-
-        ## Time embedding blocks
-        self.time_embed = nn.Sequential(
-            linear(model_channels, time_embed_dim, device=device, dtype=self.dtype),
-            nn.SiLU(),
-            linear(time_embed_dim, time_embed_dim, device=device, dtype=self.dtype),
-        )
-        if fs_condition:
-            self.fps_embedding = nn.Sequential(
-                linear(model_channels, time_embed_dim, device=device, dtype=self.dtype),
-                nn.SiLU(),
-                linear(time_embed_dim, time_embed_dim, device=device, dtype=self.dtype),
-            )
-            nn.init.zeros_(self.fps_embedding[-1].weight)
-            nn.init.zeros_(self.fps_embedding[-1].bias)
-        ## Input Block
-        self.input_blocks = nn.ModuleList(
-            [
-                TimestepEmbedSequential(
-                    operations.conv_nd(
-                        dims, 
-                        in_channels, 
-                        model_channels, 
-                        3, 
-                        padding=1, 
-                        device=device, 
-                        dtype=self.dtype
-                    ))
-            ]
-        )
-        if self.addition_attention:
-            self.init_attn=TimestepEmbedSequential(
-                TemporalTransformer(
-                    model_channels,
-                    n_heads=8,
-                    d_head=num_head_channels,
-                    depth=transformer_depth,
-                    context_dim=context_dim,
-                    use_checkpoint=use_checkpoint, only_self_att=temporal_selfatt_only, 
-                    causal_attention=False, relative_position=use_relative_position, 
-                    temporal_length=temporal_length,
-                    device=device,
-                    dtype=self.dtype
-                    ))
-
-        input_block_chans = [model_channels]
-        ch = model_channels
-        ds = 1
-        for level, mult in enumerate(channel_mult):
-            for _ in range(num_res_blocks):
-                layers = [
-                    ResBlock(ch, time_embed_dim, dropout,
-                        out_channels=mult * model_channels, dims=dims, use_checkpoint=use_checkpoint,
-                        use_scale_shift_norm=use_scale_shift_norm, tempspatial_aware=tempspatial_aware,
-                        use_temporal_conv=temporal_conv,
-                        device=device,
-                        dtype=self.dtype
-                    )
-                ]
-                ch = mult * model_channels
-                if ds in attention_resolutions:
-                    if num_head_channels == -1:
-                        dim_head = ch // num_heads
-                    else:
-                        num_heads = ch // num_head_channels
-                        dim_head = num_head_channels
-                    layers.append(
-                        SpatialTransformer(ch, num_heads, dim_head, 
-                            depth=transformer_depth, context_dim=context_dim, use_linear=use_linear,
-                            use_checkpoint=use_checkpoint, disable_self_attn=False, 
-                            video_length=temporal_length, image_cross_attention=self.image_cross_attention,
-                            image_cross_attention_scale_learnable=self.image_cross_attention_scale_learnable, 
-                            device=device,
-                            dtype=self.dtype                     
-                        )
-                    )
-                    if self.temporal_attention:
-                        layers.append(
-                            TemporalTransformer(ch, num_heads, dim_head,
-                                depth=transformer_depth, context_dim=context_dim, use_linear=use_linear,
-                                use_checkpoint=use_checkpoint, only_self_att=temporal_self_att_only, 
-                                causal_attention=use_causal_attention, relative_position=use_relative_position, 
-                                temporal_length=temporal_length,
-                                device=device,
-                                dtype=self.dtype
-                            )
-                        )
-                self.input_blocks.append(TimestepEmbedSequential(*layers))
-                input_block_chans.append(ch)
-            if level != len(channel_mult) - 1:
-                out_ch = ch
-                self.input_blocks.append(
-                    TimestepEmbedSequential(
-                        ResBlock(ch, time_embed_dim, dropout, 
-                            out_channels=out_ch, dims=dims, use_checkpoint=use_checkpoint,
-                            use_scale_shift_norm=use_scale_shift_norm,
-                            down=True,
-                            device=device,
-                            dtype=self.dtype
-                        )
-                        if resblock_updown
-                        else Downsample(
-                            ch, 
-                            conv_resample, 
-                            dims=dims, 
-                            out_channels=out_ch,
-                            device=device,
-                            dtype=self.dtype
-                        )
-                    )
-                )
-                ch = out_ch
-                input_block_chans.append(ch)
-                ds *= 2
-
-        if num_head_channels == -1:
-            dim_head = ch // num_heads
-        else:
-            num_heads = ch // num_head_channels
-            dim_head = num_head_channels
-        layers = [
-            ResBlock(ch, time_embed_dim, dropout,
-                dims=dims, use_checkpoint=use_checkpoint,
-                use_scale_shift_norm=use_scale_shift_norm, tempspatial_aware=tempspatial_aware,
-                use_temporal_conv=temporal_conv,
-                device=device,
-                dtype=self.dtype
-            ),
-            SpatialTransformer(ch, num_heads, dim_head, 
-                depth=transformer_depth, context_dim=context_dim, use_linear=use_linear,
-                use_checkpoint=use_checkpoint, disable_self_attn=False, video_length=temporal_length, 
-                image_cross_attention=self.image_cross_attention,image_cross_attention_scale_learnable=self.image_cross_attention_scale_learnable,
-                device=device,
-                dtype=self.dtype
-            )
-        ]
-        if self.temporal_attention:
-            layers.append(
-                TemporalTransformer(ch, num_heads, dim_head,
-                    depth=transformer_depth, context_dim=context_dim, use_linear=use_linear,
-                    use_checkpoint=use_checkpoint, only_self_att=temporal_self_att_only, 
-                    causal_attention=use_causal_attention, relative_position=use_relative_position, 
-                    temporal_length=temporal_length,
-                    device=device,
-                    dtype=self.dtype
-                )
-            )
-        layers.append(
-            ResBlock(ch, time_embed_dim, dropout,
-                dims=dims, use_checkpoint=use_checkpoint,
-                use_scale_shift_norm=use_scale_shift_norm, tempspatial_aware=tempspatial_aware, 
-                use_temporal_conv=temporal_conv,
-                device=device,
-                dtype=self.dtype
-                )
-        )
-
-        ## Middle Block
-        self.middle_block = TimestepEmbedSequential(*layers)
-
-        ## Output Block
-        self.output_blocks = nn.ModuleList([])
-        for level, mult in list(enumerate(channel_mult))[::-1]:
-            for i in range(num_res_blocks + 1):
-                ich = input_block_chans.pop()
-                layers = [
-                    ResBlock(ch + ich, time_embed_dim, dropout,
-                        out_channels=mult * model_channels, dims=dims, use_checkpoint=use_checkpoint,
-                        use_scale_shift_norm=use_scale_shift_norm, tempspatial_aware=tempspatial_aware,
-                        use_temporal_conv=temporal_conv,
-                        device=device,
-                        dtype=self.dtype
-                    )
-                ]
-                ch = model_channels * mult
-                if ds in attention_resolutions:
-                    if num_head_channels == -1:
-                        dim_head = ch // num_heads
-                    else:
-                        num_heads = ch // num_head_channels
-                        dim_head = num_head_channels
-                    layers.append(
-                        SpatialTransformer(ch, num_heads, dim_head, 
-                            depth=transformer_depth, context_dim=context_dim, use_linear=use_linear,
-                            use_checkpoint=use_checkpoint, disable_self_attn=False, video_length=temporal_length,
-                            image_cross_attention=self.image_cross_attention,image_cross_attention_scale_learnable=self.image_cross_attention_scale_learnable,
-                            device=device,
-                            dtype=self.dtype
-                        )
-                    )
-                    if self.temporal_attention:
-                        layers.append(
-                            TemporalTransformer(ch, num_heads, dim_head,
-                                depth=transformer_depth, context_dim=context_dim, use_linear=use_linear,
-                                use_checkpoint=use_checkpoint, only_self_att=temporal_self_att_only, 
-                                causal_attention=use_causal_attention, relative_position=use_relative_position, 
-                                temporal_length=temporal_length,
-                                device=device,
-                                dtype=self.dtype
-                            )
-                        )
-                if level and i == num_res_blocks:
-                    out_ch = ch
-                    layers.append(
-                        ResBlock(ch, time_embed_dim, dropout,
-                            out_channels=out_ch, dims=dims, use_checkpoint=use_checkpoint,
-                            use_scale_shift_norm=use_scale_shift_norm,
-                            up=True,
-                            device=device,
-                            dtype=self.dtype
-                        )
-                        if resblock_updown
-                        else Upsample(ch, conv_resample, dims=dims, out_channels=out_ch)
-                    )
-                    ds //= 2
-                self.output_blocks.append(TimestepEmbedSequential(*layers))
-
-        self.out = nn.Sequential(
-            normalization(ch, device=device, dtype=self.dtype),
-            nn.SiLU(),
-            zero_module(
-                operations.conv_nd(
-                    dims, 
-                    model_channels, 
-                    out_channels, 
-                    3, 
-                    padding=1, 
-                    device=device, 
-                    dtype=self.dtype
-                )
-            ),
-        )
-
-    # TODO Add Transformer options to leverage the usage of patches.
-    def forward(
-            self, 
-            x, 
-            timesteps, 
-            context=None, 
-            context_in=None,
-            cc_concat=None,
-            num_video_frames=16,
-            features_adapter=None, 
-            fs=None, 
-            img_emb=None,
-            control=None,
-            transformer_options={}, 
-            cond_idx=None,
-            **kwargs
-        ):
-        
-        if any([fs is None, img_emb is None, cc_concat is None]):
-            raise ValueError("One or more of the required inputs for UNet Forward is None.")
-        
-        cond_idx = transformer_options.get("cond_idx", None)
-        transformer_options['original_shape'] = list(x.shape)
-        transformer_options['transformer_index'] = 0
-        transformer_patches = transformer_options.get("patches", {})
-
-        # In ComfyUI, the frames are always with the batch, so we deconstruct it here.
-        # This is mandatory as this is a video based model.
-        # We usually denote "f" as frames, but will use "t" (time) to be consistent with DynamiCrafter.
-        b,_,t,_,_ = x.shape
-        
-        context = context_in
-        cc_concat = cc_concat.to(x.device, x.dtype)
-        x = torch.cat([x, cc_concat], dim=1)
-
-        fs = fs.to(x.device, x.dtype)
-
-        timestep = timesteps
-        context = context_processor(context, num_video_frames, img_emb=img_emb)
-
-        t_emb = timestep_embedding(timestep, self.model_channels, repeat_only=False, dtype=self.dtype)
-        emb = self.time_embed(t_emb)
-        emb = emb.repeat_interleave(repeats=t, dim=0)
-        
-        ## always in shape (b t) c h w, except for temporal layer
-        x = rearrange(x, 'b c t h w -> (b t) c h w')
-
-        ## combine emb
-        if self.fs_condition:
-            if fs is None:
-                fs = torch.tensor(
-                    [self.default_fs] * b, dtype=torch.long, device=x.device)
-            fs_emb = timestep_embedding(fs, self.model_channels, repeat_only=False, dtype=self.dtype).type(x.dtype)
-
-            fs_embed = self.fps_embedding(fs_emb)
-            fs_embed = fs_embed.repeat_interleave(repeats=t, dim=0)
-
-            emb = emb + fs_embed
-
-        h = x.type(self.dtype)
-        adapter_idx = 0
-        hs = []
-
-        for id, module in enumerate(self.input_blocks):
-            transformer_options["block"] = ("input", id)
-            #h = module(h, emb, context=context, batch_size=b)
-            h = forward_timestep_embed(
-                module, 
-                h, 
-                emb, 
-                context=context, 
-                batch_size=b, 
-                transformer_options=transformer_options
-            )
-            h = apply_control(h, control, 'input', cond_idx)
-
-            if "input_block_patch" in transformer_patches:
-                patch = transformer_patches["input_block_patch"]
-                for p in patch:
-                    h = p(h, transformer_options)
-
-            if id ==0 and self.addition_attention:
-                h = forward_timestep_embed(
-                self.init_attn, 
-                h, 
-                emb, 
-                context=context, 
-                batch_size=b, 
-                transformer_options=transformer_options
-            )
-            ## plug-in adapter features
-            if ((id+1)%3 == 0) and features_adapter is not None:
-                h = h + features_adapter[adapter_idx]
-                adapter_idx += 1
-            hs.append(h)
-            if "input_block_patch_after_skip" in transformer_patches:
-                patch = transformer_patches["input_block_patch_after_skip"]
-                for p in patch:
-                    h = p(h, transformer_options)
-        if features_adapter is not None:
-            assert len(features_adapter)==adapter_idx, 'Wrong features_adapter'
-        transformer_options["block"] = ("middle", 0)
-        h = forward_timestep_embed(
-                self.middle_block, 
-                h, 
-                emb, 
-                context=context, 
-                batch_size=b, 
-                transformer_options=transformer_options
-            )
-        h = apply_control(h, control, 'middle', cond_idx)
-        for id, module in enumerate(self.output_blocks):
-            transformer_options["block"] = ("output", id)
-            hsp = hs.pop()
-            hsp = apply_control(hsp, control, 'output', cond_idx)
-
-            if "output_block_patch" in transformer_patches:
-                patch = transformer_patches["output_block_patch"]
-                for p in patch:
-                    h, hsp = p(h, hsp, transformer_options)
-
-            h = torch.cat([h, hsp], dim=1)
-            del hsp
-            h = forward_timestep_embed(
-                module, 
-                h, 
-                emb, 
-                context=context, 
-                batch_size=b, 
-                transformer_options=transformer_options
-            )
-        h = h.type(x.dtype)
-        h = self.out(h)
-        
-        # We output with the tensor unfolded framewise, then reshape them to batched using ComfyUI nodes.
-        h = rearrange(h, '(b t) c h w -> b c t h w', t=num_video_frames)
-        
-        return h
@@ -1,639 +0,0 @@
-"""shout-out to https://github.com/lucidrains/x-transformers/tree/main/x_transformers"""
-from functools import partial
-from inspect import isfunction
-from collections import namedtuple
-from einops import rearrange, repeat
-import torch
-from torch import nn, einsum
-import torch.nn.functional as F
-
-# constants
-DEFAULT_DIM_HEAD = 64
-
-Intermediates = namedtuple('Intermediates', [
-    'pre_softmax_attn',
-    'post_softmax_attn'
-])
-
-LayerIntermediates = namedtuple('Intermediates', [
-    'hiddens',
-    'attn_intermediates'
-])
-
-
-class AbsolutePositionalEmbedding(nn.Module):
-    def __init__(self, dim, max_seq_len):
-        super().__init__()
-        self.emb = nn.Embedding(max_seq_len, dim)
-        self.init_()
-
-    def init_(self):
-        nn.init.normal_(self.emb.weight, std=0.02)
-
-    def forward(self, x):
-        n = torch.arange(x.shape[1], device=x.device)
-        return self.emb(n)[None, :, :]
-
-
-class FixedPositionalEmbedding(nn.Module):
-    def __init__(self, dim):
-        super().__init__()
-        inv_freq = 1. / (10000 ** (torch.arange(0, dim, 2).float() / dim))
-        self.register_buffer('inv_freq', inv_freq)
-
-    def forward(self, x, seq_dim=1, offset=0):
-        t = torch.arange(x.shape[seq_dim], device=x.device).type_as(self.inv_freq) + offset
-        sinusoid_inp = torch.einsum('i , j -> i j', t, self.inv_freq)
-        emb = torch.cat((sinusoid_inp.sin(), sinusoid_inp.cos()), dim=-1)
-        return emb[None, :, :]
-
-
-# helpers
-
-def exists(val):
-    return val is not None
-
-
-def default(val, d):
-    if exists(val):
-        return val
-    return d() if isfunction(d) else d
-
-
-def always(val):
-    def inner(*args, **kwargs):
-        return val
-    return inner
-
-
-def not_equals(val):
-    def inner(x):
-        return x != val
-    return inner
-
-
-def equals(val):
-    def inner(x):
-        return x == val
-    return inner
-
-
-def max_neg_value(tensor):
-    return -torch.finfo(tensor.dtype).max
-
-
-# keyword argument helpers
-
-def pick_and_pop(keys, d):
-    values = list(map(lambda key: d.pop(key), keys))
-    return dict(zip(keys, values))
-
-
-def group_dict_by_key(cond, d):
-    return_val = [dict(), dict()]
-    for key in d.keys():
-        match = bool(cond(key))
-        ind = int(not match)
-        return_val[ind][key] = d[key]
-    return (*return_val,)
-
-
-def string_begins_with(prefix, str):
-    return str.startswith(prefix)
-
-
-def group_by_key_prefix(prefix, d):
-    return group_dict_by_key(partial(string_begins_with, prefix), d)
-
-
-def groupby_prefix_and_trim(prefix, d):
-    kwargs_with_prefix, kwargs = group_dict_by_key(partial(string_begins_with, prefix), d)
-    kwargs_without_prefix = dict(map(lambda x: (x[0][len(prefix):], x[1]), tuple(kwargs_with_prefix.items())))
-    return kwargs_without_prefix, kwargs
-
-
-# classes
-class Scale(nn.Module):
-    def __init__(self, value, fn):
-        super().__init__()
-        self.value = value
-        self.fn = fn
-
-    def forward(self, x, **kwargs):
-        x, *rest = self.fn(x, **kwargs)
-        return (x * self.value, *rest)
-
-
-class Rezero(nn.Module):
-    def __init__(self, fn):
-        super().__init__()
-        self.fn = fn
-        self.g = nn.Parameter(torch.zeros(1))
-
-    def forward(self, x, **kwargs):
-        x, *rest = self.fn(x, **kwargs)
-        return (x * self.g, *rest)
-
-
-class ScaleNorm(nn.Module):
-    def __init__(self, dim, eps=1e-5):
-        super().__init__()
-        self.scale = dim ** -0.5
-        self.eps = eps
-        self.g = nn.Parameter(torch.ones(1))
-
-    def forward(self, x):
-        norm = torch.norm(x, dim=-1, keepdim=True) * self.scale
-        return x / norm.clamp(min=self.eps) * self.g
-
-
-class RMSNorm(nn.Module):
-    def __init__(self, dim, eps=1e-8):
-        super().__init__()
-        self.scale = dim ** -0.5
-        self.eps = eps
-        self.g = nn.Parameter(torch.ones(dim))
-
-    def forward(self, x):
-        norm = torch.norm(x, dim=-1, keepdim=True) * self.scale
-        return x / norm.clamp(min=self.eps) * self.g
-
-
-class Residual(nn.Module):
-    def forward(self, x, residual):
-        return x + residual
-
-
-class GRUGating(nn.Module):
-    def __init__(self, dim):
-        super().__init__()
-        self.gru = nn.GRUCell(dim, dim)
-
-    def forward(self, x, residual):
-        gated_output = self.gru(
-            rearrange(x, 'b n d -> (b n) d'),
-            rearrange(residual, 'b n d -> (b n) d')
-        )
-
-        return gated_output.reshape_as(x)
-
-
-# feedforward
-
-class GEGLU(nn.Module):
-    def __init__(self, dim_in, dim_out):
-        super().__init__()
-        self.proj = nn.Linear(dim_in, dim_out * 2)
-
-    def forward(self, x):
-        x, gate = self.proj(x).chunk(2, dim=-1)
-        return x * F.gelu(gate)
-
-
-class FeedForward(nn.Module):
-    def __init__(self, dim, dim_out=None, mult=4, glu=False, dropout=0.):
-        super().__init__()
-        inner_dim = int(dim * mult)
-        dim_out = default(dim_out, dim)
-        project_in = nn.Sequential(
-            nn.Linear(dim, inner_dim),
-            nn.GELU()
-        ) if not glu else GEGLU(dim, inner_dim)
-
-        self.net = nn.Sequential(
-            project_in,
-            nn.Dropout(dropout),
-            nn.Linear(inner_dim, dim_out)
-        )
-
-    def forward(self, x):
-        return self.net(x)
-
-
-# attention.
-class Attention(nn.Module):
-    def __init__(
-            self,
-            dim,
-            dim_head=DEFAULT_DIM_HEAD,
-            heads=8,
-            causal=False,
-            mask=None,
-            talking_heads=False,
-            sparse_topk=None,
-            use_entmax15=False,
-            num_mem_kv=0,
-            dropout=0.,
-            on_attn=False
-    ):
-        super().__init__()
-        if use_entmax15:
-            raise NotImplementedError("Check out entmax activation instead of softmax activation!")
-        self.scale = dim_head ** -0.5
-        self.heads = heads
-        self.causal = causal
-        self.mask = mask
-
-        inner_dim = dim_head * heads
-
-        self.to_q = nn.Linear(dim, inner_dim, bias=False)
-        self.to_k = nn.Linear(dim, inner_dim, bias=False)
-        self.to_v = nn.Linear(dim, inner_dim, bias=False)
-        self.dropout = nn.Dropout(dropout)
-
-        # talking heads
-        self.talking_heads = talking_heads
-        if talking_heads:
-            self.pre_softmax_proj = nn.Parameter(torch.randn(heads, heads))
-            self.post_softmax_proj = nn.Parameter(torch.randn(heads, heads))
-
-        # explicit topk sparse attention
-        self.sparse_topk = sparse_topk
-
-        # entmax
-        #self.attn_fn = entmax15 if use_entmax15 else F.softmax
-        self.attn_fn = F.softmax
-
-        # add memory key / values
-        self.num_mem_kv = num_mem_kv
-        if num_mem_kv > 0:
-            self.mem_k = nn.Parameter(torch.randn(heads, num_mem_kv, dim_head))
-            self.mem_v = nn.Parameter(torch.randn(heads, num_mem_kv, dim_head))
-
-        # attention on attention
-        self.attn_on_attn = on_attn
-        self.to_out = nn.Sequential(nn.Linear(inner_dim, dim * 2), nn.GLU()) if on_attn else nn.Linear(inner_dim, dim)
-
-    def forward(
-            self,
-            x,
-            context=None,
-            mask=None,
-            context_mask=None,
-            rel_pos=None,
-            sinusoidal_emb=None,
-            prev_attn=None,
-            mem=None
-    ):
-        b, n, _, h, talking_heads, device = *x.shape, self.heads, self.talking_heads, x.device
-        kv_input = default(context, x)
-
-        q_input = x
-        k_input = kv_input
-        v_input = kv_input
-
-        if exists(mem):
-            k_input = torch.cat((mem, k_input), dim=-2)
-            v_input = torch.cat((mem, v_input), dim=-2)
-
-        if exists(sinusoidal_emb):
-            # in shortformer, the query would start at a position offset depending on the past cached memory
-            offset = k_input.shape[-2] - q_input.shape[-2]
-            q_input = q_input + sinusoidal_emb(q_input, offset=offset)
-            k_input = k_input + sinusoidal_emb(k_input)
-
-        q = self.to_q(q_input)
-        k = self.to_k(k_input)
-        v = self.to_v(v_input)
-
-        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h=h), (q, k, v))
-
-        input_mask = None
-        if any(map(exists, (mask, context_mask))):
-            q_mask = default(mask, lambda: torch.ones((b, n), device=device).bool())
-            k_mask = q_mask if not exists(context) else context_mask
-            k_mask = default(k_mask, lambda: torch.ones((b, k.shape[-2]), device=device).bool())
-            q_mask = rearrange(q_mask, 'b i -> b () i ()')
-            k_mask = rearrange(k_mask, 'b j -> b () () j')
-            input_mask = q_mask * k_mask
-
-        if self.num_mem_kv > 0:
-            mem_k, mem_v = map(lambda t: repeat(t, 'h n d -> b h n d', b=b), (self.mem_k, self.mem_v))
-            k = torch.cat((mem_k, k), dim=-2)
-            v = torch.cat((mem_v, v), dim=-2)
-            if exists(input_mask):
-                input_mask = F.pad(input_mask, (self.num_mem_kv, 0), value=True)
-
-        dots = einsum('b h i d, b h j d -> b h i j', q, k) * self.scale
-        mask_value = max_neg_value(dots)
-
-        if exists(prev_attn):
-            dots = dots + prev_attn
-
-        pre_softmax_attn = dots
-
-        if talking_heads:
-            dots = einsum('b h i j, h k -> b k i j', dots, self.pre_softmax_proj).contiguous()
-
-        if exists(rel_pos):
-            dots = rel_pos(dots)
-
-        if exists(input_mask):
-            dots.masked_fill_(~input_mask, mask_value)
-            del input_mask
-
-        if self.causal:
-            i, j = dots.shape[-2:]
-            r = torch.arange(i, device=device)
-            mask = rearrange(r, 'i -> () () i ()') < rearrange(r, 'j -> () () () j')
-            mask = F.pad(mask, (j - i, 0), value=False)
-            dots.masked_fill_(mask, mask_value)
-            del mask
-
-        if exists(self.sparse_topk) and self.sparse_topk < dots.shape[-1]:
-            top, _ = dots.topk(self.sparse_topk, dim=-1)
-            vk = top[..., -1].unsqueeze(-1).expand_as(dots)
-            mask = dots < vk
-            dots.masked_fill_(mask, mask_value)
-            del mask
-
-        attn = self.attn_fn(dots, dim=-1)
-        post_softmax_attn = attn
-
-        attn = self.dropout(attn)
-
-        if talking_heads:
-            attn = einsum('b h i j, h k -> b k i j', attn, self.post_softmax_proj).contiguous()
-
-        out = einsum('b h i j, b h j d -> b h i d', attn, v)
-        out = rearrange(out, 'b h n d -> b n (h d)')
-
-        intermediates = Intermediates(
-            pre_softmax_attn=pre_softmax_attn,
-            post_softmax_attn=post_softmax_attn
-        )
-
-        return self.to_out(out), intermediates
-
-
-class AttentionLayers(nn.Module):
-    def __init__(
-            self,
-            dim,
-            depth,
-            heads=8,
-            causal=False,
-            cross_attend=False,
-            only_cross=False,
-            use_scalenorm=False,
-            use_rmsnorm=False,
-            use_rezero=False,
-            rel_pos_num_buckets=32,
-            rel_pos_max_distance=128,
-            position_infused_attn=False,
-            custom_layers=None,
-            sandwich_coef=None,
-            par_ratio=None,
-            residual_attn=False,
-            cross_residual_attn=False,
-            macaron=False,
-            pre_norm=True,
-            gate_residual=False,
-            **kwargs
-    ):
-        super().__init__()
-        ff_kwargs, kwargs = groupby_prefix_and_trim('ff_', kwargs)
-        attn_kwargs, _ = groupby_prefix_and_trim('attn_', kwargs)
-
-        dim_head = attn_kwargs.get('dim_head', DEFAULT_DIM_HEAD)
-
-        self.dim = dim
-        self.depth = depth
-        self.layers = nn.ModuleList([])
-
-        self.has_pos_emb = position_infused_attn
-        self.pia_pos_emb = FixedPositionalEmbedding(dim) if position_infused_attn else None
-        self.rotary_pos_emb = always(None)
-
-        assert rel_pos_num_buckets <= rel_pos_max_distance, 'number of relative position buckets must be less than the relative position max distance'
-        self.rel_pos = None
-
-        self.pre_norm = pre_norm
-
-        self.residual_attn = residual_attn
-        self.cross_residual_attn = cross_residual_attn
-
-        norm_class = ScaleNorm if use_scalenorm else nn.LayerNorm
-        norm_class = RMSNorm if use_rmsnorm else norm_class
-        norm_fn = partial(norm_class, dim)
-
-        norm_fn = nn.Identity if use_rezero else norm_fn
-        branch_fn = Rezero if use_rezero else None
-
-        if cross_attend and not only_cross:
-            default_block = ('a', 'c', 'f')
-        elif cross_attend and only_cross:
-            default_block = ('c', 'f')
-        else:
-            default_block = ('a', 'f')
-
-        if macaron:
-            default_block = ('f',) + default_block
-
-        if exists(custom_layers):
-            layer_types = custom_layers
-        elif exists(par_ratio):
-            par_depth = depth * len(default_block)
-            assert 1 < par_ratio <= par_depth, 'par ratio out of range'
-            default_block = tuple(filter(not_equals('f'), default_block))
-            par_attn = par_depth // par_ratio
-            depth_cut = par_depth * 2 // 3  # 2 / 3 attention layer cutoff suggested by PAR paper
-            par_width = (depth_cut + depth_cut // par_attn) // par_attn
-            assert len(default_block) <= par_width, 'default block is too large for par_ratio'
-            par_block = default_block + ('f',) * (par_width - len(default_block))
-            par_head = par_block * par_attn
-            layer_types = par_head + ('f',) * (par_depth - len(par_head))
-        elif exists(sandwich_coef):
-            assert sandwich_coef > 0 and sandwich_coef <= depth, 'sandwich coefficient should be less than the depth'
-            layer_types = ('a',) * sandwich_coef + default_block * (depth - sandwich_coef) + ('f',) * sandwich_coef
-        else:
-            layer_types = default_block * depth
-
-        self.layer_types = layer_types
-        self.num_attn_layers = len(list(filter(equals('a'), layer_types)))
-
-        for layer_type in self.layer_types:
-            if layer_type == 'a':
-                layer = Attention(dim, heads=heads, causal=causal, **attn_kwargs)
-            elif layer_type == 'c':
-                layer = Attention(dim, heads=heads, **attn_kwargs)
-            elif layer_type == 'f':
-                layer = FeedForward(dim, **ff_kwargs)
-                layer = layer if not macaron else Scale(0.5, layer)
-            else:
-                raise Exception(f'invalid layer type {layer_type}')
-
-            if isinstance(layer, Attention) and exists(branch_fn):
-                layer = branch_fn(layer)
-
-            if gate_residual:
-                residual_fn = GRUGating(dim)
-            else:
-                residual_fn = Residual()
-
-            self.layers.append(nn.ModuleList([
-                norm_fn(),
-                layer,
-                residual_fn
-            ]))
-
-    def forward(
-            self,
-            x,
-            context=None,
-            mask=None,
-            context_mask=None,
-            mems=None,
-            return_hiddens=False
-    ):
-        hiddens = []
-        intermediates = []
-        prev_attn = None
-        prev_cross_attn = None
-
-        mems = mems.copy() if exists(mems) else [None] * self.num_attn_layers
-
-        for ind, (layer_type, (norm, block, residual_fn)) in enumerate(zip(self.layer_types, self.layers)):
-            is_last = ind == (len(self.layers) - 1)
-
-            if layer_type == 'a':
-                hiddens.append(x)
-                layer_mem = mems.pop(0)
-
-            residual = x
-
-            if self.pre_norm:
-                x = norm(x)
-
-            if layer_type == 'a':
-                out, inter = block(x, mask=mask, sinusoidal_emb=self.pia_pos_emb, rel_pos=self.rel_pos,
-                                   prev_attn=prev_attn, mem=layer_mem)
-            elif layer_type == 'c':
-                out, inter = block(x, context=context, mask=mask, context_mask=context_mask, prev_attn=prev_cross_attn)
-            elif layer_type == 'f':
-                out = block(x)
-
-            x = residual_fn(out, residual)
-
-            if layer_type in ('a', 'c'):
-                intermediates.append(inter)
-
-            if layer_type == 'a' and self.residual_attn:
-                prev_attn = inter.pre_softmax_attn
-            elif layer_type == 'c' and self.cross_residual_attn:
-                prev_cross_attn = inter.pre_softmax_attn
-
-            if not self.pre_norm and not is_last:
-                x = norm(x)
-
-        if return_hiddens:
-            intermediates = LayerIntermediates(
-                hiddens=hiddens,
-                attn_intermediates=intermediates
-            )
-
-            return x, intermediates
-
-        return x
-
-
-class Encoder(AttentionLayers):
-    def __init__(self, **kwargs):
-        assert 'causal' not in kwargs, 'cannot set causality on encoder'
-        super().__init__(causal=False, **kwargs)
-
-
-
-class TransformerWrapper(nn.Module):
-    def __init__(
-            self,
-            *,
-            num_tokens,
-            max_seq_len,
-            attn_layers,
-            emb_dim=None,
-            max_mem_len=0.,
-            emb_dropout=0.,
-            num_memory_tokens=None,
-            tie_embedding=False,
-            use_pos_emb=True
-    ):
-        super().__init__()
-        assert isinstance(attn_layers, AttentionLayers), 'attention layers must be one of Encoder or Decoder'
-
-        dim = attn_layers.dim
-        emb_dim = default(emb_dim, dim)
-
-        self.max_seq_len = max_seq_len
-        self.max_mem_len = max_mem_len
-        self.num_tokens = num_tokens
-
-        self.token_emb = nn.Embedding(num_tokens, emb_dim)
-        self.pos_emb = AbsolutePositionalEmbedding(emb_dim, max_seq_len) if (
-                    use_pos_emb and not attn_layers.has_pos_emb) else always(0)
-        self.emb_dropout = nn.Dropout(emb_dropout)
-
-        self.project_emb = nn.Linear(emb_dim, dim) if emb_dim != dim else nn.Identity()
-        self.attn_layers = attn_layers
-        self.norm = nn.LayerNorm(dim)
-
-        self.init_()
-
-        self.to_logits = nn.Linear(dim, num_tokens) if not tie_embedding else lambda t: t @ self.token_emb.weight.t()
-
-        # memory tokens (like [cls]) from Memory Transformers paper
-        num_memory_tokens = default(num_memory_tokens, 0)
-        self.num_memory_tokens = num_memory_tokens
-        if num_memory_tokens > 0:
-            self.memory_tokens = nn.Parameter(torch.randn(num_memory_tokens, dim))
-
-            # let funnel encoder know number of memory tokens, if specified
-            if hasattr(attn_layers, 'num_memory_tokens'):
-                attn_layers.num_memory_tokens = num_memory_tokens
-
-    def init_(self):
-        nn.init.normal_(self.token_emb.weight, std=0.02)
-
-    def forward(
-            self,
-            x,
-            return_embeddings=False,
-            mask=None,
-            return_mems=False,
-            return_attn=False,
-            mems=None,
-            **kwargs
-    ):
-        b, n, device, num_mem = *x.shape, x.device, self.num_memory_tokens
-        x = self.token_emb(x)
-        x += self.pos_emb(x)
-        x = self.emb_dropout(x)
-
-        x = self.project_emb(x)
-
-        if num_mem > 0:
-            mem = repeat(self.memory_tokens, 'n d -> b n d', b=b)
-            x = torch.cat((mem, x), dim=1)
-
-            # auto-handle masking after appending memory tokens
-            if exists(mask):
-                mask = F.pad(mask, (num_mem, 0), value=True)
-
-        x, intermediates = self.attn_layers(x, mask=mask, mems=mems, return_hiddens=True, **kwargs)
-        x = self.norm(x)
-
-        mem, x = x[:, :num_mem], x[:, num_mem:]
-
-        out = self.to_logits(x) if not return_embeddings else x
-
-        if return_mems:
-            hiddens = intermediates.hiddens
-            new_mems = list(map(lambda pair: torch.cat(pair, dim=-2), zip(mems, hiddens))) if exists(mems) else hiddens
-            new_mems = list(map(lambda t: t[..., -self.max_mem_len:, :].detach(), new_mems))
-            return out, new_mems
-
-        if return_attn:
-            attn_maps = list(map(lambda t: t.post_softmax_attn, intermediates.attn_intermediates))
-            return out, attn_maps
-
-        return out
@@ -1,146 +0,0 @@
-
-import torch
-
-from collections import OrderedDict
-
-from comfy import model_base
-from comfy import utils
-from comfy import diffusers_convert
-
-try:
-    import comfy.text_encoders.sd2_clip
-except ImportError:
-    from comfy import sd2_clip
-
-from comfy import supported_models_base
-from comfy import latent_formats
-
-from ..lvdm.modules.encoders.resampler import Resampler
-
-DYNAMICRAFTER_CONFIG = {
-    'in_channels': 8,
-    'out_channels': 4,
-    'model_channels': 320,
-    'attention_resolutions': [4, 2, 1],
-    'num_res_blocks': 2,
-    'channel_mult': [1, 2, 4, 4],
-    'num_head_channels': 64,
-    'transformer_depth': 1,
-    'context_dim': 1024,
-    'use_linear': True,
-    'use_checkpoint': False,
-    'temporal_conv': True,
-    'temporal_attention': True,
-    'temporal_selfatt_only': True,
-    'use_relative_position': False,
-    'use_causal_attention': False,
-    'temporal_length': 16,
-    'addition_attention': True,
-    'image_cross_attention': True,
-    'image_cross_attention_scale_learnable': True,
-    'default_fs': 3,
-    'fs_condition': True
-}
-
-IMAGE_PROJ_CONFIG = {
-    "dim": 1024,
-    "depth": 4,
-    "dim_head": 64,
-    "heads": 12,
-    "num_queries": 16,
-    "embedding_dim": 1280,
-    "output_dim": 1024,
-    "ff_mult": 4,
-    "video_length": 16
-}
-
-def process_list_or_str(target_key_or_keys, k):
-    if isinstance(target_key_or_keys, list):
-        return any([list_k in k for list_k in target_key_or_keys])
-    else:
-        return target_key_or_keys in k
-
-def simple_state_dict_loader(state_dict: dict, target_key: str, target_dict: dict = None):
-    out_dict = {}
-    
-    if target_dict is None:
-        for k, v in state_dict.items():
-            if process_list_or_str(target_key, k):
-                out_dict[k] = v
-    else:
-        for k, v in target_dict.items():
-            out_dict[k] = state_dict[k]
-            
-    return out_dict
-
-def load_image_proj_dict(state_dict: dict):
-    return simple_state_dict_loader(state_dict, 'image_proj')
-
-def load_dynamicrafter_dict(state_dict: dict):
-    return simple_state_dict_loader(state_dict, 'model.diffusion_model')
-
-def load_vae_dict(state_dict: dict):
-    return simple_state_dict_loader(state_dict, 'first_stage_model')
-
-def get_base_model(state_dict: dict, version_checker=False):
-
-    is_256_model = False
-
-    for k in state_dict.keys():
-         if "framestride_embed" in k:
-            is_256_model = True
-            break
-
-def get_image_proj_model(state_dict: dict):
-
-    state_dict = {k.replace('image_proj_model.', ''): v for k, v in state_dict.items()}
-    #target_dict = Resampler().state_dict()
-
-    ImageProjModel = Resampler(**IMAGE_PROJ_CONFIG)
-    ImageProjModel.load_state_dict(state_dict)
-
-    print("Image Projection Model loaded successfully")
-    #del target_dict
-    return ImageProjModel
-
-class DynamiCrafterBase(supported_models_base.BASE):
-    unet_config = {}
-    unet_extra_config = {}
-
-    latent_format = latent_formats.SD15
-
-    def process_clip_state_dict(self, state_dict):
-        replace_prefix = {}
-        replace_prefix["conditioner.embedders.0.model."] = "clip_h." #SD2 in sgm format
-        replace_prefix["cond_stage_model.model."] = "clip_h."
-        state_dict = utils.state_dict_prefix_replace(state_dict, replace_prefix, filter_keys=True)
-        state_dict = utils.clip_text_transformers_convert(state_dict, "clip_h.", "clip_h.transformer.")
-        return state_dict
-
-    def process_clip_state_dict_for_saving(self, state_dict):
-        replace_prefix = {}
-        replace_prefix["clip_h"] = "cond_stage_model.model"
-        state_dict = utils.state_dict_prefix_replace(state_dict, replace_prefix)
-        state_dict = diffusers_convert.convert_text_enc_state_dict_v20(state_dict)
-        return state_dict
-
-    def clip_target(self):
-        return supported_models_base.ClipTarget(sd2_clip.SD2Tokenizer, sd2_clip.SD2ClipModel)
-
-    def process_dict_version(self, state_dict: dict):
-        processed_dict = OrderedDict()
-        is_eps = False
-        
-        for k in list(state_dict.keys()):
-            if "framestride_embed" in k:
-                new_key = k.replace("framestride_embed", "fps_embedding")
-                processed_dict[new_key] = state_dict[k]
-                is_eps = True
-                continue
-            
-            processed_dict[k] = state_dict[k]
-
-        return processed_dict, is_eps
-
-
-
@@ -1,82 +0,0 @@
-import importlib
-import numpy as np
-import cv2
-import torch
-import torch.distributed as dist
-
-MODEL_EXTS = ['ckpt', 'safetensors', 'bin']
-
-def get_models_directory(directory: list):
-    files_list = list(filter(lambda f: f.split(".")[-1] in MODEL_EXTS, directory))
-    return files_list
-
-def count_params(model, verbose=False):
-    total_params = sum(p.numel() for p in model.parameters())
-    if verbose:
-        print(f"{model.__class__.__name__} has {total_params*1.e-6:.2f} M params.")
-    return total_params
-
-
-def check_istarget(name, para_list):
-    """ 
-    name: full name of source para
-    para_list: partial name of target para 
-    """
-    istarget=False
-    for para in para_list:
-        if para in name:
-            return True
-    return istarget
-
-
-def instantiate_from_config(config):
-    if not "target" in config:
-        if config == '__is_first_stage__':
-            return None
-        elif config == "__is_unconditional__":
-            return None
-        raise KeyError("Expected key `target` to instantiate.")
-    return get_obj_from_str(config["target"])(**config.get("params", dict()))
-
-
-def get_obj_from_str(string, reload=False):
-    module, cls = string.rsplit(".", 1)
-    if reload:
-        module_imp = importlib.import_module(module)
-        importlib.reload(module_imp)
-    return getattr(importlib.import_module(module, package=None), cls)
-
-
-def load_npz_from_dir(data_dir):
-    data = [np.load(os.path.join(data_dir, data_name))['arr_0'] for data_name in os.listdir(data_dir)]
-    data = np.concatenate(data, axis=0)
-    return data
-
-
-def load_npz_from_paths(data_paths):
-    data = [np.load(data_path)['arr_0'] for data_path in data_paths]
-    data = np.concatenate(data, axis=0)
-    return data   
-
-
-def resize_numpy_image(image, max_resolution=512 * 512, resize_short_edge=None):
-    h, w = image.shape[:2]
-    if resize_short_edge is not None:
-        k = resize_short_edge / min(h, w)
-    else:
-        k = max_resolution / (h * w)
-        k = k**0.5
-    h = int(np.round(h * k / 64)) * 64
-    w = int(np.round(w * k / 64)) * 64
-    image = cv2.resize(image, (w, h), interpolation=cv2.INTER_LANCZOS4)
-    return image
-
-
-def setup_dist(args):
-    if dist.is_initialized():
-        return
-    torch.cuda.set_device(args.local_rank)
-    torch.distributed.init_process_group(
-        'nccl',
-        init_method='env://'
-    )
@@ -0,0 +1,372 @@
+import yaml
+import pathlib
+import base64
+import io
+import json
+import os
+import pickle
+import zlib
+import urllib.parse
+import urllib.request
+import urllib.error
+from enum import Enum
+from functools import singledispatch
+from typing import Any, List, Union
+
+import numpy as np
+import torch
+from PIL import Image
+
+root_path = pathlib.Path(__file__).parent.parent.parent.parent
+config_path = os.path.join(root_path, 'config.yaml')
+
+class BizyAIRAPI:
+    def __init__(self):
+        self.base_url = 'https://bizyair-api.siliconflow.cn/x/v1'
+        self.api_key = None
+
+
+    def getAPIKey(self):
+        if self.api_key is None:
+            if os.path.isfile(config_path):
+                with open(config_path, 'r') as f:
+                    data = yaml.load(f, Loader=yaml.FullLoader)
+                    if 'BIZYAIR_API_KEY' not in data:
+                        raise Exception("Please add BIZYAIR_API_KEY to config.yaml")
+                    self.api_key = data['BIZYAIR_API_KEY']
+            else:
+                raise Exception("Please add config.yaml to root path")
+        return self.api_key
+
+    def send_post_request(self, url, payload, headers):
+        try:
+            data = json.dumps(payload).encode("utf-8")
+            req = urllib.request.Request(url, data=data, headers=headers, method="POST")
+            with urllib.request.urlopen(req) as response:
+                response_data = response.read().decode("utf-8")
+            return response_data
+        except urllib.error.URLError as e:
+            if "Unauthorized" in str(e):
+                raise Exception(
+                    "Key is invalid, please refer to https://cloud.siliconflow.cn to get the API key.\n"
+                    "If you have the key, please click the 'BizyAir Key' button at the bottom right to set the key."
+                )
+            else:
+                raise Exception(
+                    f"Failed to connect to the server: {e}, if you have no key, "
+                )
+
+    # joycaption
+    def joyCaption(self, payload, image, apikey_override=None, API_URL='/supernode/joycaption2'):
+        if apikey_override is not None:
+            api_key = apikey_override
+        else:
+            api_key = self.getAPIKey()
+        url = f"{self.base_url}{API_URL}"
+        print('Sending request to:', url)
+        auth = f"Bearer {api_key}"
+        headers = {
+            "accept": "application/json",
+            "content-type": "application/json",
+            "authorization": auth,
+        }
+        input_image = encode_data(image, disable_image_marker=True)
+        payload["image"] = input_image
+
+        ret: str = self.send_post_request(url=url, payload=payload, headers=headers)
+        ret = json.loads(ret)
+
+        try:
+            if "result" in ret:
+                ret = json.loads(ret["result"])
+        except Exception as e:
+            raise Exception(f"Unexpected response: {ret} {e=}")
+
+        if ret["type"] == "error":
+            raise Exception(ret["message"])
+
+        msg = ret["data"]
+        if msg["type"] not in ("comfyair", "bizyair",):
+            raise Exception(f"Unexpected response type: {msg}")
+
+        caption = msg["data"]
+
+        return caption
+
+bizyairAPI = BizyAIRAPI()
+
+
+
+BIZYAIR_DEBUG = True
+# Marker to identify base64-encoded tensors
+TENSOR_MARKER = "TENSOR:"
+IMAGE_MARKER = "IMAGE:"
+
+
+class TaskStatus(Enum):
+    PENDING = "pending"
+    PROCESSING = "processing"
+    COMPLETED = "completed"
+
+
+def convert_image_to_rgb(image: Image.Image) -> Image.Image:
+    if image.mode != "RGB":
+        return image.convert("RGB")
+    return image
+
+
+def encode_image_to_base64(
+    image: Image.Image, format: str = "png", quality: int = 100, lossless=False
+) -> str:
+    image = convert_image_to_rgb(image)
+    with io.BytesIO() as output:
+        image.save(output, format=format, quality=quality, lossless=lossless)
+        output.seek(0)
+        img_bytes = output.getvalue()
+        if BIZYAIR_DEBUG:
+            print(f"encode_image_to_base64: {format_bytes(len(img_bytes))}")
+    return base64.b64encode(img_bytes).decode("utf-8")
+
+
+def decode_base64_to_np(img_data: str, format: str = "png") -> np.ndarray:
+    img_bytes = base64.b64decode(img_data)
+    if BIZYAIR_DEBUG:
+        print(f"decode_base64_to_np: {format_bytes(len(img_bytes))}")
+    with io.BytesIO(img_bytes) as input_buffer:
+        img = Image.open(input_buffer)
+        # https://github.com/comfyanonymous/ComfyUI/blob/a178e25912b01abf436eba1cfaab316ba02d272d/nodes.py#L1511
+        img = img.convert("RGB")
+        return np.array(img)
+
+
+def decode_base64_to_image(img_data: str) -> Image.Image:
+    img_bytes = base64.b64decode(img_data)
+    with io.BytesIO(img_bytes) as input_buffer:
+        img = Image.open(input_buffer)
+        if BIZYAIR_DEBUG:
+            format_info = img.format.upper() if img.format else "Unknown"
+            print(f"decode image format: {format_info}")
+        return img
+
+
+def format_bytes(num_bytes: int) -> str:
+    """
+    Converts a number of bytes to a human-readable string with units (B, KB, or MB).
+
+    :param num_bytes: The number of bytes to convert.
+    :return: A string representing the number of bytes in a human-readable format.
+    """
+    if num_bytes < 1024:
+        return f"{num_bytes} B"
+    elif num_bytes < 1024 * 1024:
+        return f"{num_bytes / 1024:.2f} KB"
+    else:
+        return f"{num_bytes / (1024 * 1024):.2f} MB"
+
+
+def _legacy_encode_comfy_image(image: torch.Tensor, image_format="png") -> str:
+    input_image = image.cpu().detach().numpy()
+    i = 255.0 * input_image[0]
+    input_image = np.clip(i, 0, 255).astype(np.uint8)
+    base64ed_image = encode_image_to_base64(
+        Image.fromarray(input_image), format=image_format
+    )
+    return base64ed_image
+
+
+def _legacy_decode_comfy_image(
+    img_data: Union[List, str], image_format="png"
+) -> torch.tensor:
+    if isinstance(img_data, List):
+        decoded_imgs = [decode_comfy_image(x, old_version=True) for x in img_data]
+
+        combined_imgs = torch.cat(decoded_imgs, dim=0)
+        return combined_imgs
+
+    out = decode_base64_to_np(img_data, format=image_format)
+    out = np.array(out).astype(np.float32) / 255.0
+    output = torch.from_numpy(out)[None,]
+    return output
+
+
+def _new_encode_comfy_image(images: torch.Tensor, image_format="WEBP", **kwargs) -> str:
+    """https://docs.comfy.org/essentials/custom_node_snippets#save-an-image-batch
+    Encode a batch of images to base64 strings.
+
+    Args:
+        images (torch.Tensor): A batch of images.
+        image_format (str, optional): The format of the images. Defaults to "WEBP".
+
+    Returns:
+        str: A JSON string containing the base64-encoded images.
+    """
+    results = {}
+    for batch_number, image in enumerate(images):
+        i = 255.0 * image.cpu().numpy()
+        img = Image.fromarray(np.clip(i, 0, 255).astype(np.uint8))
+        base64ed_image = encode_image_to_base64(img, format=image_format, **kwargs)
+        results[batch_number] = base64ed_image
+
+    return json.dumps(results)
+
+
+def _new_decode_comfy_image(img_datas: str, image_format="WEBP") -> torch.tensor:
+    """
+    Decode a batch of base64-encoded images.
+
+    Args:
+        img_datas (str): A JSON string containing the base64-encoded images.
+        image_format (str, optional): The format of the images. Defaults to "WEBP".
+
+    Returns:
+        torch.Tensor: A tensor containing the decoded images.
+    """
+    img_datas = json.loads(img_datas)
+
+    decoded_imgs = []
+    for img_data in img_datas.values():
+        decoded_image = decode_base64_to_np(img_data, format=image_format)
+        decoded_image = np.array(decoded_image).astype(np.float32) / 255.0
+        decoded_imgs.append(torch.from_numpy(decoded_image)[None,])
+
+    return torch.cat(decoded_imgs, dim=0)
+
+
+def encode_comfy_image(
+    image: torch.Tensor, image_format="WEBP", old_version=False, lossless=False
+) -> str:
+    if old_version:
+        return _legacy_encode_comfy_image(image, image_format)
+    return _new_encode_comfy_image(image, image_format, lossless=lossless)
+
+
+def decode_comfy_image(
+    img_data: Union[List, str], image_format="WEBP", old_version=False
+) -> torch.tensor:
+    if old_version:
+        return _legacy_decode_comfy_image(img_data, image_format)
+    return _new_decode_comfy_image(img_data, image_format)
+
+
+def tensor_to_base64(tensor: torch.Tensor, compress=True) -> str:
+    tensor_np = tensor.cpu().detach().numpy()
+
+    tensor_bytes = pickle.dumps(tensor_np)
+    if compress:
+        tensor_bytes = zlib.compress(tensor_bytes)
+
+    tensor_b64 = base64.b64encode(tensor_bytes).decode("utf-8")
+    return tensor_b64
+
+
+def base64_to_tensor(tensor_b64: str, compress=True) -> torch.Tensor:
+    tensor_bytes = base64.b64decode(tensor_b64)
+
+    if compress:
+        tensor_bytes = zlib.decompress(tensor_bytes)
+
+    tensor_np = pickle.loads(tensor_bytes)
+
+    tensor = torch.from_numpy(tensor_np)
+    return tensor
+
+
+@singledispatch
+def decode_data(input, old_version=False):
+    raise NotImplementedError(f"Unsupported type: {type(input)}")
+
+
+@decode_data.register(int)
+@decode_data.register(float)
+@decode_data.register(bool)
+@decode_data.register(type(None))
+def _(input, **kwargs):
+    return input
+
+
+@decode_data.register(dict)
+def _(input, **kwargs):
+    return {k: decode_data(v, **kwargs) for k, v in input.items()}
+
+
+@decode_data.register(list)
+def _(input, **kwargs):
+    return [decode_data(x, **kwargs) for x in input]
+
+
+@decode_data.register(str)
+def _(input: str, **kwargs):
+    if input.startswith(TENSOR_MARKER):
+        tensor_b64 = input[len(TENSOR_MARKER) :]
+        return base64_to_tensor(tensor_b64)
+    elif input.startswith(IMAGE_MARKER):
+        tensor_b64 = input[len(IMAGE_MARKER) :]
+        old_version = kwargs.get("old_version", False)
+        return decode_comfy_image(tensor_b64, old_version=old_version)
+    return input
+
+
+@singledispatch
+def encode_data(output, disable_image_marker=False, old_version=False):
+    raise NotImplementedError(f"Unsupported type: {type(output)}")
+
+
+@encode_data.register(dict)
+def _(output, **kwargs):
+    return {k: encode_data(v, **kwargs) for k, v in output.items()}
+
+
+@encode_data.register(list)
+def _(output, **kwargs):
+    return [encode_data(x, **kwargs) for x in output]
+
+
+def is_image_tensor(tensor) -> bool:
+    """https://docs.comfy.org/essentials/custom_node_datatypes#image
+
+    Check if the given tensor is in the format of an IMAGE (shape [B, H, W, C] where C=3).
+
+    `Args`:
+        tensor (torch.Tensor): The tensor to check.
+
+    `Returns`:
+        bool: True if the tensor is in the IMAGE format, False otherwise.
+    """
+    try:
+        if not isinstance(tensor, torch.Tensor):
+            return False
+
+        if len(tensor.shape) != 4:
+            return False
+
+        B, H, W, C = tensor.shape
+        if C != 3:
+            return False
+
+        return True
+    except:
+        return False
+
+
+@encode_data.register(torch.Tensor)
+def _(output, **kwargs):
+    if is_image_tensor(output) and not kwargs.get("disable_image_marker", False):
+        old_version = kwargs.get("old_version", False)
+        lossless = kwargs.get("lossless", True)
+        return IMAGE_MARKER + encode_comfy_image(
+            output, image_format="WEBP", old_version=old_version, lossless=lossless
+        )
+    return TENSOR_MARKER + tensor_to_base64(output)
+
+
+@encode_data.register(int)
+@encode_data.register(float)
+@encode_data.register(bool)
+@encode_data.register(type(None))
+def _(output, **kwargs):
+    return output
+
+
+@encode_data.register(str)
+def _(output, **kwargs):
+    return output
@@ -5,7 +5,7 @@ import requests
 import pathlib
 from aiohttp import web

-root_path = pathlib.Path(__file__).parent.parent.parent
+root_path = pathlib.Path(__file__).parent.parent.parent.parent
 config_path = os.path.join(root_path,'config.yaml')
 class FluxAIAPI:
    def __init__(self):
@@ -5,21 +5,21 @@ import requests
 import pathlib
 from aiohttp import web
 from server import PromptServer
-from .image import tensor2pil, pil2tensor, image2base64, pil2byte
-from .log import log_node_error
+from ..image import tensor2pil, pil2tensor, image2base64, pil2byte
+from ..log import log_node_error


-root_path = pathlib.Path(__file__).parent.parent.parent
+root_path = pathlib.Path(__file__).parent.parent.parent.parent
 config_path = os.path.join(root_path,'config.yaml')
 default_key = [{'name':'Default', 'key':''}]

+
 class StabilityAPI:
    def __init__(self):
        self.api_url = "https://api.stability.ai"
        self.api_keys = None
        self.api_current = 0
        self.user_info = {}
-        self.getAPIKeys()

    def getErrors(self, code):
        errors = {
@@ -154,7 +154,6 @@ class StabilityAPI:

 stableAPI = StabilityAPI()

-
@PromptServer.instance.routes.get("/easyuse/stability/api_keys")
 async def get_stability_api_keys(request):
    stableAPI.getAPIKeys()
@@ -77,10 +77,11 @@ def update_cache(k, tag, v):
    else:
        cache_count[k] += 1
 def remove_cache(key):
-    global cache
    if key == '*':
-        cache = TaggedCache(cache_settings)
+        cache.clear()
+        cache_count.clear()
    elif key in cache:
        del cache[key]
+        cache_count.pop(key, None)
    else:
-        print(f"invalid {key}")
+        print(f"invalid {key}")
@@ -1,52 +1,153 @@
+from threading import Event
+
+import torch
+
 from server import PromptServer
 from aiohttp import web
+from comfy import model_management as mm
+from comfy_execution.graph import ExecutionBlocker
 import time

 class ChooserCancelled(Exception):
    pass

-class ChooserMessage:
-    stash = {}
-    messages = {}
-    cancelled = False
+def get_chooser_cache():
+    """获取选择器缓存"""
+    if not hasattr(PromptServer.instance, '_easyuse_chooser_node'):
+        PromptServer.instance._easyuse_chooser_node = {}
+    return PromptServer.instance._easyuse_chooser_node

-    @classmethod
-    def addMessage(cls, id, message):
-        if message == '__cancel__':
-            cls.messages = {}
-            cls.cancelled = True
-        elif message == '__start__':
-            cls.messages = {}
-            cls.stash = {}
-            cls.cancelled = False
-        else:
-            cls.messages[str(id)] = message
+def cleanup_session_data(node_id):
+    """清理会话数据"""
+    node_data = get_chooser_cache()
+    if node_id in node_data:
+        session_keys = ["event", "selected", "images", "total_count", "cancelled"]
+        for key in session_keys:
+            if key in node_data[node_id]:
+                del node_data[node_id][key]
+
+def wait_for_chooser(id, images, mode, period=0.1):
+    try:
+        node_data = get_chooser_cache()
+        images = [images[i:i + 1, ...] for i in range(images.shape[0])]
+        if mode == "Keep Last Selection":
+            if id in node_data and "last_selection" in node_data[id]:
+                last_selection = node_data[id]["last_selection"]
+                if last_selection and len(last_selection) > 0:
+                    valid_indices = [idx for idx in last_selection if 0 <= idx < len(images)]
+                    if valid_indices:
+                        try:
+                            PromptServer.instance.send_sync("easyuse-image-keep-selection", {
+                                "id": id,
+                                "selected": valid_indices
+                            })
+                        except Exception as e:
+                            pass
+                        cleanup_session_data(id)
+                        indices_str = ','.join(str(i) for i in valid_indices)
+                        images = [images[idx] for idx in valid_indices]
+                        images = torch.cat(images, dim=0)
+                        return {"result": (images,)}
+
+        if id in node_data:
+            del node_data[id]
+
+        event = Event()
+        node_data[id] = {
+            "event": event,
+            "images": images,
+            "selected": None,
+            "total_count": len(images),
+            "cancelled": False,
+        }
+
+        while id in node_data:
+            node_info = node_data[id]
+            if node_info.get("cancelled", False):
+                cleanup_session_data(id)
+                raise ChooserCancelled("Manual selection cancelled")
+
+            if "selected" in node_info and node_info["selected"] is not None:
+                break

-    @classmethod
-    def waitForMessage(cls, id, period=0.1, asList=False):
-        sid = str(id)
-        while not (sid in cls.messages) and not ("-1" in cls.messages):
-            if cls.cancelled:
-                cls.cancelled = False
-                raise ChooserCancelled()
            time.sleep(period)
-        if cls.cancelled:
-            cls.cancelled = False
-            raise ChooserCancelled()
-        message = cls.messages.pop(str(id), None) or cls.messages.pop("-1")
-        try:
-            if asList:
-                return [int(x.strip()) for x in message.split(",")]
+
+        if id in node_data:
+            node_info = node_data[id]
+            selected_indices = node_info.get("selected")
+
+            if selected_indices is not None and len(selected_indices) > 0:
+                valid_indices = [idx for idx in selected_indices if 0 <= idx < len(images)]
+                if valid_indices:
+                    selected_images = [images[idx] for idx in valid_indices]
+
+                    if id not in node_data:
+                        node_data[id] = {}
+                    node_data[id]["last_selection"] = valid_indices
+                    cleanup_session_data(id)
+                    selected_images = torch.cat(selected_images, dim=0)
+                    return {"result": (selected_images,)}
+                else:
+                    cleanup_session_data(id)
+                    return {"result": (images[0] if len(images) > 0 else ExecutionBlocker(None),)}
            else:
-                return int(message.strip())
-        except ValueError:
-            print(
-                f"ERROR IN IMAGE_CHOOSER - failed to parse '${message}' as ${'comma separated list of ints' if asList else 'int'}")
-            return [1] if asList else 1
+                cleanup_session_data(id)
+                return {
+                    "result": (images[0] if len(images) > 0 else ExecutionBlocker(None),)}
+        else:
+            return {"result": (images[0] if len(images) > 0 else ExecutionBlocker(None),)}
+
+    except ChooserCancelled:
+        raise mm.InterruptProcessingException()
+    except Exception as e:
+        node_data = get_chooser_cache()
+        if id in node_data:
+            cleanup_session_data(id)
+        if 'image_list' in locals() and len(images) > 0:
+            return {"result": (images[0])}
+        else:
+            return {"result": (ExecutionBlocker(None),)}


@PromptServer.instance.routes.post('/easyuse/image_chooser_message')
-async def make_image_selection(request):
-    post = await request.post()
-    ChooserMessage.addMessage(post.get("id"), post.get("message"))
-    return web.json_response({})
+async def handle_image_selection(request):
+    try:
+        data = await request.json()
+        node_id = data.get("node_id")
+        selected = data.get("selected", [])
+        action = data.get("action")
+
+        node_data = get_chooser_cache()
+
+        if node_id not in node_data:
+            return web.json_response({"code": -1, "error": "Node data does not exist"})
+
+        try:
+            node_info = node_data[node_id]
+
+            if "total_count" not in node_info:
+                return web.json_response({"code": -1, "error": "The node has been processed"})
+
+            if action == "cancel":
+                node_info["cancelled"] = True
+                node_info["selected"] = []
+            elif action == "select" and isinstance(selected, list):
+                valid_indices = [idx for idx in selected if isinstance(idx, int) and 0 <= idx < node_info["total_count"]]
+                if valid_indices:
+                    node_info["selected"] = valid_indices
+                    node_info["cancelled"] = False
+                else:
+                    return web.json_response({"code": -1, "error": "Invalid Selection Index"})
+            else:
+                return web.json_response({"code": -1, "error": "Invalid operation"})
+
+            node_info["event"].set()
+            return web.json_response({"code": 1})
+
+        except Exception as e:
+            if node_id in node_data and "event" in node_data[node_id]:
+                node_data[node_id]["event"].set()
+            return web.json_response({"code": -1, "message": "Processing Failed"})
+
+    except Exception as e:
+        return web.json_response({"code": -1, "message": "Request Failed"})
@@ -14,7 +14,7 @@ def prompt_to_cond(type, model, clip, clip_skip, lora_stack, text, prompt_token_
    if model_type not in ['hydit'] and text is not None and has_chinese(text):
        text = zh_to_en([text])[0]

-    if model_type in ['hydit', 'flux', 'mochi']:
+    if model_type in ['hydit', 'flux', 'mochi', 'anima', 'krea2']:
        log_node_warn(title + "...")
        embeddings_final, = CLIPTextEncode().encode(clip, text) if text is not None else (None,)

@@ -14,9 +14,9 @@ class easyControlnet:
            return (positive, negative)

        # kolors controlnet patch
-        from ..kolors.loader import is_kolors_model, applyKolorsUnet
+        from ..modules.kolors.loader import is_kolors_model, applyKolorsUnet
        if is_kolors_model(model):
-            from ..kolors.model_patch import patch_controlnet
+            from ..modules.kolors.model_patch import patch_controlnet
            if control_net is None:
                with applyKolorsUnet():
                    control_net = easyCache.load_controlnet(control_net_name, scale_soft_weights, use_cache)
@@ -125,7 +125,35 @@ class ResizeMode(Enum):
      return 2
    assert False, "NOTREACHED"

-
+# credit by https://github.com/chflame163/ComfyUI_LayerStyle/blob/main/py/imagefunc.py#L591C1-L617C22
+def fit_resize_image(image: Image, target_width: int, target_height: int, fit: str, resize_sampler: str,
+                     background_color: str = '#000000') -> Image:
+  image = image.convert('RGB')
+  orig_width, orig_height = image.size
+  if image is not None:
+    if fit == 'letterbox':
+      if orig_width / orig_height > target_width / target_height:  # 更宽，上下留黑
+        fit_width = target_width
+        fit_height = int(target_width / orig_width * orig_height)
+      else:  # 更瘦，左右留黑
+        fit_height = target_height
+        fit_width = int(target_height / orig_height * orig_width)
+      fit_image = image.resize((fit_width, fit_height), resize_sampler)
+      ret_image = Image.new('RGB', size=(target_width, target_height), color=background_color)
+      ret_image.paste(fit_image, box=((target_width - fit_width) // 2, (target_height - fit_height) // 2))
+    elif fit == 'crop':
+      if orig_width / orig_height > target_width / target_height:  # 更宽，裁左右
+        fit_width = int(orig_height * target_width / target_height)
+        fit_image = image.crop(
+          ((orig_width - fit_width) // 2, 0, (orig_width - fit_width) // 2 + fit_width, orig_height))
+      else:  # 更瘦，裁上下
+        fit_height = int(orig_width * target_height / target_width)
+        fit_image = image.crop(
+          (0, (orig_height - fit_height) // 2, orig_width, (orig_height - fit_height) // 2 + fit_height))
+      ret_image = fit_image.resize((target_width, target_height), resize_sampler)
+    else:
+      ret_image = image.resize((target_width, target_height), resize_sampler)
+  return ret_image

 # CLIP反推
 import comfy.utils
@@ -8,16 +8,18 @@ from comfy.model_patcher import ModelPatcher
 from nodes import NODE_CLASS_MAPPINGS
 from collections import defaultdict
 from .log import log_node_info, log_node_error
-from ..dit.pixArt.loader import load_pixart
+from .utils import get_sd_version
+from ..config import DIFFUSION_MODEL_XY_DEFAULTS, DIFFUSION_MODEL_CLIP_TYPES
+from ..modules.dit.pixArt.loader import load_pixart

-stable_diffusion_loaders = ["easy fullLoader", "easy a1111Loader", "easy comfyLoader", "easy hunyuanDiTLoader","easy zero123Loader", "easy svdLoader"]
+diffusion_loaders = ["easy fullLoader", "easy a1111Loader", "easy fluxLoader", "easy comfyLoader", "easy hunyuanDiTLoader", "easy zero123Loader", "easy svdLoader"]
 stable_cascade_loaders = ["easy cascadeLoader"]
 dit_loaders = ['easy pixArtLoader']
-controlnet_loaders = ["easy controlnetLoader", "easy controlnetLoaderADV"]
+controlnet_loaders = ["easy controlnetLoader", "easy controlnetLoaderADV", "easy controlnetLoader++"]
 instant_loaders = ["easy instantIDApply", "easy instantIDApplyADV"]
 cascade_vae_node = ["easy preSamplingCascade", "easy fullCascadeKSampler"]
 model_merge_node = ["easy XYInputs: ModelMergeBlocks"]
-lora_widget = ["easy fullLoader", "easy a1111Loader", "easy comfyLoader"]
+lora_widget = ["easy fullLoader", "easy a1111Loader", "easy comfyLoader", "easy fluxLoader"]

 class easyLoader:
    def __init__(self):
@@ -33,7 +35,7 @@ class easyLoader:
            "t5": defaultdict(tuple),
            "chatglm3": defaultdict(tuple),
        }
-        self.memory_threshold = self.determine_memory_threshold(0.7)
+        self.memory_threshold = self.determine_memory_threshold(1)
        self.lora_name_cache = []

    def clean_values(self, values: str):
@@ -101,7 +103,7 @@ class easyLoader:
                setting = f'{lora_name};{entry["inputs"]["lora_model_strength"]};{entry["inputs"]["lora_clip_strength"]}'
                desired_lora_settings.add(setting)

-            if class_type in stable_diffusion_loaders:
+            if class_type in diffusion_loaders:
                desired_ckpt_names.add(self.get_input_value(entry, "ckpt_name", prompt))
                desired_vae_names.add(self.get_input_value(entry, "vae_name"))

@@ -145,6 +147,28 @@ class easyLoader:
                scale_soft_weights = self.get_input_value(entry, "cn_soft_weights")
                desired_controlnet_names.add(f'{control_net_name};{scale_soft_weights}')

+            elif class_type == "easy diffusionModelLoader":
+                desired_unet_names.add(self.get_input_value(entry, "model_name", prompt))
+                clip_name = self.get_input_value(entry, "clip_name", prompt)
+                vae_name = self.get_input_value(entry, "vae_name", prompt)
+                if clip_name not in ("None", "Auto"):
+                    desired_clip_names.add(clip_name)
+                if vae_name not in ("None", "Auto"):
+                    desired_vae_names.add(vae_name)
+
+            elif class_type == "easy XYInputs: DiffusionModel":
+                model_count = int(self.get_input_value(entry, "model_count", prompt) or 0)
+                for i in range(1, model_count + 1):
+                    model_name = self.get_input_value(entry, f"model_name_{i}", prompt)
+                    if model_name and model_name != "None":
+                        desired_unet_names.add(model_name)
+                    clip_name = self.get_input_value(entry, f"clip_name_{i}", prompt)
+                    if clip_name not in ("None", "Auto"):
+                        desired_clip_names.add(clip_name)
+                    vae_name = self.get_input_value(entry, f"vae_name_{i}", prompt)
+                    if vae_name not in ("None", "Auto"):
+                        desired_vae_names.add(vae_name)
+
            elif class_type in model_merge_node:
                desired_ckpt_names.add(self.get_input_value(entry, "ckpt_name_1"))
                desired_ckpt_names.add(self.get_input_value(entry, "ckpt_name_2"))
@@ -240,7 +264,7 @@ class easyLoader:
        else:
            model_options = {}
            if re.search("nf4", ckpt_name):
-                from ..bitsandbytes_NF4 import OPS
+                from ..modules.bitsandbytes_NF4 import OPS
                model_options = {"custom_operations": OPS}
            loaded_ckpt = comfy.sd.load_checkpoint_guess_config(ckpt_path, output_vae=True, output_clip=output_clip, output_clipvision=output_clipvision, embedding_directory=folder_paths.get_folder_paths("embeddings"), model_options=model_options)

@@ -282,6 +306,57 @@ class easyLoader:

        return model

+    def load_diffusion_model(self, model_name):
+        if model_name in self.loaded_objects["unet"]:
+            log_node_info("Load Diffusion Model", f"{model_name} cached")
+            return self.loaded_objects["unet"][model_name][0]
+
+        model_path = folder_paths.get_full_path("diffusion_models", model_name)
+        if not model_path:
+            raise FileNotFoundError(f"[EasyUse] diffusion model not found: {model_name}")
+
+        model = comfy.sd.load_diffusion_model(model_path)
+        self.add_to_cache("unet", model_name, model)
+        self.eviction_based_on_memory()
+
+        return model
+
+    def load_diffusion_xy_model(self, model_name, clip_name, vae_name):
+        model = self.load_diffusion_model(model_name)
+        family = get_sd_version(model)
+
+        defaults = DIFFUSION_MODEL_XY_DEFAULTS.get(family)
+        if defaults is None:
+            raise RuntimeError(f"[EasyUse] unsupported diffusion model family: {family}")
+
+        if clip_name in ("Auto", None):
+            clip_name = defaults["clip_name"]
+        if vae_name in ("Auto", None):
+            vae_name = defaults["vae_name"]
+
+        clip = self.load_clip(clip_name, type=defaults["clip_type"])
+        vae = self.load_vae(vae_name)
+
+        return model, clip, vae, family
+
+    def load_diffusion_model_required(self, model_name, clip_name, vae_name):
+        if clip_name in ("None", None):
+            raise RuntimeError("[EasyUse] clip_name is required: please select a text encoder")
+        if vae_name in ("None", None):
+            raise RuntimeError("[EasyUse] vae_name is required: please select a VAE")
+
+        model = self.load_diffusion_model(model_name)
+        family = get_sd_version(model)
+
+        clip_type = DIFFUSION_MODEL_CLIP_TYPES.get(family)
+        if clip_type is None:
+            raise RuntimeError(f"[EasyUse] unsupported diffusion model family: {family}")
+
+        clip = self.load_clip(clip_name, type=clip_type)
+        vae = self.load_vae(vae_name)
+
+        return model, clip, vae, family
+
    def load_controlnet(self, control_net_name, scale_soft_weights=1, use_cache=True):
        unique_id = f'{control_net_name};{str(scale_soft_weights)}'
        if use_cache and unique_id in self.loaded_objects["controlnet"]:
@@ -303,8 +378,9 @@ class easyLoader:

        return control_net
    def load_clip(self, clip_name, type='stable_diffusion', load_clip=None):
-        if clip_name in self.loaded_objects["clip"]:
-            return self.loaded_objects["clip"][clip_name][0]
+        cache_key = f"{clip_name}::{type}"
+        if cache_key in self.loaded_objects["clip"]:
+            return self.loaded_objects["clip"][cache_key][0]

        if type == 'stable_diffusion':
            clip_type = comfy.sd.CLIPType.STABLE_DIFFUSION
@@ -316,9 +392,13 @@ class easyLoader:
            clip_type = comfy.sd.CLIPType.FLUX
        elif type == 'stable_audio':
            clip_type = comfy.sd.CLIPType.STABLE_AUDIO
+        elif type == 'krea2':
+            clip_type = comfy.sd.CLIPType.KREA2
+        elif type == 'anima':
+            clip_type = comfy.sd.CLIPType.STABLE_DIFFUSION
        clip_path = folder_paths.get_full_path("clip", clip_name)
        load_clip = comfy.sd.load_clip(ckpt_paths=[clip_path], embedding_directory=folder_paths.get_folder_paths("embeddings"), clip_type=clip_type)
-        self.add_to_cache("clip", clip_name, load_clip)
+        self.add_to_cache("clip", cache_key, load_clip)
        self.eviction_based_on_memory()

        return load_clip
@@ -351,7 +431,7 @@ class easyLoader:
            lora_path = None

        if lora_path is not None:
-            log_node_info("Load LORA",f"{lora_name}: {model_strength}, {clip_strength}, LBW={lbw}, A={lbw_a}, B={lbw_b}")
+            log_node_info("Load LORA",f"{lora_name}: model={model_strength:.3f}, clip={clip_strength:.3f}, LBW={lbw}, A={lbw_a}, B={lbw_b}")
            if lbw:
                lbw = lora["lbw"]
                lbw_a = lora["lbw_a"]
@@ -391,7 +471,7 @@ class easyLoader:

                # PixArt
                if type is not None and type == 'PixArt':
-                    from ..dit.pixArt.loader import load_pixart_lora
+                    from ..modules.dit.pixArt.loader import load_pixart_lora
                    model = load_pixart_lora(model, _lora, lora_path, model_strength)
                else:
                    model, clip = comfy.sd.load_lora_for_models(model, clip, _lora, model_strength, clip_strength)
@@ -432,10 +512,13 @@ class easyLoader:
        clip_vision = None
        lora_stack = []

+        # Check for model override
        can_load_lora = True
        # 判断是否存在 模型或Lora叠加xyplot, 若存在优先缓存第一个模型
+        # Determine whether there is a model or Lora overlapping xyplot, and if there is, prioritize caching the first model.
        xy_model_id = next((x for x in prompt if str(prompt[x]["class_type"]) in ["easy XYInputs: ModelMergeBlocks",
                                                                                  "easy XYInputs: Checkpoint"]), None)
+        # This will find nodes that aren't actively connected to anything, and skip loading lora's for them.
        xy_lora_id = next((x for x in prompt if str(prompt[x]["class_type"]) == "easy XYInputs: Lora"), None)
        if xy_lora_id is not None:
            can_load_lora = False
@@ -461,6 +544,7 @@ class easyLoader:

        if optional_lora_stack is not None and can_load_lora:
            for lora in optional_lora_stack:
+                # This is a subtle bit of code because it uses the model created by the last call, and passes it to the next call.
                lora = {"lora_name": lora[0], "model": model, "clip": clip, "model_strength": lora[1],
                        "clip_strength": lora[2]}
                model, clip = self.load_lora(lora)
@@ -489,7 +573,7 @@ class easyLoader:
            log_node_info("Load Kolors UNet", f"{unet_name} cached")
            return self.loaded_objects["unet"][unet_name][0]
        else:
-            from ..kolors.loader import applyKolorsUnet
+            from ..modules.kolors.loader import applyKolorsUnet
            with applyKolorsUnet():
                unet_path = folder_paths.get_full_path("unet", unet_name)
                sd = comfy.utils.load_torch_file(unet_path)
@@ -503,7 +587,7 @@ class easyLoader:
                return model

    def load_chatglm3(self, chatglm3_name):
-        from ..kolors.loader import load_chatglm3
+        from ..modules.kolors.loader import load_chatglm3
        if chatglm3_name in self.loaded_objects["chatglm3"]:
            log_node_info("Load ChatGLM3", f"{chatglm3_name} cached")
            return self.loaded_objects["chatglm3"][chatglm3_name][0]
@@ -531,50 +615,6 @@ class easyLoader:
            self.eviction_based_on_memory()
        return model

-
-    def load_dit_clip(self, clip_name, **kwargs):
-        if clip_name in self.loaded_objects["clip"]:
-            return self.loaded_objects["clip"][clip_name][0]
-
-        clip_path = folder_paths.get_full_path("clip", clip_name)
-        sd = comfy.utils.load_torch_file(clip_path)
-
-        prefix = "bert."
-        state_dict = {}
-        for key in sd:
-            nkey = key
-            if key.startswith(prefix):
-                nkey = key[len(prefix):]
-            state_dict[nkey] = sd[key]
-
-        m, e = model.load_sd(state_dict)
-        if len(m) > 0 or len(e) > 0:
-            print(f"{clip_name}: clip missing {len(m)} keys ({len(e)} extra)")
-
-        self.add_to_cache("clip", clip_name, model)
-        self.eviction_based_on_memory()
-
-        return model
-
-    def load_dit_t5(self, t5_name, **kwargs):
-        if t5_name in self.loaded_objects["t5"]:
-            return self.loaded_objects["t5"][t5_name][0]
-
-        model_type = kwargs['model_type'] if "model_type" in kwargs else 'HyDiT'
-        if model_type == 'HyDiT':
-            del kwargs['model_type']
-            model = EXM_HyDiT_Tenc_Temp(model_class="mT5", **kwargs)
-        t5_path = folder_paths.get_full_path("t5", t5_name)
-        sd = comfy.utils.load_torch_file(t5_path)
-        m, e = model.load_sd(sd)
-        if len(m) > 0 or len(e) > 0:
-            print(f"{t5_name}: mT5 missing {len(m)} keys ({len(e)} extra)")
-
-        self.add_to_cache("t5", t5_name, model)
-        self.eviction_based_on_memory()
-
-        return model
-
    def load_t5_from_sd3_clip(self, sd3_clip, padding):
        try:
            from comfy.text_encoders.sd3_clip import SD3Tokenizer, SD3ClipModel
@@ -0,0 +1,148 @@
+"""
+Math utility functions for formula evaluation
+"""
+import math
+import re
+
+def evaluate_formula(formula: str, a=0, b=0, c=0, d=0):
+    """
+    计算字符串数学公式
+    
+    支持的运算符和函数：
+    - 基本运算：+, -, *, /, //, %, **
+    - 比较运算：>, <, >=, <=, ==, !=
+    - 数学函数：abs, pow, round, ceil, floor, sqrt, exp, log, log10
+    - 三角函数：sin, cos, tan, asin, acos, atan
+    - 常量：pi, e
+    
+    Args:
+        formula: 数学公式字符串，可以使用变量a、b、c、d
+        a: 变量a的值
+        b: 变量b的值
+        c: 变量c的值
+        d: 变量d的值
+    
+    Returns:
+        如果任意输入为list则返回list[float]，否则返回float
+    
+    Examples:
+        >>> evaluate_formula("a + b", 1, 2)
+        3.0
+        >>> evaluate_formula("pow(a, 2)", 5)
+        25.0
+        >>> evaluate_formula("ceil(a / b)", 5, 2)
+        3.0
+        >>> evaluate_formula("(a>b)*b+(a<=b)*a", 5, 3)
+        3.0
+        >>> evaluate_formula("(a>b)*b+(a<=b)*a", 2, 3)
+        2.0
+    """
+    # 安全的数学函数白名单
+    safe_dict = {
+        # 基本运算
+        'abs': abs,
+        'pow': pow,
+        'round': round,
+        # 数学函数
+        'ceil': math.ceil,
+        'floor': math.floor,
+        'sqrt': math.sqrt,
+        'exp': math.exp,
+        'log': math.log,
+        'log10': math.log10,
+        # 三角函数
+        'sin': math.sin,
+        'cos': math.cos,
+        'tan': math.tan,
+        'asin': math.asin,
+        'acos': math.acos,
+        'atan': math.atan,
+        # 常量
+        'pi': math.pi,
+        'e': math.e,
+    }
+
+    # 判断是否有 list 输入
+    list_inputs = {k: v for k, v in {'a': a, 'b': b, 'c': c, 'd': d}.items() if isinstance(v, (list, tuple))}
+    scalar_inputs = {k: v for k, v in {'a': a, 'b': b, 'c': c, 'd': d}.items() if not isinstance(v, (list, tuple))}
+
+    def _eval_single(vals: dict) -> float:
+        env = dict(safe_dict)
+        env.update({k: float(v) for k, v in vals.items()})
+        try:
+            result = eval(formula, {"__builtins__": {}}, env)
+            return float(result)
+        except Exception as e:
+            raise ValueError(f"公式计算错误: {str(e)}")
+
+    if not list_inputs:
+        # 全是标量
+        return _eval_single({k: v for k, v in {'a': a, 'b': b, 'c': c, 'd': d}.items()})
+
+    # 有 list 输入，逐元素计算
+    max_len = max(len(v) for v in list_inputs.values())
+    results = []
+    for i in range(max_len):
+        vals = {k: float(v) for k, v in scalar_inputs.items()}
+        for k, v in list_inputs.items():
+            vals[k] = float(v[i] if i < len(v) else v[-1])
+        results.append(_eval_single(vals))
+    return results
+
+
+def ceil_value(value: float) -> int:
+    """向上取整"""
+    return math.ceil(value)
+
+
+def floor_value(value: float) -> int:
+    """向下取整"""
+    return math.floor(value)
+
+
+def round_value(value: float, decimals: int = 0) -> float:
+    """
+    四舍五入
+    
+    Args:
+        value: 要取整的值
+        decimals: 保留小数位数
+    
+    Returns:
+        四舍五入后的值
+    """
+    return round(value, decimals)
+
+
+def power(base: float, exponent: float) -> float:
+    """计算幂运算"""
+    return math.pow(base, exponent)
+
+
+def sqrt_value(value: float) -> float:
+    """计算平方根"""
+    if value < 0:
+        raise ValueError("不能对负数求平方根")
+    return math.sqrt(value)
+
+
+def add(a: float, b: float) -> float:
+    """加法"""
+    return a + b
+
+
+def subtract(a: float, b: float) -> float:
+    """减法"""
+    return a - b
+
+
+def multiply(a: float, b: float) -> float:
+    """乘法"""
+    return a * b
+
+
+def divide(a: float, b: float) -> float:
+    """除法"""
+    if b == 0:
+        raise ValueError("除数不能为零")
+    return a / b
@@ -0,0 +1,55 @@
+from server import PromptServer
+from aiohttp import web
+import time
+import json
+
+class MessageCancelled(Exception):
+    pass
+
+class Message:
+    stash = {}
+    messages = {}
+    cancelled = False
+
+    @classmethod
+    def addMessage(cls, id, message):
+        if message == '__cancel__':
+            cls.messages = {}
+            cls.cancelled = True
+        elif message == '__start__':
+            cls.messages = {}
+            cls.stash = {}
+            cls.cancelled = False
+        else:
+            cls.messages[str(id)] = message
+
+    @classmethod
+    def waitForMessage(cls, id, period=0.1, asList=False):
+        sid = str(id)
+        while not (sid in cls.messages) and not ("-1" in cls.messages):
+            if cls.cancelled:
+                cls.cancelled = False
+                raise MessageCancelled()
+            time.sleep(period)
+        if cls.cancelled:
+            cls.cancelled = False
+            raise MessageCancelled()
+        message = cls.messages.pop(str(id), None) or cls.messages.pop("-1")
+        try:
+            if asList:
+                return [str(x.strip()) for x in message.split(",")]
+            else:
+                try:
+                    return json.loads(message)
+                except ValueError:
+                    return message
+        except ValueError:
+            print( f"ERROR IN MESSAGE - failed to parse '${message}' as ${'comma separated list of strings' if asList else 'string'}")
+            return [message] if asList else message
+
+
+@PromptServer.instance.routes.post('/easyuse/message_callback')
+async def message_callback(request):
+    post = await request.post()
+    Message.addMessage(post.get("id"), post.get("message"))
+    return web.json_response({})
@@ -0,0 +1,29 @@
+import os
+
+
+def resolve_output_file_path(output_root, output_file_path, file_name, file_extension):
+    """Resolve a workflow-provided output path beneath ``output_root``.
+
+    Relative output directories remain supported, but are interpreted relative
+    to ComfyUI's configured output directory rather than the process working
+    directory. Resolving both paths prevents ``..`` components and existing
+    symlinks from escaping the allowed root.
+    """
+    output_root = os.path.realpath(output_root)
+    requested_directory = output_file_path
+    if not os.path.isabs(requested_directory):
+        requested_directory = os.path.join(output_root, requested_directory)
+
+    candidate = os.path.realpath(
+        os.path.join(requested_directory, f"{file_name}.{file_extension}")
+    )
+    try:
+        is_within_output = os.path.commonpath((output_root, candidate)) == output_root
+    except ValueError:
+        # Different Windows drives and paths containing null bytes are unsafe.
+        is_within_output = False
+
+    if not is_within_output:
+        raise ValueError("Saving outside the ComfyUI output directory is not allowed")
+
+    return candidate
@@ -7,7 +7,7 @@ import latent_preview
 from nodes import MAX_RESOLUTION
 from PIL import Image
 from typing import Dict, List, Optional, Tuple, Union, Any
-from ..brushnet.model_patch import add_model_patch
+from ..modules.brushnet.model_patch import add_model_patch

 class easySampler:
    def __init__(self):
@@ -65,6 +65,9 @@ class easySampler:
        elif model_type == 'mochi':
            latent = torch.zeros([batch_size, 12, ((video_length - 1) // 6) + 1, empty_latent_height // 8, empty_latent_width // 8], device=self.device)
            samples = {"samples": latent}
+        elif model_type in ("anima", "krea2"):
+            latent = torch.zeros([batch_size, 16, 1, empty_latent_height // 8, empty_latent_width // 8], device=self.device)
+            samples = {"samples": latent}
        elif compression == 0:
            latent = torch.zeros([batch_size, 4, empty_latent_height // 8, empty_latent_width // 8], device=self.device)
            samples = {"samples": latent}
@@ -84,7 +87,7 @@ class easySampler:
        """

        latent_size = latent_image.size()
-        latent_size_1batch = [1, latent_size[1], latent_size[2], latent_size[3]]
+        latent_size_1batch = [1] + list(latent_size[1:])

        if variation_strength is not None and variation_strength > 0 or incremental_seed_mode.startswith(
                "variation str inc"):
@@ -108,7 +111,7 @@ class easySampler:
                if strength_up is not None:
                    strength += strength_up

-                variation_noise = variation_latent.expand(input_latent.size()[0], -1, -1, -1)
+                variation_noise = variation_latent.expand(input_latent.size()[0], *([-1] * (variation_latent.dim() - 1)))
                result = (1 - strength) * input_latent + strength * variation_noise
                return result

@@ -35,9 +35,13 @@ import sys
 import importlib.util
 import importlib.metadata
 import comfy.model_management as mm
+import logging
 import gc
 from packaging import version
 from server import PromptServer
+
+LOG = logging.getLogger(__name__)
+
 def is_package_installed(package):
    try:
        module = importlib.util.find_spec(package)
@@ -82,6 +86,7 @@ def compare_revision(num):
    if not comfy_ui_revision:
        comfy_ui_revision = get_comfyui_revision()
    return True if comfy_ui_revision == 'Unknown' or int(comfy_ui_revision) >= num else False
+
 def find_tags(string: str, sep="/") -> list[str]:
    """
    find tags from string use the sep for split
@@ -123,6 +128,10 @@ def get_sd_version(model):
        return 'flux'
    elif isinstance(model_config, comfy.supported_models.GenmoMochi):
        return 'mochi'
+    elif isinstance(model_config, comfy.supported_models.Anima):
+        return 'anima'
+    elif isinstance(model_config, comfy.supported_models.Krea2):
+        return 'krea2'
    else:
        return 'unknown'

@@ -217,14 +226,15 @@ def get_local_filepath(url, dirname, local_file_name=None):
        except Exception as e:
            use_mirror = True
            url = url.replace('huggingface.co', 'hf-mirror.com')
-            print(f'无法从huggingface下载，正在尝试从 {url} 下载...')
-            PromptServer.instance.send_sync("easyuse-toast", {'content': f'无法连接huggingface，正在尝试从 {url} 下载...', 'duration': 10000})
+            print(f'Unable to download from huggingface, trying mirror: {url}')
+            PromptServer.instance.send_sync("easyuse-toast", {'content': f'Unable to connect to huggingface, trying mirror: {url}', 'duration': 10000})
            try:
                download_url_to_file(url, destination)
            except Exception as err:
+                error_msg = str(err.args[0]) if err.args else str(err)
                PromptServer.instance.send_sync("easyuse-toast",
-                                                {'content': f'无法从 {url} 下载模型', 'type':'error'})
-                raise Exception(f'无法从 {url} 下载，错误信息：{str(err.args[0])}')
+                                                {'content': f'Unable to download model from {url}', 'type':'error'})
+                raise Exception(f'Download failed. Original URL and mirror both failed.\nError: {error_msg}')
    return destination

 def to_lora_patch_dict(state_dict: dict) -> dict:
@@ -275,6 +285,20 @@ def getMetadata(filepath):
        return header

 def cleanGPUUsedForce():
+    from .cache import remove_cache
+
+    remove_cache("*")
    gc.collect()
+    try:
+        import torch
+    except (ImportError, OSError, RuntimeError) as exc:
+        LOG.debug("Skipping CUDA synchronize during cleanGPUUsedForce: torch import failed: %s", exc)
+    else:
+        try:
+            if torch.cuda.is_available():
+                torch.cuda.synchronize()
+        except (AttributeError, OSError, RuntimeError) as exc:
+            LOG.debug("Skipping CUDA synchronize during cleanGPUUsedForce: %s", exc)
+
    mm.unload_all_models()
-    mm.soft_empty_cache()
+    mm.soft_empty_cache()
@@ -1,9 +1,13 @@
-import re
-import random
-import os
-import folder_paths
-import yaml
 import json
+import os
+import random
+import re
+from math import prod
+
+import yaml
+
+import folder_paths
+
 from .log import log_node_info

 easy_wildcard_dict = {}
@@ -34,16 +38,16 @@ def read_wildcard_dict(wildcard_path):
                key = os.path.splitext(rel_path)[0].replace('\\', '/').lower()

                try:
-                    with open(file_path, 'r', encoding="ISO-8859-1") as f:
+                    with open(file_path, 'r', encoding="UTF-8", errors="ignore") as f:
                        lines = f.read().splitlines()
                        easy_wildcard_dict[key] = lines
                except UnicodeDecodeError:
-                    with open(file_path, 'r', encoding="UTF-8", errors="ignore") as f:
+                    with open(file_path, 'r', encoding="ISO-8859-1") as f:
                        lines = f.read().splitlines()
                        easy_wildcard_dict[key] = lines
            elif file.endswith('.yaml'):
                file_path = os.path.join(root, file)
-                with open(file_path, 'r') as f:
+                with open(file_path, 'r', encoding="utf-8") as f:
                    yaml_data = yaml.load(f, Loader=yaml.FullLoader)

                    for k, v in yaml_data.items():
@@ -51,7 +55,7 @@ def read_wildcard_dict(wildcard_path):
            elif file.endswith('.json'):
                file_path = os.path.join(root, file)
                try:
-                    with open(file_path, 'r') as f:
+                    with open(file_path, 'r', encoding="utf-8") as f:
                        json_data = json.load(f)
                        for key, value in json_data.items():
                            key = wildcard_normalize(key)
@@ -302,3 +306,171 @@ def process_with_loras(wildcard_opt, model, clip, title="Positive", seed=None, c
        log_node_info("easy wildcards",f'{title}_decode: {pass1}')

    return model, clip, pass2, pass1, show_wildcard_prompt, pipe_lora_stack
+
+
+def expand_wildcard(keyword: str) -> tuple[str]:
+    """传入文件通配符的关键词，从 easy_wildcard_dict 中获取通配符的所有选项。"""
+    global easy_wildcard_dict
+    if keyword in easy_wildcard_dict:
+        return tuple(easy_wildcard_dict[keyword])
+    elif '*' in keyword:
+        subpattern = keyword.replace('*', '.*').replace('+', r"\+")
+        total_pattern = []
+        for k, v in easy_wildcard_dict.items():
+            if re.match(subpattern, k) is not None:
+                total_pattern.extend(v)
+        if total_pattern:
+            return tuple(total_pattern)
+    elif '/' not in keyword:
+        return expand_wildcard(f"*/{keyword}")
+
+def expand_options(options: str) -> tuple[str]:
+    """传入去掉 {} 的选项。
+    展开选项通配符，返回该选项中的每一项，这里的每一项都是一个替换项。
+    不会对选项内容进行任何处理，即便存在空格或特殊符号，也会原样返回。"""
+    return tuple(options.split("|"))
+
+
+def decimal_to_irregular(n, bases):
+    """
+    将十进制数转换为不规则进制
+
+    :param n: 十进制数
+    :param bases: 各位置的基数列表，从低位到高位
+    :return: 不规则进制表示的列表，从低位到高位
+    """
+    if n == 0:
+        return [0] * len(bases) if bases else [0]
+
+    digits = []
+    remaining = n
+
+    # 从低位到高位处理
+    for base in bases:
+        digit = remaining % base
+        digits.append(digit)
+        remaining = remaining // base
+
+    return digits
+
+
+class WildcardProcessor:
+    """通配符处理器
+
+    通配符格式：
+    + option  :   {a|b}
+    + wildcard:   __keyword__ 通配符内容将从 Easy-Use 插件提供的 easy_wildcard_dict 中获取
+    """
+
+    RE_OPTIONS = re.compile(r"{([^{}]*?)}")
+    RE_WILDCARD = re.compile(r"__([\w\s.\-+/*\\]+?)__")
+    RE_REPLACER = re.compile(r"{([^{}]*?)}|__([\w\s.\-+/*\\]+?)__")
+
+    # 将输入的提示词转化成符合 python str.format 要求格式的模板，并将 option 和 wildcard 按照顺序在模板中留下 {0}, {1} 等占位符
+    template: str
+    # option、wildcard 的替换项列表，按照在模板中出现的顺序排列，相同的替换项列表只保留第一份
+    replacers: dict[int, tuple[str]]
+    # 占位符的编号和替换项列表的索引的映射，占位符编号按照在模板中出现的顺序排列，方便减少替换项的存储占用
+    placeholder_mapping: dict[str, int]  # placeholder_id => replacer_id
+    # 各替换项列表的项数，按照在模板中出现的顺序排列，提前计算，方便后续使用
+    placeholder_choices: dict[str, int]  # placeholder_id => len(replacer)
+
+    def __init__(self, text: str):
+        self.__make_template(text)
+        self.__total = None
+
+    def random(self, seed=None) -> str:
+        "从所有可能性中随机获取一个"
+        if seed is not None:
+            random.seed(seed)
+        return self.getn(random.randint(0, self.total() - 1))
+
+    def getn(self, n: int) -> str:
+        "从所有可能性中获取第 n 个，以 self.total() 为周期循环"
+        n = n % self.total()
+        indice = decimal_to_irregular(n, self.placeholder_choices.values())
+        replacements = {
+            placeholder_id: self.replacers[self.placeholder_mapping[placeholder_id]][i]
+            for placeholder_id, i in zip(self.placeholder_mapping.keys(), indice)
+        }
+        return self.template.format(**replacements)
+
+    def getmany(self, limit: int, offset: int = 0) -> list[str]:
+        """返回一组可能性组成的列表，为了避免结果太长导致内存占用超限，使用 limit 限制列表的长度，使用 offset 调整偏移。
+        若 limit 和 offset 的设置导致预期的结果长度超过剩下的实际长度，则会回到开头。
+        """
+        return [self.getn(n) for n in range(offset, offset + limit)]
+
+    def total(self) -> int:
+        "计算可能性的数目"
+        if self.__total is None:
+            self.__total = prod(self.placeholder_choices.values())
+        return self.__total
+
+    def __make_template(self, text: str):
+        """将输入的提示词转化成符合 python str.format 要求格式的模板，
+        并将 option 和 wildcard 按照顺序在模板中留下 {r0}, {r1} 等占位符，
+        即使遇到相同的 option 或 wildcard，留下的占位符编号也不同，从而使每项都独立变化。
+        """
+        self.placeholder_mapping = {}
+        placeholder_id = 0
+        replacer_id = 0
+        replacers_rev = {}  # replacers => id
+        blocks = []
+        # 记录所处理过的通配符末尾在文本中的位置，用于拼接完整的模板
+        tail = 0
+        for match in self.RE_REPLACER.finditer(text):
+            # 提取并展开通配符内容
+            m = match.group(0)
+            if m.startswith("{"):
+                choices = expand_options(m[1:-1])
+            elif m.startswith("__"):
+                keyword = m[2:-2].lower()
+                keyword = wildcard_normalize(keyword)
+                choices = expand_wildcard(keyword)
+            else:
+                raise ValueError(f"{m!r} is not a wildcard or option")
+
+            # 记录通配符的替换项列表和ID，相同的通配符只保留第一个
+            if choices not in replacers_rev:
+                replacers_rev[choices] = replacer_id
+                replacer_id += 1
+
+            # 拼接通配符前方文本
+            start, end = match.span()
+            blocks.append(text[tail:start])
+            tail = end
+            # 将通配符替换为占位符，并记录占位符和替换项列表的索引的映射
+            blocks.append(f"{{r{placeholder_id}}}")
+            self.placeholder_mapping[f"r{placeholder_id}"] = replacers_rev[choices]
+            placeholder_id += 1
+
+        if tail < len(text):
+            blocks.append(text[tail:])
+        self.template = "".join(blocks)
+        self.replacers = {v: k for k, v in replacers_rev.items()}
+        self.placeholder_choices = {
+            placeholder_id: len(self.replacers[replacer_id])
+            for placeholder_id, replacer_id in self.placeholder_mapping.items()
+        }
+
+
+def test_option():
+    text = "{|a|b|c}"
+    answer = ["", "a", "b", "c"]
+    p = WildcardProcessor(text)
+    assert p.total() == len(answer)
+    assert p.getn(0) == answer[0]
+    assert p.getmany(4) == answer
+    assert p.getmany(4, 1) == answer[1:]
+
+
+def test_same():
+    text = "{a|b},{a|b}"
+    answer = ["a,a", "b,a", "a,b", "b,b"]
+    p = WildcardProcessor(text)
+    assert p.total() == len(answer)
+    assert p.getn(0) == answer[0]
+    assert p.getmany(4) == answer
+    assert p.getmany(4, 1) == answer[1:]
+
@@ -5,9 +5,10 @@ from .utils import easySave, get_sd_version
 from .adv_encode import advanced_encode
 from .controlnet import easyControlnet
 from .log import log_node_warn
-from ..layer_diffuse import LayerDiffuse
+from ..modules.layer_diffuse import LayerDiffuse
 from ..config import RESOURCES_DIR
 from nodes import CLIPTextEncode
+import pprint
 try:
    from comfy_extras.nodes_flux import FluxGuidance
 except:
@@ -52,7 +53,7 @@ class easyXYPlot():

        plot_image_vars[value_type] = value
        if value_type in ["seed", "Seeds++ Batch"]:
-            value_label = f"{value}"
+            value_label = f"seed: {value}"
        else:
            value_label = f"{value_type}: {value}"

@@ -62,8 +63,14 @@ class easyXYPlot():
        if value_type in ['Lora', 'Checkpoint']:
            arr = value.split(',')
            model_name = os.path.basename(os.path.splitext(arr[0])[0])
-            trigger_words = ' ' + arr[3] if value_type == 'Lora' and len(arr[3]) > 2 else ''
-            value_label = f"{model_name}{trigger_words}"
+            trigger_words = ' ' + arr[3] if value_type == 'Lora' and len(arr) > 3 and len(arr[3]) > 2 else ''
+            lora_weight = float(arr[1]) if value_type == 'Lora' and len(arr) > 1 else 0
+            lora_weight_desc = f" w:{lora_weight:.2f}" if value_type == 'Lora' and lora_weight != 1.0 else ''
+            value_label = f"{model_name[:25]}{lora_weight_desc}{trigger_words}"
+
+        if value_type == "DiffusionModel":
+            model_name = os.path.basename(os.path.splitext(value.split(",")[0])[0])
+            value_label = model_name[:25]

        if value_type in ["ModelMergeBlocks"]:
            if ":" in value:
@@ -95,6 +102,32 @@ class easyXYPlot():

        return plot_image_vars, value_label

+    @staticmethod
+    def _ensure_latent_for_model(model, vae, samples, plot_image_vars):
+        fmt = model.model.latent_format
+        x = samples["samples"]
+        expected_ndim = 2 + fmt.latent_dimensions
+
+        if x.ndim == expected_ndim and x.shape[1] == fmt.latent_channels:
+            return samples
+
+        if fmt.latent_dimensions == 3 and x.ndim == 4:
+            if x.count_nonzero() == 0:
+                x = torch.zeros(
+                    [x.shape[0], fmt.latent_channels, 1, x.shape[2], x.shape[3]],
+                    dtype=x.dtype, device=x.device)
+            elif plot_image_vars.get("images") is not None:
+                x = vae.encode(plot_image_vars["images"][..., :3])
+            else:
+                raise RuntimeError(
+                    "Switching to a 3D-latent model requires an input image "
+                    "or an empty latent"
+                )
+
+            return {**samples, "samples": x}
+
+        return samples
+
    @staticmethod
    def get_font(font_size, font_path=None):
        if font_path is None:
@@ -118,24 +151,32 @@ class easyXYPlot():

    def calculate_background_dimensions(self):
        border_size = int((self.max_width // 8) * 1.5) if self.y_type != "None" or self.x_type != "None" else 0
+
        bg_width = self.num_cols * (self.max_width + self.grid_spacing) - self.grid_spacing + border_size * (
                    self.y_type != "None")
        bg_height = self.num_rows * (self.max_height + self.grid_spacing) - self.grid_spacing + border_size * (
                    self.x_type != "None")
+        
+        # Add space at the bottom of the image for common informaiton about the image
+        bg_height = bg_height + (border_size*2)
+#        print(f"Grid Size: width = {bg_width} height = {bg_height} border_size = {border_size}")

        x_offset_initial = border_size if self.y_type != "None" else 0
        y_offset = border_size if self.x_type != "None" else 0

        return bg_width, bg_height, x_offset_initial, y_offset

+
    def adjust_font_size(self, text, initial_font_size, label_width):
        font = self.get_font(initial_font_size, self.custom_font)
        text_width = font.getbbox(text)
+#        pprint.pp(f"Initial font size: {initial_font_size}, text: {text}, text_width: {text_width}")
        if text_width and text_width[2]:
            text_width = text_width[2]

        scaling_factor = 0.9
        if text_width > (label_width * scaling_factor):
+#            print(f"Adjusting font size from {initial_font_size} to fit text width {text_width} into label width {label_width} scaling_factor {scaling_factor}")
            return int(initial_font_size * (label_width / text_width) * scaling_factor)
        else:
            return initial_font_size
@@ -144,15 +185,22 @@ class easyXYPlot():
        _, _, width, height = d.textbbox((0, 0), text=text, font=font)
        return width, height

-    def create_label(self, img, text, initial_font_size, is_x_label=True, max_font_size=70, min_font_size=10):
-        label_width = img.width if is_x_label else img.height
+    def create_label(self, img, text, initial_font_size, is_x_label=True, max_font_size=70, min_font_size=10, label_width=0, label_height=0):

+        # if the label_width is specified, leave it along.  Otherwise do the old logic.
+        if label_width == 0:          
+            label_width = img.width if is_x_label else img.height
+
+        text_lines = text.split('\n')
+        longest_line = max(text_lines, key=len)
+                
        # Adjust font size
-        font_size = self.adjust_font_size(text, initial_font_size, label_width)
+        font_size = self.adjust_font_size(longest_line, initial_font_size, label_width)
        font_size = min(max_font_size, font_size)  # Ensure font isn't too large
        font_size = max(min_font_size, font_size)  # Ensure font isn't too small

-        label_height = int(font_size * 1.5) if is_x_label else font_size
+        if label_height == 0:
+            label_height = int(font_size * 1.5) if is_x_label else font_size

        label_bg = Image.new('RGBA', (label_width, label_height), color=(255, 255, 255, 0))
        d = ImageDraw.Draw(label_bg)
@@ -166,7 +214,7 @@ class easyXYPlot():
            text = text + '...'

        # Compute text width and height for multi-line text
-        text_lines = text.split('\n')
+  
        text_widths, text_heights = zip(*[self.textsize(d, line, font=font) for line in text_lines])
        max_text_width = max(text_widths)
        total_text_height = sum(text_heights)
@@ -195,8 +243,7 @@ class easyXYPlot():
        clip = clip if clip is not None else plot_image_vars["clip"]
        steps = plot_image_vars['steps'] if "steps" in plot_image_vars else 1

-        sd_version = get_sd_version(plot_image_vars['model'])
-
+        sd_version = get_sd_version(plot_image_vars['model'])          
        # 高级用法
        if plot_image_vars["x_node_type"] == "advanced" or plot_image_vars["y_node_type"] == "advanced":
            if self.x_type == "Seeds++ Batch" or self.y_type == "Seeds++ Batch":
@@ -345,19 +392,58 @@ class easyXYPlot():
                    if "negative_cond" in plot_image_vars:
                        negative = negative + plot_image_vars["negative_cond"]

+            # DiffusionModel
+            if self.x_type == "DiffusionModel" or self.y_type == "DiffusionModel":
+                xy_values = x_value if self.x_type == "DiffusionModel" else y_value
+                model_name, clip_name, vae_name = xy_values.split(",")
+                model, clip, vae, family = self.easyCache.load_diffusion_xy_model(
+                    model_name.replace("*", ","),
+                    clip_name.replace("*", ","),
+                    vae_name.replace("*", ","),
+                )
+                sd_version = family
+
+                positive = plot_image_vars["positive"]
+                negative = plot_image_vars["negative"]
+                if positive is not None:
+                    positive, = CLIPTextEncode().encode(clip, positive)
+                if negative is not None:
+                    negative, = CLIPTextEncode().encode(clip, negative)
+
+                samples = self._ensure_latent_for_model(
+                    model, vae, samples, plot_image_vars
+                )
+
            # Lora
            if self.x_type == "Lora" or self.y_type == "Lora":
+#                print(f"Lora: {x_value} {y_value}")
                model = model if model is not None else plot_image_vars["model"]
                clip = clip if clip is not None else plot_image_vars["clip"]
+                
+                # Build lora_stack from both X and Y axes if both are LoRA types
+                lora_stack = []
+                
+                # Add X axis LoRA if present
+                if self.x_type == "Lora":
+                    lora_name, lora_model_strength, lora_clip_strength, _ = x_value.split(",")
+                    lora_stack.append({"lora_name": lora_name, "model": model, "clip": clip, "model_strength": float(lora_model_strength), "clip_strength": float(lora_clip_strength)})
+                
+                # Add Y axis LoRA if present
+                if self.y_type == "Lora":
+                    lora_name, lora_model_strength, lora_clip_strength, _ = y_value.split(",")
+                    lora_stack.append({"lora_name": lora_name, "model": model, "clip": clip, "model_strength": float(lora_model_strength), "clip_strength": float(lora_clip_strength)})
+                
+#                print(f"new_lora_stack: {new_lora_stack}")

-                xy_values = x_value if self.x_type == "Lora" else y_value
-                lora_name, lora_model_strength, lora_clip_strength, _ = xy_values.split(",")
-                lora_stack = [{"lora_name": lora_name, "model": model, "clip" :clip, "model_strength": float(lora_model_strength), "clip_strength": float(lora_clip_strength)}]
+                
                if 'lora_stack' in plot_image_vars:
                    lora_stack = lora_stack + plot_image_vars['lora_stack']
-
+                
                if lora_stack is not None and lora_stack != []:
                    for lora in lora_stack:
+                        # Each generation of the model, must use the reference to previously created model / clip objects.
+                        lora['model'] = model
+                        lora['clip'] = clip
                        model, clip = self.easyCache.load_lora(lora)

            # 提示词
@@ -365,7 +451,7 @@ class easyXYPlot():
                if self.x_type == 'Positive Prompt S/R' or self.y_type == 'Positive Prompt S/R':
                    positive = x_value if self.x_type == "Positive Prompt S/R" else y_value

-                if sd_version == 'flux':
+                if sd_version in ("flux", "anima", "krea2"):
                    positive, = CLIPTextEncode().encode(clip, positive)
                else:
                    positive = advanced_encode(clip, positive,
@@ -381,7 +467,7 @@ class easyXYPlot():
                if self.x_type == 'Negative Prompt S/R' or self.y_type == 'Negative Prompt S/R':
                    negative = x_value if self.x_type == "Negative Prompt S/R" else y_value

-                if sd_version == 'flux':
+                if sd_version in ("flux", "anima", "krea2"):
                    negative, = CLIPTextEncode().encode(clip, negative)
                else:
                    negative = advanced_encode(clip, negative,
@@ -406,7 +492,8 @@ class easyXYPlot():
                        strength = item[2]
                        start_percent = item[3]
                        end_percent = item[4]
-                        positive, negative = easyControlnet().apply(control_net_name, image, positive, negative, strength, start_percent, end_percent, None, 1)
+                        provided_control_net = item[5] if len(item) > 5 else None
+                        positive, negative = easyControlnet().apply(control_net_name, image, positive, negative, strength, start_percent, end_percent, provided_control_net, 1)
            # Flux guidance
            if self.x_type == "Flux Guidance" or self.y_type == "Flux Guidance":
                positive = plot_image_vars["positive_cond"] if "positive" in plot_image_vars else None
@@ -415,15 +502,32 @@ class easyXYPlot():

        # 简单用法
        if plot_image_vars["x_node_type"] == "loader" or plot_image_vars["y_node_type"] == "loader":
-            model, clip, vae, clip_vision = self.easyCache.load_checkpoint(plot_image_vars['ckpt_name'])
+            if self.x_type == 'ckpt_name' or self.y_type == 'ckpt_name':
+                ckpt_name = x_value if self.x_type == "ckpt_name" else y_value
+                model, clip, vae, clip_vision = self.easyCache.load_checkpoint(ckpt_name)

-            if plot_image_vars['lora_name'] != "None":
-                lora = {"lora_name": plot_image_vars['lora_name'], "model": model, "clip": clip, "model_strength": plot_image_vars['lora_model_strength'], "clip_strength": plot_image_vars['lora_clip_strength']}
+            if self.x_type == 'lora_name' or self.y_type == 'lora_name':
+                model, clip, vae, clip_vision = self.easyCache.load_checkpoint(plot_image_vars['ckpt_name'])
+                lora_name = x_value if self.x_type == "lora_name" else y_value
+                lora = {"lora_name": lora_name, "model": model, "clip": clip, "model_strength": 1, "clip_strength": 1}
+                model, clip = self.easyCache.load_lora(lora)
+
+            if self.x_type == 'lora_model_strength' or self.y_type == 'lora_model_strength':
+                model, clip, vae, clip_vision = self.easyCache.load_checkpoint(plot_image_vars['ckpt_name'])
+                lora_model_strength = float(x_value) if self.x_type == "lora_model_strength" else float(y_value)
+                lora = {"lora_name": plot_image_vars['lora_name'], "model": model, "clip": clip, "model_strength": lora_model_strength, "clip_strength": plot_image_vars['lora_clip_strength']}
+                model, clip = self.easyCache.load_lora(lora)
+
+            if self.x_type == 'lora_clip_strength' or self.y_type == 'lora_clip_strength':
+                model, clip, vae, clip_vision = self.easyCache.load_checkpoint(plot_image_vars['ckpt_name'])
+                lora_clip_strength = float(x_value) if self.x_type == "lora_clip_strength" else float(y_value)
+                lora = {"lora_name": plot_image_vars['lora_name'], "model": model, "clip": clip, "model_strength": plot_image_vars['lora_model_strength'], "clip_strength": lora_clip_strength}
                model, clip = self.easyCache.load_lora(lora)

            # Check for custom VAE
-            if plot_image_vars['vae_name'] not in ["Baked-VAE", "Baked VAE"]:
-                vae = self.easyCache.load_vae(plot_image_vars['vae_name'])
+            if self.x_type == 'vae_name' or self.y_type == 'vae_name':
+                vae_name = x_value if self.x_type == "vae_name" else y_value
+                vae = self.easyCache.load_vae(vae_name)

            # CLIP skip
            if not clip:
@@ -431,7 +535,7 @@ class easyXYPlot():
            clip = clip.clone()
            clip.clip_layer(plot_image_vars['clip_skip'])

-            if sd_version == 'flux':
+            if sd_version in ("flux", "anima", "krea2"):
                positive, = CLIPTextEncode().encode(clip, positive)
            else:
                positive = advanced_encode(clip, plot_image_vars['positive'],
@@ -439,7 +543,7 @@ class easyXYPlot():
                                                            plot_image_vars['positive_weight_interpretation'], w_max=1.0,
                                                            apply_to_pooled="enable",a1111_prompt_style=a1111_prompt_style, steps=steps)

-            if sd_version == 'flux':
+            if sd_version in ("flux", "anima", "krea2"):
                negative, = CLIPTextEncode().encode(clip, negative)
            else:
                negative = advanced_encode(clip, plot_image_vars['negative'],
@@ -447,6 +551,7 @@ class easyXYPlot():
                                                            plot_image_vars['negative_weight_interpretation'], w_max=1.0,
                                                            apply_to_pooled="enable", a1111_prompt_style=a1111_prompt_style, steps=steps)

+
        model = model if model is not None else plot_image_vars["model"]
        vae = vae if vae is not None else plot_image_vars["vae"]
        positive = positive if positive is not None else plot_image_vars["positive_cond"]
@@ -534,28 +639,40 @@ class easyXYPlot():

    def get_labels_and_sample(self, plot_image_vars, latent_image, preview_latent, start_step, last_step,
                              force_full_denoise, disable_noise):
-        for x_index, x_value in enumerate(self.x_values):
-            plot_image_vars, x_value_label = self.define_variable(plot_image_vars, self.x_type, x_value,
-                                                                  x_index)
-            self.x_label = self.update_label(self.x_label, x_value_label, len(self.x_values))
-            if self.y_type != 'None':
+        # Handle X-only variation (Y is "None")
+        if self.y_type == 'None':
+            for x_index, x_value in enumerate(self.x_values):
+                plot_image_vars, x_value_label = self.define_variable(plot_image_vars, self.x_type, x_value, x_index)
+                self.x_label = self.update_label(self.x_label, x_value_label, len(self.x_values))
+                
+                self.image_list, self.max_width, self.max_height, self.latents_plot = self.sample_plot_image(
+                    plot_image_vars, latent_image, preview_latent, self.latents_plot, self.image_list,
+                    disable_noise, start_step, last_step, force_full_denoise, x_value)
+                self.num += 1
+        # Handle Y-only variation (X is "None")
+        elif self.x_type == 'None':
+            for y_index, y_value in enumerate(self.y_values):
+                plot_image_vars, y_value_label = self.define_variable(plot_image_vars, self.y_type, y_value, y_index)
+                self.y_label = self.update_label(self.y_label, y_value_label, len(self.y_values))
+                
+                self.image_list, self.max_width, self.max_height, self.latents_plot = self.sample_plot_image(
+                    plot_image_vars, latent_image, preview_latent, self.latents_plot, self.image_list,
+                    disable_noise, start_step, last_step, force_full_denoise, y_value=y_value)
+                self.num += 1
+        # Handle both X and Y variation
+        else:
+            for x_index, x_value in enumerate(self.x_values):
+                plot_image_vars, x_value_label = self.define_variable(plot_image_vars, self.x_type, x_value, x_index)
+                self.x_label = self.update_label(self.x_label, x_value_label, len(self.x_values))
+                
                for y_index, y_value in enumerate(self.y_values):
-                    plot_image_vars, y_value_label = self.define_variable(plot_image_vars, self.y_type, y_value,
-                                                                          y_index)
+                    plot_image_vars, y_value_label = self.define_variable(plot_image_vars, self.y_type, y_value, y_index)
                    self.y_label = self.update_label(self.y_label, y_value_label, len(self.y_values))
-                    # ttNl(f'{CC.GREY}X: {x_value_label}, Y: {y_value_label}').t(
-                    #     f'Plot Values {self.num}/{self.total} ->').p()
-
+                    
                    self.image_list, self.max_width, self.max_height, self.latents_plot = self.sample_plot_image(
                        plot_image_vars, latent_image, preview_latent, self.latents_plot, self.image_list,
                        disable_noise, start_step, last_step, force_full_denoise, x_value, y_value)
                    self.num += 1
-            else:
-                # ttNl(f'{CC.GREY}X: {x_value_label}').t(f'Plot Values {self.num}/{self.total} ->').p()
-                self.image_list, self.max_width, self.max_height, self.latents_plot = self.sample_plot_image(
-                    plot_image_vars, latent_image, preview_latent, self.latents_plot, self.image_list, disable_noise,
-                    start_step, last_step, force_full_denoise, x_value)
-                self.num += 1

        # Rearrange latent array to match preview image grid
        self.latents_plot = self.rearrange_tensors(self.latents_plot, self.num_cols, self.num_rows)
@@ -565,11 +682,10 @@ class easyXYPlot():

        return self.latents_plot

-    def plot_images_and_labels(self):
-        # Calculate the background dimensions
+    def plot_images_and_labels(self, plot_image_vars):
+                    
        bg_width, bg_height, x_offset_initial, y_offset = self.calculate_background_dimensions()

-        # Create the white background image
        background = Image.new('RGBA', (int(bg_width), int(bg_height)), color=(255, 255, 255, 255))

        output_image = []
@@ -601,4 +717,55 @@ class easyXYPlot():

            y_offset += img.height + self.grid_spacing

-        return (self.sampler.pil2tensor(background), output_image)
+        # lookup used models in the image
+        common_label = ""
+        # Update to add a function to do the heavy lifting. Parameters are plot_image_vars name, label to use, names of the axis, 
+
+        # pprint.pp(plot_image_vars)
+
+        # We don't process LORAs here because there can be multiple of them.
+        labels = [
+            {"id": "ckpt_name", "id_desc": "ckpt", "axis_type" : "Checkpoint"},
+            {"id": "vae_name", "id_desc": '', "axis_type" : "vae_name"},
+            {"id": "sampler_name", "id_desc": "sampler", "axis_type" : "Sampler"},
+            {"id": "scheduler", "id_desc": '', "axis_type" : "Scheduler"},
+            {"id": "steps", "id_desc": '', "axis_type" : "Steps"},
+            {"id": "Flux Guidance", "id_desc": 'guidance', "axis_type" : "Flux Guidance"},     
+            {"id": "seed", "id_desc": '', "axis_type" : "Seeds++ Batch"}
+        ]
+        
+        for item in labels:
+            # Only add the label if it's not one of the axis
+            # print(f"Checking item: {item['id']} axis_type {item['axis_type']} x_type: {self.x_type} y_type: {self.y_type}")
+            if self.x_type != item['axis_type'] and self.y_type != item['axis_type']:
+                common_label += self.add_common_label(item['id'], plot_image_vars, item['id_desc'])
+        common_label += f"\n"
+                
+        if plot_image_vars['lora_stack'] is not None and plot_image_vars['lora_stack'] != []:
+#            print(f"lora_stack: {plot_image_vars['lora_stack']}")
+            for lora in plot_image_vars['lora_stack']:
+
+                lora_name = lora['lora_name']
+                lora_weight = lora['model_strength']
+                if lora_name is not None and len(lora_name) > 0 and lora_weight > 0:
+                    common_label += f"LORA: {lora_name} weight: {lora_weight:.2f} \n"
+                    
+        common_label = common_label.strip()
+        
+        if len(common_label) > 0:
+            label_height = background.height - y_offset
+            label_bg = self.create_label(background, common_label, int(48 * background.width / 512), label_width=background.width, label_height=label_height)
+            label_x = (background.width - label_bg.width) // 2
+            label_y = y_offset
+#            print(f"Adding common label: {common_label} x = {label_x} y = {label_y}")
+            background.alpha_composite(label_bg, (label_x, label_y))
+
+        return (self.sampler.pil2tensor(background), output_image)
+
+    def add_common_label(self, tag, plot_image_vars, description = ''):
+        label = ''
+        if description == '': description = tag
+        if tag in plot_image_vars and plot_image_vars[tag] is not None and plot_image_vars[tag] != 'None':
+            label += f"{description}: {plot_image_vars[tag]} "
+#        print(f"add_common_label: {tag} description: {description} label: {label}" )
+        return label
@@ -3,7 +3,7 @@
 import comfy.ops
 import torch
 import folder_paths
-from ..libs.utils import install_package
+from ...libs.utils import install_package

 try:
    from bitsandbytes.nn.modules import Params4bit, QuantState
@@ -5,13 +5,21 @@ import os
 import types

 import torch
-from accelerate import init_empty_weights, load_checkpoint_and_dispatch
+try:
+    from accelerate import init_empty_weights, load_checkpoint_and_dispatch
+except:
+    init_empty_weights, load_checkpoint_and_dispatch = None, None

 import comfy

-from .model import BrushNetModel, PowerPaintModel
-from .model_patch import add_model_patch_option, patch_model_function_wrapper
-from .powerpaint_utils import TokenizerWrapper, add_tokens
+try:
+    from .model import BrushNetModel, PowerPaintModel
+    from .model_patch import add_model_patch_option, patch_model_function_wrapper
+    from .powerpaint_utils import TokenizerWrapper, add_tokens
+except:
+    BrushNetModel, PowerPaintModel = None, None
+    add_model_patch_option, patch_model_function_wrapper = None, None
+    TokenizerWrapper, add_tokens = None, None

 cwd_path = os.path.dirname(os.path.realpath(__file__))
 brushnet_config_file = os.path.join(cwd_path, 'config', 'brushnet.json')
@@ -272,11 +280,11 @@ class BrushNet:

        # unload vae
        del vae
-        for loaded_model in comfy.model_management.current_loaded_models:
-            if type(loaded_model.model.model) in ModelsToUnload:
-                comfy.model_management.current_loaded_models.remove(loaded_model)
-                loaded_model.model_unload()
-                del loaded_model
+        # for loaded_model in comfy.model_management.current_loaded_models:
+        #     if type(loaded_model.model.model) in ModelsToUnload:
+        #         comfy.model_management.current_loaded_models.remove(loaded_model)
+        #         loaded_model.model_unload()
+        #         del loaded_model

        # prepare embeddings
        prompt_embeds = positive[0][0].to(dtype=torch_dtype).to(brushnet['brushnet'].device)
@@ -449,11 +457,11 @@ class BrushNet:
        # unload vae and CLIPs
        del vae
        del clip
-        for loaded_model in comfy.model_management.current_loaded_models:
-            if type(loaded_model.model.model) in ModelsToUnload:
-                comfy.model_management.current_loaded_models.remove(loaded_model)
-                loaded_model.model_unload()
-                del loaded_model
+        # for loaded_model in comfy.model_management.current_loaded_models:
+        #     if type(loaded_model.model.model) in ModelsToUnload:
+        #         comfy.model_management.current_loaded_models.remove(loaded_model)
+        #         loaded_model.model_unload()
+        #         del loaded_model

        # apply patch to model

@@ -663,8 +671,16 @@ def add_brushnet_patch(model, brushnet, torch_dtype, conditioning_latents,

    is_SDXL = isinstance(model.model.model_config, comfy.supported_models.SDXL)

+    if model.model.model_config.custom_operations is None:
+        fp8 = model.model.model_config.optimizations.get("fp8", model.model.model_config.scaled_fp8 is not None)
+        operations = comfy.ops.pick_operations(model.model.model_config.unet_config.get("dtype", None), model.model.manual_cast_dtype,
+                                               fp8_optimizations=fp8, scaled_fp8=model.model.model_config.scaled_fp8)
+    else:
+        # such as gguf
+        operations = model.model.model_config.custom_operations
+
    if is_SDXL:
-        input_blocks = [[0, comfy.ops.manual_cast.Conv2d],
+        input_blocks = [[0, operations.Conv2d],
                        [1, comfy.ldm.modules.diffusionmodules.openaimodel.ResBlock],
                        [2, comfy.ldm.modules.diffusionmodules.openaimodel.ResBlock],
                        [3, comfy.ldm.modules.diffusionmodules.openaimodel.Downsample],
@@ -686,7 +702,7 @@ def add_brushnet_patch(model, brushnet, torch_dtype, conditioning_latents,
                         [7, comfy.ldm.modules.diffusionmodules.openaimodel.ResBlock],
                         [8, comfy.ldm.modules.diffusionmodules.openaimodel.ResBlock]]
    else:
-        input_blocks = [[0, comfy.ops.manual_cast.Conv2d],
+        input_blocks = [[0, operations.Conv2d],
                        [1, comfy.ldm.modules.attention.SpatialTransformer],
                        [2, comfy.ldm.modules.attention.SpatialTransformer],
                        [3, comfy.ldm.modules.diffusionmodules.openaimodel.Downsample],
@@ -4,7 +4,7 @@ from typing import Any, Dict, List, Optional, Tuple, Union
 import torch
 from torch import nn

-from ..libs.utils import install_package
+from ...libs.utils import install_package
 try:
    install_package("diffusers", "0.27.2", True, "0.25.0")

@@ -1,3 +1,6 @@
+import os
+import json
+import copy
 import torch
 import math
 import comfy.supported_models_base
@@ -7,7 +10,7 @@ import comfy.model_base
 import comfy.utils
 import comfy.conds
 from comfy import model_management
-from .diffusers_convert import convert_state_dict
+from .diffusers_convert import convert_state_dict, convert_lora_state_dict

 # checkpointbf
 class EXM_PixArt(comfy.supported_models_base.BASE):
@@ -77,7 +77,7 @@ class ControlPixArtHalf(Module):

    def forward_c(self, c):
        self.h, self.w = c.shape[-2]//self.patch_size, c.shape[-1]//self.patch_size
-        pos_embed = torch.from_numpy(get_2d_sincos_pos_embed(self.pos_embed.shape[-1], (self.h, self.w), lewei_scale=self.lewei_scale, base_size=self.base_size)).unsqueeze(0).to(c.device).to(self.dtype)
+        pos_embed = torch.from_numpy(get_2d_sincos_pos_embed(self.pos_embed.shape[-1], (self.h, self.w), pe_interpolation=self.pe_interpolation, base_size=self.base_size)).unsqueeze(0).to(c.device).to(self.dtype)
        return self.x_embedder(c) + pos_embed if c is not None else c

    # def forward(self, x, t, c, **kwargs):
@@ -225,7 +225,7 @@ class ControlPixArtMSHalf(ControlPixArtHalf):
        c_size, ar = data_info['img_hw'].to(self.dtype), data_info['aspect_ratio'].to(self.dtype)
        self.h, self.w = x.shape[-2]//self.patch_size, x.shape[-1]//self.patch_size

-        pos_embed = torch.from_numpy(get_2d_sincos_pos_embed(self.pos_embed.shape[-1], (self.h, self.w), lewei_scale=self.lewei_scale, base_size=self.base_size)).unsqueeze(0).to(x.device).to(self.dtype)
+        pos_embed = torch.from_numpy(get_2d_sincos_pos_embed(self.pos_embed.shape[-1], (self.h, self.w), pe_interpolation=self.pe_interpolation, base_size=self.base_size)).unsqueeze(0).to(x.device).to(self.dtype)
        x = self.x_embedder(x) + pos_embed  # (N, T, D), where T = H * W / patch_size ** 2
        t = self.t_embedder(timestep)  # (N, D)
        csize = self.csize_embedder(c_size, bs)  # (N, D)
@@ -7,7 +7,7 @@ from comfy.model_base import BaseModel
 from comfy.model_patcher import ModelPatcher
 from comfy.model_management import cast_to_device

-from ..libs.log import log_node_warn, log_node_error, log_node_info
+from ...libs.log import log_node_warn, log_node_error, log_node_info

 class InpaintHead(torch.nn.Module):
    def __init__(self, *args, **kwargs):
@@ -2,7 +2,7 @@ import numpy as np
 import torch
 from PIL import Image
 from .parsing_api import onnx_inference
-from ..libs.utils import install_package
+from ...libs.utils import install_package

 class HumanParsing:
    def __init__(self, model_path):
@@ -19,7 +19,7 @@ class HumanParsing:
            session_options.execution_mode = ort.ExecutionMode.ORT_SEQUENTIAL
            # session_options.add_session_config_entry('gpu_id', str(gpu_id))
            self.session = ort.InferenceSession(self.model_path, sess_options=session_options,
-                                                providers=['CPUExecutionProvider'])
+                                                providers=['CUDAExecutionProvider', 'CPUExecutionProvider'])

        parsed_image, mask = onnx_inference(self.session, input_image, mask_components)
        return parsed_image, mask
@@ -11,7 +11,7 @@ from comfy.model_base import BaseModel
 from comfy.model_patcher import ModelPatcher
 from PIL import Image
 from nodes import VAEEncode
-from ..libs.image import np2tensor, pil2tensor
+from ...libs.image import np2tensor, pil2tensor

 class UnetParams(TypedDict):
    input: torch.Tensor
--- a/Show More
+++ b/Show More