Bump Version

* Change to new mask components on humanSegmentation

* Change segformer index

* Add segformer_b3_clothes and fashion

* Add face_parsing

* Fix face_parsing output error images

---------

Co-authored-by: yolain <me@yolain.com>

.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+custom: ["https://space.bilibili.com/1840885116"]

.github/workflows/publish.yml

@@ -7,15 +7,19 @@ on:
     paths:
       - "pyproject.toml"
 
+permissions:
+  issues: 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: 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 }}

.gitignore

@@ -7,9 +7,14 @@ wildcards/**
 styles/**
 workflow/**
 autocomplete/**
+web_beta/**
+web_version/dev/**
 docs/**
 .vscode/
 .idea/
 mmb-preset.custom.txt
 config.yaml
-node.tar.gz
+node.tar.gz
+
+.cursorrules
+tools/ComfyUI-Easy-Use.json

.gitmodules

@@ -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

README.ZH_CN.md

@@ -0,0 +1,541 @@
+![comfyui-easy-use](https://github.com/user-attachments/assets/9b7a5e44-f5e2-4c27-aed2-d0e6b50c46bb)
+
+<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>
+<a href="./README.md"><img src="https://img.shields.io/badge/🇬🇧English-e9e9e9"></a>
+<a href="./README.ZH_CN.md"><img src="https://img.shields.io/badge/🇨🇳中文简体-0b8cf5"></a>
+</div>
+
+**ComfyUI-Easy-Use** 是一个化繁为简的节点整合包, 在 [tinyterraNodes](https://github.com/TinyTerra/ComfyUI_tinyterraNodes) 的基础上进行延展，并针对了诸多主流的节点包做了整合与优化，以达到更快更方便使用ComfyUI的目的，在保证自由度的同时还原了本属于Stable Diffusion的极致畅快出图体验。
+
+## 👨🏻‍🎨 特色介绍
+
+- 沿用了 [tinyterraNodes](https://github.com/TinyTerra/ComfyUI_tinyterraNodes) 的思路，大大减少了折腾工作流的时间成本。
+- UI界面美化，首次安装的用户，如需使用UI主题，请在 Settings -> Color Palette 中自行切换主题并**刷新页面**即可
+- 增加了预采样参数配置的节点，可与采样节点分离，更方便预览。
+- 支持通配符与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)
+- 可使用`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)
+- 简化 Layer Diffuse [示例参考](https://github.com/yolain/ComfyUI-Yolain-Workflows?tab=readme-ov-file#2-3-layerdiffusion)
+- 简化 InstantID [示例参考](https://github.com/yolain/ComfyUI-Yolain-Workflows?tab=readme-ov-file#2-2-instantid), 需先保证自定义节点包中安装了 [ComfyUI_InstantID](https://github.com/cubiq/ComfyUI_InstantID)
+- 简化 IPAdapter, 需先保证自定义节点包中安装最新版v2的 [ComfyUI_IPAdapter_plus](https://github.com/cubiq/ComfyUI_IPAdapter_plus)
+- 扩展 XYplot 的可用性
+- 整合了Fooocus Inpaint功能
+- 整合了常用的逻辑计算、转换类型、展示所有类型等
+- 支持节点上checkpoint、lora模型子目录分类及预览图 (请在设置中开启上下文菜单嵌套子目录)
+- 支持BriaAI的RMBG-1.4模型的背景去除节点，[技术参考](https://huggingface.co/briaai/RMBG-1.4)
+- 支持 强制清理comfyUI模型显存占用
+- 支持Stable Diffusion 3 多账号API节点
+- 支持IC-Light的应用 [示例参考](https://github.com/yolain/ComfyUI-Yolain-Workflows?tab=readme-ov-file#2-5-ic-light) | [代码整合来源](https://github.com/huchenlei/ComfyUI-IC-Light) | [技术参考](https://github.com/lllyasviel/IC-Light)
+- 中文提示词自动识别，使用[opus-mt-zh-en模型](https://huggingface.co/Helsinki-NLP/opus-mt-zh-en)
+- 支持 sd3 模型
+- 支持 kolors 模型
+- 支持 flux 模型
+- 支持 惰性条件判断（ifElse）和 for循环
+
+## 👨🏻‍🔧 安装
+
+1. 将存储库克隆到 **custom_nodes** 目录并安装依赖
+```shell
+#1. git下载
+git clone https://github.com/yolain/ComfyUI-Easy-Use
+#2. 安装依赖
+双击install.bat安装依赖
+```
+
+## 📜 更新日志
+
+**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**
+
+- 修复了在缺少自定义节点时缺少 “红色框框” 样式的问题。
+- 在一些简单的加载器中，将 `clip_skip` 的默认值从 `-1` 调整为 `-2`。
+- 修复因设置节点中缺少相连接的自定义节点而导致弄乱画布的问题
+- 修复 'easy imageChooser' 不能循环使用的问题。
+
+**v1.2.5**
+
+- 在 `easy preSamplingCustom` 和 `easy preSamplingAdvanced` 上增加 `enable (GPU=A1111)` 噪波生成模式选择项
+- 增加 `easy makeImageForICLora`
+- 在 `easy ipadapterApply` 添加 `REGULAR - FLUX and SD3.5 only (high strength)` 预置项以支持 InstantX Flux ipadapter 
+- 修复brushnet 无法在 `--fast` 模式下使用 
+- 支持briaai RMBG-2.0
+- 支持mochi模型
+- 实现在循环主体中重复使用终端节点输出（例如预览图像和显示任何内容等输出节点...）
+
+**v1.2.4**
+
+- 增加 `easy imageSplitTiles` and `easy imageTilesFromBatch` - 图像分块
+- 支持 `model_override`,`vae_override`,`clip_override` 可以在 `easy fullLoader` 中单独输入
+- 增加 `easy saveImageLazy`
+- 增加 `easy loadImageForLoop`
+- 增加 `easy isFileExist`
+- 增加 `easy saveText`
+
+**v1.2.3**
+
+- `easy showAnything` 和 `easy cleanGPUUsed` 增加输出插槽
+- 添加新的人体分割在 `easy humanSegmentation` 节点上 - 代码从 [ComfyUI_Human_Parts](https://github.com/metal3d/ComfyUI_Human_Parts) 整合
+- 当你在 `easy preSamplingCustom` 节点上选择basicGuider，CFG>0 且当前模型为Flux时，将使用FluxGuidance
+- 增加 `easy loraStackApply` and `easy controlnetStackApply`
+
+**v1.2.2**
+
+- 增加 `easy batchAny`
+- 增加 `easy anythingIndexSwitch`
+- 增加 `easy forLoopStart` 和 `easy forLoopEnd`  
+- 增加 `easy ifElse`
+- 增加 v2 版本新前端代码
+- 增加 `easy fluxLoader`
+- 增加 `controlnetApply` 相关节点对sd3和hunyuanDiT的支持
+- 修复 当使用fooocus inpaint后，再使用Lora模型无法生效的问题
+
+**v1.2.1**
+
+- 增加 `easy ipadapterApplyFaceIDKolors`
+- `easy ipadapterApply` 和 `easy ipadapterApplyADV` 增加 **PLUS (kolors genernal)** 和 **FACEID PLUS KOLORS** 预置项
+- `easy imageRemBg` 增加 **inspyrenet** 选项
+- 增加 `easy controlnetLoader++`
+- 去除 `easy positive` `easy negative` 等prompt节点的自动将中文翻译功能，自动翻译仅在 `easy a1111Loader` 等不支持中文TE的加载器中生效
+- 增加 `easy kolorsLoader` - 可灵加载器，参考了 [MinusZoneAI](https://github.com/MinusZoneAI/ComfyUI-Kolors-MZ) 和 [kijai](https://github.com/kijai/ComfyUI-KwaiKolorsWrapper) 的代码。
+
+**v1.2.0**
+
+- 增加 `easy pulIDApply` 和 `easy pulIDApplyADV`
+- 增加 `easy hunyuanDiTLoader` 和 `easy pixArtLoader`
+- 当新菜单的位置在上或者下时增加上 crystools 的显示，推荐开两个就好（如果后续crystools有更新UI适配我可能会删除掉）
+- 增加 **easy sliderControl** - 滑块控制节点，当前可用于控制ipadapterMS的参数 (双击滑块可重置为默认值)
+- 增加 **layer_weights** 属性在 `easy ipadapterApplyADV` 节点
+
+**v1.1.9**
+
+- 增加 新的调度器 **gitsScheduler**
+- 增加 `easy imageBatchToImageList` 和 `easy imageListToImageBatch` (修复Impact版的一点小问题)
+- 递归模型子目录嵌套
+- 支持 sd3 模型 
+- 增加 `easy applyInpaint` - 局部重绘全模式节点 (相比与之前的kSamplerInpating节点逻辑会更合理些)
+
+**v1.1.8**
+
+- 增加中文提示词自动翻译，使用[opus-mt-zh-en模型](https://huggingface.co/Helsinki-NLP/opus-mt-zh-en), 默认已对wildcard、lora正则处理, 其他需要保留的中文，可使用`@你的提示词@`包裹 (若依赖安装完成后报错, 请重启)，测算大约会占0.3GB显存
+- 增加 `easy controlnetStack` - controlnet堆
+- 增加 `easy applyBrushNet` - [示例参考](https://github.com/yolain/ComfyUI-Yolain-Workflows/blob/main/workflows/2_advanced/2-4inpainting/2-4brushnet_1.1.8.json)
+- 增加 `easy applyPowerPaint` - [示例参考](https://github.com/yolain/ComfyUI-Yolain-Workflows/blob/main/workflows/2_advanced/2-4inpainting/2-4powerpaint_outpaint_1.1.8.json)
+
+**v1.1.7**
+
+- 修复 一些模型(如controlnet模型等)未成功写入缓存，导致修改前置节点束参数（如提示词）需要二次载入模型的问题
+- 增加 `easy prompt` - 主体和光影预置项，后期可能会调整
+- 增加 `easy icLightApply` - 重绘光影, 从[ComfyUI-IC-Light](https://github.com/huchenlei/ComfyUI-IC-Light)优化
+- 增加 `easy imageSplitGrid` - 图像网格拆分
+- `easy kSamplerInpainting` 的 **additional** 属性增加差异扩散和brushnet等相关选项 
+- 增加 brushnet模型加载的支持 - [ComfyUI-BrushNet](https://github.com/nullquant/ComfyUI-BrushNet)
+- 增加 `easy applyFooocusInpaint` - Fooocus内补节点 替代原有的 FooocusInpaintLoader
+- 移除 `easy fooocusInpaintLoader` - 容易bug，不再使用
+- 修改 easy kSampler等采样器中并联的model 不再替换输出中pipe里的model
+
+**v1.1.6**
+
+- 增加步调齐整适配 - 在所有的预采样和全采样器节点中的 调度器(schedulder) 增加了 **alignYourSteps** 选项
+- `easy kSampler` 和 `easy fullkSampler` 的 **image_output** 增加 **Preview&Choose**选项
+- 增加 `easy styleAlignedBatchAlign` - 风格对齐 [style_aligned_comfy](https://github.com/brianfitzgerald/style_aligned_comfy)
+- 增加 `easy ckptNames`
+- 增加 `easy controlnetNames`
+- 增加 `easy imagesSplitimage` - 批次图像拆分单张
+- 增加 `easy imageCount` - 图像数量
+- 增加 `easy textSwitch` - 文字切换
+
+<details>
+<summary><b>v1.1.5</b></summary>
+
+- 重写 `easy cleanGPUUsed` - 可强制清理comfyUI的模型显存占用
+- 增加 `easy humanSegmentation` - 多类分割、人像分割
+- 增加 `easy imageColorMatch`
+- 增加 `easy ipadapterApplyRegional`
+- 增加 `easy ipadapterApplyFromParams`
+- 增加 `easy imageInterrogator` - 图像反推
+- 增加 `easy stableDiffusion3API` - 简易的Stable Diffusion 3 多账号API节点
+</details>
+
+<details>
+<summary><b>v1.1.4</b></summary>
+
+- 增加 `easy imageChooser` - 从[cg-image-picker](https://github.com/chrisgoringe/cg-image-picker)简化的图片选择器
+- 增加 `easy preSamplingCustom` - 自定义预采样，可支持cosXL-edit
+- 增加 `easy ipadapterStyleComposition`
+- 增加 在Loaders上右键菜单可查看 checkpoints、lora 信息
+- 修复 `easy preSamplingNoiseIn`、`easy latentNoisy`、`east Unsampler` 以兼容ComfyUI Revision>=2098 [0542088e] 以上版本
+- 修复 FooocusInpaint修改ModelPatcher计算权重引发的问题，理应在生成model后重置ModelPatcher为默认值
+</details>
+
+<details>
+<summary><b>v1.1.3</b></summary>
+
+- `easy ipadapterApply` 增加 **COMPOSITION** 预置项
+- 增加 对[ResAdapter](https://huggingface.co/jiaxiangc/res-adapter) lora模型 的加载支持
+- 增加 `easy promptLine`
+- 增加 `easy promptReplace`
+- 增加 `easy promptConcat`
+- `easy wildcards` 增加 **multiline_mode**属性 
+- 增加 当节点需要下载模型时，若huggingface连接超时，会切换至镜像地址下载模型
+</details>
+
+<details>
+<summary><b>v1.1.2</b></summary>
+
+- 改写 EasyUse 相关节点的部分插槽推荐节点
+- 增加 **启用上下文菜单自动嵌套子目录** 设置项，默认为启用状态，可分类子目录及checkpoints、loras预览图
+- 增加 `easy sv3dLoader` 
+- 增加 `easy dynamiCrafterLoader` 
+- 增加 `easy ipadapterApply`
+- 增加 `easy ipadapterApplyADV`
+- 增加 `easy ipadapterApplyEncoder`
+- 增加 `easy ipadapterApplyEmbeds`
+- 增加 `easy preMaskDetailerFix`
+- `easy kSamplerInpainting` 增加 **additional** 属性，可设置成 Differential Diffusion 或 Only InpaintModelConditioning
+- 修复 `easy stylesSelector` 当未选择样式时，原有提示词发生了变化
+- 修复 `easy pipeEdit` 提示词输入lora时报错
+- 修复 layerDiffuse xyplot相关bug
+</details>
+
+<details>
+<summary><b>v1.1.1</b></summary>
+
+- 修复首次添加含seed的节点且当前模式为control_before_generate时，seed为0的问题
+- `easy preSamplingAdvanced` 增加 **return_with_leftover_noise**
+- 修复 `easy stylesSelector` 当选择自定义样式文件时运行队列报错
+- `easy preSamplingLayerDiffusion` 增加 mask 可选传入参数
+- 将所有 **seed_num** 调整回 **seed**
+- 修补官方BUG: 当control_mode为before 在首次加载页面时未修改节点中widget名称为 control_before_generate
+- 去除强制**control_before_generate**设定
+- 增加 `easy imageRemBg` - 默认为BriaAI的RMBG-1.4模型, 移除背景效果更加，速度更快
+</details>
+
+<details>
+<summary><b>v1.1.0</b></summary>
+
+- 增加 `easy imageSplitList` - 拆分每 N 张图像
+- 增加 `easy preSamplingDiffusionADDTL` - 可配置前景、背景、blended的additional_prompt等   
+- 增加 `easy preSamplingNoiseIn` 可替代需要前置的`easy latentNoisy`节点 实现效果更好的噪声注入
+- `easy pipeEdit` 增加 条件拼接模式选择，可选择替换、合并、联结、平均、设置条件时间
+- 增加 `easy pipeEdit` - 可编辑Pipe的节点（包含可重新输入提示词）
+- 增加 `easy preSamplingLayerDiffusion` 与 `easy kSamplerLayerDiffusion` （连接 `easy kSampler` 也能通）
+- 增加 在 加载器、预采样、采样器、Controlnet等节点上右键可快速替换同类型节点的便捷菜单
+- 增加 `easy instantIDApplyADV` 可连入 positive 与 negative
+- 修复 `easy wildcards` 读取lora未填写完整路径时未自动检索导致加载lora失败的问题
+- 修复 `easy instantIDApply` mask 未传入正确值
+- 修复 在 非a1111提示词风格下 BREAK 不生效的问题
+</details>
+
+<details>
+<summary><b>v1.0.9</b></summary>
+
+- 修复未安装 ComfyUI-Impack-Pack 和 ComfyUI_InstantID 时报错
+- 修复 `easy pipeIn` - pipe设为可不必选
+- 增加 `easy instantIDApply` - 需要先安装 [ComfyUI_InstantID](https://github.com/cubiq/ComfyUI_InstantID), 工作流参考[示例](https://github.com/yolain/ComfyUI-Yolain-Workflows?tab=readme-ov-file#2-2-instantid)
+- 修复 `easy detailerFix` 未添加到保存图片格式化扩展名可用节点列表
+- 修复 `easy XYInputs: PromptSR` 在替换负面提示词时报错
+</details>
+
+<details>
+<summary><b>v1.0.8</b></summary>
+
+- `easy cascadeLoader` stage_c 与 stage_b 支持checkpoint模型 (需要下载[checkpoints](https://huggingface.co/stabilityai/stable-cascade/tree/main/comfyui_checkpoints)) 
+- `easy styleSelector` 搜索框修改为不区分大小写匹配
+- `easy fullLoader` 增加 **positive**、**negative**、**latent** 输出项
+- 修复 SDXLClipModel 在 ComfyUI 修订版本号 2016[c2cb8e88] 及以上的报错（判断了版本号可兼容老版本）
+- 修复 `easy detailerFix` 批次大小大于1时生成出错
+- 修复`easy preSampling`等 latent传入后无法根据批次索引生成的问题
+- 修复 `easy svdLoader` 报错
+- 优化代码，减少了诸多冗余，提升运行速度
+- 去除中文翻译对照文本
+
+（翻译对照已由 [AIGODLIKE-COMFYUI-TRANSLATION](https://github.com/AIGODLIKE/AIGODLIKE-ComfyUI-Translation) 统一维护啦！
+首次下载或者版本较早的朋友请更新 AIGODLIKE-COMFYUI-TRANSLATION 和本节点包至最新版本。）
+</details>
+
+<details>
+<summary><b>v1.0.7</b></summary>
+
+- 增加 `easy cascadeLoader` - stable cascade 加载器
+- 增加 `easy preSamplingCascade` - stabled cascade stage_c 预采样参数
+- 增加 `easy fullCascadeKSampler` - stable cascade stage_c 完整版采样器
+- 增加 `easy cascadeKSampler` - stable cascade stage-c ksampler simple
+</details>
+
+<details>
+<summary><b>v1.0.6</b></summary>
+
+- 增加 `easy XYInputs: Checkpoint`
+- 增加 `easy XYInputs: Lora`
+- `easy seed` 增加固定种子值时可手动切换随机种
+- 修复 `easy fullLoader`等加载器切换lora时自动调整节点大小的问题
+- 去除原有ttn的图片保存逻辑并适配ComfyUI默认的图片保存格式化扩展
+</details>
+
+<details>
+<summary><b>v1.0.5</b></summary>
+
+- 增加 `easy isSDXL` 
+- `easy svdLoader` 增加提示词控制, 可配合open_clip模型进行使用
+- `easy wildcards` 增加 **populated_text** 可输出通配填充后文本
+</details>
+
+<details>
+<summary><b>v1.0.4</b></summary>
+
+- 增加 `easy showLoaderSettingsNames` 可显示与输出加载器部件中的 模型与VAE名称
+- 增加 `easy promptList` - 提示词列表
+- 增加 `easy fooocusInpaintLoader` - Fooocus内补节点（仅支持XL模型的流程）
+- 增加 **Logic** 逻辑类节点 - 包含类型、计算、判断和转换类型等
+- 增加 `easy imageSave` - 带日期转换和宽高格式化的图像保存节点
+- 增加 `easy joinImageBatch` - 合并图像批次
+- `easy showAnything` 增加支持转换其他类型（如：tensor类型的条件、图像等）
+- `easy kSamplerInpainting` 增加 **patch** 传入值，配合Fooocus内补节点使用
+- `easy imageSave` 增加 **only_preivew**
+
+- 修复 xyplot在pillow>9.5中报错
+- 修复 `easy wildcards` 在使用PS扩展插件运行时报错
+- 修复 `easy latentCompositeMaskedWithCond`
+- 修复 `easy XYInputs: ControlNet` 报错
+- 修复 `easy loraStack` **toggle** 为 disabled 时报错
+
+- 修改首次安装节点包不再自动替换主题，需手动调整并刷新页面
+</details>
+
+<details>
+<summary><b>v1.0.3</b></summary>
+
+- 增加 `easy stylesSelector` 风格化提示词选择器
+- 增加队列进度条设置项，默认为未启用状态
+- `easy controlnetLoader` 和 `easy controlnetLoaderADV` 增加参数 **scale_soft_weights**
+
+
+- 修复 `easy XYInputs: Sampler/Scheduler` 报错
+- 修复 右侧菜单 点击按钮时老是跑位的问题
+- 修复 styles 路径在其他环境报错
+- 修复 `easy comfyLoader` 读取错误
+- 修复 xyPlot 在连接 zero123 时报错
+- 修复加载器中提示词为组件时报错
+- 修复 `easy getNode` 和 `easy setNode` 加载时标题未更改
+- 修复所有采样器中存储图片使用子目录前缀不生效的问题
+
+
+- 调整UI主题
+</details>
+
+<details>
+<summary><b>v1.0.2</b></summary>
+
+- 增加 **autocomplete** 文件夹，如果您安装了 [ComfyUI-Custom-Scripts](https://github.com/pythongosssss/ComfyUI-Custom-Scripts), 将在启动时合并该文件夹下的所有txt文件并覆盖到pyssss包里的autocomplete.txt文件。
+- 增加 `easy XYPlotAdvanced` 和 `easy XYInputs` 等相关节点
+- 增加 **Alt+1到9** 快捷键，可快速粘贴 Node templates 的节点预设 （对应 1到9 顺序）
+
+- 修复 `easy imageInsetCrop` 测量值为百分比时步进为1
+- 修复 开启 `a1111_prompt_style` 时XY图表无法使用的问题
+- 右键菜单中增加了一个 `📜Groups Map(EasyUse)` 
+
+- 修复在Comfy新版本中UI加载失败
+- 修复 `easy pipeToBasicPipe` 报错
+- 修改 `easy fullLoader` 和 `easy a1111Loader` 中的 **a1111_prompt_style** 默认值为 False
+- `easy XYInputs ModelMergeBlocks` 支持csv文件导入数值
+
+- 替换了XY图生成时的字体文件
+
+- 移除 `easy imageRemBg`
+- 移除包中的介绍图和工作流文件，减少包体积
+
+</details>
+
+<details>
+<summary><b>v1.0.1</b></summary>
+
+- 新增 `easy seed` - 简易随机种
+- `easy preDetailerFix` 新增了 `optional_image` 传入图像可选，如未传默认取值为pipe里的图像
+- 新增 `easy kSamplerInpainting` 用于内补潜空间的采样器
+- 新增 `easy pipeToBasicPipe` 用于转换到Impact的某些节点上
+
+- 修复 `easy comfyLoader` 报错
+- 修复所有包含输出图片尺寸的节点取值方式无法批处理的问题
+- 修复 `width` 和 `height` 无法在 `easy svdLoader` 自定义的报错问题
+- 修复所有采样器预览图片的地址链接 (解决在 MACOS 系统中图片无法在采样器中预览的问题）
+- 修复 `vae_name` 在 `easy fullLoader` 和 `easy a1111Loader` 和 `easy comfyLoader` 中选择但未替换原始vae问题
+- 修复 `easy fullkSampler` 除pipe外其他输出值的报错
+- 修复 `easy hiresFix` 输入连接pipe和image、vae同时存在时报错
+- 修复 `easy fullLoader` 中 `model_override` 连接后未执行 
+- 修复 因新增`easy seed` 导致action错误
+- 修复 `easy xyplot` 的字体文件路径读取错误
+- 修复 convert 到 `easy seed` 随机种无法固定的问题
+- 修复 `easy pipeIn` 值传入的报错问题
+- 修复 `easy zero123Loader` 和 `easy svdLoader` 读取模型时将模型加入到缓存中
+- 修复 `easy kSampler` `easy kSamplerTiled` `easy detailerFix` 的 `image_output` 默认值为 Preview
+- `easy fullLoader` 和 `easy a1111Loader` 新增了 `a1111_prompt_style` 参数可以重现和webui生成相同的图像，当前您需要安装 [ComfyUI_smZNodes](https://github.com/shiimizu/ComfyUI_smZNodes) 才能使用此功能
+</details>
+
+<details>
+<summary><b>v1.0.0</b></summary>
+
+- 新增`easy positive` - 简易正面提示词文本
+- 新增`easy negative`  - 简易负面提示词文本
+- 新增`easy wildcards` - 支持通配符和Lora选择的提示词文本
+- 新增`easy portraitMaster` - 肖像大师v2.2
+- 新增`easy loraStack` - Lora堆
+- 新增`easy fullLoader` - 完整版的加载器
+- 新增`easy zero123Loader` - 简易zero123加载器
+- 新增`easy svdLoader` - 简易svd加载器
+- 新增`easy fullkSampler` - 完整版的采样器（无分离）
+- 新增`easy hiresFix` - 支持Pipe的高清修复
+- 新增`easy predetailerFix` `easy DetailerFix` - 支持Pipe的细节修复
+- 新增`easy ultralyticsDetectorPipe` `easy samLoaderPipe` - 检测加载器（细节修复的输入项）
+- 新增`easy pipein` `easy pipeout` - Pipe的输入与输出
+- 新增`easy xyPlot` - 简易的xyplot (后续会更新更多可控参数)
+- 新增`easy imageRemoveBG` - 图像去除背景
+- 新增`easy imagePixelPerfect` - 图像完美像素
+- 新增`easy poseEditor` - 姿势编辑器
+- 新增UI主题（黑曜石）- 默认自动加载UI, 也可在设置中自行更替 
+
+- 修复 `easy globalSeed` 不生效问题
+- 修复所有的`seed_num` 因 [cg-use-everywhere](https://github.com/chrisgoringe/cg-use-everywhere) 实时更新图表导致值错乱的问题
+- 修复`easy imageSize` `easy imageSizeBySide` `easy imageSizeByLongerSide` 可作为终节点
+- 修复 `seed_num` (随机种子值) 在历史记录中读取无法一致的Bug
+</details>
+
+
+<details>
+<summary><b>v0.5</b></summary>
+
+- 新增 `easy controlnetLoaderADV` 节点
+-  新增 `easy imageSizeBySide` 节点，可选输出为长边或短边
+-  新增 `easy LLLiteLoader` 节点，如果您预先安装过 kohya-ss/ControlNet-LLLite-ComfyUI 包，请将 models 里的模型文件移动至 ComfyUI\models\controlnet\ (即comfy默认的controlnet路径里，请勿修改模型的文件名，不然会读取不到)。
+-  新增 `easy imageSize` 和 `easy imageSizeByLongerSize` 输出的尺寸显示。
+-  新增 `easy showSpentTime` 节点用于展示图片推理花费时间与VAE解码花费时间。
+- `easy controlnetLoaderADV` 和 `easy controlnetLoader` 新增 `control_net` 可选传入参数
+- `easy preSampling` 和 `easy preSamplingAdvanced` 新增 `image_to_latent` 可选传入参数
+- `easy a1111Loader` 和 `easy comfyLoader` 新增 `batch_size` 传入参数
+
+-  修改 `easy controlnetLoader` 到 loader 分类底下。
+</details>
+
+## 整合参考到的相关节点包
+
+声明: 非常尊重这些原作者们的付出，开源不易，我仅仅只是做了一些整合与优化。
+
+| 节点名 (搜索名)                      | 相关的库                                                                        | 库相关的节点                  |
+|:-------------------------------|:----------------------------------------------------------------------------|:------------------------|
+| easy setNode                   | [ComfyUI-extensions](https://github.com/diffus3/ComfyUI-extensions) | diffus3.SetNode         |
+| easy getNode                   | [ComfyUI-extensions](https://github.com/diffus3/ComfyUI-extensions) | diffus3.GetNode         |
+| easy bookmark                  | [rgthree-comfy](https://github.com/rgthree/rgthree-comfy) | Bookmark 🔖             |
+| easy portraitMarker            | [comfyui-portrait-master](https://github.com/florestefano1975/comfyui-portrait-master) | Portrait Master         |
+| easy LLLiteLoader              | [ControlNet-LLLite-ComfyUI](https://github.com/kohya-ss/ControlNet-LLLite-ComfyUI) | LLLiteLoader            |
+| easy globalSeed                | [ComfyUI-Inspire-Pack](https://github.com/ltdrdata/ComfyUI-Inspire-Pack) | Global Seed (Inspire)   | 
+| easy preSamplingDynamicCFG     | [sd-dynamic-thresholding](https://github.com/mcmonkeyprojects/sd-dynamic-thresholding) | DynamicThresholdingFull | 
+| dynamicThresholdingFull        | [sd-dynamic-thresholding](https://github.com/mcmonkeyprojects/sd-dynamic-thresholding) | DynamicThresholdingFull | 
+| easy imageInsetCrop            | [rgthree-comfy](https://github.com/rgthree/rgthree-comfy) | ImageInsetCrop          | 
+| easy poseEditor                | [ComfyUI_Custom_Nodes_AlekPet](https://github.com/AlekPet/ComfyUI_Custom_Nodes_AlekPet) | poseNode                | 
+| easy if                        | [ComfyUI-Logic](https://github.com/theUpsider/ComfyUI-Logic) | IfExecute               | 
+| easy preSamplingLayerDiffusion | [ComfyUI-layerdiffusion](https://github.com/huchenlei/ComfyUI-layerdiffusion) | LayeredDiffusionApply等  | 
+| easy dynamiCrafterLoader       | [ComfyUI-layerdiffusion](https://github.com/ExponentialML/ComfyUI_Native_DynamiCrafter) | Apply Dynamicrafter     | 
+| easy imageChooser              | [cg-image-picker](https://github.com/chrisgoringe/cg-image-picker) | Preview Chooser         | 
+| easy styleAlignedBatchAlign    | [style_aligned_comfy](https://github.com/chrisgoringe/cg-image-picker) | styleAlignedBatchAlign  | 
+| easy icLightApply              | [ComfyUI-IC-Light](https://github.com/huchenlei/ComfyUI-IC-Light) | ICLightApply等           |
+| easy kolorsLoader              | [ComfyUI-Kolors-MZ](https://github.com/MinusZoneAI/ComfyUI-Kolors-MZ) | kolorsLoader            |
+
+## Credits
+
+[ComfyUI](https://github.com/comfyanonymous/ComfyUI) - 功能强大且模块化的Stable Diffusion GUI
+
+[ComfyUI-ComfyUI-Manager](https://github.com/ltdrdata/ComfyUI-Manager) - ComfyUI管理器
+
+[tinyterraNodes](https://github.com/TinyTerra/ComfyUI_tinyterraNodes) - 管道节点（节点束）让用户减少了不必要的连接
+
+[ComfyUI-extensions](https://github.com/diffus3/ComfyUI-extensions) - diffus3的获取与设置点让用户可以分离工作流构成
+
+[ComfyUI-Impact-Pack](https://github.com/ltdrdata/ComfyUI-Impact-Pack) - 常规整合包1
+
+[ComfyUI-Inspire-Pack](https://github.com/ltdrdata/ComfyUI-Inspire-Pack) - 常规整合包2
+
+[ComfyUI-Logic](https://github.com/theUpsider/ComfyUI-Logic) -  ComfyUI逻辑运算
+
+[ComfyUI-ResAdapter](https://github.com/jiaxiangc/ComfyUI-ResAdapter) - 让模型生成不受训练分辨率限制
+
+[ComfyUI_IPAdapter_plus](https://github.com/cubiq/ComfyUI_IPAdapter_plus) - 风格迁移
+
+[ComfyUI_InstantID](https://github.com/cubiq/ComfyUI_InstantID) - 人脸迁移
+
+[ComfyUI_PuLID](https://github.com/cubiq/PuLID_ComfyUI) - 人脸迁移
+
+[ComfyUI-Custom-Scripts](https://github.com/pythongosssss/ComfyUI-Custom-Scripts) - pyssss 小蛇🐍脚本
+
+[cg-image-picker](https://github.com/chrisgoringe/cg-image-picker) - 图片选择器
+
+[ComfyUI-BrushNet](https://github.com/nullquant/ComfyUI-BrushNet) - BrushNet 内补节点
+
+[ComfyUI_ExtraModels](https://github.com/city96/ComfyUI_ExtraModels) - DiT架构相关节点（Pixart、混元DiT等）
+
+## 免责声明
+
+本开源项目及其内容按 “原样 ”提供，不作任何明示或暗示的保证，包括但不限于适销性、特定用途适用性和非侵权保证。在任何情况下，作者或其他版权所有者均不对因本软件或本软件的使用或其他交易而产生、引起或与之相关的任何索赔、损害或其他责任承担责任，无论是合同诉讼、侵权诉讼还是其他诉讼。
+
+用户应自行负责确保在使用本软件或发布由本软件生成的内容时，遵守所在司法管辖区的所有适用法律和法规。作者和版权所有者不对用户在其各自所在地违反法律或法规的行为负责。
+
+## ☕️ 投喂
+
+**Comfyui-Easy-Use** 是一个 GPL 许可的开源项目。为了项目取得更好、可持续的发展，我希望能够获得更多的支持。 如果我的自定义节点为您的一天增添了价值，请考虑喝杯咖啡来进一步补充能量！ 💖感谢您的支持，每一杯咖啡都是我创作的动力！
+
+- [BiliBili充电](https://space.bilibili.com/1840885116)
+- [Wechat/Alipay](https://github.com/user-attachments/assets/803469bd-ed6a-4fab-932d-50e5088a2d03)
+
+感谢您的捐助，我将用这些费用来租用 GPU 或购买其他 GPT 服务，以便更好地调试和完善 ComfyUI-Easy-Use 功能
+
+##  🌟大富大贵的人儿
+
+我对那些慷慨的赐予一颗星的人表示感谢。非常感谢您的支持！
+
+[![Stargazers repo roster for @yolain/ComfyUI-Easy-Use](https://reporoster.com/stars/yolain/ComfyUI-Easy-Use)](https://github.com/yolain/ComfyUI-Easy-Use/stargazers)

README.en.md

@@ -1,393 +0,0 @@
-<p align="right">
-   <a href="./README.md">中文</a> | <strong>English</strong>
-</p>
-
-<div align="center">
-
-# ComfyUI Easy Use
-</div>
-
-**ComfyUI-Easy-Use** is a simplified node integration package, which is extended on the basis of [tinyterraNodes](https://github.com/TinyTerra/ComfyUI_tinyterraNodes), and has been integrated and optimized for many mainstream node packages 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.
-
-<img src="https://raw.githubusercontent.com/yolain/yolain-comfyui-workflow/main/Docs/workflow_node_compare.png">
-
-## Introduce
-
-- Inspire 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)
-- 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
-- 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
-
-## Changelog
-
-**v1.1.8**
-
-- Added `easy controlnetStack`
-- Added `easy applyBrushNet` - [Workflow Example](https://github.com/yolain/ComfyUI-Yolain-Workflows/blob/main/workflows/2_advanced/2-4inpainting/2-4brushnet_1.1.8.json)
-- Added `easy applyPowerPaint` - [Workflow Example](https://github.com/yolain/ComfyUI-Yolain-Workflows/blob/main/workflows/2_advanced/2-4inpainting/2-4powerpaint_outpaint_1.1.8.json)
-
-**v1.1.7**
-
-- Added `easy prompt` - Subject and light presets, maybe adjusted later
-- Added `easy icLightApply` - Light and shadow migration, Code based on [ComfyUI-IC-Light](https://github.com/huchenlei/ComfyUI-IC-Light)
-- Added `easy imageSplitGrid`
-- `easy kSamplerInpainting` added options such as different diffusion and brushnet in **additional** widget
-- Support for brushnet model loading - [ComfyUI-BrushNet](https://github.com/nullquant/ComfyUI-BrushNet)
-- Added `easy applyFooocusInpaint` - Replace FooocusInpaintLoader
-- Removed `easy fooocusInpaintLoader`
-
-**v1.1.6**
-
-- Added **alignYourSteps** to **schedulder** widget in all `easy preSampling` and `easy fullkSampler`
-- Added **Preview&Choose** to **image_output** widget in `easy kSampler` & `easy fullkSampler`
-- Added `easy styleAlignedBatchAlign` - Credit of [style_aligned_comfy](https://github.com/brianfitzgerald/style_aligned_comfy)
-- Added `easy ckptNames`
-- Added `easy controlnetNames`
-- Added `easy imagesSplitimage` - Batch images split into single images
-- Added `easy imageCount` - Get Image Count
-- Added `easy textSwitch` - Text Switch
-
-**v1.1.5**
-
-- Rewrite `easy cleanGPUUsed` - the memory usage of the comfyUI can to be cleared
-- Added `easy humanSegmentation` - Human Part Segmentation
-- Added `easy imageColorMatch`
-- Added `easy ipadapterApplyRegional`
-- Added `easy ipadapterApplyFromParams`
-- Added `easy imageInterrogator` - Image To Prompt
-- Added `easy stableDiffusion3API` - Easy Stable Diffusion 3 Multiple accounts API Node
-
-**v1.1.4**
-
-- 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
- 
-
-**v1.1.3**
-
-- `easy ipadapterApply` Added **COMPOSITION** preset
-- Supported [ResAdapter](https://huggingface.co/jiaxiangc/res-adapter) when load ResAdapter lora
-- Added `easy promptLine`
-- Added `easy promptReplace`
-- Added `easy promptConcat`
-- `easy wildcards` Added **multiline_mode**  
-
-**v1.1.2**
-
-- Optimized some of the recommended nodes for slots related to EasyUse
-- Added **Enable ContextMenu Auto Nest Subdirectories** The setting item is enabled by default, and it can be classified into subdirectories, checkpoints and loras previews
-- Added `easy sv3dLoader` 
-- Added `easy dynamiCrafterLoader` 
-- Added `easy ipadapterApply`
-- Added `easy ipadapterApplyADV`
-- Added `easy ipadapterApplyEncoder`
-- Added `easy ipadapterApplyEmbeds`
-- Added `easy preMaskDetailerFix`
-- Fixed `easy stylesSelector` is change the prompt when not select the style
-- Fixed `easy pipeEdit` error when add lora to prompt
-- Fixed layerDiffuse xyplot bug
-- `easy kSamplerInpainting` add *additional* widget，you can choose 'Differential Diffusion' or 'Only InpaintModelConditioning'
-
-**v1.1.1**
-
-- The issue that the seed is 0 when a node with a seed control is added and **control before generate** is fixed for the first time run queue prompt.
-- `easy preSamplingAdvanced` Added **return_with_leftover_noise**
-- Fixed `easy stylesSelector` error when choose the custom file
-- `easy preSamplingLayerDiffusion` Added optional input parameter for mask
-- Renamed all nodes widget name named seed_num to seed
-- Remove forced **control_before_generate** settings。 If you want to use control_before_generate, change widget_value_control_mode to before in system settings
-- Added `easy imageRemBg` - The default is BriaAI's RMBG-1.4 model, which removes the background effect more and faster
-
-**v1.1.0**
-
-- Added `easy imageSplitList` - to split every N images
-- Added `easy preSamplingDiffusionADDTL` - It can modify foreground、background or blended additional prompt
-- Added `easy preSamplingNoiseIn` It can replace the `easy latentNoisy` node that needs to be fronted to achieve better noise injection
-- `easy pipeEdit` Added conditioning splicing mode selection, you can choose to replace, concat, combine, average, and set timestep range
-- Added `easy pipeEdit` - nodes that can edit pipes (including re-enterable prompts)
-- Added `easy preSamplingLayerDiffusion` and `easy kSamplerLayerDiffusion`
-- Added a convenient menu to right-click on nodes such as Loader, Presampler, Sampler, Controlnet, etc. to quickly replace nodes of the same type
-- Added `easy instantIDApplyADV` can link positive and negative
-- Fixed layerDiffusion error when batch size greater than 1
-- Fixed `easy wildcards` When LoRa is not filled in completely, LoRa is not automatically retrieved, resulting in failure to load LoRa
-- Fixed the issue that 'BREAK' non-initiation when didn't use a1111 prompt style
-- Fixed `easy instantIDApply` mask not input right
-
-
-<details>
-<summary><b>v1.0.9</b></summary>
-
-- Fixed the error when ComfyUI-Impack-Pack and ComfyUI_InstantID were not installed
-- Fixed `easy pipeIn`
-- Added `easy instantIDApply` - you need installed [ComfyUI_InstantID](https://github.com/cubiq/ComfyUI_InstantID) fisrt, Workflow[Example](https://github.com/yolain/ComfyUI-Easy-Use/blob/main/README.en.md#InstantID)
-- Fixed `easy detailerFix` not added to the list of nodes available for saving images formatting extensions
-- Fixed `easy XYInputs: PromptSR` errors are reported when replacing negative prompts
-</details>
-
-<details>
-<summary><b>v1.0.8</b></summary>
-
-- `easy cascadeLoader` stage_c and stage_b support the checkpoint model (Download [checkpoints](https://huggingface.co/stabilityai/stable-cascade/tree/main/comfyui_checkpoints) models) 
-- `easy styleSelector` The search box is modified to be case-insensitive
-- `easy fullLoader` **positive**、**negative**、**latent** added to the output items
-- Fixed the issue that 'easy preSampling' and other similar node, latent could not be generated based on the batch index after passing in
-- Fixed `easy svdLoader` error when the positive or negative is empty
-- Fixed the error of SDXLClipModel in ComfyUI revision 2016[c2cb8e88] and above (the revision number was judged to be compatible with the old revision)
-- Fixed `easy detailerFix` generation error when batch size is greater than 1
-- Optimize the code, reduce a lot of redundant code and improve the running speed
-</details>
-
-<details>
-<summary><b>v1.0.7</b></summary>
-
-- Added `easy cascadeLoader` - stable cascade Loader
-- Added `easy preSamplingCascade` - stable cascade preSampling Settings
-- Added `easy fullCascadeKSampler` - stable cascade stage-c ksampler full
-- Added `easy cascadeKSampler` - stable cascade stage-c ksampler simple
-- 
-- Optimize the image to image[Example](https://github.com/yolain/ComfyUI-Easy-Use/blob/main/README.en.md#image-to-image)
-</details>
-
-<details>
-<summary><b>v1.0.6</b></summary>
-
-- Added `easy XYInputs: Checkpoint`
-- Added `easy XYInputs: Lora`
-- `easy seed` can manually switch the random seed when increasing the fixed seed value
-- Fixed `easy fullLoader` and all loaders to automatically adjust the node size when switching LoRa
-- Removed the original ttn image saving logic and adapted to the default image saving format extension of ComfyUI
-</details>
-
-<details>
-<summary><b>v1.0.5</b></summary>
-
-- Added `easy isSDXL` 
-- Added prompt word control on `easy svdLoader`, which can be used with open_clip model
-- Added **populated_text** on `easy wildcards`, wildcard populated text can be output
-</details>
-
-<details>
-<summary><b>v1.0.4</b></summary>
-
-- `easy showAnything` added support for converting other types (e.g., tensor conditions, images, etc.)
-- Added `easy showLoaderSettingsNames` can display the model and VAE name in the output loader assembly
-- Added `easy promptList`
-- Added `easy fooocusInpaintLoader` （only the process of SDXLModel is supported）
-- Added **Logic** nodes
-- Added `easy imageSave` - Image saving node with date conversion and aspect and height formatting
-- Added `easy joinImageBatch`
-- `easy kSamplerInpainting` Added the **patch** input value to be used with the FooocusInpaintLoader node
-
-- Fixed xyplot error when with Pillow>9.5
-- Fixed `easy wildcards` An error is reported when running with the PS extension
-- Fixed `easy XYInputs: ControlNet` Error
-- Fixed `easy loraStack` error when **toggle** is disabled
-
-
-- Changing the first-time install node package no longer automatically replaces the theme, you need to manually adjust and refresh the page
-- `easy imageSave` added **only_preivew**
-- Adjust the `easy latentCompositeMaskedWithCond` node
-</details>
-
-<details>
-<summary><b>v1.0.3</b></summary>
-
-- Added `easy stylesSelector`
-- Added **scale_soft_weights** in `easy controlnetLoader` and `easy controlnetLoaderADV` 
-- Added the queue progress bar setting item, which is not enabled by default
-
-
-- Fixed `easy XYInputs: Sampler/Scheduler` Error
-- Fixed the right menu has a problem when clicking the button
-- Fixed `easy comfyLoader` error
-- Fixed xyPlot error when connecting to zero123
-- Fixed the error message in the loader when the prompt word was component
-- Fixed `easy getNode` and `easy setNode` the title does not change when loading
-- Fixed all samplers using subdirectories to store images
-
-
-- Adjust the UI theme, divided into two sets of styles: the official default background and the dark black background, which can be switched in the color palette in the settings
-- Modify the styles path to be compatible with other environments
-</details>
-
-<details>
-<summary><b>v1.0.2</b></summary>
-
-- Added `easy XYPlotAdvanced` and some nodes about `easy XYInputs`
-- Added **Alt+1-Alt+9** Shortcut keys to quickly paste node presets for Node templates (corresponding to 1~9 sequences)
-- Added a `📜Groups Map(EasyUse)` to the context menu.
-- An `autocomplete` folder has been added, If you have [ComfyUI-Custom-Scripts](https://github.com/pythongosssss/ComfyUI-Custom-Scripts) installed, the txt files in that folder will be merged and overwritten to the autocomplete .txt file of the pyssss package at startup.
-
-
-- Fixed XYPlot is not working when `a1111_prompt_style` is True
-- Fixed UI loading failure in the new version of ComfyUI
-- `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
-</details>
-
-<details>
-<summary><b>v1.0.1</b></summary>
-
-- Fixed `easy comfyLoader` error
-- Fixed All nodes that contain the value of the image size
-- Added `easy kSamplerInpainting`
-- Added `easy pipeToBasicPipe`
-- Fixed `width` and `height` can not customize in `easy svdLoader`
-- Fixed all preview image path (Previously, it was not possible to preview the image on the Mac system)
-- Fixed `vae_name` is not working in `easy fullLoader` and `easy a1111Loader` and `easy comfyLoader`
-- Fixed `easy fullkSampler` outputs error
-- Fixed `model_override` is not working in `easy fullLoader`
-- Fixed `easy hiresFix` error
-- Fixed `easy xyplot` font file path error
-- Fixed seed that cannot be fixed when you convert `seed_num` to `easy seed` 
-- Fixed `easy pipeIn` inputs bug
-- `easy preDetailerFix` have added a new parameter `optional_image`
-- Fixed `easy zero123Loader` and `easy svdLoader` model into cache.
-- Added `easy seed`
-- Fixed `image_output` default value is "Preview"
-- `easy fullLoader` and `easy a1111Loader` have added a new parameter `a1111_prompt_style`,that can reproduce the same image generated from stable-diffusion-webui on comfyui, but you need to install [ComfyUI_smZNodes](https://github.com/shiimizu/ComfyUI_smZNodes) to use this feature in the current version
-</details>
-
-<details>
-<summary><b>v1.0.0</b></summary>
-
-- Added `easy positive` - simple positive prompt text
-- Added `easy negative` - simple negative prompt text
-- Added `easy wildcards` - support for wildcards and hint text selected by Lora
-- Added `easy portraitMaster` - PortraitMaster v2.2
-- Added `easy loraStack` - Lora stack
-- Added `easy fullLoader` - full version of the loader
-- Added `easy zero123Loader` - simple zero123 loader
-- Added `easy svdLoader` - easy svd loader
-- Added `easy fullkSampler` - full version of the sampler (no separation)
-- Added `easy hiresFix` - support for HD repair of Pipe
-- Added `easy predetailerFix` and `easy DetailerFix` - support for Pipe detail fixing
-- Added `easy ultralyticsDetectorPipe` and `easy samLoaderPipe` - Detect loader (detail fixed input)
-- Added `easy pipein` `easy pipeout` - Pipe input and output
-- Added `easy xyPlot` - simple xyplot (more controllable parameters will be updated in the future)
-- Added `easy imageRemoveBG` - image to remove background
-- Added `easy imagePixelPerfect` - image pixel perfect
-- Added `easy poseEditor` - Pose editor
-- New UI Theme (Obsidian) - Auto-load UI by default, which can also be changed in the settings 
-
-- Fixed `easy globalSeed` is not working
-- Fixed an issue where all `seed_num` values were out of order due to [cg-use-everywhere](https://github.com/chrisgoringe/cg-use-everywhere) updating the chart in real time
-- Fixed `easy imageSize`, `easy imageSizeBySide`, `easy imageSizeByLongerSide` as end nodes
-- Fixed the bug that `seed_num` (random seed value) could not be read consistently in history
-</details>
-
-<details>
-<summary><b>Updated at 12/14/2023</b></summary>
-
-- `easy a1111Loader` and `easy comfyLoader` added `batch_size` of required input parameters 
-- Added the `easy controlnetLoaderADV` node
-- `easy controlnetLoaderADV` and `easy controlnetLoader` added `control_net ` of optional input parameters
-- `easy preSampling` and `easy preSamplingAdvanced` added `image_to_latent` optional input parameters
-- Added the `easy imageSizeBySide` node, which can be output as a long side or a short side
-</details>
-
-<details>
-<summary><b>Updated at 12/13/2023</b></summary>
-
--  Added the `easy LLLiteLoader` node, if you have pre-installed the kohya-ss/ControlNet-LLLite-ComfyUI package, please move the model files in the models to `ComfyUI\models\controlnet\` (i.e. in the default controlnet path of comfy, please do not change the file name of the model, otherwise it will not be read).
--  Modify `easy controlnetLoader` to the bottom of the loader category.
--  Added size display for `easy imageSize` and `easy imageSizeByLongerSize` outputs.
-</details>
-
-<details>
-<summary><b>Updated at 12/11/2023</b></summary>
--  Added the `showSpentTime` node to display the time spent on image diffusion and the time spent on VAE decoding images
-</details>
-
-## The relevant node package involved
-
-Disclaimer: Opened source was not easy. I have a lot of respect for the contributions of these original authors. I just did some integration and optimization.
-
-| Nodes Name(Search Name)        | Related libraries                                                                        | Library-related node     |
-|:-------------------------------|:----------------------------------------------------------------------------|:-------------------------|
-| easy setNode                   | [ComfyUI-extensions](https://github.com/diffus3/ComfyUI-extensions) | diffus3.SetNode          |
-| easy getNode                   | [ComfyUI-extensions](https://github.com/diffus3/ComfyUI-extensions) | diffus3.GetNode          |
-| easy bookmark                  | [rgthree-comfy](https://github.com/rgthree/rgthree-comfy) | Bookmark 🔖              |
-| easy portraitMarker            | [comfyui-portrait-master](https://github.com/florestefano1975/comfyui-portrait-master) | Portrait Master          |
-| easy LLLiteLoader              | [ControlNet-LLLite-ComfyUI](https://github.com/kohya-ss/ControlNet-LLLite-ComfyUI) | LLLiteLoader             |
-| easy globalSeed                | [ComfyUI-Inspire-Pack](https://github.com/ltdrdata/ComfyUI-Inspire-Pack) | Global Seed (Inspire)    | 
-| easy preSamplingDynamicCFG     | [sd-dynamic-thresholding](https://github.com/mcmonkeyprojects/sd-dynamic-thresholding) | DynamicThresholdingFull  | 
-| dynamicThresholdingFull        | [sd-dynamic-thresholding](https://github.com/mcmonkeyprojects/sd-dynamic-thresholding) | DynamicThresholdingFull  | 
-| easy imageInsetCrop            | [rgthree-comfy](https://github.com/rgthree/rgthree-comfy) | ImageInsetCrop           | 
-| easy poseEditor                | [ComfyUI_Custom_Nodes_AlekPet](https://github.com/AlekPet/ComfyUI_Custom_Nodes_AlekPet) | poseNode                 | 
-| easy preSamplingLayerDiffusion | [ComfyUI-layerdiffusion](https://github.com/huchenlei/ComfyUI-layerdiffusion) | LayeredDiffusionApply... | 
-| easy dynamiCrafterLoader       | [ComfyUI-layerdiffusion](https://github.com/ExponentialML/ComfyUI_Native_DynamiCrafter) | Apply Dynamicrafter    | 
-| easy imageChooser              | [cg-image-picker](https://github.com/chrisgoringe/cg-image-picker) | Preview Chooser         | 
-| easy styleAlignedBatchAlign              | [style_aligned_comfy](https://github.com/chrisgoringe/cg-image-picker) | styleAlignedBatchAlign       | 
-
-## Workflow Examples
-
-### Text to image
-
-<img src="https://raw.githubusercontent.com/yolain/yolain-comfyui-workflow/main/Workflows/Simple/text_to_image.png">
-
-### Image to image + controlnet
-
-<img src="https://raw.githubusercontent.com/yolain/yolain-comfyui-workflow/main/Workflows/Simple/image_to_image_controlnet.png">
-
-### SDTurbo + HiresFix + SVD
-
-<img src="https://raw.githubusercontent.com/yolain/yolain-comfyui-workflow/main/Workflows/Simple/sdturbo_hiresfix_svd.png">
-
-### LayerDiffusion
-#### SD15
-<img src="https://raw.githubusercontent.com/yolain/yolain-comfyui-workflow/main/Workflows/Simple/layer_diffusion_sd15.png">
-
-#### SDXL
-<img src="https://raw.githubusercontent.com/yolain/yolain-comfyui-workflow/main/Workflows/Simple/layer_diffusion_example.png">
-
-### StableCascade
-#### Text to image
-<img src="https://raw.githubusercontent.com/yolain/yolain-comfyui-workflow/main/Workflows/StableCascade/text_to_image.png">
-
-#### Image to image
-<img src="https://raw.githubusercontent.com/yolain/yolain-comfyui-workflow/main/Workflows/StableCascade/image_to_image.png">
-
-## Credits
-
-[ComfyUI](https://github.com/comfyanonymous/ComfyUI) - Powerful and modular Stable Diffusion GUI
-
-[ComfyUI-ComfyUI-Manager](https://github.com/ltdrdata/ComfyUI-Manager) - ComfyUI Manager
-
-[tinyterraNodes](https://github.com/TinyTerra/ComfyUI_tinyterraNodes) - Pipe nodes (node bundles) allow users to reduce unnecessary connections
-
-[ComfyUI-extensions](https://github.com/diffus3/ComfyUI-extensions) - Diffus3 gets and sets points that allow the user to detach the composition of the workflow 
-
-[ComfyUI-Impact-Pack](https://github.com/ltdrdata/ComfyUI-Impact-Pack) - General modpack 1
-
-[ComfyUI-Inspire-Pack](https://github.com/ltdrdata/ComfyUI-Inspire-Pack) - General Modpack 2
-
-[ComfyUI-ResAdapter](https://github.com/jiaxiangc/ComfyUI-ResAdapter) - Make model generation independent of training resolution
-
-[ComfyUI_IPAdapter_plus](https://github.com/cubiq/ComfyUI_IPAdapter_plus) - Style migration
-
-[ComfyUI_InstantID](https://github.com/cubiq/ComfyUI_InstantID) - Face migration
-
-[ComfyUI-Custom-Scripts](https://github.com/pythongosssss/ComfyUI-Custom-Scripts) - pyssss🐍
-
-[cg-image-picker](https://github.com/chrisgoringe/cg-image-picker) - Image Preview Chooser

README.md

@@ -1,381 +1,523 @@
-<p align="right">
-   <strong>中文</strong> | <a href="./README.en.md">English</a>
-</p>
-
-<div align="center">
-
-# ComfyUI Easy Use
-
-[![Bilibili Badge](https://img.shields.io/badge/1.0版本-00A1D6?style=for-the-badge&logo=bilibili&logoColor=white&link=https://www.bilibili.com/video/BV1Wi4y1h76G)](https://www.bilibili.com/video/BV1Wi4y1h76G)
-[![Bilibili Badge](https://img.shields.io/badge/基本介绍-00A1D6?style=for-the-badge&logo=bilibili&logoColor=white&link=https://www.bilibili.com/video/BV1vQ4y1G7z7)](https://www.bilibili.com/video/BV1vQ4y1G7z7/)
-</div>
-
-**ComfyUI-Easy-Use** 是一个化繁为简的节点整合包, 在 [tinyterraNodes](https://github.com/TinyTerra/ComfyUI_tinyterraNodes) 的基础上进行延展，并针对了诸多主流的节点包做了整合与优化，以达到更快更方便使用ComfyUI的目的，在保证自由度的同时还原了本属于Stable Diffusion的极致畅快出图体验。
-
-[![ComfyUI-Yolain-Workflows](https://github.com/yolain/ComfyUI-Easy-Use/assets/73304135/9a3f54bc-a677-4bf1-a196-8845dd57c942)](https://github.com/yolain/ComfyUI-Yolain-Workflows)
-
-## 特色介绍
-
-- 沿用了 [tinyterraNodes](https://github.com/TinyTerra/ComfyUI_tinyterraNodes) 的思路，大大减少了折腾工作流的时间成本。
-- UI界面美化，首次安装的用户，如需使用UI主题，请在 Settings -> Color Palette 中自行切换主题并**刷新页面**即可
-- 增加了预采样参数配置的节点，可与采样节点分离，更方便预览。
-- 支持通配符与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)
-- 可使用`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)
-- 简化 Layer Diffuse [示例参考](https://github.com/yolain/ComfyUI-Yolain-Workflows?tab=readme-ov-file#2-3-layerdiffusion)
-- 简化 InstantID [示例参考](https://github.com/yolain/ComfyUI-Yolain-Workflows?tab=readme-ov-file#2-2-instantid), 需先保证自定义节点包中安装了 [ComfyUI_InstantID](https://github.com/cubiq/ComfyUI_InstantID)
-- 简化 IPAdapter, 需先保证自定义节点包中安装最新版v2的 [ComfyUI_IPAdapter_plus](https://github.com/cubiq/ComfyUI_IPAdapter_plus)
-- 扩展 XYplot 的可用性
-- 整合了Fooocus Inpaint功能
-- 整合了常用的逻辑计算、转换类型、展示所有类型等
-- 支持节点上checkpoint、lora模型子目录分类及预览图 (请在设置中开启上下文菜单嵌套子目录)
-- 支持BriaAI的RMBG-1.4模型的背景去除节点，[技术参考](https://huggingface.co/briaai/RMBG-1.4)
-- 支持 强制清理comfyUI模型显存占用
-- 支持Stable Diffusion 3 多账号API节点
-- 支持IC-Light的应用 [示例参考](https://github.com/yolain/ComfyUI-Yolain-Workflows?tab=readme-ov-file#2-5-ic-light) | [代码整合来源](https://github.com/huchenlei/ComfyUI-IC-Light) | [技术参考](https://github.com/lllyasviel/IC-Light)
-- 中文提示词自动识别，使用[opus-mt-zh-en模型](https://huggingface.co/Helsinki-NLP/opus-mt-zh-en)
-
-## 更新日志
-
-**v1.1.8**
-
-- 增加中文提示词自动翻译，使用[opus-mt-zh-en模型](https://huggingface.co/Helsinki-NLP/opus-mt-zh-en), 默认已对wildcard、lora正则处理, 其他需要保留的中文，可使用`@你的提示词@`包裹 (若依赖安装完成后报错, 请重启)，测算大约会占0.3GB显存
-- 增加 `easy controlnetStack` - controlnet堆
-- 增加 `easy applyBrushNet` - [示例参考](https://github.com/yolain/ComfyUI-Yolain-Workflows/blob/main/workflows/2_advanced/2-4inpainting/2-4brushnet_1.1.8.json)
-- 增加 `easy applyPowerPaint` - [示例参考](https://github.com/yolain/ComfyUI-Yolain-Workflows/blob/main/workflows/2_advanced/2-4inpainting/2-4powerpaint_outpaint_1.1.8.json)
-
-**v1.1.7**
-
-- 修复 一些模型(如controlnet模型等)未成功写入缓存，导致修改前置节点束参数（如提示词）需要二次载入模型的问题
-- 增加 `easy prompt` - 主体和光影预置项，后期可能会调整
-- 增加 `easy icLightApply` - 重绘光影, 从[ComfyUI-IC-Light](https://github.com/huchenlei/ComfyUI-IC-Light)优化
-- 增加 `easy imageSplitGrid` - 图像网格拆分
-- `easy kSamplerInpainting` 的 **additional** 属性增加差异扩散和brushnet等相关选项 
-- 增加 brushnet模型加载的支持 - [ComfyUI-BrushNet](https://github.com/nullquant/ComfyUI-BrushNet)
-- 增加 `easy applyFooocusInpaint` - Fooocus内补节点 替代原有的 FooocusInpaintLoader
-- 移除 `easy fooocusInpaintLoader` - 容易bug，不再使用
-- 修改 easy kSampler等采样器中并联的model 不再替换输出中pipe里的model
-
-**v1.1.6**
-
-- 增加步调齐整适配 - 在所有的预采样和全采样器节点中的 调度器(schedulder) 增加了 **alignYourSteps** 选项
-- `easy kSampler` 和 `easy fullkSampler` 的 **image_output** 增加 **Preview&Choose**选项
-- 增加 `easy styleAlignedBatchAlign` - 风格对齐 [style_aligned_comfy](https://github.com/brianfitzgerald/style_aligned_comfy)
-- 增加 `easy ckptNames`
-- 增加 `easy controlnetNames`
-- 增加 `easy imagesSplitimage` - 批次图像拆分单张
-- 增加 `easy imageCount` - 图像数量
-- 增加 `easy textSwitch` - 文字切换
-
-**v1.1.5**
-
-- 重写 `easy cleanGPUUsed` - 可强制清理comfyUI的模型显存占用
-- 增加 `easy humanSegmentation` - 多类分割、人像分割
-- 增加 `easy imageColorMatch`
-- 增加 `easy ipadapterApplyRegional`
-- 增加 `easy ipadapterApplyFromParams`
-- 增加 `easy imageInterrogator` - 图像反推
-- 增加 `easy stableDiffusion3API` - 简易的Stable Diffusion 3 多账号API节点
-
-**v1.1.4**
-
-- 增加 `easy imageChooser` - 从[cg-image-picker](https://github.com/chrisgoringe/cg-image-picker)简化的图片选择器
-- 增加 `easy preSamplingCustom` - 自定义预采样，可支持cosXL-edit
-- 增加 `easy ipadapterStyleComposition`
-- 增加 在Loaders上右键菜单可查看 checkpoints、lora 信息
-- 修复 `easy preSamplingNoiseIn`、`easy latentNoisy`、`east Unsampler` 以兼容ComfyUI Revision>=2098 [0542088e] 以上版本
-- 修复 FooocusInpaint修改ModelPatcher计算权重引发的问题，理应在生成model后重置ModelPatcher为默认值
-
-**v1.1.3**
-
-- `easy ipadapterApply` 增加 **COMPOSITION** 预置项
-- 增加 对[ResAdapter](https://huggingface.co/jiaxiangc/res-adapter) lora模型 的加载支持
-- 增加 `easy promptLine`
-- 增加 `easy promptReplace`
-- 增加 `easy promptConcat`
-- `easy wildcards` 增加 **multiline_mode**属性 
-- 增加 当节点需要下载模型时，若huggingface连接超时，会切换至镜像地址下载模型
-
-**v1.1.2**
-
-- 改写 EasyUse 相关节点的部分插槽推荐节点
-- 增加 **启用上下文菜单自动嵌套子目录** 设置项，默认为启用状态，可分类子目录及checkpoints、loras预览图
-- 增加 `easy sv3dLoader` 
-- 增加 `easy dynamiCrafterLoader` 
-- 增加 `easy ipadapterApply`
-- 增加 `easy ipadapterApplyADV`
-- 增加 `easy ipadapterApplyEncoder`
-- 增加 `easy ipadapterApplyEmbeds`
-- 增加 `easy preMaskDetailerFix`
-- `easy kSamplerInpainting` 增加 **additional** 属性，可设置成 Differential Diffusion 或 Only InpaintModelConditioning
-- 修复 `easy stylesSelector` 当未选择样式时，原有提示词发生了变化
-- 修复 `easy pipeEdit` 提示词输入lora时报错
-- 修复 layerDiffuse xyplot相关bug
-
-**v1.1.1**
-
-- 修复首次添加含seed的节点且当前模式为control_before_generate时，seed为0的问题
-- `easy preSamplingAdvanced` 增加 **return_with_leftover_noise**
-- 修复 `easy stylesSelector` 当选择自定义样式文件时运行队列报错
-- `easy preSamplingLayerDiffusion` 增加 mask 可选传入参数
-- 将所有 **seed_num** 调整回 **seed**
-- 修补官方BUG: 当control_mode为before 在首次加载页面时未修改节点中widget名称为 control_before_generate
-- 去除强制**control_before_generate**设定
-- 增加 `easy imageRemBg` - 默认为BriaAI的RMBG-1.4模型, 移除背景效果更加，速度更快
-
-**v1.1.0**
-
-- 增加 `easy imageSplitList` - 拆分每 N 张图像
-- 增加 `easy preSamplingDiffusionADDTL` - 可配置前景、背景、blended的additional_prompt等   
-- 增加 `easy preSamplingNoiseIn` 可替代需要前置的`easy latentNoisy`节点 实现效果更好的噪声注入
-- `easy pipeEdit` 增加 条件拼接模式选择，可选择替换、合并、联结、平均、设置条件时间
-- 增加 `easy pipeEdit` - 可编辑Pipe的节点（包含可重新输入提示词）
-- 增加 `easy preSamplingLayerDiffusion` 与 `easy kSamplerLayerDiffusion` （连接 `easy kSampler` 也能通）
-- 增加 在 加载器、预采样、采样器、Controlnet等节点上右键可快速替换同类型节点的便捷菜单
-- 增加 `easy instantIDApplyADV` 可连入 positive 与 negative
-- 修复 `easy wildcards` 读取lora未填写完整路径时未自动检索导致加载lora失败的问题
-- 修复 `easy instantIDApply` mask 未传入正确值
-- 修复 在 非a1111提示词风格下 BREAK 不生效的问题
-
-<details>
-<summary><b>v1.0.9</b></summary>
-
-- 修复未安装 ComfyUI-Impack-Pack 和 ComfyUI_InstantID 时报错
-- 修复 `easy pipeIn` - pipe设为可不必选
-- 增加 `easy instantIDApply` - 需要先安装 [ComfyUI_InstantID](https://github.com/cubiq/ComfyUI_InstantID), 工作流参考[示例](https://github.com/yolain/ComfyUI-Yolain-Workflows?tab=readme-ov-file#2-2-instantid)
-- 修复 `easy detailerFix` 未添加到保存图片格式化扩展名可用节点列表
-- 修复 `easy XYInputs: PromptSR` 在替换负面提示词时报错
-</details>
-
-<details>
-<summary><b>v1.0.8</b></summary>
-
-- `easy cascadeLoader` stage_c 与 stage_b 支持checkpoint模型 (需要下载[checkpoints](https://huggingface.co/stabilityai/stable-cascade/tree/main/comfyui_checkpoints)) 
-- `easy styleSelector` 搜索框修改为不区分大小写匹配
-- `easy fullLoader` 增加 **positive**、**negative**、**latent** 输出项
-- 修复 SDXLClipModel 在 ComfyUI 修订版本号 2016[c2cb8e88] 及以上的报错（判断了版本号可兼容老版本）
-- 修复 `easy detailerFix` 批次大小大于1时生成出错
-- 修复`easy preSampling`等 latent传入后无法根据批次索引生成的问题
-- 修复 `easy svdLoader` 报错
-- 优化代码，减少了诸多冗余，提升运行速度
-- 去除中文翻译对照文本
-
-（翻译对照已由 [AIGODLIKE-COMFYUI-TRANSLATION](https://github.com/AIGODLIKE/AIGODLIKE-ComfyUI-Translation) 统一维护啦！
-首次下载或者版本较早的朋友请更新 AIGODLIKE-COMFYUI-TRANSLATION 和本节点包至最新版本。）
-</details>
-
-<details>
-<summary><b>v1.0.7</b></summary>
-
-- 增加 `easy cascadeLoader` - stable cascade 加载器
-- 增加 `easy preSamplingCascade` - stabled cascade stage_c 预采样参数
-- 增加 `easy fullCascadeKSampler` - stable cascade stage_c 完整版采样器
-- 增加 `easy cascadeKSampler` - stable cascade stage-c ksampler simple
-</details>
-
-<details>
-<summary><b>v1.0.6</b></summary>
-
-- 增加 `easy XYInputs: Checkpoint`
-- 增加 `easy XYInputs: Lora`
-- `easy seed` 增加固定种子值时可手动切换随机种
-- 修复 `easy fullLoader`等加载器切换lora时自动调整节点大小的问题
-- 去除原有ttn的图片保存逻辑并适配ComfyUI默认的图片保存格式化扩展
-</details>
-
-<details>
-<summary><b>v1.0.5</b></summary>
-
-- 增加 `easy isSDXL` 
-- `easy svdLoader` 增加提示词控制, 可配合open_clip模型进行使用
-- `easy wildcards` 增加 **populated_text** 可输出通配填充后文本
-</details>
-
-<details>
-<summary><b>v1.0.4</b></summary>
-
-- 增加 `easy showLoaderSettingsNames` 可显示与输出加载器部件中的 模型与VAE名称
-- 增加 `easy promptList` - 提示词列表
-- 增加 `easy fooocusInpaintLoader` - Fooocus内补节点（仅支持XL模型的流程）
-- 增加 **Logic** 逻辑类节点 - 包含类型、计算、判断和转换类型等
-- 增加 `easy imageSave` - 带日期转换和宽高格式化的图像保存节点
-- 增加 `easy joinImageBatch` - 合并图像批次
-- `easy showAnything` 增加支持转换其他类型（如：tensor类型的条件、图像等）
-- `easy kSamplerInpainting` 增加 **patch** 传入值，配合Fooocus内补节点使用
-- `easy imageSave` 增加 **only_preivew**
-
-- 修复 xyplot在pillow>9.5中报错
-- 修复 `easy wildcards` 在使用PS扩展插件运行时报错
-- 修复 `easy latentCompositeMaskedWithCond`
-- 修复 `easy XYInputs: ControlNet` 报错
-- 修复 `easy loraStack` **toggle** 为 disabled 时报错
-
-- 修改首次安装节点包不再自动替换主题，需手动调整并刷新页面
-</details>
-
-<details>
-<summary><b>v1.0.3</b></summary>
-
-- 增加 `easy stylesSelector` 风格化提示词选择器
-- 增加队列进度条设置项，默认为未启用状态
-- `easy controlnetLoader` 和 `easy controlnetLoaderADV` 增加参数 **scale_soft_weights**
-
-
-- 修复 `easy XYInputs: Sampler/Scheduler` 报错
-- 修复 右侧菜单 点击按钮时老是跑位的问题
-- 修复 styles 路径在其他环境报错
-- 修复 `easy comfyLoader` 读取错误
-- 修复 xyPlot 在连接 zero123 时报错
-- 修复加载器中提示词为组件时报错
-- 修复 `easy getNode` 和 `easy setNode` 加载时标题未更改
-- 修复所有采样器中存储图片使用子目录前缀不生效的问题
-
-
-- 调整UI主题
-</details>
-
-<details>
-<summary><b>v1.0.2</b></summary>
-
-- 增加 **autocomplete** 文件夹，如果您安装了 [ComfyUI-Custom-Scripts](https://github.com/pythongosssss/ComfyUI-Custom-Scripts), 将在启动时合并该文件夹下的所有txt文件并覆盖到pyssss包里的autocomplete.txt文件。
-- 增加 `easy XYPlotAdvanced` 和 `easy XYInputs` 等相关节点
-- 增加 **Alt+1到9** 快捷键，可快速粘贴 Node templates 的节点预设 （对应 1到9 顺序）
-
-- 修复 `easy imageInsetCrop` 测量值为百分比时步进为1
-- 修复 开启 `a1111_prompt_style` 时XY图表无法使用的问题
-- 右键菜单中增加了一个 `📜Groups Map(EasyUse)` 
-
-- 修复在Comfy新版本中UI加载失败
-- 修复 `easy pipeToBasicPipe` 报错
-- 修改 `easy fullLoader` 和 `easy a1111Loader` 中的 **a1111_prompt_style** 默认值为 False
-- `easy XYInputs ModelMergeBlocks` 支持csv文件导入数值
-
-- 替换了XY图生成时的字体文件
-
-- 移除 `easy imageRemBg`
-- 移除包中的介绍图和工作流文件，减少包体积
-
-</details>
-
-<details>
-<summary><b>v1.0.1</b></summary>
-
-- 新增 `easy seed` - 简易随机种
-- `easy preDetailerFix` 新增了 `optional_image` 传入图像可选，如未传默认取值为pipe里的图像
-- 新增 `easy kSamplerInpainting` 用于内补潜空间的采样器
-- 新增 `easy pipeToBasicPipe` 用于转换到Impact的某些节点上
-
-- 修复 `easy comfyLoader` 报错
-- 修复所有包含输出图片尺寸的节点取值方式无法批处理的问题
-- 修复 `width` 和 `height` 无法在 `easy svdLoader` 自定义的报错问题
-- 修复所有采样器预览图片的地址链接 (解决在 MACOS 系统中图片无法在采样器中预览的问题）
-- 修复 `vae_name` 在 `easy fullLoader` 和 `easy a1111Loader` 和 `easy comfyLoader` 中选择但未替换原始vae问题
-- 修复 `easy fullkSampler` 除pipe外其他输出值的报错
-- 修复 `easy hiresFix` 输入连接pipe和image、vae同时存在时报错
-- 修复 `easy fullLoader` 中 `model_override` 连接后未执行 
-- 修复 因新增`easy seed` 导致action错误
-- 修复 `easy xyplot` 的字体文件路径读取错误
-- 修复 convert 到 `easy seed` 随机种无法固定的问题
-- 修复 `easy pipeIn` 值传入的报错问题
-- 修复 `easy zero123Loader` 和 `easy svdLoader` 读取模型时将模型加入到缓存中
-- 修复 `easy kSampler` `easy kSamplerTiled` `easy detailerFix` 的 `image_output` 默认值为 Preview
-- `easy fullLoader` 和 `easy a1111Loader` 新增了 `a1111_prompt_style` 参数可以重现和webui生成相同的图像，当前您需要安装 [ComfyUI_smZNodes](https://github.com/shiimizu/ComfyUI_smZNodes) 才能使用此功能
-</details>
-
-<details>
-<summary><b>v1.0.0</b></summary>
-
-- 新增`easy positive` - 简易正面提示词文本
-- 新增`easy negative`  - 简易负面提示词文本
-- 新增`easy wildcards` - 支持通配符和Lora选择的提示词文本
-- 新增`easy portraitMaster` - 肖像大师v2.2
-- 新增`easy loraStack` - Lora堆
-- 新增`easy fullLoader` - 完整版的加载器
-- 新增`easy zero123Loader` - 简易zero123加载器
-- 新增`easy svdLoader` - 简易svd加载器
-- 新增`easy fullkSampler` - 完整版的采样器（无分离）
-- 新增`easy hiresFix` - 支持Pipe的高清修复
-- 新增`easy predetailerFix` `easy DetailerFix` - 支持Pipe的细节修复
-- 新增`easy ultralyticsDetectorPipe` `easy samLoaderPipe` - 检测加载器（细节修复的输入项）
-- 新增`easy pipein` `easy pipeout` - Pipe的输入与输出
-- 新增`easy xyPlot` - 简易的xyplot (后续会更新更多可控参数)
-- 新增`easy imageRemoveBG` - 图像去除背景
-- 新增`easy imagePixelPerfect` - 图像完美像素
-- 新增`easy poseEditor` - 姿势编辑器
-- 新增UI主题（黑曜石）- 默认自动加载UI, 也可在设置中自行更替 
-
-- 修复 `easy globalSeed` 不生效问题
-- 修复所有的`seed_num` 因 [cg-use-everywhere](https://github.com/chrisgoringe/cg-use-everywhere) 实时更新图表导致值错乱的问题
-- 修复`easy imageSize` `easy imageSizeBySide` `easy imageSizeByLongerSide` 可作为终节点
-- 修复 `seed_num` (随机种子值) 在历史记录中读取无法一致的Bug
-</details>
-
-
-<details>
-<summary><b>v0.5</b></summary>
-
-- 新增 `easy controlnetLoaderADV` 节点
--  新增 `easy imageSizeBySide` 节点，可选输出为长边或短边
--  新增 `easy LLLiteLoader` 节点，如果您预先安装过 kohya-ss/ControlNet-LLLite-ComfyUI 包，请将 models 里的模型文件移动至 ComfyUI\models\controlnet\ (即comfy默认的controlnet路径里，请勿修改模型的文件名，不然会读取不到)。
--  新增 `easy imageSize` 和 `easy imageSizeByLongerSize` 输出的尺寸显示。
--  新增 `easy showSpentTime` 节点用于展示图片推理花费时间与VAE解码花费时间。
-- `easy controlnetLoaderADV` 和 `easy controlnetLoader` 新增 `control_net` 可选传入参数
-- `easy preSampling` 和 `easy preSamplingAdvanced` 新增 `image_to_latent` 可选传入参数
-- `easy a1111Loader` 和 `easy comfyLoader` 新增 `batch_size` 传入参数
-
--  修改 `easy controlnetLoader` 到 loader 分类底下。
-</details>
-
-## 整合参考到的相关节点包
-
-声明: 非常尊重这些原作者们的付出，开源不易，我仅仅只是做了一些整合与优化。
-
-| 节点名 (搜索名)                      | 相关的库                                                                        | 库相关的节点                  |
-|:-------------------------------|:----------------------------------------------------------------------------|:------------------------|
-| easy setNode                   | [ComfyUI-extensions](https://github.com/diffus3/ComfyUI-extensions) | diffus3.SetNode         |
-| easy getNode                   | [ComfyUI-extensions](https://github.com/diffus3/ComfyUI-extensions) | diffus3.GetNode         |
-| easy bookmark                  | [rgthree-comfy](https://github.com/rgthree/rgthree-comfy) | Bookmark 🔖             |
-| easy portraitMarker            | [comfyui-portrait-master](https://github.com/florestefano1975/comfyui-portrait-master) | Portrait Master         |
-| easy LLLiteLoader              | [ControlNet-LLLite-ComfyUI](https://github.com/kohya-ss/ControlNet-LLLite-ComfyUI) | LLLiteLoader            |
-| easy globalSeed                | [ComfyUI-Inspire-Pack](https://github.com/ltdrdata/ComfyUI-Inspire-Pack) | Global Seed (Inspire)   | 
-| easy preSamplingDynamicCFG     | [sd-dynamic-thresholding](https://github.com/mcmonkeyprojects/sd-dynamic-thresholding) | DynamicThresholdingFull | 
-| dynamicThresholdingFull        | [sd-dynamic-thresholding](https://github.com/mcmonkeyprojects/sd-dynamic-thresholding) | DynamicThresholdingFull | 
-| easy imageInsetCrop            | [rgthree-comfy](https://github.com/rgthree/rgthree-comfy) | ImageInsetCrop          | 
-| easy poseEditor                | [ComfyUI_Custom_Nodes_AlekPet](https://github.com/AlekPet/ComfyUI_Custom_Nodes_AlekPet) | poseNode                | 
-| easy if                        | [ComfyUI-Logic](https://github.com/theUpsider/ComfyUI-Logic) | IfExecute               | 
-| easy preSamplingLayerDiffusion | [ComfyUI-layerdiffusion](https://github.com/huchenlei/ComfyUI-layerdiffusion) | LayeredDiffusionApply等  | 
-| easy dynamiCrafterLoader       | [ComfyUI-layerdiffusion](https://github.com/ExponentialML/ComfyUI_Native_DynamiCrafter) | Apply Dynamicrafter     | 
-| easy imageChooser              | [cg-image-picker](https://github.com/chrisgoringe/cg-image-picker) | Preview Chooser         | 
-| easy styleAlignedBatchAlign    | [style_aligned_comfy](https://github.com/chrisgoringe/cg-image-picker) | styleAlignedBatchAlign  | 
-| easy icLightApply              | [ComfyUI-IC-Light](https://github.com/huchenlei/ComfyUI-IC-Light) | ICLightApply等           |
-
-## Credits
-
-[ComfyUI](https://github.com/comfyanonymous/ComfyUI) - 功能强大且模块化的Stable Diffusion GUI
-
-[ComfyUI-ComfyUI-Manager](https://github.com/ltdrdata/ComfyUI-Manager) - ComfyUI管理器
-
-[tinyterraNodes](https://github.com/TinyTerra/ComfyUI_tinyterraNodes) - 管道节点（节点束）让用户减少了不必要的连接
-
-[ComfyUI-extensions](https://github.com/diffus3/ComfyUI-extensions) - diffus3的获取与设置点让用户可以分离工作流构成
-
-[ComfyUI-Impact-Pack](https://github.com/ltdrdata/ComfyUI-Impact-Pack) - 常规整合包1
-
-[ComfyUI-Inspire-Pack](https://github.com/ltdrdata/ComfyUI-Inspire-Pack) - 常规整合包2
-
-[ComfyUI-Logic](https://github.com/theUpsider/ComfyUI-Logic) -  ComfyUI逻辑运算
-
-[ComfyUI-ResAdapter](https://github.com/jiaxiangc/ComfyUI-ResAdapter) - 让模型生成不受训练分辨率限制
-
-[ComfyUI_IPAdapter_plus](https://github.com/cubiq/ComfyUI_IPAdapter_plus) - 风格迁移
-
-[ComfyUI_InstantID](https://github.com/cubiq/ComfyUI_InstantID) - 人脸迁移
-
-[ComfyUI-Custom-Scripts](https://github.com/pythongosssss/ComfyUI-Custom-Scripts) - pyssss 小蛇🐍脚本
-
-[cg-image-picker](https://github.com/chrisgoringe/cg-image-picker) - 图片选择器
-
-[ComfyUI-BrushNet](https://github.com/nullquant/ComfyUI-BrushNet) - BrushNet 内补节点
+![comfyui-easy-use](https://github.com/user-attachments/assets/9b7a5e44-f5e2-4c27-aed2-d0e6b50c46bb)
+
+<div align="center">
+<a href="https://space.bilibili.com/1840885116">Video Tutorial</a> |
+<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>
+<a href="./README.md"><img src="https://img.shields.io/badge/🇬🇧English-0b8cf5"></a>
+<a href="./README.ZH_CN.md"><img src="https://img.shields.io/badge/🇨🇳中文简体-e9e9e9"></a>
+</div>
+
+**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
+
+- Inspire 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)
+- 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
+- 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
+
+## 👨🏻‍🔧 Installation
+Clone the repo into the **custom_nodes** directory and install the requirements:
+```shell
+#1. Clone the repo
+git clone https://github.com/yolain/ComfyUI-Easy-Use
+#2. Install the requirements
+Double-click install.bat to install the required dependencies
+```
+
+## 📜 Changelog
+
+**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.
+- Adjust the default value of `clip_skip` from `-1` to `-2` in some easy loaders.
+- Fix the issue due to set nodes missing custom nodes which their connected, causing canvas to be messed up.
+- Fix the `easy imageChooser` can not using in a loop.
+
+**v1.2.5**
+
+- Added `enable (GPU=A1111)` noise mode on `easy preSamplingCustom` and `easy preSamplingAdvanced` 
+- Added `easy makeImageForICLora`
+- Added `REGULAR - FLUX and SD3.5 only (high strength)` preset for InstantX Flux ipadapter on `easy ipadapterApply`
+- Fix brushnet can not be used with startup arg `--fast` mode
+- Support briaai RMBG-2.0
+- Support mochi 
+- Implement reuse of end nodes output in the loop body (e.g: previewImage and showAnything and sth.) 
+
+**v1.2.4**
+
+- Added `easy imageSplitTiles` and `easy imageTilesFromBatch`
+- Support `model_override`,`vae_override`,`clip_override` can be input separately to `easy fullLoader`
+- Added `easy saveImageLazy`
+- Added `easy loadImageForLoop`
+- Added `easy isFileExist`
+- Added `easy saveText`
+
+**v1.2.3**
+
+- `easy showAnything` and `easy cleanGPUUsed` added slot of output
+- Added human parts segmentation to `easy humanSegmentation` - Code based on [ComfyUI_Human_Parts](https://github.com/metal3d/ComfyUI_Human_Parts)
+- Using FluxGuidance when you are using a flux model and choose basicGuider and set the cfg>0 on `easy preSamplingCustom`
+- Added `easy loraStackApply` and `easy controlnetStackApply` - Apply loraStack and controlnetStack
+
+**v1.2.2**
+
+- Added `easy batchAny`
+- Added `easy anythingIndexSwitch`
+- Added `easy forLoopStart` and `easy forLoopEnd`  
+- Added `easy ifElse`  
+- Added v2 web frond-end code
+- Added `easy fluxLoader`
+- Added support for `controlnetApply` Related nodes with SD3 and hunyuanDiT
+- Fixed after using `easy applyFooocusInpaint`, all lora models become unusable
+
+**v1.2.1**
+
+- Added `easy ipadapterApplyFaceIDKolors`
+- Added **inspyrenet** to `easy imageRemBg` 
+- Added `easy controlnetLoader++`
+- Added **PLUS (kolors genernal)** and **FACEID PLUS KOLORS** preset to `easy ipadapterApply` and `easy ipadapterApplyADV` (Supported kolors ipadapter）
+- Added `easy kolorsLoader` - Code based on [MinusZoneAI](https://github.com/MinusZoneAI/ComfyUI-Kolors-MZ)'s and [kijai](https://github.com/kijai/ComfyUI-KwaiKolorsWrapper)'s repo, thanks for their contribution.
+
+**v1.2.0**
+
+- Added `easy pulIDApply` and `easy pulIDApplyADV`
+- Added `easy huanyuanDiTLoader` and `easy pixArtLoader`
+- Added **easy sliderControl** - Slider control node, which can currently be used to control the parameters of ipadapterMS (double-click the slider to reset to default)
+- Added **layer_weights** in `easy ipadapterApplyADV`
+
+**v1.1.9**
+
+- Added **gitsScheduler**
+- Added `easy imageBatchToImageList` and `easy imageListToImageBatch` 
+- Recursive subcategories nested for models
+- Support for Stable Diffusion 3 model
+- Added `easy applyInpaint` - All inpainting mode in this node
+
+**v1.1.8**
+
+- Added `easy controlnetStack`
+- Added `easy applyBrushNet` - [Workflow Example](https://github.com/yolain/ComfyUI-Yolain-Workflows/blob/main/workflows/2_advanced/2-4inpainting/2-4brushnet_1.1.8.json)
+- Added `easy applyPowerPaint` - [Workflow Example](https://github.com/yolain/ComfyUI-Yolain-Workflows/blob/main/workflows/2_advanced/2-4inpainting/2-4powerpaint_outpaint_1.1.8.json)
+
+**v1.1.7**
+
+- Added `easy prompt` - Subject and light presets, maybe adjusted later
+- Added `easy icLightApply` - Light and shadow migration, Code based on [ComfyUI-IC-Light](https://github.com/huchenlei/ComfyUI-IC-Light)
+- Added `easy imageSplitGrid`
+- `easy kSamplerInpainting` added options such as different diffusion and brushnet in **additional** widget
+- Support for brushnet model loading - [ComfyUI-BrushNet](https://github.com/nullquant/ComfyUI-BrushNet)
+- Added `easy applyFooocusInpaint` - Replace FooocusInpaintLoader
+- Removed `easy fooocusInpaintLoader`
+
+**v1.1.6**
+
+- Added **alignYourSteps** to **schedulder** widget in all `easy preSampling` and `easy fullkSampler`
+- Added **Preview&Choose** to **image_output** widget in `easy kSampler` & `easy fullkSampler`
+- Added `easy styleAlignedBatchAlign` - Credit of [style_aligned_comfy](https://github.com/brianfitzgerald/style_aligned_comfy)
+- Added `easy ckptNames`
+- Added `easy controlnetNames`
+- Added `easy imagesSplitimage` - Batch images split into single images
+- Added `easy imageCount` - Get Image Count
+- Added `easy textSwitch` - Text Switch
+
+<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
+- Added `easy imageColorMatch`
+- Added `easy ipadapterApplyRegional`
+- Added `easy ipadapterApplyFromParams`
+- Added `easy imageInterrogator` - Image To Prompt
+- Added `easy stableDiffusion3API` - Easy Stable Diffusion 3 Multiple accounts API Node
+</details>
+
+<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>
+
+<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
+- Added `easy promptLine`
+- Added `easy promptReplace`
+- Added `easy promptConcat`
+- `easy wildcards` Added **multiline_mode**  
+</details>
+
+<details>
+<summary><b>v1.1.2</b></summary>
+
+- Optimized some of the recommended nodes for slots related to EasyUse
+- Added **Enable ContextMenu Auto Nest Subdirectories** The setting item is enabled by default, and it can be classified into subdirectories, checkpoints and loras previews
+- Added `easy sv3dLoader` 
+- Added `easy dynamiCrafterLoader` 
+- Added `easy ipadapterApply`
+- Added `easy ipadapterApplyADV`
+- Added `easy ipadapterApplyEncoder`
+- Added `easy ipadapterApplyEmbeds`
+- Added `easy preMaskDetailerFix`
+- Fixed `easy stylesSelector` is change the prompt when not select the style
+- Fixed `easy pipeEdit` error when add lora to prompt
+- Fixed layerDiffuse xyplot bug
+- `easy kSamplerInpainting` add *additional* widget，you can choose 'Differential Diffusion' or 'Only InpaintModelConditioning'
+</details>
+
+<details>
+<summary><b>v1.1.1</b></summary>
+
+- The issue that the seed is 0 when a node with a seed control is added and **control before generate** is fixed for the first time run queue prompt.
+- `easy preSamplingAdvanced` Added **return_with_leftover_noise**
+- Fixed `easy stylesSelector` error when choose the custom file
+- `easy preSamplingLayerDiffusion` Added optional input parameter for mask
+- Renamed all nodes widget name named seed_num to seed
+- Remove forced **control_before_generate** settings。 If you want to use control_before_generate, change widget_value_control_mode to before in system settings
+- Added `easy imageRemBg` - The default is BriaAI's RMBG-1.4 model, which removes the background effect more and faster
+</details>
+
+<details>
+<summary><b>v1.1.0</b></summary>
+
+- Added `easy imageSplitList` - to split every N images
+- Added `easy preSamplingDiffusionADDTL` - It can modify foreground、background or blended additional prompt
+- Added `easy preSamplingNoiseIn` It can replace the `easy latentNoisy` node that needs to be fronted to achieve better noise injection
+- `easy pipeEdit` Added conditioning splicing mode selection, you can choose to replace, concat, combine, average, and set timestep range
+- Added `easy pipeEdit` - nodes that can edit pipes (including re-enterable prompts)
+- Added `easy preSamplingLayerDiffusion` and `easy kSamplerLayerDiffusion`
+- Added a convenient menu to right-click on nodes such as Loader, Presampler, Sampler, Controlnet, etc. to quickly replace nodes of the same type
+- Added `easy instantIDApplyADV` can link positive and negative
+- Fixed layerDiffusion error when batch size greater than 1
+- Fixed `easy wildcards` When LoRa is not filled in completely, LoRa is not automatically retrieved, resulting in failure to load LoRa
+- Fixed the issue that 'BREAK' non-initiation when didn't use a1111 prompt style
+- Fixed `easy instantIDApply` mask not input right
+</details>
+
+<details>
+<summary><b>v1.0.9</b></summary>
+
+- Fixed the error when ComfyUI-Impack-Pack and ComfyUI_InstantID were not installed
+- Fixed `easy pipeIn`
+- Added `easy instantIDApply` - you need installed [ComfyUI_InstantID](https://github.com/cubiq/ComfyUI_InstantID) fisrt, Workflow[Example](https://github.com/yolain/ComfyUI-Easy-Use/blob/main/README.en.md#InstantID)
+- Fixed `easy detailerFix` not added to the list of nodes available for saving images formatting extensions
+- Fixed `easy XYInputs: PromptSR` errors are reported when replacing negative prompts
+</details>
+
+<details>
+<summary><b>v1.0.8</b></summary>
+
+- `easy cascadeLoader` stage_c and stage_b support the checkpoint model (Download [checkpoints](https://huggingface.co/stabilityai/stable-cascade/tree/main/comfyui_checkpoints) models) 
+- `easy styleSelector` The search box is modified to be case-insensitive
+- `easy fullLoader` **positive**、**negative**、**latent** added to the output items
+- Fixed the issue that 'easy preSampling' and other similar node, latent could not be generated based on the batch index after passing in
+- Fixed `easy svdLoader` error when the positive or negative is empty
+- Fixed the error of SDXLClipModel in ComfyUI revision 2016[c2cb8e88] and above (the revision number was judged to be compatible with the old revision)
+- Fixed `easy detailerFix` generation error when batch size is greater than 1
+- Optimize the code, reduce a lot of redundant code and improve the running speed
+</details>
+
+<details>
+<summary><b>v1.0.7</b></summary>
+
+- Added `easy cascadeLoader` - stable cascade Loader
+- Added `easy preSamplingCascade` - stable cascade preSampling Settings
+- Added `easy fullCascadeKSampler` - stable cascade stage-c ksampler full
+- Added `easy cascadeKSampler` - stable cascade stage-c ksampler simple
+- 
+- Optimize the image to image[Example](https://github.com/yolain/ComfyUI-Easy-Use/blob/main/README.en.md#image-to-image)
+</details>
+
+<details>
+<summary><b>v1.0.6</b></summary>
+
+- Added `easy XYInputs: Checkpoint`
+- Added `easy XYInputs: Lora`
+- `easy seed` can manually switch the random seed when increasing the fixed seed value
+- Fixed `easy fullLoader` and all loaders to automatically adjust the node size when switching LoRa
+- Removed the original ttn image saving logic and adapted to the default image saving format extension of ComfyUI
+</details>
+
+<details>
+<summary><b>v1.0.5</b></summary>
+
+- Added `easy isSDXL` 
+- Added prompt word control on `easy svdLoader`, which can be used with open_clip model
+- Added **populated_text** on `easy wildcards`, wildcard populated text can be output
+</details>
+
+<details>
+<summary><b>v1.0.4</b></summary>
+
+- `easy showAnything` added support for converting other types (e.g., tensor conditions, images, etc.)
+- Added `easy showLoaderSettingsNames` can display the model and VAE name in the output loader assembly
+- Added `easy promptList`
+- Added `easy fooocusInpaintLoader` （only the process of SDXLModel is supported）
+- Added **Logic** nodes
+- Added `easy imageSave` - Image saving node with date conversion and aspect and height formatting
+- Added `easy joinImageBatch`
+- `easy kSamplerInpainting` Added the **patch** input value to be used with the FooocusInpaintLoader node
+
+- Fixed xyplot error when with Pillow>9.5
+- Fixed `easy wildcards` An error is reported when running with the PS extension
+- Fixed `easy XYInputs: ControlNet` Error
+- Fixed `easy loraStack` error when **toggle** is disabled
+
+
+- Changing the first-time install node package no longer automatically replaces the theme, you need to manually adjust and refresh the page
+- `easy imageSave` added **only_preivew**
+- Adjust the `easy latentCompositeMaskedWithCond` node
+</details>
+
+<details>
+<summary><b>v1.0.3</b></summary>
+
+- Added `easy stylesSelector`
+- Added **scale_soft_weights** in `easy controlnetLoader` and `easy controlnetLoaderADV` 
+- Added the queue progress bar setting item, which is not enabled by default
+
+
+- Fixed `easy XYInputs: Sampler/Scheduler` Error
+- Fixed the right menu has a problem when clicking the button
+- Fixed `easy comfyLoader` error
+- Fixed xyPlot error when connecting to zero123
+- Fixed the error message in the loader when the prompt word was component
+- Fixed `easy getNode` and `easy setNode` the title does not change when loading
+- Fixed all samplers using subdirectories to store images
+
+
+- Adjust the UI theme, divided into two sets of styles: the official default background and the dark black background, which can be switched in the color palette in the settings
+- Modify the styles path to be compatible with other environments
+</details>
+
+<details>
+<summary><b>v1.0.2</b></summary>
+
+- Added `easy XYPlotAdvanced` and some nodes about `easy XYInputs`
+- Added **Alt+1-Alt+9** Shortcut keys to quickly paste node presets for Node templates (corresponding to 1~9 sequences)
+- Added a `📜Groups Map(EasyUse)` to the context menu.
+- An `autocomplete` folder has been added, If you have [ComfyUI-Custom-Scripts](https://github.com/pythongosssss/ComfyUI-Custom-Scripts) installed, the txt files in that folder will be merged and overwritten to the autocomplete .txt file of the pyssss package at startup.
+
+
+- Fixed XYPlot is not working when `a1111_prompt_style` is True
+- Fixed UI loading failure in the new version of ComfyUI
+- `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
+</details>
+
+<details>
+<summary><b>v1.0.1</b></summary>
+
+- Fixed `easy comfyLoader` error
+- Fixed All nodes that contain the value of the image size
+- Added `easy kSamplerInpainting`
+- Added `easy pipeToBasicPipe`
+- Fixed `width` and `height` can not customize in `easy svdLoader`
+- Fixed all preview image path (Previously, it was not possible to preview the image on the Mac system)
+- Fixed `vae_name` is not working in `easy fullLoader` and `easy a1111Loader` and `easy comfyLoader`
+- Fixed `easy fullkSampler` outputs error
+- Fixed `model_override` is not working in `easy fullLoader`
+- Fixed `easy hiresFix` error
+- Fixed `easy xyplot` font file path error
+- Fixed seed that cannot be fixed when you convert `seed_num` to `easy seed` 
+- Fixed `easy pipeIn` inputs bug
+- `easy preDetailerFix` have added a new parameter `optional_image`
+- Fixed `easy zero123Loader` and `easy svdLoader` model into cache.
+- Added `easy seed`
+- Fixed `image_output` default value is "Preview"
+- `easy fullLoader` and `easy a1111Loader` have added a new parameter `a1111_prompt_style`,that can reproduce the same image generated from stable-diffusion-webui on comfyui, but you need to install [ComfyUI_smZNodes](https://github.com/shiimizu/ComfyUI_smZNodes) to use this feature in the current version
+</details>
+
+<details>
+<summary><b>v1.0.0</b></summary>
+
+- Added `easy positive` - simple positive prompt text
+- Added `easy negative` - simple negative prompt text
+- Added `easy wildcards` - support for wildcards and hint text selected by Lora
+- Added `easy portraitMaster` - PortraitMaster v2.2
+- Added `easy loraStack` - Lora stack
+- Added `easy fullLoader` - full version of the loader
+- Added `easy zero123Loader` - simple zero123 loader
+- Added `easy svdLoader` - easy svd loader
+- Added `easy fullkSampler` - full version of the sampler (no separation)
+- Added `easy hiresFix` - support for HD repair of Pipe
+- Added `easy predetailerFix` and `easy DetailerFix` - support for Pipe detail fixing
+- Added `easy ultralyticsDetectorPipe` and `easy samLoaderPipe` - Detect loader (detail fixed input)
+- Added `easy pipein` `easy pipeout` - Pipe input and output
+- Added `easy xyPlot` - simple xyplot (more controllable parameters will be updated in the future)
+- Added `easy imageRemoveBG` - image to remove background
+- Added `easy imagePixelPerfect` - image pixel perfect
+- Added `easy poseEditor` - Pose editor
+- New UI Theme (Obsidian) - Auto-load UI by default, which can also be changed in the settings 
+
+- Fixed `easy globalSeed` is not working
+- Fixed an issue where all `seed_num` values were out of order due to [cg-use-everywhere](https://github.com/chrisgoringe/cg-use-everywhere) updating the chart in real time
+- Fixed `easy imageSize`, `easy imageSizeBySide`, `easy imageSizeByLongerSide` as end nodes
+- Fixed the bug that `seed_num` (random seed value) could not be read consistently in history
+</details>
+
+<details>
+<summary><b>Updated at 12/14/2023</b></summary>
+
+- `easy a1111Loader` and `easy comfyLoader` added `batch_size` of required input parameters 
+- Added the `easy controlnetLoaderADV` node
+- `easy controlnetLoaderADV` and `easy controlnetLoader` added `control_net ` of optional input parameters
+- `easy preSampling` and `easy preSamplingAdvanced` added `image_to_latent` optional input parameters
+- Added the `easy imageSizeBySide` node, which can be output as a long side or a short side
+</details>
+
+<details>
+<summary><b>Updated at 12/13/2023</b></summary>
+
+-  Added the `easy LLLiteLoader` node, if you have pre-installed the kohya-ss/ControlNet-LLLite-ComfyUI package, please move the model files in the models to `ComfyUI\models\controlnet\` (i.e. in the default controlnet path of comfy, please do not change the file name of the model, otherwise it will not be read).
+-  Modify `easy controlnetLoader` to the bottom of the loader category.
+-  Added size display for `easy imageSize` and `easy imageSizeByLongerSize` outputs.
+</details>
+
+<details>
+<summary><b>Updated at 12/11/2023</b></summary>
+-  Added the `showSpentTime` node to display the time spent on image diffusion and the time spent on VAE decoding images
+</details>
+
+## The relevant node package involved
+
+Disclaimer: Opened source was not easy. I have a lot of respect for the contributions of these original authors. I just did some integration and optimization.
+
+| Nodes Name(Search Name)        | Related libraries                                                                        | Library-related node     |
+|:-------------------------------|:----------------------------------------------------------------------------|:-------------------------|
+| easy setNode                   | [ComfyUI-extensions](https://github.com/diffus3/ComfyUI-extensions) | diffus3.SetNode          |
+| easy getNode                   | [ComfyUI-extensions](https://github.com/diffus3/ComfyUI-extensions) | diffus3.GetNode          |
+| easy bookmark                  | [rgthree-comfy](https://github.com/rgthree/rgthree-comfy) | Bookmark 🔖              |
+| easy portraitMarker            | [comfyui-portrait-master](https://github.com/florestefano1975/comfyui-portrait-master) | Portrait Master          |
+| easy LLLiteLoader              | [ControlNet-LLLite-ComfyUI](https://github.com/kohya-ss/ControlNet-LLLite-ComfyUI) | LLLiteLoader             |
+| easy globalSeed                | [ComfyUI-Inspire-Pack](https://github.com/ltdrdata/ComfyUI-Inspire-Pack) | Global Seed (Inspire)    | 
+| easy preSamplingDynamicCFG     | [sd-dynamic-thresholding](https://github.com/mcmonkeyprojects/sd-dynamic-thresholding) | DynamicThresholdingFull  | 
+| dynamicThresholdingFull        | [sd-dynamic-thresholding](https://github.com/mcmonkeyprojects/sd-dynamic-thresholding) | DynamicThresholdingFull  | 
+| easy imageInsetCrop            | [rgthree-comfy](https://github.com/rgthree/rgthree-comfy) | ImageInsetCrop           | 
+| easy poseEditor                | [ComfyUI_Custom_Nodes_AlekPet](https://github.com/AlekPet/ComfyUI_Custom_Nodes_AlekPet) | poseNode                 | 
+| easy preSamplingLayerDiffusion | [ComfyUI-layerdiffusion](https://github.com/huchenlei/ComfyUI-layerdiffusion) | LayeredDiffusionApply... | 
+| easy dynamiCrafterLoader       | [ComfyUI-layerdiffusion](https://github.com/ExponentialML/ComfyUI_Native_DynamiCrafter) | Apply Dynamicrafter    | 
+| easy imageChooser              | [cg-image-picker](https://github.com/chrisgoringe/cg-image-picker) | Preview Chooser         | 
+| easy styleAlignedBatchAlign              | [style_aligned_comfy](https://github.com/chrisgoringe/cg-image-picker) | styleAlignedBatchAlign       | 
+| easy kolorsLoader              | [ComfyUI-Kolors-MZ](https://github.com/MinusZoneAI/ComfyUI-Kolors-MZ) | kolorsLoader            |
+
+
+## Credits
+
+[ComfyUI](https://github.com/comfyanonymous/ComfyUI) - Powerful and modular Stable Diffusion GUI
+
+[ComfyUI-ComfyUI-Manager](https://github.com/ltdrdata/ComfyUI-Manager) - ComfyUI Manager
+
+[tinyterraNodes](https://github.com/TinyTerra/ComfyUI_tinyterraNodes) - Pipe nodes (node bundles) allow users to reduce unnecessary connections
+
+[ComfyUI-extensions](https://github.com/diffus3/ComfyUI-extensions) - Diffus3 gets and sets points that allow the user to detach the composition of the workflow 
+
+[ComfyUI-Impact-Pack](https://github.com/ltdrdata/ComfyUI-Impact-Pack) - General modpack 1
+
+[ComfyUI-Inspire-Pack](https://github.com/ltdrdata/ComfyUI-Inspire-Pack) - General Modpack 2
+
+[ComfyUI-ResAdapter](https://github.com/jiaxiangc/ComfyUI-ResAdapter) - Make model generation independent of training resolution
+
+[ComfyUI_IPAdapter_plus](https://github.com/cubiq/ComfyUI_IPAdapter_plus) - Style migration
+
+[ComfyUI_InstantID](https://github.com/cubiq/ComfyUI_InstantID) - Face migration
+
+[ComfyUI_PuLID](https://github.com/cubiq/PuLID_ComfyUI) - Face migration
+
+[ComfyUI-Custom-Scripts](https://github.com/pythongosssss/ComfyUI-Custom-Scripts) - pyssss🐍
+
+[cg-image-picker](https://github.com/chrisgoringe/cg-image-picker) - Image Preview Chooser
+
+[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>
+If my custom nodes has added value to your day, consider indulging in a coffee to fuel it further! <br>
+💖You can support me in any of the following ways:
+
+- [BiliBili](https://space.bilibili.com/1840885116)
+- [Wechat / Alipay](https://github.com/user-attachments/assets/803469bd-ed6a-4fab-932d-50e5088a2d03)
+
+##  🌟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)

__init__.py

@@ -1,36 +1,38 @@
-__version__ = "1.1.8"
+__version__ = "1.3.2"
 
+import yaml
+import json
 import os
 import folder_paths
 import importlib
-from pathlib import Path
-
-node_list = [
-    "server",
-    "api",
-    "easyNodes",
-    "image",
-    "logic"
-]
-
-NODE_CLASS_MAPPINGS = {}
-NODE_DISPLAY_NAME_MAPPINGS = {}
-
-for module_name in node_list:
-    imported_module = importlib.import_module(".py.{}".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读取
+NODE_CLASS_MAPPINGS = {}
+NODE_DISPLAY_NAME_MAPPINGS = {}
+
+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}
+
+#Wildcards
 from .py.libs.wildcards import read_wildcard_dict
 wildcards_path = os.path.join(os.path.dirname(__file__), "wildcards")
-if os.path.exists(wildcards_path):
-    read_wildcard_dict(wildcards_path)
-else:
+if not os.path.exists(wildcards_path):
     os.mkdir(wildcards_path)
+    
+# Add custom wildcards example
+example_path = os.path.join(wildcards_path, "example.txt")
+if not os.path.exists(example_path):
+    with open(example_path, 'w') as f:
+        text = "blue\nred\nyellow\ngreen\nbrown\npink\npurple\norange\nblack\nwhite"
+        f.write(text)
+read_wildcard_dict(wildcards_path)
 
 #Styles
 styles_path = os.path.join(os.path.dirname(__file__), "styles")
@@ -42,19 +44,52 @@ else:
     os.mkdir(styles_path)
     os.mkdir(samples_path)
 
-# ComfyUI-Easy-PS相关 (需要把模型预览图暴露给PS读取，此处借鉴了 AIGODLIKE-ComfyUI-Studio 的部分代码)
-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)
+# Add custom styles example
+example_path = os.path.join(styles_path, "your_styles.json.example")
+if not os.path.exists(example_path):
+    import json
+    data = [
+        {
+            "name": "Example Style",
+            "name_cn": "示例样式",
+            "prompt": "(masterpiece), (best quality), (ultra-detailed), {prompt} ",
+            "negative_prompt": "text, watermark, logo"
+        },
+    ]
+    # Write to file
+    with open(example_path, 'w', encoding='utf-8') as f:
+        json.dump(data, f, indent=4, ensure_ascii=False)
+
+
+web_default_version = 'v2'
+# web directory
+config_path = os.path.join(cwd_path, "config.yaml")
+if os.path.isfile(config_path):
+    with open(config_path, 'r') as f:
+        data = yaml.load(f, Loader=yaml.FullLoader)
+        if data and "WEB_VERSION" in data:
+            directory = f"web_version/{data['WEB_VERSION']}"
+            with open(config_path, 'w') as f:
+                yaml.dump(data, f)
+        elif web_default_version != 'v1':
+            if not data:
+                data = {'WEB_VERSION': web_default_version}
+            elif 'WEB_VERSION' not in data:
+                data = {**data, 'WEB_VERSION': web_default_version}
+            with open(config_path, 'w') as f:
+                yaml.dump(data, f)
+            directory = f"web_version/{web_default_version}"
+        else:
+            directory = f"web_version/v1"
+    if not os.path.exists(os.path.join(cwd_path, directory)):
+        print(f"web root {data['WEB_VERSION']} not found, using default")
+        directory = f"web_version/{web_default_version}"
+    WEB_DIRECTORY = directory
+else:
+    directory = f"web_version/{web_default_version}"
+    WEB_DIRECTORY =  directory
 
-WEB_DIRECTORY = "./web"
 __all__ = ['NODE_CLASS_MAPPINGS', 'NODE_DISPLAY_NAME_MAPPINGS', "WEB_DIRECTORY"]
 
-
-print(f'\033[34mComfy-Easy-Use v{__version__}: \033[92mLoaded\033[0m')
+print(f'\033[34m[ComfyUI-Easy-Use] server: \033[0mv{__version__} \033[92mLoaded\033[0m')
+print(f'\033[34m[ComfyUI-Easy-Use] web root: \033[0m{os.path.join(cwd_path, directory)} \033[92mLoaded\033[0m')

install.bat

@@ -1,14 +1,24 @@
 @echo off
 
 set "requirements_txt=%~dp0\requirements.txt"
+set "requirements_repair_txt=%~dp0\repair_dependency_list.txt"
 set "python_exec=..\..\..\python_embeded\python.exe"
+set "aki_python_exec=..\..\python\python.exe"
 
 echo Installing EasyUse Requirements...
 
 if exist "%python_exec%" (
     echo Installing with ComfyUI Portable
     "%python_exec%" -s -m pip install -r "%requirements_txt%"
-) else (
+)^
+else if exist "%aki_python_exec%" (
+    echo Installing with ComfyUI Aki
+    "%aki_python_exec%" -s -m pip install -r "%requirements_txt%"
+    for /f "delims=" %%i in (%requirements_repair_txt%) do (
+        %aki_python_exec% -s -m pip install -i https://pypi.tuna.tsinghua.edu.cn/simple "%%i"
+        )
+)^
+else (
     echo Installing with system Python
     pip install -r "%requirements_txt%"
 )

install.sh

@@ -0,0 +1,24 @@
+#!/bin/bash
+
+requirements_txt="$(dirname "$0")/requirements.txt"
+requirements_repair_txt="$(dirname "$0")/repair_dependency_list.txt"
+python_exec="../../../python_embeded/python.exe"
+aki_python_exec="../../python/python.exe"
+
+echo "Installing EasyUse Requirements..."
+
+if [ -f "$python_exec" ]; then
+    echo "Installing with ComfyUI Portable"
+    "$python_exec" -s -m pip install -r "$requirements_txt"
+elif [ -f "$aki_python_exec" ]; then
+    echo "Installing with ComfyUI Aki"
+    "$aki_python_exec" -s -m pip install -r "$requirements_txt"
+    while IFS= read -r line; do
+        "$aki_python_exec" -s -m pip install -i https://pypi.tuna.tsinghua.edu.cn/simple "$line"
+    done < "$requirements_repair_txt"
+else
+    echo "Installing with system Python"
+    pip install -r "$requirements_txt"
+fi
+
+read -p "Press any key to continue..."

locales/en/main.json

@@ -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"
+  }
+}

locales/en/settings.json

@@ -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"
+  }
+}

locales/fr/main.json

@@ -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"
+  }
+}

locales/fr/settings.json

@@ -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"
+  }
+}

locales/ja/main.json

@@ -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": "画像読み込み"
+  }
+}

locales/ja/settings.json

@@ -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": "ページを更新する必要があります"
+  }
+}

locales/ko/main.json

@@ -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": "이미지 로드"
+  }
+}

locales/ko/settings.json

@@ -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": "업데이트를 위해 페이지를 새로고침해야 합니다"
+  }
+}

locales/ru/main.json

@@ -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": "Загрузка изображения"
+  }
+}

locales/ru/settings.json

@@ -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": "Необходимо обновить страницу для успешного обновления"
+  }
+}

locales/zh/main.json

@@ -0,0 +1,32 @@
+{
+  "settingsCategories": {
+    "Hotkeys": "快捷键",
+    "Nodes": "节点相关",
+    "NodesMap": "管理节点组",
+    "StylesSelector": "样式选择器"
+  },
+  "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": "加载图像"
+  }
+}

locales/zh/settings.json

@@ -0,0 +1,75 @@
+{
+  "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": {
+      "Gird": "网格",
+      "List": "列表"
+    }
+  }
+}

prestartup_script.py

@@ -22,6 +22,7 @@ add_folder_path_and_extensions("mmdets", [os.path.join(model_path, "mmdets")], f
 add_folder_path_and_extensions("sams", [os.path.join(model_path, "sams")], folder_paths.supported_pt_extensions)
 add_folder_path_and_extensions("onnx", [os.path.join(model_path, "onnx")], {'.onnx'})
 add_folder_path_and_extensions("instantid", [os.path.join(model_path, "instantid")], folder_paths.supported_pt_extensions)
+add_folder_path_and_extensions("pulid", [os.path.join(model_path, "pulid")], folder_paths.supported_pt_extensions)
 add_folder_path_and_extensions("layer_model", [os.path.join(model_path, "layer_model")], folder_paths.supported_pt_extensions)
 add_folder_path_and_extensions("rembg", [os.path.join(model_path, "rembg")], folder_paths.supported_pt_extensions)
 add_folder_path_and_extensions("ipadapter", [os.path.join(model_path, "ipadapter")], folder_paths.supported_pt_extensions)
@@ -29,6 +30,5 @@ add_folder_path_and_extensions("dynamicrafter_models", [os.path.join(model_path,
 add_folder_path_and_extensions("mediapipe", [os.path.join(model_path, "mediapipe")], set(['.tflite','.pth']))
 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("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("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)

py/__init__.py

@@ -0,0 +1,6 @@
+from .libs.loader import easyLoader
+from .libs.sampler import easySampler
+
+sampler = easySampler()
+easyCache = easyLoader()
+

py/config.py

@@ -3,7 +3,7 @@ import folder_paths
 from pathlib import Path
 
 BASE_RESOLUTIONS = [
-    ("自定义", "自定义"),
+    ("width", "height"),
     (512, 512),
     (512, 768),
     (576, 1024),
@@ -15,6 +15,7 @@ BASE_RESOLUTIONS = [
     (768, 1536),
     (816, 1920),
     (832, 1152),
+    (832, 1216),
     (896, 1152),
     (896, 1088),
     (1024, 1024),
@@ -23,6 +24,7 @@ BASE_RESOLUTIONS = [
     (1080, 1920),
     (1440, 2560),
     (1088, 896),
+    (1216, 832),
     (1152, 832),
     (1152, 896),
     (1280, 768),
@@ -76,9 +78,13 @@ BRUSHNET_MODELS = {
         }
     }
 }
-POWERPAINT_CLIP = {
-    "base_fp16":{
-        "model_url":"https://huggingface.co/runwayml/stable-diffusion-v1-5/resolve/main/text_encoder/model.fp16.safetensors"
+POWERPAINT_MODELS = {
+    "base_fp16": {
+        "model_url": "https://huggingface.co/runwayml/stable-diffusion-v1-5/resolve/main/text_encoder/model.fp16.safetensors"
+    },
+    "v2.1": {
+        "model_url": "https://huggingface.co/JunhaoZhuang/PowerPaint-v2-1/resolve/main/PowerPaint_Brushnet/diffusion_pytorch_model.safetensors",
+        "clip_url": "https://huggingface.co/JunhaoZhuang/PowerPaint-v2-1/resolve/main/PowerPaint_Brushnet/pytorch_model.bin",
     }
 }
 
@@ -184,6 +190,12 @@ REMBG_DIR = os.path.join(folder_paths.models_dir, "rembg")
 REMBG_MODELS = {
     "RMBG-1.4": {
         "model_url": "https://huggingface.co/briaai/RMBG-1.4/resolve/main/model.pth"
+    },
+    "RMBG-2.0": {
+        "model_url": "briaai/RMBG-2.0"
+    },
+    "BEN2": {
+        "model_url": "https://huggingface.co/PramaLLC/BEN2/resolve/main/BEN2_Base.pth"
     }
 }
 
@@ -191,7 +203,7 @@ REMBG_MODELS = {
 IPADAPTER_DIR = os.path.join(folder_paths.models_dir, "ipadapter")
 IPADAPTER_MODELS = {
     "LIGHT - SD1.5 only (low strength)": {
-        "sd15": {
+        "sd1": {
             "model_url": "https://huggingface.co/h94/IP-Adapter/resolve/main/models/ip-adapter_sd15_light_v11.bin"
         },
         "sdxl": {
@@ -199,7 +211,7 @@ IPADAPTER_MODELS = {
         }
     },
     "STANDARD (medium strength)": {
-        "sd15": {
+        "sd1": {
             "model_url": "https://huggingface.co/h94/IP-Adapter/resolve/main/models/ip-adapter_sd15.safetensors"
         },
         "sdxl": {
@@ -207,7 +219,7 @@ IPADAPTER_MODELS = {
         }
     },
     "VIT-G (medium strength)": {
-        "sd15": {
+        "sd1": {
             "model_url": "https://huggingface.co/h94/IP-Adapter/resolve/main/models/ip-adapter_sd15_vit-G.safetensors"
         },
         "sdxl": {
@@ -215,15 +227,33 @@ IPADAPTER_MODELS = {
         }
     },
     "PLUS (high strength)": {
-        "sd15": {
+        "sd1": {
             "model_url": "https://huggingface.co/h94/IP-Adapter/resolve/main/models/ip-adapter-plus_sd15.safetensors"
         },
         "sdxl": {
             "model_url": "https://huggingface.co/h94/IP-Adapter/resolve/main/sdxl_models/ip-adapter-plus_sdxl_vit-h.safetensors"
         }
     },
+    "PLUS (kolors genernal)": {
+        "sd1": {
+            "model_url": ""
+        },
+        "sdxl": {
+            "model_url":"https://huggingface.co/Kwai-Kolors/Kolors-IP-Adapter-Plus/resolve/main/ip_adapter_plus_general.bin"
+        }
+    },
+    "REGULAR - FLUX and SD3.5 only (high strength)": {
+       "flux": {
+           "model_url": "https://huggingface.co/InstantX/FLUX.1-dev-IP-Adapter/resolve/main/ip-adapter.bin",
+           "model_file_name": "ip-adapter_flux_1_dev.bin",
+       },
+       "sd3": {
+           "model_url": "https://huggingface.co/InstantX/SD3.5-Large-IP-Adapter/resolve/main/ip-adapter.bin",
+           "model_file_name": "ip-adapter_sd35.bin",
+       },
+    },
     "PLUS FACE (portraits)": {
-        "sd15": {
+        "sd1": {
             "model_url": "https://huggingface.co/h94/IP-Adapter/resolve/main/models/ip-adapter-plus-face_sd15.safetensors"
         },
         "sdxl": {
@@ -231,7 +261,7 @@ IPADAPTER_MODELS = {
         }
     },
     "FULL FACE - SD1.5 only (portraits stronger)": {
-        "sd15": {
+        "sd1": {
             "model_url": "https://huggingface.co/h94/IP-Adapter/resolve/main/models/ip-adapter-full-face_sd15.safetensors"
         },
         "sdxl": {
@@ -239,7 +269,7 @@ IPADAPTER_MODELS = {
         }
     },
     "FACEID": {
-        "sd15": {
+        "sd1": {
             "model_url": "https://huggingface.co/h94/IP-Adapter-FaceID/resolve/main/ip-adapter-faceid_sd15.bin",
             "lora_url": "https://huggingface.co/h94/IP-Adapter-FaceID/resolve/main/ip-adapter-faceid_sd15_lora.safetensors"
         },
@@ -249,7 +279,7 @@ IPADAPTER_MODELS = {
         }
     },
     "FACEID PLUS - SD1.5 only": {
-        "sd15": {
+        "sd1": {
             "model_url": "https://huggingface.co/h94/IP-Adapter-FaceID/resolve/main/ip-adapter-faceid-plus_sd15.bin",
             "lora_url": "https://huggingface.co/h94/IP-Adapter-FaceID/resolve/main/ip-adapter-faceid-plus_sd15_lora.safetensors"
         },
@@ -259,7 +289,7 @@ IPADAPTER_MODELS = {
         }
     },
     "FACEID PLUS V2": {
-        "sd15": {
+        "sd1": {
             "model_url": "https://huggingface.co/h94/IP-Adapter-FaceID/resolve/main/ip-adapter-faceid-plusv2_sd15.bin",
             "lora_url": "https://huggingface.co/h94/IP-Adapter-FaceID/resolve/main/ip-adapter-faceid-plusv2_sd15_lora.safetensors"
         },
@@ -268,16 +298,32 @@ IPADAPTER_MODELS = {
             "lora_url": "https://huggingface.co/h94/IP-Adapter-FaceID/resolve/main/ip-adapter-faceid-plusv2_sdxl_lora.safetensors"
         }
     },
+    "FACEID PLUS KOLORS":{
+        "sd1":{
+
+        },
+        "sdxl":{
+            "model_url":"https://huggingface.co/Kwai-Kolors/Kolors-IP-Adapter-FaceID-Plus/resolve/main/ipa-faceid-plus.bin"
+        }
+    },
     "FACEID PORTRAIT (style transfer)": {
-        "sd15": {
+        "sd1": {
             "model_url": "https://huggingface.co/h94/IP-Adapter-FaceID/resolve/main/ip-adapter-faceid-portrait-v11_sd15.bin",
         },
         "sdxl": {
             "model_url": "https://huggingface.co/h94/IP-Adapter-FaceID/resolve/main/ip-adapter-faceid-portrait_sdxl.bin",
         }
     },
+    "FACEID PORTRAIT UNNORM - SDXL only (strong)": {
+        "sd1": {
+            "model_url":""
+        },
+        "sdxl": {
+            "model_url": "https://huggingface.co/h94/IP-Adapter-FaceID/resolve/main/ip-adapter-faceid-portrait_sdxl_unnorm.bin",
+        }
+    },
     "COMPOSITION": {
-        "sd15": {
+        "sd1": {
             "model_url": "https://huggingface.co/ostris/ip-composition-adapter/resolve/main/ip_plus_composition_sd15.safetensors"
         },
         "sdxl": {
@@ -285,6 +331,17 @@ IPADAPTER_MODELS = {
         }
     }
 }
+IPADAPTER_CLIPVISION_MODELS = {
+    "clip-vit-large-patch14-336":{
+        "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_model.safetensors"
+    },
+    "sigclip_vision_patch14_384":{
+        "model_url": "https://huggingface.co/Comfy-Org/sigclip_vision_384/resolve/main/sigclip_vision_patch14_384.safetensors"
+    }
+}
 
 # dynamiCrafter
 DYNAMICRAFTER_DIR = os.path.join(folder_paths.models_dir, "dynamicrafter_models")
@@ -293,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"
@@ -311,6 +368,18 @@ HUMANPARSING_MODELS = {
     "parsing_lip": {
         "model_url": "https://huggingface.co/levihsu/OOTDiffusion/resolve/main/checkpoints/humanparsing/parsing_lip.onnx",
     },
+    "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"
+    }
 }
 
 #mediapipe
@@ -319,4 +388,20 @@ 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']

py/dynamiCrafter/__init__.py

@@ -1,332 +0,0 @@
-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,)

py/dynamiCrafter/lvdm/basics.py

@@ -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]}

py/dynamiCrafter/lvdm/common.py

@@ -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)

py/dynamiCrafter/lvdm/distributions.py

@@ -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)
-    )

py/dynamiCrafter/lvdm/ema.py

@@ -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)

py/dynamiCrafter/lvdm/models/autoencoder.py

@@ -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

py/dynamiCrafter/lvdm/models/ddpm3d.py

@@ -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

py/dynamiCrafter/lvdm/models/samplers/ddim.py

@@ -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)

py/dynamiCrafter/lvdm/models/samplers/ddim_multiplecond.py

@@ -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)

py/dynamiCrafter/lvdm/models/samplers/unipc/__init__.py

@@ -1 +0,0 @@
-from .sampler import UniPCSampler

py/dynamiCrafter/lvdm/models/samplers/unipc/sampler.py

@@ -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

py/dynamiCrafter/lvdm/models/samplers/unipc/uni_pc.py

@@ -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)]

py/dynamiCrafter/lvdm/models/utils_diffusion.py

@@ -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

py/dynamiCrafter/lvdm/modules/attention.py

@@ -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_

py/dynamiCrafter/lvdm/modules/encoders/condition.py

@@ -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]

py/dynamiCrafter/lvdm/modules/encoders/resampler.py

@@ -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

py/dynamiCrafter/lvdm/modules/networks/openaimodel3d.py

@@ -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

py/dynamiCrafter/lvdm/modules/x_transformer.py

@@ -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

py/dynamiCrafter/utils/model_utils.py

@@ -1,143 +0,0 @@
-
-import torch
-
-from collections import OrderedDict
-
-from comfy import model_base
-from comfy import utils
-from comfy import diffusers_convert
-
-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
-
-
-

py/dynamiCrafter/utils/utils.py

@@ -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://'
-    )

py/human_parsing/run_parsing.py

@@ -1,23 +0,0 @@
-from .parsing_api import onnx_inference
-from ..libs.utils import install_package
-
-class HumanParsing:
-    def __init__(self, model_path):
-        self.model_path = model_path
-        self.session = None
-
-    def __call__(self, input_image, mask_components):
-        if self.session is None:
-            install_package('onnxruntime')
-            import onnxruntime as ort
-
-            session_options = ort.SessionOptions()
-            session_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
-            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'])
-
-        parsed_image, mask = onnx_inference(self.session, input_image, mask_components)
-        return parsed_image, mask
-

py/ic_light/func.py

@@ -1,185 +0,0 @@
-import torch
-import numpy as np
-from typing import Tuple, TypedDict, Callable
-
-import comfy.model_management
-from comfy.sd import load_unet
-from comfy.ldm.models.autoencoder import AutoencoderKL
-from comfy.model_base import BaseModel
-from PIL import Image
-from nodes import VAEEncode
-
-from ..layer_diffuse.model import ModelPatcher, calculate_weight_adjust_channel
-from ..libs.image import np2tensor, pil2tensor
-
-class UnetParams(TypedDict):
-    input: torch.Tensor
-    timestep: torch.Tensor
-    c: dict
-    cond_or_uncond: torch.Tensor
-
-
-class VAEEncodeArgMax(VAEEncode):
-    def encode(self, vae, pixels):
-        assert isinstance(
-            vae.first_stage_model, AutoencoderKL
-        ), "ArgMax only supported for AutoencoderKL"
-        original_sample_mode = vae.first_stage_model.regularization.sample
-        vae.first_stage_model.regularization.sample = False
-        ret = super().encode(vae, pixels)
-        vae.first_stage_model.regularization.sample = original_sample_mode
-        return ret
-
-class ICLight:
-
-    @staticmethod
-    def apply_c_concat(params: UnetParams, concat_conds) -> UnetParams:
-        """Apply c_concat on unet call."""
-        sample = params["input"]
-        params["c"]["c_concat"] = torch.cat(
-            (
-                    [concat_conds.to(sample.device)]
-                    * (sample.shape[0] // concat_conds.shape[0])
-            ),
-            dim=0,
-        )
-        return params
-
-    @staticmethod
-    def create_custom_conv(
-        original_conv: torch.nn.Module,
-        dtype: torch.dtype,
-        device=torch.device,
-    ) -> torch.nn.Module:
-        with torch.no_grad():
-            new_conv_in = torch.nn.Conv2d(
-                8,
-                original_conv.out_channels,
-                original_conv.kernel_size,
-                original_conv.stride,
-                original_conv.padding,
-            )
-            new_conv_in.weight.zero_()
-            new_conv_in.weight[:, :4, :, :].copy_(original_conv.weight)
-            new_conv_in.bias = original_conv.bias
-            return new_conv_in.to(dtype=dtype, device=device)
-
-    def generate_lighting_image(self, original_image, direction):
-        _, image_height, image_width, _ = original_image.shape
-        match direction:
-            case 'Left Light':
-                gradient = np.linspace(255, 0, image_width)
-                image = np.tile(gradient, (image_height, 1))
-                input_bg = np.stack((image,) * 3, axis=-1).astype(np.uint8)
-                return np2tensor(input_bg)
-            case 'Right Light':
-                gradient = np.linspace(0, 255, image_width)
-                image = np.tile(gradient, (image_height, 1))
-                input_bg = np.stack((image,) * 3, axis=-1).astype(np.uint8)
-                return np2tensor(input_bg)
-            case 'Top Light':
-                gradient = np.linspace(255, 0, image_height)[:, None]
-                image = np.tile(gradient, (1, image_width))
-                input_bg = np.stack((image,) * 3, axis=-1).astype(np.uint8)
-                return np2tensor(input_bg)
-            case 'Bottom Light':
-                gradient = np.linspace(0, 255, image_height)[:, None]
-                image = np.tile(gradient, (1, image_width))
-                input_bg = np.stack((image,) * 3, axis=-1).astype(np.uint8)
-                return np2tensor(input_bg)
-            case 'Circle Light':
-                x = np.linspace(-1, 1, image_width)
-                y = np.linspace(-1, 1, image_height)
-                x, y = np.meshgrid(x, y)
-                r = np.sqrt(x ** 2 + y ** 2)
-                r = r / r.max()
-                color1 = np.array([0, 0, 0])[np.newaxis, np.newaxis, :]
-                color2 = np.array([255, 255, 255])[np.newaxis, np.newaxis, :]
-                gradient = (color1 * r[..., np.newaxis] + color2 * (1 - r)[..., np.newaxis]).astype(np.uint8)
-                image = pil2tensor(Image.fromarray(gradient))
-                return image
-            case _:
-                image = pil2tensor(Image.new('RGB', (1, 1), (0, 0, 0)))
-                return image
-
-    def generate_source_image(self, original_image, source):
-        batch_size, image_height, image_width, _ = original_image.shape
-        match source:
-            case 'Use Flipped Background Image':
-                if batch_size < 2:
-                    raise ValueError('Must be at least 2 image to use flipped background image.')
-                original_image = [img.unsqueeze(0) for img in original_image]
-                image = torch.flip(original_image[1], [2])
-                return image
-            case 'Ambient':
-                input_bg = np.zeros(shape=(image_height, image_width, 3), dtype=np.uint8) + 64
-                return np2tensor(input_bg)
-            case 'Left Light':
-                gradient = np.linspace(224, 32, image_width)
-                image = np.tile(gradient, (image_height, 1))
-                input_bg = np.stack((image,) * 3, axis=-1).astype(np.uint8)
-                return np2tensor(input_bg)
-            case 'Right Light':
-                gradient = np.linspace(32, 224, image_width)
-                image = np.tile(gradient, (image_height, 1))
-                input_bg = np.stack((image,) * 3, axis=-1).astype(np.uint8)
-                return np2tensor(input_bg)
-            case 'Top Light':
-                gradient = np.linspace(224, 32, image_height)[:, None]
-                image = np.tile(gradient, (1, image_width))
-                input_bg = np.stack((image,) * 3, axis=-1).astype(np.uint8)
-                return np2tensor(input_bg)
-            case 'Bottom Light':
-                gradient = np.linspace(32, 224, image_height)[:, None]
-                image = np.tile(gradient, (1, image_width))
-                input_bg = np.stack((image,) * 3, axis=-1).astype(np.uint8)
-                return np2tensor(input_bg)
-            case _:
-                image = pil2tensor(Image.new('RGB', (1, 1), (0, 0, 0)))
-                return image
-
-
-    def apply(self, ic_model_path, model: ModelPatcher, c_concat: dict, ic_model=None) -> Tuple[ModelPatcher]:
-        try:
-            ModelPatcher.calculate_weight = calculate_weight_adjust_channel(ModelPatcher.calculate_weight)
-        except:
-            pass
-
-        device = comfy.model_management.get_torch_device()
-        dtype = comfy.model_management.unet_dtype()
-        work_model = model.clone()
-
-        # Apply scale factor.
-        base_model: BaseModel = work_model.model
-        scale_factor = base_model.model_config.latent_format.scale_factor
-
-        # [B, 4, H, W]
-        concat_conds: torch.Tensor = c_concat["samples"] * scale_factor
-        # [1, 4 * B, H, W]
-        concat_conds = torch.cat([c[None, ...] for c in concat_conds], dim=1)
-
-        def unet_dummy_apply(unet_apply: Callable, params: UnetParams):
-            """A dummy unet apply wrapper serving as the endpoint of wrapper
-            chain."""
-            return unet_apply(x=params["input"], t=params["timestep"], **params["c"])
-
-        existing_wrapper = work_model.model_options.get(
-            "model_function_wrapper", unet_dummy_apply
-        )
-
-        def wrapper_func(unet_apply: Callable, params: UnetParams):
-            return existing_wrapper(unet_apply, params=self.apply_c_concat(params, concat_conds))
-
-        work_model.set_model_unet_function_wrapper(wrapper_func)
-        if not ic_model:
-            ic_model = load_unet(ic_model_path)
-        ic_model_state_dict = ic_model.model.diffusion_model.state_dict()
-
-        work_model.add_patches(
-            patches={
-                ("diffusion_model." + key): (value.to(dtype=dtype, device=device),)
-                for key, value in ic_model_state_dict.items()
-            }
-        )
-
-        return (work_model, ic_model)

py/libs/adv_encode.py

@@ -1,10 +1,16 @@
 import torch
 import numpy as np
+import re
 import itertools
 
 from comfy import model_management
 from comfy.sdxl_clip import SDXLClipModel, SDXLRefinerClipModel, SDXLClipG
-from nodes import NODE_CLASS_MAPPINGS, ConditioningConcat
+try:
+    from comfy.text_encoders.sd3_clip import SD3ClipModel, T5XXLModel
+except ImportError:
+    from comfy.sd3_clip import SD3ClipModel, T5XXLModel
+
+from nodes import NODE_CLASS_MAPPINGS, ConditioningConcat, ConditioningZeroOut, ConditioningSetTimestepRange, ConditioningCombine
 
 def _grouper(n, iterable):
     it = iter(iterable)
@@ -238,6 +244,9 @@ def encode_token_weights_l(model, token_weight_pairs):
     l_out, pooled = model.clip_l.encode_token_weights(token_weight_pairs)
     return l_out, pooled
 
+def encode_token_weights_t5(model, token_weight_pairs):
+    return model.t5xxl.encode_token_weights(token_weight_pairs)
+
 
 def encode_token_weights(model, token_weight_pairs, encode_func):
     if model.layer_idx is not None:
@@ -258,6 +267,14 @@ def prepareXL(embs_l, embs_g, pooled, clip_balance):
     else:
         return embs_g, pooled
 
+def prepareSD3(out, pooled, clip_balance):
+    lg_w = 1 - max(0, clip_balance - .5) * 2
+    t5_w = 1 - max(0, .5 - clip_balance) * 2
+    if out.shape[0] > 1:
+        return torch.cat([out[0] * lg_w, out[1] * t5_w], dim=-1), pooled
+    else:
+        return out, pooled
+
 def advanced_encode(clip, text, token_normalization, weight_interpretation, w_max=1.0, clip_balance=.5,
                     apply_to_pooled=True, width=1024, height=1024, crop_w=0, crop_h=0, target_width=1024, target_height=1024, a1111_prompt_style=False, steps=1):
 
@@ -270,6 +287,25 @@ def advanced_encode(clip, text, token_normalization, weight_interpretation, w_ma
         else:
             raise Exception(f"[smzNodes Not Found] you need to install 'ComfyUI-smzNodes'")
 
+    time_start = 0
+    time_end = 1
+    match = re.search(r'TIMESTEP.*$', text)
+    if match:
+        timestep = match.group()
+        timestep = timestep.split(' ')
+        timestep = timestep[0]
+        text = text.replace(timestep, '')
+        value = timestep.split(':')
+        if len(value) >= 3:
+            time_start = float(value[1])
+            time_end = float(value[2])
+        elif len(value) == 2:
+            time_start = float(value[1])
+            time_end = 1
+        elif len(value) == 1:
+            time_start = 0.1
+            time_end = 1
+
     pass3 = [x.strip() for x in text.split("BREAK")]
     pass3 = [x for x in pass3 if x != '']
 
@@ -283,7 +319,62 @@ def advanced_encode(clip, text, token_normalization, weight_interpretation, w_ma
 
     for text in pass3:
         tokenized = clip.tokenize(text, return_word_ids=True)
-        if isinstance(clip.cond_stage_model, (SDXLClipModel, SDXLRefinerClipModel, SDXLClipG)):
+        if SD3ClipModel and isinstance(clip.cond_stage_model, SD3ClipModel):
+            lg_out = None
+            pooled = None
+            out = None
+
+            if len(tokenized['l']) > 0 or len(tokenized['g']) > 0:
+                if clip.cond_stage_model.clip_l is not None:
+                    lg_out, l_pooled = advanced_encode_from_tokens(tokenized['l'],
+                                                                           token_normalization,
+                                                                           weight_interpretation,
+                                                                           lambda x: encode_token_weights(clip, x, encode_token_weights_l),
+                                                                           w_max=w_max, return_pooled=True,)
+                else:
+                    l_pooled = torch.zeros((1, 768), device=model_management.intermediate_device())
+
+                if clip.cond_stage_model.clip_g is not None:
+                    g_out, g_pooled = advanced_encode_from_tokens(tokenized['g'],
+                               token_normalization,
+                               weight_interpretation,
+                               lambda x: encode_token_weights(clip, x, encode_token_weights_g),
+                               w_max=w_max, return_pooled=True)
+                    if lg_out is not None:
+                        lg_out = torch.cat([lg_out, g_out], dim=-1)
+                    else:
+                        lg_out = torch.nn.functional.pad(g_out, (768, 0))
+                else:
+                    g_out = None
+                    g_pooled = torch.zeros((1, 1280), device=model_management.intermediate_device())
+
+                if lg_out is not None:
+                    lg_out = torch.nn.functional.pad(lg_out, (0, 4096 - lg_out.shape[-1]))
+                    out = lg_out
+                pooled = torch.cat((l_pooled, g_pooled), dim=-1)
+
+            # t5xxl
+            if 't5xxl' in tokenized:
+                t5_out, t5_pooled = advanced_encode_from_tokens(tokenized['t5xxl'],
+                               token_normalization,
+                               weight_interpretation,
+                               lambda x: encode_token_weights(clip, x, encode_token_weights_t5),
+                               w_max=w_max, return_pooled=True)
+                if lg_out is not None:
+                    out = torch.cat([lg_out, t5_out], dim=-2)
+                else:
+                    out = t5_out
+
+            if out is None:
+                out = torch.zeros((1, 77, 4096), device=model_management.intermediate_device())
+
+            if pooled is None:
+                pooled = torch.zeros((1, 768 + 1280), device=model_management.intermediate_device())
+
+            embeddings_final, pooled = prepareSD3(out, pooled, clip_balance)
+            cond = [[embeddings_final, {"pooled_output": pooled}]]
+
+        elif isinstance(clip.cond_stage_model, (SDXLClipModel, SDXLRefinerClipModel, SDXLClipG)):
             embs_l = None
             embs_g = None
             pooled = None
@@ -323,6 +414,13 @@ def advanced_encode(clip, text, token_normalization, weight_interpretation, w_ma
         else:
             conditioning = cond
 
+    # setTimeStepRange
+    if time_start > 0 or time_end < 1:
+        conditioning_2, = ConditioningSetTimestepRange().set_range(conditioning, 0, time_start)
+        conditioning_1, = ConditioningZeroOut().zero_out(conditioning)
+        conditioning_1, = ConditioningSetTimestepRange().set_range(conditioning_1, time_start, time_end)
+        conditioning, = ConditioningCombine().combine(conditioning_1, conditioning_2)
+
     return conditioning
 
 

py/libs/api/bizyair.py

@@ -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

py/libs/api/fluxai.py

@@ -0,0 +1,51 @@
+import json
+import os
+import yaml
+import requests
+import pathlib
+from aiohttp import web
+
+root_path = pathlib.Path(__file__).parent.parent.parent.parent
+config_path = os.path.join(root_path,'config.yaml')
+class FluxAIAPI:
+    def __init__(self):
+        self.api_url = "https://fluxaiimagegenerator.com/api"
+        self.origin = "https://fluxaiimagegenerator.com"
+        self.user_agent = None
+        self.cookie = None
+
+    def promptGenerate(self, text, cookies=None):
+        cookie = self.cookie if cookies is None else cookies
+        if cookie is None:
+            if os.path.isfile(config_path):
+                with open(config_path, 'r') as f:
+                    data = yaml.load(f, Loader=yaml.FullLoader)
+                    if 'FLUXAI_COOKIE' not in data:
+                        raise Exception("Please add FLUXAI_COOKIE to config.yaml")
+                    if "FLUXAI_USER_AGENT" in data:
+                        self.user_agent = data["FLUXAI_USER_AGENT"]
+                    self.cookie = cookie = data['FLUXAI_COOKIE']
+
+        headers = {
+            "Cookie": cookie,
+            "Referer": "https://fluxaiimagegenerator.com/flux-prompt-generator",
+            "Origin": self.origin,
+            "Content-Type": "application/json",
+        }
+        if self.user_agent is not None:
+            headers['User-Agent'] = self.user_agent
+
+        url = self.api_url + '/prompt'
+        json = {
+            "prompt": text
+        }
+
+        response = requests.post(url, json=json, headers=headers)
+        res = response.json()
+        if "error" in res:
+            return res['error']
+        elif "data" in res and "prompt" in res['data']:
+            return res['data']['prompt']
+
+fluxaiAPI = FluxAIAPI()
+

py/libs/api/stability.py

@@ -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()

py/libs/chooser.py

@@ -1,52 +1,148 @@
+from threading import Event
 from server import PromptServer
 from aiohttp import web
+from comfy import model_management as mm
 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()
+
+        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)
+                        return {"result": ([images[idx] for idx in valid_indices],)}
+
+        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)
+                    indices_str = ','.join(str(i) for i in valid_indices)
+                    return {"result": (selected_images, indices_str)}
+                else:
+                    cleanup_session_data(id)
+                    return {"result": ([images[0]] if len(images) > 0 else [], "0" if len(images) > 0 else "")}
             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 [],)}
+        else:
+            return {"result": ([images[0]] if len(images) > 0 else [],)}
+
+    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": ([])}
 
 
 @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"})

py/libs/conditioning.py

@@ -4,32 +4,40 @@ from .translate import zh_to_en, has_chinese
 from .wildcards import process_with_loras
 from .adv_encode import advanced_encode
 
-from nodes import ConditioningConcat, ConditioningCombine, ConditioningAverage, ConditioningSetTimestepRange
+from nodes import ConditioningConcat, ConditioningCombine, ConditioningAverage, ConditioningSetTimestepRange, CLIPTextEncode
 
-def prompt_to_cond(type, model, clip, clip_skip, lora_stack, text, prompt_token_normalization, prompt_weight_interpretation, a1111_prompt_style ,my_unique_id, prompt, easyCache, can_load_lora=True, steps=None):
+def prompt_to_cond(type, model, clip, clip_skip, lora_stack, text, prompt_token_normalization, prompt_weight_interpretation, a1111_prompt_style ,my_unique_id, prompt, easyCache, can_load_lora=True, steps=None, model_type=None):
     styles_selector = is_linked_styles_selector(prompt, my_unique_id, type)
-    title = "正面提示词" if type == 'positive' else "负面提示词"
-    log_node_warn("正在进行" + title + "...")
+    title = "Positive encoding" if type == 'positive' else "Negative encoding"
 
     # Translate cn to en
-    if has_chinese(text):
+    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']:
+        log_node_warn(title + "...")
+        embeddings_final, = CLIPTextEncode().encode(clip, text) if text is not None else (None,)
+
+        return (embeddings_final, "", model, clip)
+
+    log_node_warn(title + "...")
+
     positive_seed = find_wildcards_seed(my_unique_id, text, prompt)
     model, clip, text, cond_decode, show_prompt, pipe_lora_stack = process_with_loras(
         text, model, clip, type, positive_seed, can_load_lora, lora_stack, easyCache)
     wildcard_prompt = cond_decode if show_prompt or styles_selector else ""
 
     clipped = clip.clone()
-    if clip_skip != 0:
-        clipped.clip_layer(clip_skip)
+    # 当clip模型不存在t5xxl时，可执行跳过层
+    if not hasattr(clip.cond_stage_model, 't5xxl'):
+        if clip_skip != 0:
+            clipped.clip_layer(clip_skip)
 
-    log_node_warn("正在进行" + title + "编码...")
     steps = steps if steps is not None else find_nearest_steps(my_unique_id, prompt)
     return (advanced_encode(clipped, text, prompt_token_normalization,
                             prompt_weight_interpretation, w_max=1.0,
                             apply_to_pooled='enable',
-                            a1111_prompt_style=a1111_prompt_style, steps=steps), wildcard_prompt, model, clipped)
+                            a1111_prompt_style=a1111_prompt_style, steps=steps) if text is not None else None, wildcard_prompt, model, clipped)
 
 def set_cond(old_cond, new_cond, mode, average_strength, old_cond_start, old_cond_end, new_cond_start, new_cond_end):
     if not old_cond:

py/libs/controlnet.py

@@ -3,16 +3,40 @@ import comfy.controlnet
 import comfy.model_management
 from nodes import NODE_CLASS_MAPPINGS
 
+union_controlnet_types = {"auto": -1, "openpose": 0, "depth": 1, "hed/pidi/scribble/ted": 2, "canny/lineart/anime_lineart/mlsd": 3, "normal": 4, "segment": 5, "tile": 6, "repaint": 7}
+
 class easyControlnet:
     def __init__(self):
         pass
 
-    def apply(self, control_net_name, image, positive, negative, strength, start_percent=0, end_percent=1, control_net=None, scale_soft_weights=1, mask=None, easyCache=None, use_cache=True):
+    def apply(self, control_net_name, image, positive, negative, strength, start_percent=0, end_percent=1, control_net=None, scale_soft_weights=1, mask=None, union_type=None, easyCache=None, use_cache=True, model=None, vae=None):
         if strength == 0:
             return (positive, negative)
 
-        if control_net is None:
-            control_net = easyCache.load_controlnet(control_net_name, scale_soft_weights, use_cache)
+        # kolors controlnet patch
+        from ..modules.kolors.loader import is_kolors_model, applyKolorsUnet
+        if is_kolors_model(model):
+            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)
+                control_net = patch_controlnet(model, control_net)
+        else:
+            if control_net is None:
+                if easyCache is not None:
+                    control_net = easyCache.load_controlnet(control_net_name, scale_soft_weights, use_cache)
+                else:
+                    controlnet_path = folder_paths.get_full_path("controlnet", control_net_name)
+                    control_net = comfy.controlnet.load_controlnet(controlnet_path)
+
+        # union controlnet
+        if union_type is not None:
+            control_net = control_net.copy()
+            type_number = union_controlnet_types[union_type]
+            if type_number >= 0:
+                control_net.set_extra_arg("control_type", [type_number])
+            else:
+                control_net.set_extra_arg("control_type", [])
 
         if mask is not None:
             mask = mask.to(self.device)
@@ -49,7 +73,7 @@ class easyControlnet:
                     if prev_cnet in cnets:
                         c_net = cnets[prev_cnet]
                     else:
-                        c_net = control_net.copy().set_cond_hint(control_hint, strength, (start_percent, end_percent))
+                        c_net = control_net.copy().set_cond_hint(control_hint, strength, (start_percent, end_percent), vae)
                         c_net.set_previous_controlnet(prev_cnet)
                         cnets[prev_cnet] = c_net
 

py/libs/fooocus.py

@@ -1,104 +0,0 @@
-import torch
-import comfy
-from comfy.model_patcher import ModelPatcher
-from comfy.model_management import cast_to_device
-
-from .log import log_node_warn, log_node_error, log_node_info
-
-# Inpaint
-class InpaintHead(torch.nn.Module):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.head = torch.nn.Parameter(torch.empty(size=(320, 5, 3, 3), device='cpu'))
-
-    def __call__(self, x):
-        x = torch.nn.functional.pad(x, (1, 1, 1, 1), "replicate")
-        return torch.nn.functional.conv2d(input=x, weight=self.head)
-
-class InpaintWorker:
-    def __init__(self, node_name):
-        self.node_name = node_name if node_name is not None else ""
-        self.original_calculate_weight = ModelPatcher.calculate_weight
-        if not hasattr(ModelPatcher, "original_calculate_weight"):
-            ModelPatcher.original_calculate_weight = self.original_calculate_weight
-        self.injected_model_patcher_calculate_weight = False
-
-    def load_fooocus_patch(self, lora: dict, to_load: dict):
-        patch_dict = {}
-        loaded_keys = set()
-        for key in to_load.values():
-            if value := lora.get(key, None):
-                patch_dict[key] = ("fooocus", value)
-                loaded_keys.add(key)
-
-        not_loaded = sum(1 for x in lora if x not in loaded_keys)
-        log_node_info(self.node_name,
-            f"{len(loaded_keys)} Lora keys loaded, {not_loaded} remaining keys not found in model."
-        )
-        return patch_dict
-
-    def calculate_weight_patched(self: ModelPatcher, patches, weight, key):
-        remaining = []
-
-        for p in patches:
-            alpha, v, strength_model = p
-
-            is_fooocus_patch = isinstance(v, tuple) and len(v) == 2 and v[0] == "fooocus"
-            if not is_fooocus_patch:
-                remaining.append(p)
-                continue
-
-            if alpha != 0.0:
-                v = v[1]
-                w1 = cast_to_device(v[0], weight.device, torch.float32)
-                if w1.shape == weight.shape:
-                    w_min = cast_to_device(v[1], weight.device, torch.float32)
-                    w_max = cast_to_device(v[2], weight.device, torch.float32)
-                    w1 = (w1 / 255.0) * (w_max - w_min) + w_min
-                    weight += alpha * cast_to_device(w1, weight.device, weight.dtype)
-                else:
-                    pass
-                    # log_node_warn(self.node_name,
-                    #     f"Shape mismatch {key}, weight not merged ({w1.shape} != {weight.shape})"
-                    # )
-
-        if len(remaining) > 0:
-            return self.original_calculate_weight(self, remaining, weight, key)
-        return weight
-
-    def inject_patched_calculate_weight(self):
-        if not self.injected_model_patcher_calculate_weight:
-            log_node_info(self.node_name,"Injecting patched comfy.model_patcher.ModelPatcher.calculate_weight")
-            ModelPatcher.calculate_weight = self.calculate_weight_patched
-            self.injected_model_patcher_calculate_weight = True
-
-    def patch(self, model, latent, patch):
-        base_model = model.model
-        latent_pixels = base_model.process_latent_in(latent["samples"])
-        noise_mask = latent["noise_mask"].round()
-        latent_mask = torch.nn.functional.max_pool2d(noise_mask, (8, 8)).round().to(latent_pixels)
-
-        inpaint_head_model, inpaint_lora = patch
-        feed = torch.cat([latent_mask, latent_pixels], dim=1)
-        inpaint_head_model.to(device=feed.device, dtype=feed.dtype)
-        inpaint_head_feature = inpaint_head_model(feed)
-
-        def input_block_patch(h, transformer_options):
-            if transformer_options["block"][1] == 0:
-                h = h + inpaint_head_feature.to(h)
-            return h
-
-        lora_keys = comfy.lora.model_lora_keys_unet(model.model, {})
-        lora_keys.update({x: x for x in base_model.state_dict().keys()})
-        loaded_lora = self.load_fooocus_patch(inpaint_lora, lora_keys)
-
-        m = model.clone()
-        m.set_model_input_block_patch(input_block_patch)
-        patched = m.add_patches(loaded_lora, 1.0)
-
-        not_patched_count = sum(1 for x in loaded_lora if x not in patched)
-        if not_patched_count > 0:
-            log_node_error(self.node_name, f"Failed to patch {not_patched_count} keys")
-
-        self.inject_patched_calculate_weight()
-        return (m,)

py/libs/image.py

@@ -105,6 +105,11 @@ class blendImage:
     return blended_image
 
 
+def empty_image(width, height, batch_size=1, color=0):
+    r = torch.full([batch_size, height, width, 1], ((color >> 16) & 0xFF) / 0xFF)
+    g = torch.full([batch_size, height, width, 1], ((color >> 8) & 0xFF) / 0xFF)
+    b = torch.full([batch_size, height, width, 1], ((color) & 0xFF) / 0xFF)
+    return torch.cat((r, g, b), dim=-1)
 
 
 class ResizeMode(Enum):
@@ -120,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

py/libs/loader.py

@@ -1,4 +1,4 @@
-import time, os, psutil
+import re, time, os, psutil
 import folder_paths
 import comfy.utils
 import comfy.sd
@@ -8,14 +8,16 @@ 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 ..modules.dit.pixArt.loader import load_pixart
 
-stable_diffusion_loaders = ["easy fullLoader", "easy a1111Loader", "easy comfyLoader", "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"]
-controlnet_loaders = ["easy controlnetLoader", "easy controlnetLoaderADV"]
+dit_loaders = ['easy pixArtLoader']
+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):
@@ -28,8 +30,10 @@ class easyLoader:
             "vae": defaultdict(object),
             "lora": defaultdict(dict),  # {lora_name: {UID: (model_lora, clip_lora)}}
             "controlnet": defaultdict(dict),
+            "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):
@@ -86,6 +90,8 @@ class easyLoader:
         desired_lora_names = set()
         desired_lora_settings = set()
         desired_controlnet_names = set()
+        desired_t5_names = set()
+        desired_glm3_names = set()
 
         for entry in prompt.values():
             class_type = entry["class_type"]
@@ -95,10 +101,26 @@ 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"))
 
+            elif class_type in ['easy kolorsLoader']:
+                desired_unet_names.add(self.get_input_value(entry, "unet_name"))
+                desired_vae_names.add(self.get_input_value(entry, "vae_name"))
+                desired_glm3_names.add(self.get_input_value(entry, "chatglm3_name"))
+
+            elif class_type in dit_loaders:
+                t5_name = self.get_input_value(entry, "mt5_name") if "mt5_name" in entry["inputs"] else  None
+                clip_name = self.get_input_value(entry, "clip_name") if "clip_name" in entry["inputs"] else None
+                model_name = self.get_input_value(entry, "model_name")
+                ckpt_name = self.get_input_value(entry, "ckpt_name", prompt)
+                if t5_name:
+                    desired_t5_names.add(t5_name)
+                if clip_name:
+                    desired_clip_names.add(clip_name)
+                desired_ckpt_names.add(ckpt_name+'_'+model_name)
+
             elif class_type in stable_cascade_loaders:
                 desired_unet_names.add(self.get_input_value(entry, "stage_c"))
                 desired_unet_names.add(self.get_input_value(entry, "stage_b"))
@@ -130,7 +152,7 @@ class easyLoader:
                 if vae_use != 'Use Model 1' and vae_use != 'Use Model 2':
                     desired_vae_names.add(vae_use)
 
-        object_types = ["ckpt", "unet", "clip", "bvae", "vae", "lora", "controlnet"]
+        object_types = ["ckpt", "unet", "clip", "bvae", "vae", "lora", "controlnet", "t5"]
         for object_type in object_types:
             if object_type == 'unet':
                 desired_names = desired_unet_names
@@ -143,6 +165,10 @@ class easyLoader:
                 desired_names = desired_vae_names
             elif object_type == "controlnet":
                 desired_names = desired_controlnet_names
+            elif object_type == "t5":
+                desired_names = desired_t5_names
+            elif object_type == "chatglm3":
+                desired_names = desired_glm3_names
             else:
                 desired_names = desired_lora_names
             self.clear_unused_objects(desired_names, object_type)
@@ -181,7 +207,7 @@ class easyLoader:
         current_memory = self.get_memory_usage()
         if current_memory < self.memory_threshold:
             return
-        eviction_order = ["vae", "lora", "bvae", "clip", "ckpt", "controlnet"]
+        eviction_order = ["vae", "lora", "bvae", "clip", "ckpt", "controlnet", "unet", "t5", "chatglm3"]
         for obj_type in eviction_order:
             if current_memory < self.memory_threshold:
                 break
@@ -212,7 +238,11 @@ class easyLoader:
             config_path = folder_paths.get_full_path("configs", config_name)
             loaded_ckpt = comfy.sd.load_checkpoint(config_path, ckpt_path, output_vae=True, output_clip=output_clip, embedding_directory=folder_paths.get_folder_paths("embeddings"))
         else:
-            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 = {}
+            if re.search("nf4", ckpt_name):
+                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)
 
         self.add_to_cache("ckpt", cache_name, loaded_ckpt[0])
         self.add_to_cache("bvae", cache_name, loaded_ckpt[2])
@@ -242,6 +272,7 @@ class easyLoader:
 
     def load_unet(self, unet_name):
         if unet_name in self.loaded_objects["unet"]:
+            log_node_info("Load UNet", f"{unet_name} cached")
             return self.loaded_objects["unet"][unet_name][0]
 
         unet_path = folder_paths.get_full_path("unet", unet_name)
@@ -262,20 +293,29 @@ class easyLoader:
                 cn_adv_cls = NODE_CLASS_MAPPINGS['ControlNetLoaderAdvanced']
                 control_net, = cn_adv_cls().load_controlnet(control_net_name, timestep_keyframe)
             else:
-                raise Exception(
-                    f"[Advanced-ControlNet Not Found] you need to install 'COMFYUI-Advanced-ControlNet'")
+                raise Exception(f"[Advanced-ControlNet Not Found] you need to install 'COMFYUI-Advanced-ControlNet'")
         else:
             controlnet_path = folder_paths.get_full_path("controlnet", control_net_name)
             control_net = comfy.controlnet.load_controlnet(controlnet_path)
         if use_cache:
             self.add_to_cache("controlnet", unique_id, control_net)
             self.eviction_based_on_memory()
+
         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]
+
         if type == 'stable_diffusion':
             clip_type = comfy.sd.CLIPType.STABLE_DIFFUSION
-        else:
+        elif type == 'stable_cascade':
             clip_type = comfy.sd.CLIPType.STABLE_CASCADE
+        elif type == 'sd3':
+            clip_type = comfy.sd.CLIPType.SD3
+        elif type == 'flux':
+            clip_type = comfy.sd.CLIPType.FLUX
+        elif type == 'stable_audio':
+            clip_type = comfy.sd.CLIPType.STABLE_AUDIO
         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)
@@ -283,7 +323,7 @@ class easyLoader:
 
         return load_clip
 
-    def load_lora(self, lora, model=None, clip=None):
+    def load_lora(self, lora, model=None, clip=None, type=None , use_cache=True):
         lora_name = lora["lora_name"]
         model = model if model is not None else lora["model"]
         clip = clip if clip is not None else lora["clip"]
@@ -294,11 +334,12 @@ class easyLoader:
         lbw_b = lora["lbw_b"] if "lbw_b" in lora else None
 
         model_hash = str(model)[44:-1]
-        clip_hash = str(clip)[25:-1]
+        clip_hash = str(clip)[25:-1] if clip else ''
 
         unique_id = f'{model_hash};{clip_hash};{lora_name};{model_strength};{clip_strength}'
 
-        if unique_id in self.loaded_objects["lora"] and unique_id in self.loaded_objects["lora"][lora_name]:
+        if use_cache and unique_id in self.loaded_objects["lora"]:
+            log_node_info("Load LORA",f"{lora_name} cached")
             return self.loaded_objects["lora"][unique_id][0]
 
         orig_lora_name = lora_name
@@ -310,7 +351,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"]
@@ -348,10 +389,16 @@ class easyLoader:
                     model.model.load_state_dict(mapping_norm, strict=False)
                     return (model, clip)
 
-                model, clip = comfy.sd.load_lora_for_models(model, clip, _lora, model_strength, clip_strength)
+                # PixArt
+                if type is not None and type == 'PixArt':
+                    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)
 
-            self.add_to_cache("lora", unique_id, (model, clip))
-            self.eviction_based_on_memory()
+            if use_cache:
+                self.add_to_cache("lora", unique_id, (model, clip))
+                self.eviction_based_on_memory()
         else:
             log_node_error(f"LORA NOT FOUND", orig_lora_name)
 
@@ -378,17 +425,20 @@ class easyLoader:
 
             return None
 
-    def load_main(self, ckpt_name, config_name, vae_name, lora_name, lora_model_strength, lora_clip_strength, optional_lora_stack, model_override, clip_override, vae_override, prompt):
+    def load_main(self, ckpt_name, config_name, vae_name, lora_name, lora_model_strength, lora_clip_strength, optional_lora_stack, model_override, clip_override, vae_override, prompt, nf4=False):
         model: ModelPatcher | None = None
         clip: comfy.sd.CLIP | None = None
         vae: comfy.sd.VAE | None = None
         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
@@ -398,22 +448,23 @@ class easyLoader:
                 ckpt_name_1 = node["inputs"]["ckpt_name_1"]
                 model, clip, vae, clip_vision = self.load_checkpoint(ckpt_name_1)
                 can_load_lora = False
-        # Load models
         elif model_override is not None and clip_override is not None and vae_override is not None:
             model = model_override
             clip = clip_override
             vae = vae_override
-        elif model_override is not None:
-            raise Exception(f"[ERROR] clip or vae is missing")
-        elif vae_override is not None:
-            raise Exception(f"[ERROR] model or clip is missing")
-        elif clip_override is not None:
-            raise Exception(f"[ERROR] model or vae is missing")
         else:
             model, clip, vae, clip_vision = self.load_checkpoint(ckpt_name, config_name)
+            if model_override is not None:
+                model = model_override
+            if vae_override is not None:
+                vae = vae_override
+            elif clip_override is not None:
+                clip = clip_override
+
 
         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)
@@ -434,4 +485,86 @@ class easyLoader:
         if not clip:
             raise Exception("No CLIP found")
 
-        return model, clip, vae, clip_vision, lora_stack
+        return model, clip, vae, clip_vision, lora_stack
+
+    # Kolors
+    def load_kolors_unet(self, unet_name):
+        if unet_name in self.loaded_objects["unet"]:
+            log_node_info("Load Kolors UNet", f"{unet_name} cached")
+            return self.loaded_objects["unet"][unet_name][0]
+        else:
+            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)
+                model = comfy.sd.load_unet_state_dict(sd)
+                if model is None:
+                    raise RuntimeError("ERROR: Could not detect model type of: {}".format(unet_path))
+
+                self.add_to_cache("unet", unet_name, model)
+                self.eviction_based_on_memory()
+
+                return model
+
+    def load_chatglm3(self, chatglm3_name):
+        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]
+
+        chatglm_model = load_chatglm3(model_path=folder_paths.get_full_path("llm", chatglm3_name))
+        self.add_to_cache("chatglm3", chatglm3_name, chatglm_model)
+        self.eviction_based_on_memory()
+
+        return chatglm_model
+
+
+    # DiT
+    def load_dit_ckpt(self, ckpt_name, model_name, **kwargs):
+        if (ckpt_name+'_'+model_name) in self.loaded_objects["ckpt"]:
+            return self.loaded_objects["ckpt"][ckpt_name+'_'+model_name][0]
+        model = None
+        ckpt_path = folder_paths.get_full_path("checkpoints", ckpt_name)
+        model_type = kwargs['model_type'] if "model_type" in kwargs else 'PixArt'
+        if model_type == 'PixArt':
+            pixart_conf = kwargs['pixart_conf']
+            model_conf = pixart_conf[model_name]
+            model = load_pixart(ckpt_path, model_conf)
+        if model:
+            self.add_to_cache("ckpt", ckpt_name + '_' + model_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
+        except:
+            from comfy.sd3_clip import SD3Tokenizer, SD3ClipModel
+        import copy
+
+        clip = sd3_clip.clone()
+        assert clip.cond_stage_model.t5xxl is not None, "CLIP must have T5 loaded!"
+
+        # remove transformer
+        transformer = clip.cond_stage_model.t5xxl.transformer
+        clip.cond_stage_model.t5xxl.transformer = None
+
+        # clone object
+        tmp = SD3ClipModel(clip_l=False, clip_g=False, t5=False)
+        tmp.t5xxl = copy.deepcopy(clip.cond_stage_model.t5xxl)
+        # put transformer back
+        clip.cond_stage_model.t5xxl.transformer = transformer
+        tmp.t5xxl.transformer = transformer
+
+        # override special tokens
+        tmp.t5xxl.special_tokens = copy.deepcopy(clip.cond_stage_model.t5xxl.special_tokens)
+        tmp.t5xxl.special_tokens.pop("end")  # make sure empty tokens match
+
+        # tokenizer
+        tok = SD3Tokenizer()
+        tok.t5xxl.min_length = padding
+
+        clip.cond_stage_model = tmp
+        clip.tokenizer = tok
+
+        return clip

py/libs/messages.py

@@ -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({})

py/libs/translate.py

@@ -1,3 +1,5 @@
+#credit to shadowcz007 for this module
+#from https://github.com/shadowcz007/comfyui-mixlab-nodes/blob/main/nodes/TextGenerateNode.py
 import re
 import os
 import folder_paths
@@ -10,8 +12,8 @@ from .utils import install_package
 try:
     from lark import Lark, Transformer, v_args
 except:
-    print('install lark-parser...')
-    install_package('lark-parser')
+    print('install lark...')
+    install_package('lark')
     from lark import Lark, Transformer, v_args
 
 model_path = os.path.join(folder_paths.models_dir, 'prompt_generator')
@@ -22,7 +24,7 @@ def correct_prompt_syntax(prompt=""):
     # print("input prompt",prompt)
     corrected_elements = []
     # 处理成统一的英文标点
-    prompt = prompt.replace('（', '(').replace('）', ')').replace('，', ',').replace(';', ',').replace('。', '.').replace('：',':')
+    prompt = prompt.replace('（', '(').replace('）', ')').replace('，', ',').replace(';', ',').replace('。', '.').replace('：',':').replace('\\',',')
     # 删除多余的空格
     prompt = re.sub(r'\s+', ' ', prompt).strip()
     prompt = prompt.replace("< ","<").replace(" >",">").replace("( ","(").replace(" )",")").replace("[ ","[").replace(' ]',']')
@@ -78,7 +80,7 @@ def has_chinese(text):
     _text = text
     _text = re.sub(r'<.*?>', '', _text)
     _text = re.sub(r'__.*?__', '', _text)
-    _text = re.sub(r'embedding:.*?(\d+)?', '', _text)
+    _text = re.sub(r'embedding:.*?$', '', _text)
     for char in _text:
         if '\u4e00' <= char <= '\u9fff':
             has_cn = True
@@ -125,8 +127,6 @@ class ChinesePromptTranslate(Transformer):
     def embedding(self, *args):
         print('prompt embedding', args[0])
         if len(args) == 1:
-            # print('prompt embedding',str(args[0]))
-            # 只传递了一个参数，意味着只有embedding名称没有数字
             embedding_name = str(args[0])
             return f"embedding:{embedding_name}"
         elif len(args) > 1:
@@ -165,18 +165,27 @@ class ChinesePromptTranslate(Transformer):
 
     def word(self, word):
         # Translate each word using the dictionary
-        if re.search(r'__.*?__', str(word)):
-            return str(word).rstrip('.')
-        elif re.search(r'@.*?@', str(word)):
-            return str(word).replace('@', '').rstrip('.')
-        elif detect_language(str(word)) == "cn":
-            return translate(str(word)).rstrip('.')
+        word = str(word)
+        match_cn = re.search(r'@.*?@', word)
+        if re.search(r'__.*?__', word):
+            return word.rstrip('.')
+        elif match_cn:
+            chinese = match_cn.group()
+            before = word.split('@', 1)
+            before = before[0] if len(before) > 0 else ''
+            before = translate(str(before)).rstrip('.') if before else ''
+            after = word.rsplit('@', 1)
+            after = after[len(after)-1] if len(after) > 1 else ''
+            after = translate(after).rstrip('.') if after else ''
+            return before + chinese.replace('@', '').rstrip('.') + after
+        elif detect_language(word) == "cn":
+            return translate(word).rstrip('.')
         else:
-            return str(word).rstrip('.')
+            return word.rstrip('.')
 
 
 #定义Prompt文法
-grammar = """
+grammar = r"""
 start: sentence
 sentence: phrase ("," phrase)*
 phrase: emphasis | weight | word | lora | embedding | schedule 

py/libs/utils.py

@@ -5,6 +5,19 @@ class AlwaysEqualProxy(str):
     def __ne__(self, _):
         return False
 
+class TautologyStr(str):
+    def __ne__(self, other):
+        return False
+
+class ByPassTypeTuple(tuple):
+    def __getitem__(self, index):
+        if index>0:
+            index=0
+        item = super().__getitem__(index)
+        if isinstance(item, str):
+            return TautologyStr(item)
+        return item
+
 comfy_ui_revision = None
 def get_comfyui_revision():
     try:
@@ -69,6 +82,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
@@ -92,6 +106,8 @@ def get_sd_version(model):
     model_config: comfy.supported_models.supported_models_base.BASE = base.model_config
     if isinstance(model_config, comfy.supported_models.SDXL):
         return 'sdxl'
+    elif isinstance(model_config, comfy.supported_models.SDXLRefiner):
+        return 'sdxl_refiner'
     elif isinstance(
             model_config, (comfy.supported_models.SD15, comfy.supported_models.SD20)
     ):
@@ -100,6 +116,14 @@ def get_sd_version(model):
             model_config, (comfy.supported_models.SVD_img2vid)
     ):
         return 'svd'
+    elif isinstance(model_config, comfy.supported_models.SD3):
+        return 'sd3'
+    elif isinstance(model_config, comfy.supported_models.HunyuanDiT):
+        return 'hydit'
+    elif isinstance(model_config, comfy.supported_models.Flux):
+        return 'flux'
+    elif isinstance(model_config, comfy.supported_models.GenmoMochi):
+        return 'mochi'
     else:
         return 'unknown'
 
@@ -161,8 +185,9 @@ def find_wildcards_seed(clip_id, text, prompt):
     else:
         return None
 
-def is_linked_styles_selector(prompt, my_unique_id, prompt_type='positive'):
-    inputs_values = prompt[my_unique_id]['inputs'][prompt_type] if prompt_type in prompt[my_unique_id][
+def is_linked_styles_selector(prompt, unique_id, prompt_type='positive'):
+    unique_id = unique_id.split('.')[len(unique_id.split('.')) - 1] if "." in unique_id else unique_id
+    inputs_values = prompt[unique_id]['inputs'][prompt_type] if prompt_type in prompt[unique_id][
         'inputs'] else None
     if type(inputs_values) == list and inputs_values != 'undefined' and inputs_values[0]:
         return True if prompt[inputs_values[0]] and prompt[inputs_values[0]]['class_type'] == 'easy stylesSelector' else False
@@ -193,14 +218,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:
@@ -225,9 +251,9 @@ def to_lora_patch_dict(state_dict: dict) -> dict:
 def easySave(images, filename_prefix, output_type, prompt=None, extra_pnginfo=None):
     """Save or Preview Image"""
     from nodes import PreviewImage, SaveImage
-    if output_type == "Hide":
+    if output_type in ["Hide", "None"]:
         return list()
-    if output_type in ["Preview", "Preview&Choose"]:
+    elif output_type in ["Preview", "Preview&Choose"]:
         filename_prefix = 'easyPreview'
         results = PreviewImage().save_images(images, filename_prefix, prompt, extra_pnginfo)
         return results['ui']['images']
@@ -253,4 +279,4 @@ def getMetadata(filepath):
 def cleanGPUUsedForce():
     gc.collect()
     mm.unload_all_models()
-    mm.soft_empty_cache()
+    mm.soft_empty_cache()

py/libs/wildcards.py

@@ -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,11 +38,11 @@ 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'):
@@ -168,7 +172,7 @@ def process(text, seed=None):
                 replacements_found = True
                 string = string.replace(f"__{match}__", replacement, 1)
             elif '*' in keyword:
-                subpattern = keyword.replace('*', '.*').replace('+','\+')
+                subpattern = keyword.replace('*', '.*').replace('+', r'\+')
                 total_patterns = []
                 found = False
                 for k, v in easy_wildcard_dict.items():
@@ -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:]
+

py/libs/xyplot.py

@@ -1,12 +1,18 @@
 import os, torch
 from pathlib import Path
 from PIL import Image, ImageDraw, ImageFont
-from .utils import easySave
+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.func 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:
+    FluxGuidance = None
 
 class easyXYPlot():
 
@@ -15,6 +21,7 @@ class easyXYPlot():
         self.y_node_type, self.y_type = sampler.safe_split(xyPlotData.get("y_axis"), ': ')
         self.x_values = xyPlotData.get("x_vals") if self.x_type != "None" else []
         self.y_values = xyPlotData.get("y_vals") if self.y_type != "None" else []
+        self.custom_font = xyPlotData.get("custom_font")
 
         self.grid_spacing = xyPlotData.get("grid_spacing")
         self.latent_id = 0
@@ -46,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}"
 
@@ -54,7 +61,12 @@ class easyXYPlot():
             value_label = f"ControlNet {index + 1}"
 
         if value_type in ['Lora', 'Checkpoint']:
-            value_label = f"{os.path.basename(os.path.splitext(value.split(',')[0])[0])}"
+            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 ''
+            lora_weight = float(arr[1]) if value_type == 'Lora' and len(arr) > 1 else 0
+            lora_weight_desc = f"({lora_weight:.2f})" if lora_weight > 0 else ''
+            value_label = f"{model_name[:30]}{lora_weight_desc} {trigger_words}"
 
         if value_type in ["ModelMergeBlocks"]:
             if ":" in value:
@@ -87,8 +99,10 @@ class easyXYPlot():
         return plot_image_vars, value_label
 
     @staticmethod
-    def get_font(font_size):
-        return ImageFont.truetype(str(Path(os.path.join(RESOURCES_DIR, 'OpenSans-Medium.ttf'))), font_size)
+    def get_font(font_size, font_path=None):
+        if font_path is None:
+            font_path = str(Path(os.path.join(RESOURCES_DIR, 'OpenSans-Medium.ttf')))
+        return ImageFont.truetype(font_path, font_size)
 
     @staticmethod
     def update_label(label, value, num_items):
@@ -107,24 +121,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)
+        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
@@ -133,20 +155,27 @@ 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)
 
-        font = self.get_font(font_size)
+        font = self.get_font(font_size, self.custom_font)
 
         # Check if text will fit, if not insert ellipsis and reduce text
         if self.textsize(d, text, font=font)[0] > label_width:
@@ -155,7 +184,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)
@@ -184,9 +213,9 @@ 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'])          
         # 高级用法
         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":
                 seed = int(x_value) if self.x_type == "Seeds++ Batch" else int(y_value)
             if self.x_type == "Steps" or self.y_type == "Steps":
@@ -288,28 +317,12 @@ class easyXYPlot():
                 if plot_image_vars['clip_skip'] != 0:
                     clip.clip_layer(plot_image_vars['clip_skip'])
 
-            # Lora
-            if self.x_type == "Lora" or self.y_type == "Lora":
-                model = model if model is not None else plot_image_vars["model"]
-                clip = clip if clip is not None else plot_image_vars["clip"]
-
-                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:
-                        model, clip = self.easyCache.load_lora(lora)
-
             # CheckPoint
             if self.x_type == "Checkpoint" or self.y_type == "Checkpoint":
                 xy_values = x_value if self.x_type == "Checkpoint" else y_value
                 ckpt_name, clip_skip, vae_name = xy_values.split(",")
                 ckpt_name = ckpt_name.replace('*', ',')
                 vae_name = vae_name.replace('*', ',')
-                print(ckpt_name)
                 model, clip, vae, clip_vision = self.easyCache.load_checkpoint(ckpt_name)
                 if vae_name != 'None':
                     vae = self.easyCache.load_vae(vae_name)
@@ -349,16 +362,41 @@ class easyXYPlot():
                     if "negative_cond" in plot_image_vars:
                         negative = negative + plot_image_vars["negative_cond"]
 
+            # 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"]
+                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)}]
+                
+#                print(f"new_lora_stack: {new_lora_stack}")
+
+                
+                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)
+
             # 提示词
             if "Positive" in self.x_type or "Positive" in self.y_type:
                 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
 
-                positive = advanced_encode(clip, positive,
-                                            plot_image_vars['positive_token_normalization'],
-                                            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':
+                    positive, = CLIPTextEncode().encode(clip, positive)
+                else:
+                    positive = advanced_encode(clip, positive,
+                                                plot_image_vars['positive_token_normalization'],
+                                                plot_image_vars['positive_weight_interpretation'],
+                                                w_max=1.0,
+                                                apply_to_pooled="enable", a1111_prompt_style=a1111_prompt_style, steps=steps)
 
                 # if "positive_cond" in plot_image_vars:
                 #     positive = positive + plot_image_vars["positive_cond"]
@@ -367,11 +405,14 @@ 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
 
-                negative = advanced_encode(clip, negative,
-                                            plot_image_vars['negative_token_normalization'],
-                                            plot_image_vars['negative_weight_interpretation'],
-                                            w_max=1.0,
-                                            apply_to_pooled="enable", a1111_prompt_style=a1111_prompt_style, steps=steps)
+                if sd_version == 'flux':
+                    negative, = CLIPTextEncode().encode(clip, negative)
+                else:
+                    negative = advanced_encode(clip, negative,
+                                                plot_image_vars['negative_token_normalization'],
+                                                plot_image_vars['negative_weight_interpretation'],
+                                                w_max=1.0,
+                                                apply_to_pooled="enable", a1111_prompt_style=a1111_prompt_style, steps=steps)
                 # if "negative_cond" in plot_image_vars:
                 #     negative = negative + plot_image_vars["negative_cond"]
 
@@ -390,18 +431,40 @@ class easyXYPlot():
                         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)
+            # 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
+                flux_guidance = float(x_value) if self.x_type == "Flux Guidance" else float(y_value)
+                positive, = FluxGuidance().append(positive, flux_guidance)
 
         # 简单用法
         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['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:
@@ -409,15 +472,22 @@ class easyXYPlot():
             clip = clip.clone()
             clip.clip_layer(plot_image_vars['clip_skip'])
 
-            positive = advanced_encode(clip, plot_image_vars['positive'],
-                                                        plot_image_vars['positive_token_normalization'],
-                                                        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':
+                positive, = CLIPTextEncode().encode(clip, positive)
+            else:
+                positive = advanced_encode(clip, plot_image_vars['positive'],
+                                                            plot_image_vars['positive_token_normalization'],
+                                                            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':
+                negative, = CLIPTextEncode().encode(clip, negative)
+            else:
+                negative = advanced_encode(clip, plot_image_vars['negative'],
+                                                            plot_image_vars['negative_token_normalization'],
+                                                            plot_image_vars['negative_weight_interpretation'], w_max=1.0,
+                                                            apply_to_pooled="enable", a1111_prompt_style=a1111_prompt_style, steps=steps)
 
-            negative = advanced_encode(clip, plot_image_vars['negative'],
-                                                        plot_image_vars['negative_token_normalization'],
-                                                        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"]
@@ -431,6 +501,8 @@ class easyXYPlot():
         scheduler = scheduler if scheduler is not None else plot_image_vars["scheduler"]
         denoise = denoise if denoise is not None else plot_image_vars["denoise"]
 
+        noise_device = plot_image_vars["noise_device"] if "noise_device" in plot_image_vars else 'cpu'
+
         # LayerDiffuse
         layer_diffusion_method = plot_image_vars["layer_diffusion_method"] if "layer_diffusion_method" in plot_image_vars else None
         empty_samples = plot_image_vars["empty_samples"] if "empty_samples" in plot_image_vars else None
@@ -447,11 +519,10 @@ class easyXYPlot():
 
         samples = empty_samples if layer_diffusion_method is not None and empty_samples is not None else samples
         # Sample
-
         samples = self.sampler.common_ksampler(model, seed, steps, cfg, sampler_name, scheduler, positive, negative, samples,
                                           denoise=denoise, disable_noise=disable_noise, preview_latent=preview_latent,
                                           start_step=start_step, last_step=last_step,
-                                          force_full_denoise=force_full_denoise)
+                                          force_full_denoise=force_full_denoise, noise_device=noise_device)
 
         # Decode images and store
         latent = samples["samples"]
@@ -536,11 +607,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 = []
@@ -572,4 +642,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

py/logic.py

@@ -1,619 +0,0 @@
-from typing import Iterator, List, Tuple, Dict, Any, Union, Optional
-from _decimal import Context, getcontext
-from decimal import Decimal
-from .libs.utils import AlwaysEqualProxy, cleanGPUUsedForce
-from .libs.cache import remove_cache
-import numpy as np
-import json
-
-def validate_list_args(args: Dict[str, List[Any]]) -> Tuple[bool, Optional[str], Optional[str]]:
-    """
-    Checks that if there are multiple arguments, they are all the same length or 1
-    :param args:
-    :return: Tuple (Status, mismatched_key_1, mismatched_key_2)
-    """
-    # Only have 1 arg
-    if len(args) == 1:
-        return True, None, None
-
-    len_to_match = None
-    matched_arg_name = None
-    for arg_name, arg in args.items():
-        if arg_name == 'self':
-            # self is in locals()
-            continue
-
-        if len(arg) != 1:
-            if len_to_match is None:
-                len_to_match = len(arg)
-                matched_arg_name = arg_name
-            elif len(arg) != len_to_match:
-                return False, arg_name, matched_arg_name
-
-    return True, None, None
-def error_if_mismatched_list_args(args: Dict[str, List[Any]]) -> None:
-    is_valid, failed_key1, failed_key2 = validate_list_args(args)
-    if not is_valid:
-        assert failed_key1 is not None
-        assert failed_key2 is not None
-        raise ValueError(
-            f"Mismatched list inputs received. {failed_key1}({len(args[failed_key1])}) !== {failed_key2}({len(args[failed_key2])})"
-        )
-
-def zip_with_fill(*lists: Union[List[Any], None]) -> Iterator[Tuple[Any, ...]]:
-    """
-    Zips lists together, but if a list has 1 element, it will be repeated for each element in the other lists.
-    If a list is None, None will be used for that element.
-    (Not intended for use with lists of different lengths)
-    :param lists:
-    :return: Iterator of tuples of length len(lists)
-    """
-    max_len = max(len(lst) if lst is not None else 0 for lst in lists)
-    for i in range(max_len):
-        yield tuple(None if lst is None else (lst[0] if len(lst) == 1 else lst[i]) for lst in lists)
-
-# ---------------------------------------------------------------类型 开始----------------------------------------------------------------------#
-
-# 字符串
-class String:
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {"value": ("STRING", {"default": ""})},
-        }
-
-    RETURN_TYPES = ("STRING",)
-    RETURN_NAMES = ("string",)
-    FUNCTION = "execute"
-    CATEGORY = "EasyUse/Logic/Type"
-
-    def execute(self, value):
-        return (value,)
-
-# 整数
-class Int:
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {"value": ("INT", {"default": 0})},
-        }
-
-    RETURN_TYPES = ("INT",)
-    RETURN_NAMES = ("int",)
-    FUNCTION = "execute"
-    CATEGORY = "EasyUse/Logic/Type"
-
-    def execute(self, value):
-        return (value,)
-
-# 整数范围
-class RangeInt:
-    def __init__(self) -> None:
-        pass
-
-    @classmethod
-    def INPUT_TYPES(s) -> Dict[str, Dict[str, Any]]:
-        return {
-            "required": {
-                "range_mode": (["step", "num_steps"], {"default": "step"}),
-                "start": ("INT", {"default": 0, "min": -4096, "max": 4096, "step": 1}),
-                "stop": ("INT", {"default": 0, "min": -4096, "max": 4096, "step": 1}),
-                "step": ("INT", {"default": 0, "min": -4096, "max": 4096, "step": 1}),
-                "num_steps": ("INT", {"default": 0, "min": -4096, "max": 4096, "step": 1}),
-                "end_mode": (["Inclusive", "Exclusive"], {"default": "Inclusive"}),
-            },
-        }
-
-    RETURN_TYPES = ("INT", "INT")
-    RETURN_NAMES = ("range", "range_sizes")
-    INPUT_IS_LIST = True
-    OUTPUT_IS_LIST = (True, True)
-    FUNCTION = "build_range"
-
-    CATEGORY = "EasyUse/Logic/Type"
-
-    def build_range(
-        self,  range_mode, start, stop, step,  num_steps, end_mode
-    ) -> Tuple[List[int], List[int]]:
-        error_if_mismatched_list_args(locals())
-
-        ranges = []
-        range_sizes = []
-        for range_mode, e_start, e_stop, e_num_steps, e_step, e_end_mode in zip_with_fill(
-            range_mode, start, stop, num_steps, step, end_mode
-        ):
-            if range_mode == 'step':
-                if e_end_mode == "Inclusive":
-                    e_stop += 1
-                vals = list(range(e_start, e_stop, e_step))
-                ranges.extend(vals)
-                range_sizes.append(len(vals))
-            elif range_mode == 'num_steps':
-                direction = 1 if e_stop > e_start else -1
-                if e_end_mode == "Exclusive":
-                    e_stop -= direction
-                vals = (np.rint(np.linspace(e_start, e_stop, e_num_steps)).astype(int).tolist())
-                ranges.extend(vals)
-                range_sizes.append(len(vals))
-        return ranges, range_sizes
-
-
-
-# 浮点数
-class Float:
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {"value": ("FLOAT", {"default": 0, "step": 0.01})},
-        }
-
-    RETURN_TYPES = ("FLOAT",)
-    RETURN_NAMES = ("float",)
-    FUNCTION = "execute"
-    CATEGORY = "EasyUse/Logic/Type"
-
-    def execute(self, value):
-        return (value,)
-
-
-# 浮点数范围
-class RangeFloat:
-    def __init__(self) -> None:
-        pass
-
-    @classmethod
-    def INPUT_TYPES(s) -> Dict[str, Dict[str, Any]]:
-        return {
-            "required": {
-                "range_mode": (["step", "num_steps"], {"default": "step"}),
-                "start": ("FLOAT", {"default": 0, "min": -4096, "max": 4096, "step": 0.1}),
-                "stop": ("FLOAT", {"default": 0, "min": -4096, "max": 4096, "step": 0.1}),
-                "step": ("FLOAT", {"default": 0, "min": -4096, "max": 4096, "step": 0.1}),
-                "num_steps": ("INT", {"default": 0, "min": -4096, "max": 4096, "step": 1}),
-                "end_mode": (["Inclusive", "Exclusive"], {"default": "Inclusive"}),
-            },
-        }
-
-    RETURN_TYPES = ("FLOAT", "INT")
-    RETURN_NAMES = ("range", "range_sizes")
-    INPUT_IS_LIST = True
-    OUTPUT_IS_LIST = (True, True)
-    FUNCTION = "build_range"
-
-    CATEGORY = "EasyUse/Logic/Type"
-
-    @staticmethod
-    def _decimal_range(
-           range_mode: String, start: Decimal, stop: Decimal, step: Decimal, num_steps: Int, inclusive: bool
-    ) -> Iterator[float]:
-        if range_mode == 'step':
-            ret_val = start
-            if inclusive:
-                stop = stop + step
-            direction = 1 if step > 0 else -1
-            while (ret_val - stop) * direction < 0:
-                yield float(ret_val)
-                ret_val += step
-        elif range_mode == 'num_steps':
-            step = (stop - start) / (num_steps - 1)
-            direction = 1 if step > 0 else -1
-
-            ret_val = start
-            for _ in range(num_steps):
-                if (ret_val - stop) * direction > 0:  # Ensure we don't exceed the 'stop' value
-                    break
-                yield float(ret_val)
-                ret_val += step
-
-    def build_range(
-            self,
-            range_mode,
-            start,
-            stop,
-            step,
-            num_steps,
-            end_mode,
-    ) -> Tuple[List[float], List[int]]:
-        error_if_mismatched_list_args(locals())
-        getcontext().prec = 12
-
-        start = [Decimal(s) for s in start]
-        stop = [Decimal(s) for s in stop]
-        step = [Decimal(s) for s in step]
-
-        ranges = []
-        range_sizes = []
-        for range_mode, e_start, e_stop, e_step, e_num_steps, e_end_mode in zip_with_fill(
-                range_mode, start, stop, step, num_steps, end_mode
-        ):
-            vals = list(
-                self._decimal_range(range_mode, e_start, e_stop, e_step, e_num_steps, e_end_mode == 'Inclusive')
-            )
-            ranges.extend(vals)
-            range_sizes.append(len(vals))
-
-        return ranges, range_sizes
-
-
-# 布尔
-class Boolean:
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {"value": ("BOOLEAN", {"default": False})},
-        }
-
-    RETURN_TYPES = ("BOOLEAN",)
-    RETURN_NAMES = ("boolean",)
-    FUNCTION = "execute"
-    CATEGORY = "EasyUse/Logic/Type"
-
-    def execute(self, value):
-        return (value,)
-
-# ---------------------------------------------------------------开关 开始----------------------------------------------------------------------#
-class imageSwitch:
-    def __init__(self):
-        pass
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "image_a": ("IMAGE",),
-                "image_b": ("IMAGE",),
-                "boolean": ("BOOLEAN", {"default": False}),
-            }
-        }
-
-    RETURN_TYPES = ("IMAGE",)
-    FUNCTION = "image_switch"
-
-    CATEGORY = "EasyUse/Logic/Switch"
-
-    def image_switch(self, image_a, image_b, boolean):
-
-        if boolean:
-            return (image_a, )
-        else:
-            return (image_b, )
-
-class textSwitch:
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "input": ("INT", {"default": 1, "min": 1, "max": 2}),
-            },
-            "optional": {
-                "text1": ("STRING", {"forceInput": True}),
-                "text2": ("STRING", {"forceInput": True}),
-            }
-        }
-
-    RETURN_TYPES = ("STRING",)
-    RETURN_NAMES = ("STRING",)
-    CATEGORY = "EasyUse/Logic/Switch"
-    FUNCTION = "switch"
-
-    def switch(self, input, text1=None, text2=None,):
-        if input == 1:
-            return (text1,)
-        else:
-            return (text2,)
-
-# ---------------------------------------------------------------运算 开始----------------------------------------------------------------------#
-
-COMPARE_FUNCTIONS = {
-    "a == b": lambda a, b: a == b,
-    "a != b": lambda a, b: a != b,
-    "a < b": lambda a, b: a < b,
-    "a > b": lambda a, b: a > b,
-    "a <= b": lambda a, b: a <= b,
-    "a >= b": lambda a, b: a >= b,
-}
-
-# 比较
-class Compare:
-    @classmethod
-    def INPUT_TYPES(s):
-        s.compare_functions = list(COMPARE_FUNCTIONS.keys())
-        return {
-            "required": {
-                "a": (AlwaysEqualProxy("*"), {"default": 0}),
-                "b": (AlwaysEqualProxy("*"), {"default": 0}),
-                "comparison": (s.compare_functions, {"default": "a == b"}),
-            },
-        }
-
-    RETURN_TYPES = ("BOOLEAN",)
-    RETURN_NAMES = ("boolean",)
-    FUNCTION = "compare"
-    CATEGORY = "EasyUse/Logic/Math"
-
-    def compare(self, a, b, comparison):
-        return (COMPARE_FUNCTIONS[comparison](a, b),)
-
-# 判断
-class If:
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "any": (AlwaysEqualProxy("*"),),
-                "if": (AlwaysEqualProxy("*"),),
-                "else": (AlwaysEqualProxy("*"),),
-            },
-        }
-
-    RETURN_TYPES = (AlwaysEqualProxy("*"),)
-    RETURN_NAMES = ("?",)
-    FUNCTION = "execute"
-    CATEGORY = "EasyUse/Logic/Math"
-
-    def execute(self, *args, **kwargs):
-        return (kwargs['if'] if kwargs['any'] else kwargs['else'],)
-
-
-#是否为SDXL
-from comfy.sdxl_clip import SDXLClipModel, SDXLRefinerClipModel, SDXLClipG
-class isSDXL:
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {},
-            "optional": {
-                "optional_pipe": ("PIPE_LINE",),
-                "optional_clip": ("CLIP",),
-            }
-        }
-
-    RETURN_TYPES = ("BOOLEAN",)
-    RETURN_NAMES = ("boolean",)
-    FUNCTION = "execute"
-    CATEGORY = "EasyUse/Logic"
-
-    def execute(self, optional_pipe=None, optional_clip=None):
-        if optional_pipe is None and optional_clip is None:
-            raise Exception(f"[ERROR] optional_pipe or optional_clip is missing")
-        clip = optional_clip if optional_clip is not None else optional_pipe['clip']
-        if isinstance(clip.cond_stage_model, (SDXLClipModel, SDXLRefinerClipModel, SDXLClipG)):
-            return (True,)
-        else:
-            return (False,)
-
-#xy矩阵
-class xyAny:
-
-    @classmethod
-    def INPUT_TYPES(s):
-
-        return {
-            "required": {
-                "X": (AlwaysEqualProxy("*"), {}),
-                "Y": (AlwaysEqualProxy("*"), {}),
-                "direction": (["horizontal", "vertical"], {"default": "horizontal"})
-            }
-        }
-
-    RETURN_TYPES = (AlwaysEqualProxy("*"), AlwaysEqualProxy("*"))
-    RETURN_NAMES = ("X", "Y")
-    INPUT_IS_LIST = True
-    OUTPUT_IS_LIST = (True, True)
-    CATEGORY = "EasyUse/Logic"
-    FUNCTION = "to_xy"
-
-    def to_xy(self, X, Y, direction):
-        new_x = list()
-        new_y = list()
-        if direction[0] == "horizontal":
-            for y in Y:
-                for x in X:
-                    new_x.append(x)
-                    new_y.append(y)
-        else:
-            for x in X:
-                for y in Y:
-                    new_x.append(x)
-                    new_y.append(y)
-
-        return (new_x, new_y)
-
-# 转换所有类型
-class ConvertAnything:
-    @classmethod
-    def INPUT_TYPES(s):
-        return {"required": {
-            "anything": (AlwaysEqualProxy("*"),),
-            "output_type": (["string", "int", "float", "boolean"], {"default": "string"}),
-        }}
-
-    RETURN_TYPES = (AlwaysEqualProxy("*"),),
-    RETURN_NAMES = ('*',)
-    OUTPUT_NODE = True
-    FUNCTION = "convert"
-    CATEGORY = "EasyUse/Logic"
-
-    def convert(self, *args, **kwargs):
-        print(kwargs)
-        anything = kwargs['anything']
-        output_type = kwargs['output_type']
-        params = None
-        if output_type == 'string':
-            params = str(anything)
-        elif output_type == 'int':
-            params = int(anything)
-        elif output_type == 'float':
-            params = float(anything)
-        elif output_type == 'boolean':
-            params = bool(anything)
-        return (params,)
-
-# 将所有类型的内容都转成字符串输出
-class showAnything:
-    @classmethod
-    def INPUT_TYPES(s):
-        return {"required": {}, "optional": {"anything": (AlwaysEqualProxy("*"), {}), },
-                "hidden": {"unique_id": "UNIQUE_ID", "extra_pnginfo": "EXTRA_PNGINFO",
-            }}
-
-    RETURN_TYPES = ()
-    INPUT_IS_LIST = True
-    OUTPUT_NODE = True
-    FUNCTION = "log_input"
-    CATEGORY = "EasyUse/Logic"
-
-    def log_input(self, unique_id=None, extra_pnginfo=None, **kwargs):
-
-        values = []
-        if "anything" in kwargs:
-            for val in kwargs['anything']:
-                try:
-                    if type(val) is str:
-                        values.append(val)
-                    else:
-                        val = json.dumps(val)
-                        values.append(str(val))
-                except Exception:
-                    values.append(str(val))
-                    pass
-
-        if unique_id and extra_pnginfo and "workflow" in extra_pnginfo[0]:
-            workflow = extra_pnginfo[0]["workflow"]
-            node = next((x for x in workflow["nodes"] if str(x["id"]) == unique_id[0]), None)
-            if node:
-                node["widgets_values"] = [values]
-
-        return {"ui": {"text": values}}
-
-class showTensorShape:
-    @classmethod
-    def INPUT_TYPES(s):
-        return {"required": {"tensor": (AlwaysEqualProxy("*"),)}, "optional": {},
-                "hidden": {"unique_id": "UNIQUE_ID", "extra_pnginfo": "EXTRA_PNGINFO"
-               }}
-
-    RETURN_TYPES = ()
-    RETURN_NAMES = ()
-    OUTPUT_NODE = True
-    FUNCTION = "log_input"
-    CATEGORY = "EasyUse/Logic"
-
-    def log_input(self, tensor, unique_id=None, extra_pnginfo=None):
-        shapes = []
-
-        def tensorShape(tensor):
-            if isinstance(tensor, dict):
-                for k in tensor:
-                    tensorShape(tensor[k])
-            elif isinstance(tensor, list):
-                for i in range(len(tensor)):
-                    tensorShape(tensor[i])
-            elif hasattr(tensor, 'shape'):
-                shapes.append(list(tensor.shape))
-
-        tensorShape(tensor)
-
-        return {"ui": {"text": shapes}}
-
-# cleanGpuUsed
-class cleanGPUUsed:
-    @classmethod
-    def INPUT_TYPES(s):
-        return {"required": {"anything": (AlwaysEqualProxy("*"), {})}, "optional": {},
-                "hidden": {"unique_id": "UNIQUE_ID", "extra_pnginfo": "EXTRA_PNGINFO",
-                           }}
-
-    RETURN_TYPES = ()
-    RETURN_NAMES = ()
-    OUTPUT_NODE = True
-    FUNCTION = "empty_cache"
-    CATEGORY = "EasyUse/Logic"
-
-    def empty_cache(self, anything, unique_id=None, extra_pnginfo=None):
-        cleanGPUUsedForce()
-        remove_cache('*')
-        return ()
-
-class clearCacheKey:
-    @classmethod
-    def INPUT_TYPES(s):
-        return {"required": {
-            "anything": (AlwaysEqualProxy("*"), {}),
-            "cache_key": ("STRING", {"default": "*"}),
-        }, "optional": {},
-            "hidden": {"unique_id": "UNIQUE_ID", "extra_pnginfo": "EXTRA_PNGINFO",}
-        }
-
-    RETURN_TYPES = ()
-    RETURN_NAMES = ()
-    OUTPUT_NODE = True
-    FUNCTION = "empty_cache"
-    CATEGORY = "EasyUse/Logic"
-
-    def empty_cache(self, anything, cache_name, unique_id=None, extra_pnginfo=None):
-        remove_cache(cache_name)
-        return ()
-
-class clearCacheAll:
-    @classmethod
-    def INPUT_TYPES(s):
-        return {"required": {
-            "anything": (AlwaysEqualProxy("*"), {}),
-        }, "optional": {},
-            "hidden": {"unique_id": "UNIQUE_ID", "extra_pnginfo": "EXTRA_PNGINFO",}
-        }
-
-    RETURN_TYPES = ()
-    RETURN_NAMES = ()
-    OUTPUT_NODE = True
-    FUNCTION = "empty_cache"
-    CATEGORY = "EasyUse/Logic"
-
-    def empty_cache(self, anything, unique_id=None, extra_pnginfo=None):
-        remove_cache('*')
-        return ()
-
-
-
-
-NODE_CLASS_MAPPINGS = {
-  "easy string": String,
-  "easy int": Int,
-  "easy rangeInt": RangeInt,
-  "easy float": Float,
-  "easy rangeFloat": RangeFloat,
-  "easy boolean": Boolean,
-  "easy compare": Compare,
-  "easy imageSwitch": imageSwitch,
-  "easy textSwitch": textSwitch,
-  "easy if": If,
-  "easy isSDXL": isSDXL,
-  "easy xyAny": xyAny,
-  "easy convertAnything": ConvertAnything,
-  "easy showAnything": showAnything,
-  "easy showTensorShape": showTensorShape,
-  "easy clearCacheKey": clearCacheKey,
-  "easy clearCacheAll": clearCacheAll,
-  "easy cleanGpuUsed": cleanGPUUsed,
-}
-NODE_DISPLAY_NAME_MAPPINGS = {
-  "easy string": "String",
-  "easy int": "Int",
-  "easy rangeInt": "Range(Int)",
-  "easy float": "Float",
-  "easy rangeFloat": "Range(Float)",
-  "easy boolean": "Boolean",
-  "easy compare": "Compare",
-  "easy imageSwitch": "Image Switch",
-  "easy textSwitch": "Text Switch",
-  "easy if": "If",
-  "easy isSDXL": "Is SDXL",
-  "easy xyAny": "XYAny",
-  "easy convertAnything": "Convert Any",
-  "easy showAnything": "Show Any",
-  "easy showTensorShape": "Show Tensor Shape",
-  "easy clearCacheKey": "Clear Cache Key",
-  "easy clearCacheAll": "Clear Cache All",
-  "easy cleanGpuUsed": "Clean GPU Used"
-}

py/modules/bitsandbytes_NF4/__init__.py

@@ -0,0 +1,167 @@
+#credit to comfyanonymous for this module
+#from https://github.com/comfyanonymous/ComfyUI_bitsandbytes_NF4
+import comfy.ops
+import torch
+import folder_paths
+from ...libs.utils import install_package
+
+try:
+    from bitsandbytes.nn.modules import Params4bit, QuantState
+except ImportError:
+    Params4bit = torch.nn.Parameter
+    raise ImportError("Please install bitsandbytes>=0.43.3")
+
+def functional_linear_4bits(x, weight, bias):
+    try:
+        install_package("bitsandbytes", "0.43.3", True, "0.43.3")
+        import bitsandbytes as bnb
+    except ImportError:
+        raise ImportError("Please install bitsandbytes>=0.43.3")
+
+    out = bnb.matmul_4bit(x, weight.t(), bias=bias, quant_state=weight.quant_state)
+    out = out.to(x)
+    return out
+
+
+def copy_quant_state(state, device: torch.device = None):
+    if state is None:
+        return None
+
+    device = device or state.absmax.device
+
+    state2 = (
+        QuantState(
+            absmax=state.state2.absmax.to(device),
+            shape=state.state2.shape,
+            code=state.state2.code.to(device),
+            blocksize=state.state2.blocksize,
+            quant_type=state.state2.quant_type,
+            dtype=state.state2.dtype,
+        )
+        if state.nested
+        else None
+    )
+
+    return QuantState(
+        absmax=state.absmax.to(device),
+        shape=state.shape,
+        code=state.code.to(device),
+        blocksize=state.blocksize,
+        quant_type=state.quant_type,
+        dtype=state.dtype,
+        offset=state.offset.to(device) if state.nested else None,
+        state2=state2,
+    )
+
+
+class ForgeParams4bit(Params4bit):
+
+    def to(self, *args, **kwargs):
+        device, dtype, non_blocking, convert_to_format = torch._C._nn._parse_to(*args, **kwargs)
+        if device is not None and device.type == "cuda" and not self.bnb_quantized:
+            return self._quantize(device)
+        else:
+            n = ForgeParams4bit(
+                torch.nn.Parameter.to(self, device=device, dtype=dtype, non_blocking=non_blocking),
+                requires_grad=self.requires_grad,
+                quant_state=copy_quant_state(self.quant_state, device),
+                blocksize=self.blocksize,
+                compress_statistics=self.compress_statistics,
+                quant_type=self.quant_type,
+                quant_storage=self.quant_storage,
+                bnb_quantized=self.bnb_quantized,
+                module=self.module
+            )
+            self.module.quant_state = n.quant_state
+            self.data = n.data
+            self.quant_state = n.quant_state
+            return n
+
+class ForgeLoader4Bit(torch.nn.Module):
+    def __init__(self, *, device, dtype, quant_type, **kwargs):
+        super().__init__()
+        self.dummy = torch.nn.Parameter(torch.empty(1, device=device, dtype=dtype))
+        self.weight = None
+        self.quant_state = None
+        self.bias = None
+        self.quant_type = quant_type
+
+    def _save_to_state_dict(self, destination, prefix, keep_vars):
+        super()._save_to_state_dict(destination, prefix, keep_vars)
+        quant_state = getattr(self.weight, "quant_state", None)
+        if quant_state is not None:
+            for k, v in quant_state.as_dict(packed=True).items():
+                destination[prefix + "weight." + k] = v if keep_vars else v.detach()
+        return
+
+    def _load_from_state_dict(self, state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs):
+        quant_state_keys = {k[len(prefix + "weight."):] for k in state_dict.keys() if k.startswith(prefix + "weight.")}
+
+        if any('bitsandbytes' in k for k in quant_state_keys):
+            quant_state_dict = {k: state_dict[prefix + "weight." + k] for k in quant_state_keys}
+
+            self.weight = ForgeParams4bit().from_prequantized(
+                data=state_dict[prefix + 'weight'],
+                quantized_stats=quant_state_dict,
+                requires_grad=False,
+                device=self.dummy.device,
+                module=self
+            )
+            self.quant_state = self.weight.quant_state
+
+            if prefix + 'bias' in state_dict:
+                self.bias = torch.nn.Parameter(state_dict[prefix + 'bias'].to(self.dummy))
+
+            del self.dummy
+        elif hasattr(self, 'dummy'):
+            if prefix + 'weight' in state_dict:
+                self.weight = ForgeParams4bit(
+                    state_dict[prefix + 'weight'].to(self.dummy),
+                    requires_grad=False,
+                    compress_statistics=True,
+                    quant_type=self.quant_type,
+                    quant_storage=torch.uint8,
+                    module=self,
+                )
+                self.quant_state = self.weight.quant_state
+
+            if prefix + 'bias' in state_dict:
+                self.bias = torch.nn.Parameter(state_dict[prefix + 'bias'].to(self.dummy))
+
+            del self.dummy
+        else:
+            super()._load_from_state_dict(state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs)
+
+current_device = None
+current_dtype = None
+current_manual_cast_enabled = False
+current_bnb_dtype = None
+
+class OPS(comfy.ops.manual_cast):
+    class Linear(ForgeLoader4Bit):
+        def __init__(self, *args, device=None, dtype=None, **kwargs):
+            super().__init__(device=device, dtype=dtype, quant_type=current_bnb_dtype)
+            self.parameters_manual_cast = current_manual_cast_enabled
+
+        def forward(self, x):
+            self.weight.quant_state = self.quant_state
+
+            if self.bias is not None and self.bias.dtype != x.dtype:
+                # Maybe this can also be set to all non-bnb ops since the cost is very low.
+                # And it only invokes one time, and most linear does not have bias
+                self.bias.data = self.bias.data.to(x.dtype)
+
+            if not self.parameters_manual_cast:
+                return functional_linear_4bits(x, self.weight, self.bias)
+            elif not self.weight.bnb_quantized:
+                assert x.device.type == 'cuda', 'BNB Must Use CUDA as Computation Device!'
+                layer_original_device = self.weight.device
+                self.weight = self.weight._quantize(x.device)
+                bias = self.bias.to(x.device) if self.bias is not None else None
+                out = functional_linear_4bits(x, self.weight, bias)
+                self.weight = self.weight.to(layer_original_device)
+                return out
+            else:
+                weight, bias, signal = weights_manual_cast(self, x, skip_weight_dtype=True, skip_bias_dtype=True)
+                with main_stream_worker(weight, bias, signal):
+                    return functional_linear_4bits(x, weight, bias)

py/modules/brushnet/__init__.py

@@ -0,0 +1,822 @@
+#credit to nullquant for this module
+#from https://github.com/nullquant/ComfyUI-BrushNet
+
+import os
+import types
+
+import torch
+try:
+    from accelerate import init_empty_weights, load_checkpoint_and_dispatch
+except:
+    init_empty_weights, load_checkpoint_and_dispatch = None, None
+
+import comfy
+
+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')
+brushnet_xl_config_file = os.path.join(cwd_path, 'config', 'brushnet_xl.json')
+powerpaint_config_file = os.path.join(cwd_path, 'config', 'powerpaint.json')
+
+sd15_scaling_factor = 0.18215
+sdxl_scaling_factor = 0.13025
+
+ModelsToUnload = [comfy.sd1_clip.SD1ClipModel, comfy.ldm.models.autoencoder.AutoencoderKL]
+
+class BrushNet:
+
+    # Check models compatibility
+    def check_compatibilty(self, model, brushnet):
+        is_SDXL = False
+        is_PP = False
+        if isinstance(model.model.model_config, comfy.supported_models.SD15):
+            print('Base model type: SD1.5')
+            is_SDXL = False
+            if brushnet["SDXL"]:
+                raise Exception("Base model is SD15, but BrushNet is SDXL type")
+            if brushnet["PP"]:
+                is_PP = True
+        elif isinstance(model.model.model_config, comfy.supported_models.SDXL):
+            print('Base model type: SDXL')
+            is_SDXL = True
+            if not brushnet["SDXL"]:
+                raise Exception("Base model is SDXL, but BrushNet is SD15 type")
+        else:
+            print('Base model type: ', type(model.model.model_config))
+            raise Exception("Unsupported model type: " + str(type(model.model.model_config)))
+
+        return (is_SDXL, is_PP)
+
+    def check_image_mask(self, image, mask, name):
+        if len(image.shape) < 4:
+            # image tensor shape should be [B, H, W, C], but batch somehow is missing
+            image = image[None, :, :, :]
+
+        if len(mask.shape) > 3:
+            # mask tensor shape should be [B, H, W] but we get [B, H, W, C], image may be?
+            # take first mask, red channel
+            mask = (mask[:, :, :, 0])[:, :, :]
+        elif len(mask.shape) < 3:
+            # mask tensor shape should be [B, H, W] but batch somehow is missing
+            mask = mask[None, :, :]
+
+        if image.shape[0] > mask.shape[0]:
+            print(name, "gets batch of images (%d) but only %d masks" % (image.shape[0], mask.shape[0]))
+            if mask.shape[0] == 1:
+                print(name, "will copy the mask to fill batch")
+                mask = torch.cat([mask] * image.shape[0], dim=0)
+            else:
+                print(name, "will add empty masks to fill batch")
+                empty_mask = torch.zeros([image.shape[0] - mask.shape[0], mask.shape[1], mask.shape[2]])
+                mask = torch.cat([mask, empty_mask], dim=0)
+        elif image.shape[0] < mask.shape[0]:
+            print(name, "gets batch of images (%d) but too many (%d) masks" % (image.shape[0], mask.shape[0]))
+            mask = mask[:image.shape[0], :, :]
+
+        return (image, mask)
+
+    # Prepare image and mask
+    def prepare_image(self, image, mask):
+
+        image, mask = self.check_image_mask(image, mask, 'BrushNet')
+
+        print("BrushNet image.shape =", image.shape, "mask.shape =", mask.shape)
+
+        if mask.shape[2] != image.shape[2] or mask.shape[1] != image.shape[1]:
+            raise Exception("Image and mask should be the same size")
+
+        # As a suggestion of inferno46n2 (https://github.com/nullquant/ComfyUI-BrushNet/issues/64)
+        mask = mask.round()
+
+        masked_image = image * (1.0 - mask[:, :, :, None])
+
+        return (masked_image, mask)
+
+    # Get origin of the mask
+    def cut_with_mask(self, mask, width, height):
+        iy, ix = (mask == 1).nonzero(as_tuple=True)
+
+        h0, w0 = mask.shape
+
+        if iy.numel() == 0:
+            x_c = w0 / 2.0
+            y_c = h0 / 2.0
+        else:
+            x_min = ix.min().item()
+            x_max = ix.max().item()
+            y_min = iy.min().item()
+            y_max = iy.max().item()
+
+            if x_max - x_min > width or y_max - y_min > height:
+                raise Exception("Mask is bigger than provided dimensions")
+
+            x_c = (x_min + x_max) / 2.0
+            y_c = (y_min + y_max) / 2.0
+
+        width2 = width / 2.0
+        height2 = height / 2.0
+
+        if w0 <= width:
+            x0 = 0
+            w = w0
+        else:
+            x0 = max(0, x_c - width2)
+            w = width
+            if x0 + width > w0:
+                x0 = w0 - width
+
+        if h0 <= height:
+            y0 = 0
+            h = h0
+        else:
+            y0 = max(0, y_c - height2)
+            h = height
+            if y0 + height > h0:
+                y0 = h0 - height
+
+        return (int(x0), int(y0), int(w), int(h))
+
+    # Prepare conditioning_latents
+    @torch.inference_mode()
+    def get_image_latents(self, masked_image, mask, vae, scaling_factor):
+        processed_image = masked_image.to(vae.device)
+        image_latents = vae.encode(processed_image[:, :, :, :3]) * scaling_factor
+        processed_mask = 1. - mask[:, None, :, :]
+        interpolated_mask = torch.nn.functional.interpolate(
+            processed_mask,
+            size=(
+                image_latents.shape[-2],
+                image_latents.shape[-1]
+            )
+        )
+        interpolated_mask = interpolated_mask.to(image_latents.device)
+
+        conditioning_latents = [image_latents, interpolated_mask]
+
+        print('BrushNet CL: image_latents shape =', image_latents.shape, 'interpolated_mask shape =',
+              interpolated_mask.shape)
+
+        return conditioning_latents
+
+    def brushnet_blocks(self, sd):
+        brushnet_down_block = 0
+        brushnet_mid_block = 0
+        brushnet_up_block = 0
+        for key in sd:
+            if 'brushnet_down_block' in key:
+                brushnet_down_block += 1
+            if 'brushnet_mid_block' in key:
+                brushnet_mid_block += 1
+            if 'brushnet_up_block' in key:
+                brushnet_up_block += 1
+        return (brushnet_down_block, brushnet_mid_block, brushnet_up_block, len(sd))
+
+    def get_model_type(self, brushnet_file):
+        sd = comfy.utils.load_torch_file(brushnet_file)
+        brushnet_down_block, brushnet_mid_block, brushnet_up_block, keys = self.brushnet_blocks(sd)
+        del sd
+        if brushnet_down_block == 24 and brushnet_mid_block == 2 and brushnet_up_block == 30:
+            is_SDXL = False
+            if keys == 322:
+                is_PP = False
+                print('BrushNet model type: SD1.5')
+            else:
+                is_PP = True
+                print('PowerPaint model type: SD1.5')
+        elif brushnet_down_block == 18 and brushnet_mid_block == 2 and brushnet_up_block == 22:
+            print('BrushNet model type: Loading SDXL')
+            is_SDXL = True
+            is_PP = False
+        else:
+            raise Exception("Unknown BrushNet model")
+        return is_SDXL, is_PP
+
+    def load_brushnet_model(self, brushnet_file, dtype='float16'):
+        is_SDXL, is_PP = self.get_model_type(brushnet_file)
+        with init_empty_weights():
+            if is_SDXL:
+                brushnet_config = BrushNetModel.load_config(brushnet_xl_config_file)
+                brushnet_model = BrushNetModel.from_config(brushnet_config)
+            elif is_PP:
+                brushnet_config = PowerPaintModel.load_config(powerpaint_config_file)
+                brushnet_model = PowerPaintModel.from_config(brushnet_config)
+            else:
+                brushnet_config = BrushNetModel.load_config(brushnet_config_file)
+                brushnet_model = BrushNetModel.from_config(brushnet_config)
+        if is_PP:
+            print("PowerPaint model file:", brushnet_file)
+        else:
+            print("BrushNet model file:", brushnet_file)
+
+        if dtype == 'float16':
+            torch_dtype = torch.float16
+        elif dtype == 'bfloat16':
+            torch_dtype = torch.bfloat16
+        elif dtype == 'float32':
+            torch_dtype = torch.float32
+        else:
+            torch_dtype = torch.float64
+
+        brushnet_model = load_checkpoint_and_dispatch(
+            brushnet_model,
+            brushnet_file,
+            device_map="sequential",
+            max_memory=None,
+            offload_folder=None,
+            offload_state_dict=False,
+            dtype=torch_dtype,
+            force_hooks=False,
+        )
+
+        if is_PP:
+            print("PowerPaint model is loaded")
+        elif is_SDXL:
+            print("BrushNet SDXL model is loaded")
+        else:
+            print("BrushNet SD1.5 model is loaded")
+
+        return ({"brushnet": brushnet_model, "SDXL": is_SDXL, "PP": is_PP, "dtype": torch_dtype},)
+
+    def brushnet_model_update(self, model, vae, image, mask, brushnet, positive, negative, scale, start_at, end_at):
+
+        is_SDXL, is_PP = self.check_compatibilty(model, brushnet)
+
+        if is_PP:
+            raise Exception("PowerPaint model was loaded, please use PowerPaint node")
+
+            # Make a copy of the model so that we're not patching it everywhere in the workflow.
+        model = model.clone()
+
+        # prepare image and mask
+        # no batches for original image and mask
+        masked_image, mask = self.prepare_image(image, mask)
+
+        batch = masked_image.shape[0]
+        width = masked_image.shape[2]
+        height = masked_image.shape[1]
+
+        if hasattr(model.model.model_config, 'latent_format') and hasattr(model.model.model_config.latent_format,
+                                                                          'scale_factor'):
+            scaling_factor = model.model.model_config.latent_format.scale_factor
+        elif is_SDXL:
+            scaling_factor = sdxl_scaling_factor
+        else:
+            scaling_factor = sd15_scaling_factor
+
+        torch_dtype = brushnet['dtype']
+
+        # prepare conditioning latents
+        conditioning_latents = self.get_image_latents(masked_image, mask, vae, scaling_factor)
+        conditioning_latents[0] = conditioning_latents[0].to(dtype=torch_dtype).to(brushnet['brushnet'].device)
+        conditioning_latents[1] = conditioning_latents[1].to(dtype=torch_dtype).to(brushnet['brushnet'].device)
+
+        # 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
+
+        # prepare embeddings
+        prompt_embeds = positive[0][0].to(dtype=torch_dtype).to(brushnet['brushnet'].device)
+        negative_prompt_embeds = negative[0][0].to(dtype=torch_dtype).to(brushnet['brushnet'].device)
+
+        max_tokens = max(prompt_embeds.shape[1], negative_prompt_embeds.shape[1])
+        if prompt_embeds.shape[1] < max_tokens:
+            multiplier = max_tokens // 77 - prompt_embeds.shape[1] // 77
+            prompt_embeds = torch.concat([prompt_embeds] + [prompt_embeds[:, -77:, :]] * multiplier, dim=1)
+            print('BrushNet: negative prompt more than 75 tokens:', negative_prompt_embeds.shape,
+                  'multiplying prompt_embeds')
+        if negative_prompt_embeds.shape[1] < max_tokens:
+            multiplier = max_tokens // 77 - negative_prompt_embeds.shape[1] // 77
+            negative_prompt_embeds = torch.concat(
+                [negative_prompt_embeds] + [negative_prompt_embeds[:, -77:, :]] * multiplier, dim=1)
+            print('BrushNet: positive prompt more than 75 tokens:', prompt_embeds.shape,
+                  'multiplying negative_prompt_embeds')
+
+        if len(positive[0]) > 1 and 'pooled_output' in positive[0][1] and positive[0][1]['pooled_output'] is not None:
+            pooled_prompt_embeds = positive[0][1]['pooled_output'].to(dtype=torch_dtype).to(brushnet['brushnet'].device)
+        else:
+            print('BrushNet: positive conditioning has not pooled_output')
+            if is_SDXL:
+                print('BrushNet will not produce correct results')
+            pooled_prompt_embeds = torch.empty([2, 1280], device=brushnet['brushnet'].device).to(dtype=torch_dtype)
+
+        if len(negative[0]) > 1 and 'pooled_output' in negative[0][1] and negative[0][1]['pooled_output'] is not None:
+            negative_pooled_prompt_embeds = negative[0][1]['pooled_output'].to(dtype=torch_dtype).to(
+                brushnet['brushnet'].device)
+        else:
+            print('BrushNet: negative conditioning has not pooled_output')
+            if is_SDXL:
+                print('BrushNet will not produce correct results')
+            negative_pooled_prompt_embeds = torch.empty([1, pooled_prompt_embeds.shape[1]],
+                                                        device=brushnet['brushnet'].device).to(dtype=torch_dtype)
+
+        time_ids = torch.FloatTensor([[height, width, 0., 0., height, width]]).to(dtype=torch_dtype).to(
+            brushnet['brushnet'].device)
+
+        if not is_SDXL:
+            pooled_prompt_embeds = None
+            negative_pooled_prompt_embeds = None
+            time_ids = None
+
+        # apply patch to model
+        brushnet_conditioning_scale = scale
+        control_guidance_start = start_at
+        control_guidance_end = end_at
+
+        add_brushnet_patch(model,
+                           brushnet['brushnet'],
+                           torch_dtype,
+                           conditioning_latents,
+                           (brushnet_conditioning_scale, control_guidance_start, control_guidance_end),
+                           prompt_embeds, negative_prompt_embeds,
+                           pooled_prompt_embeds, negative_pooled_prompt_embeds, time_ids,
+                           False)
+
+        latent = torch.zeros([batch, 4, conditioning_latents[0].shape[2], conditioning_latents[0].shape[3]],
+                             device=brushnet['brushnet'].device)
+
+        return (model, positive, negative, {"samples": latent},)
+
+    #powperpaint
+    def load_powerpaint_clip(self, base_clip_file, pp_clip_file):
+        pp_clip = comfy.sd.load_clip(ckpt_paths=[base_clip_file])
+
+        print('PowerPaint base CLIP file: ', base_clip_file)
+
+        pp_tokenizer = TokenizerWrapper(pp_clip.tokenizer.clip_l.tokenizer)
+        pp_text_encoder = pp_clip.patcher.model.clip_l.transformer
+
+        add_tokens(
+            tokenizer=pp_tokenizer,
+            text_encoder=pp_text_encoder,
+            placeholder_tokens=["P_ctxt", "P_shape", "P_obj"],
+            initialize_tokens=["a", "a", "a"],
+            num_vectors_per_token=10,
+        )
+
+        pp_text_encoder.load_state_dict(comfy.utils.load_torch_file(pp_clip_file), strict=False)
+
+        print('PowerPaint CLIP file: ', pp_clip_file)
+
+        pp_clip.tokenizer.clip_l.tokenizer = pp_tokenizer
+        pp_clip.patcher.model.clip_l.transformer = pp_text_encoder
+
+        return (pp_clip,)
+
+    def powerpaint_model_update(self, model, vae, image, mask, powerpaint, clip, positive, negative, fitting, function, scale, start_at, end_at, save_memory):
+        is_SDXL, is_PP = self.check_compatibilty(model, powerpaint)
+        if not is_PP:
+            raise Exception("BrushNet model was loaded, please use BrushNet node")
+
+            # Make a copy of the model so that we're not patching it everywhere in the workflow.
+        model = model.clone()
+
+        # prepare image and mask
+        # no batches for original image and mask
+        masked_image, mask = self.prepare_image(image, mask)
+
+        batch = masked_image.shape[0]
+        # width = masked_image.shape[2]
+        # height = masked_image.shape[1]
+
+        if hasattr(model.model.model_config, 'latent_format') and hasattr(model.model.model_config.latent_format,
+                                                                          'scale_factor'):
+            scaling_factor = model.model.model_config.latent_format.scale_factor
+        else:
+            scaling_factor = sd15_scaling_factor
+
+        torch_dtype = powerpaint['dtype']
+
+        # prepare conditioning latents
+        conditioning_latents = self.get_image_latents(masked_image, mask, vae, scaling_factor)
+        conditioning_latents[0] = conditioning_latents[0].to(dtype=torch_dtype).to(powerpaint['brushnet'].device)
+        conditioning_latents[1] = conditioning_latents[1].to(dtype=torch_dtype).to(powerpaint['brushnet'].device)
+
+        # prepare embeddings
+
+        if function == "object removal":
+            promptA = "P_ctxt"
+            promptB = "P_ctxt"
+            negative_promptA = "P_obj"
+            negative_promptB = "P_obj"
+            print('You should add to positive prompt: "empty scene blur"')
+            # positive = positive + " empty scene blur"
+        elif function == "context aware":
+            promptA = "P_ctxt"
+            promptB = "P_ctxt"
+            negative_promptA = ""
+            negative_promptB = ""
+            # positive = positive + " empty scene"
+            print('You should add to positive prompt: "empty scene"')
+        elif function == "shape guided":
+            promptA = "P_shape"
+            promptB = "P_ctxt"
+            negative_promptA = "P_shape"
+            negative_promptB = "P_ctxt"
+        elif function == "image outpainting":
+            promptA = "P_ctxt"
+            promptB = "P_ctxt"
+            negative_promptA = "P_obj"
+            negative_promptB = "P_obj"
+            # positive = positive + " empty scene"
+            print('You should add to positive prompt: "empty scene"')
+        else:
+            promptA = "P_obj"
+            promptB = "P_obj"
+            negative_promptA = "P_obj"
+            negative_promptB = "P_obj"
+
+        tokens = clip.tokenize(promptA)
+        prompt_embedsA = clip.encode_from_tokens(tokens, return_pooled=False)
+
+        tokens = clip.tokenize(negative_promptA)
+        negative_prompt_embedsA = clip.encode_from_tokens(tokens, return_pooled=False)
+
+        tokens = clip.tokenize(promptB)
+        prompt_embedsB = clip.encode_from_tokens(tokens, return_pooled=False)
+
+        tokens = clip.tokenize(negative_promptB)
+        negative_prompt_embedsB = clip.encode_from_tokens(tokens, return_pooled=False)
+
+        prompt_embeds_pp = (prompt_embedsA * fitting + (1.0 - fitting) * prompt_embedsB).to(dtype=torch_dtype).to(
+            powerpaint['brushnet'].device)
+        negative_prompt_embeds_pp = (negative_prompt_embedsA * fitting + (1.0 - fitting) * negative_prompt_embedsB).to(
+            dtype=torch_dtype).to(powerpaint['brushnet'].device)
+
+        # 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
+
+        # apply patch to model
+
+        brushnet_conditioning_scale = scale
+        control_guidance_start = start_at
+        control_guidance_end = end_at
+
+        if save_memory != 'none':
+            powerpaint['brushnet'].set_attention_slice(save_memory)
+
+        add_brushnet_patch(model,
+                           powerpaint['brushnet'],
+                           torch_dtype,
+                           conditioning_latents,
+                           (brushnet_conditioning_scale, control_guidance_start, control_guidance_end),
+                           negative_prompt_embeds_pp, prompt_embeds_pp,
+                           None, None, None,
+                           False)
+
+        latent = torch.zeros([batch, 4, conditioning_latents[0].shape[2], conditioning_latents[0].shape[3]],
+                             device=powerpaint['brushnet'].device)
+
+        return (model, positive, negative, {"samples": latent},)
+@torch.inference_mode()
+def brushnet_inference(x, timesteps, transformer_options, debug):
+    if 'model_patch' not in transformer_options:
+        print('BrushNet inference: there is no model_patch key in transformer_options')
+        return ([], 0, [])
+    mp = transformer_options['model_patch']
+    if 'brushnet' not in mp:
+        print('BrushNet inference: there is no brushnet key in mdel_patch')
+        return ([], 0, [])
+    bo = mp['brushnet']
+    if 'model' not in bo:
+        print('BrushNet inference: there is no model key in brushnet')
+        return ([], 0, [])
+    brushnet = bo['model']
+    if not (isinstance(brushnet, BrushNetModel) or isinstance(brushnet, PowerPaintModel)):
+        print('BrushNet model is not a BrushNetModel class')
+        return ([], 0, [])
+
+    torch_dtype = bo['dtype']
+    cl_list = bo['latents']
+    brushnet_conditioning_scale, control_guidance_start, control_guidance_end = bo['controls']
+    pe = bo['prompt_embeds']
+    npe = bo['negative_prompt_embeds']
+    ppe, nppe, time_ids = bo['add_embeds']
+
+    #do_classifier_free_guidance = mp['free_guidance']
+    do_classifier_free_guidance = len(transformer_options['cond_or_uncond']) > 1
+
+    x = x.detach().clone()
+    x = x.to(torch_dtype).to(brushnet.device)
+
+    timesteps = timesteps.detach().clone()
+    timesteps = timesteps.to(torch_dtype).to(brushnet.device)
+
+    total_steps = mp['total_steps']
+    step = mp['step']
+
+    added_cond_kwargs = {}
+
+    if do_classifier_free_guidance and step == 0:
+        print('BrushNet inference: do_classifier_free_guidance is True')
+
+    sub_idx = None
+    if 'ad_params' in transformer_options and 'sub_idxs' in transformer_options['ad_params']:
+        sub_idx = transformer_options['ad_params']['sub_idxs']
+
+    # we have batch input images
+    batch = cl_list[0].shape[0]
+    # we have incoming latents
+    latents_incoming = x.shape[0]
+    # and we already got some
+    latents_got = bo['latent_id']
+    if step == 0 or batch > 1:
+        print('BrushNet inference, step = %d: image batch = %d, got %d latents, starting from %d' \
+                % (step, batch, latents_incoming, latents_got))
+
+    image_latents = []
+    masks = []
+    prompt_embeds = []
+    negative_prompt_embeds = []
+    pooled_prompt_embeds = []
+    negative_pooled_prompt_embeds = []
+    if sub_idx:
+        # AnimateDiff indexes detected
+        if step == 0:
+            print('BrushNet inference: AnimateDiff indexes detected and applied')
+
+        batch = len(sub_idx)
+
+        if do_classifier_free_guidance:
+            for i in sub_idx:
+                image_latents.append(cl_list[0][i][None,:,:,:])
+                masks.append(cl_list[1][i][None,:,:,:])
+                prompt_embeds.append(pe)
+                negative_prompt_embeds.append(npe)
+                pooled_prompt_embeds.append(ppe)
+                negative_pooled_prompt_embeds.append(nppe)
+            for i in sub_idx:
+                image_latents.append(cl_list[0][i][None,:,:,:])
+                masks.append(cl_list[1][i][None,:,:,:])
+        else:
+            for i in sub_idx:
+                image_latents.append(cl_list[0][i][None,:,:,:])
+                masks.append(cl_list[1][i][None,:,:,:])
+                prompt_embeds.append(pe)
+                pooled_prompt_embeds.append(ppe)
+    else:
+        # do_classifier_free_guidance = 2 passes, 1st pass is cond, 2nd is uncond
+        continue_batch = True
+        for i in range(latents_incoming):
+            number = latents_got + i
+            if number < batch:
+                # 1st pass, cond
+                image_latents.append(cl_list[0][number][None,:,:,:])
+                masks.append(cl_list[1][number][None,:,:,:])
+                prompt_embeds.append(pe)
+                pooled_prompt_embeds.append(ppe)
+            elif do_classifier_free_guidance and number < batch * 2:
+                # 2nd pass, uncond
+                image_latents.append(cl_list[0][number-batch][None,:,:,:])
+                masks.append(cl_list[1][number-batch][None,:,:,:])
+                negative_prompt_embeds.append(npe)
+                negative_pooled_prompt_embeds.append(nppe)
+            else:
+                # latent batch
+                image_latents.append(cl_list[0][0][None,:,:,:])
+                masks.append(cl_list[1][0][None,:,:,:])
+                prompt_embeds.append(pe)
+                pooled_prompt_embeds.append(ppe)
+                latents_got = -i
+                continue_batch = False
+
+        if continue_batch:
+            # we don't have full batch yet
+            if do_classifier_free_guidance:
+                if number < batch * 2 - 1:
+                    bo['latent_id'] = number + 1
+                else:
+                    bo['latent_id'] = 0
+            else:
+                if number < batch - 1:
+                    bo['latent_id'] = number + 1
+                else:
+                    bo['latent_id'] = 0
+        else:
+            bo['latent_id'] = 0
+
+    cl = []
+    for il, m in zip(image_latents, masks):
+        cl.append(torch.concat([il, m], dim=1))
+    cl2apply = torch.concat(cl, dim=0)
+
+    conditioning_latents = cl2apply.to(torch_dtype).to(brushnet.device)
+
+    prompt_embeds.extend(negative_prompt_embeds)
+    prompt_embeds = torch.concat(prompt_embeds, dim=0).to(torch_dtype).to(brushnet.device)
+
+    if ppe is not None:
+        added_cond_kwargs = {}
+        added_cond_kwargs['time_ids'] = torch.concat([time_ids] * latents_incoming, dim = 0).to(torch_dtype).to(brushnet.device)
+
+        pooled_prompt_embeds.extend(negative_pooled_prompt_embeds)
+        pooled_prompt_embeds = torch.concat(pooled_prompt_embeds, dim=0).to(torch_dtype).to(brushnet.device)
+        added_cond_kwargs['text_embeds'] = pooled_prompt_embeds
+    else:
+        added_cond_kwargs = None
+
+    if x.shape[2] != conditioning_latents.shape[2] or x.shape[3] != conditioning_latents.shape[3]:
+        if step == 0:
+            print('BrushNet inference: image', conditioning_latents.shape, 'and latent', x.shape, 'have different size, resizing image')
+        conditioning_latents = torch.nn.functional.interpolate(
+            conditioning_latents, size=(
+                x.shape[2],
+                x.shape[3],
+            ), mode='bicubic',
+        ).to(torch_dtype).to(brushnet.device)
+
+    if step == 0:
+        print('BrushNet inference: sample', x.shape, ', CL', conditioning_latents.shape, 'dtype', torch_dtype)
+
+    if debug: print('BrushNet: step =', step)
+
+    if step < control_guidance_start or step > control_guidance_end:
+        cond_scale = 0.0
+    else:
+        cond_scale = brushnet_conditioning_scale
+
+    return brushnet(x,
+        encoder_hidden_states=prompt_embeds,
+        brushnet_cond=conditioning_latents,
+        timestep = timesteps,
+        conditioning_scale=cond_scale,
+        guess_mode=False,
+        added_cond_kwargs=added_cond_kwargs,
+        return_dict=False,
+        debug=debug,
+    )
+
+def add_brushnet_patch(model, brushnet, torch_dtype, conditioning_latents,
+                       controls,
+                       prompt_embeds, negative_prompt_embeds,
+                       pooled_prompt_embeds, negative_pooled_prompt_embeds, time_ids,
+                       debug):
+
+    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, operations.Conv2d],
+                        [1, comfy.ldm.modules.diffusionmodules.openaimodel.ResBlock],
+                        [2, comfy.ldm.modules.diffusionmodules.openaimodel.ResBlock],
+                        [3, comfy.ldm.modules.diffusionmodules.openaimodel.Downsample],
+                        [4, comfy.ldm.modules.attention.SpatialTransformer],
+                        [5, comfy.ldm.modules.attention.SpatialTransformer],
+                        [6, comfy.ldm.modules.diffusionmodules.openaimodel.Downsample],
+                        [7, comfy.ldm.modules.attention.SpatialTransformer],
+                        [8, comfy.ldm.modules.attention.SpatialTransformer]]
+        middle_block = [0, comfy.ldm.modules.diffusionmodules.openaimodel.ResBlock]
+        output_blocks = [[0, comfy.ldm.modules.attention.SpatialTransformer],
+                         [1, comfy.ldm.modules.attention.SpatialTransformer],
+                         [2, comfy.ldm.modules.attention.SpatialTransformer],
+                         [2, comfy.ldm.modules.diffusionmodules.openaimodel.Upsample],
+                         [3, comfy.ldm.modules.attention.SpatialTransformer],
+                         [4, comfy.ldm.modules.attention.SpatialTransformer],
+                         [5, comfy.ldm.modules.attention.SpatialTransformer],
+                         [5, comfy.ldm.modules.diffusionmodules.openaimodel.Upsample],
+                         [6, comfy.ldm.modules.diffusionmodules.openaimodel.ResBlock],
+                         [7, comfy.ldm.modules.diffusionmodules.openaimodel.ResBlock],
+                         [8, comfy.ldm.modules.diffusionmodules.openaimodel.ResBlock]]
+    else:
+        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, comfy.ldm.modules.attention.SpatialTransformer],
+                        [5, comfy.ldm.modules.attention.SpatialTransformer],
+                        [6, comfy.ldm.modules.diffusionmodules.openaimodel.Downsample],
+                        [7, comfy.ldm.modules.attention.SpatialTransformer],
+                        [8, comfy.ldm.modules.attention.SpatialTransformer],
+                        [9, comfy.ldm.modules.diffusionmodules.openaimodel.Downsample],
+                        [10, comfy.ldm.modules.diffusionmodules.openaimodel.ResBlock],
+                        [11, comfy.ldm.modules.diffusionmodules.openaimodel.ResBlock]]
+        middle_block = [0, comfy.ldm.modules.diffusionmodules.openaimodel.ResBlock]
+        output_blocks = [[0, comfy.ldm.modules.diffusionmodules.openaimodel.ResBlock],
+                         [1, comfy.ldm.modules.diffusionmodules.openaimodel.ResBlock],
+                         [2, comfy.ldm.modules.diffusionmodules.openaimodel.ResBlock],
+                         [2, comfy.ldm.modules.diffusionmodules.openaimodel.Upsample],
+                         [3, comfy.ldm.modules.attention.SpatialTransformer],
+                         [4, comfy.ldm.modules.attention.SpatialTransformer],
+                         [5, comfy.ldm.modules.attention.SpatialTransformer],
+                         [5, comfy.ldm.modules.diffusionmodules.openaimodel.Upsample],
+                         [6, comfy.ldm.modules.attention.SpatialTransformer],
+                         [7, comfy.ldm.modules.attention.SpatialTransformer],
+                         [8, comfy.ldm.modules.attention.SpatialTransformer],
+                         [8, comfy.ldm.modules.diffusionmodules.openaimodel.Upsample],
+                         [9, comfy.ldm.modules.attention.SpatialTransformer],
+                         [10, comfy.ldm.modules.attention.SpatialTransformer],
+                         [11, comfy.ldm.modules.attention.SpatialTransformer]]
+
+    def last_layer_index(block, tp):
+        layer_list = []
+        for layer in block:
+            layer_list.append(type(layer))
+        layer_list.reverse()
+        if tp not in layer_list:
+            return -1, layer_list.reverse()
+        return len(layer_list) - 1 - layer_list.index(tp), layer_list
+
+    def brushnet_forward(model, x, timesteps, transformer_options, control):
+        if 'brushnet' not in transformer_options['model_patch']:
+            input_samples = []
+            mid_sample = 0
+            output_samples = []
+        else:
+            # brushnet inference
+            input_samples, mid_sample, output_samples = brushnet_inference(x, timesteps, transformer_options, debug)
+
+        # give additional samples to blocks
+        for i, tp in input_blocks:
+            idx, layer_list = last_layer_index(model.input_blocks[i], tp)
+            if idx < 0:
+                print("BrushNet can't find", tp, "layer in", i, "input block:", layer_list)
+                continue
+            model.input_blocks[i][idx].add_sample_after = input_samples.pop(0) if input_samples else 0
+
+        idx, layer_list = last_layer_index(model.middle_block, middle_block[1])
+        if idx < 0:
+            print("BrushNet can't find", middle_block[1], "layer in middle block", layer_list)
+        model.middle_block[idx].add_sample_after = mid_sample
+
+        for i, tp in output_blocks:
+            idx, layer_list = last_layer_index(model.output_blocks[i], tp)
+            if idx < 0:
+                print("BrushNet can't find", tp, "layer in", i, "outnput block:", layer_list)
+                continue
+            model.output_blocks[i][idx].add_sample_after = output_samples.pop(0) if output_samples else 0
+
+    patch_model_function_wrapper(model, brushnet_forward)
+
+    to = add_model_patch_option(model)
+    mp = to['model_patch']
+    if 'brushnet' not in mp:
+        mp['brushnet'] = {}
+    bo = mp['brushnet']
+
+    bo['model'] = brushnet
+    bo['dtype'] = torch_dtype
+    bo['latents'] = conditioning_latents
+    bo['controls'] = controls
+    bo['prompt_embeds'] = prompt_embeds
+    bo['negative_prompt_embeds'] = negative_prompt_embeds
+    bo['add_embeds'] = (pooled_prompt_embeds, negative_pooled_prompt_embeds, time_ids)
+    bo['latent_id'] = 0
+
+    # patch layers `forward` so we can apply brushnet
+    def forward_patched_by_brushnet(self, x, *args, **kwargs):
+        h = self.original_forward(x, *args, **kwargs)
+        if hasattr(self, 'add_sample_after') and type(self):
+            to_add = self.add_sample_after
+            if torch.is_tensor(to_add):
+                # interpolate due to RAUNet
+                if h.shape[2] != to_add.shape[2] or h.shape[3] != to_add.shape[3]:
+                    to_add = torch.nn.functional.interpolate(to_add, size=(h.shape[2], h.shape[3]), mode='bicubic')
+                h += to_add.to(h.dtype).to(h.device)
+            else:
+                h += self.add_sample_after
+            self.add_sample_after = 0
+        return h
+
+    for i, block in enumerate(model.model.diffusion_model.input_blocks):
+        for j, layer in enumerate(block):
+            if not hasattr(layer, 'original_forward'):
+                layer.original_forward = layer.forward
+            layer.forward = types.MethodType(forward_patched_by_brushnet, layer)
+            layer.add_sample_after = 0
+
+    for j, layer in enumerate(model.model.diffusion_model.middle_block):
+        if not hasattr(layer, 'original_forward'):
+            layer.original_forward = layer.forward
+        layer.forward = types.MethodType(forward_patched_by_brushnet, layer)
+        layer.add_sample_after = 0
+
+    for i, block in enumerate(model.model.diffusion_model.output_blocks):
+        for j, layer in enumerate(block):
+            if not hasattr(layer, 'original_forward'):
+                layer.original_forward = layer.forward
+            layer.forward = types.MethodType(forward_patched_by_brushnet, layer)
+            layer.add_sample_after = 0

py/modules/brushnet/config/brushnet.json

@@ -0,0 +1,58 @@
+{
+  "_class_name": "BrushNetModel",
+  "_diffusers_version": "0.27.0.dev0",
+  "_name_or_path": "runs/logs/brushnet_randommask/checkpoint-100000",
+  "act_fn": "silu",
+  "addition_embed_type": null,
+  "addition_embed_type_num_heads": 64,
+  "addition_time_embed_dim": null,
+  "attention_head_dim": 8,
+  "block_out_channels": [
+    320,
+    640,
+    1280,
+    1280
+  ],
+  "brushnet_conditioning_channel_order": "rgb",
+  "class_embed_type": null,
+  "conditioning_channels": 5,
+  "conditioning_embedding_out_channels": [
+    16,
+    32,
+    96,
+    256
+  ],
+  "cross_attention_dim": 768,
+  "down_block_types": [
+    "DownBlock2D",
+    "DownBlock2D",
+    "DownBlock2D",
+    "DownBlock2D"
+  ],
+  "downsample_padding": 1,
+  "encoder_hid_dim": null,
+  "encoder_hid_dim_type": null,
+  "flip_sin_to_cos": true,
+  "freq_shift": 0,
+  "global_pool_conditions": false,
+  "in_channels": 4,
+  "layers_per_block": 2,
+  "mid_block_scale_factor": 1,
+  "mid_block_type": "MidBlock2D",
+  "norm_eps": 1e-05,
+  "norm_num_groups": 32,
+  "num_attention_heads": null,
+  "num_class_embeds": null,
+  "only_cross_attention": false,
+  "projection_class_embeddings_input_dim": null,
+  "resnet_time_scale_shift": "default",
+  "transformer_layers_per_block": 1,
+  "up_block_types": [
+    "UpBlock2D",
+    "UpBlock2D",
+    "UpBlock2D",
+    "UpBlock2D"
+  ],
+  "upcast_attention": false,
+  "use_linear_projection": false
+}

py/modules/brushnet/config/brushnet_xl.json

@@ -0,0 +1,63 @@
+{
+  "_class_name": "BrushNetModel",
+  "_diffusers_version": "0.27.0.dev0",
+  "_name_or_path": "runs/logs/brushnetsdxl_randommask/checkpoint-80000",
+  "act_fn": "silu",
+  "addition_embed_type": "text_time",
+  "addition_embed_type_num_heads": 64,
+  "addition_time_embed_dim": 256,
+  "attention_head_dim": [
+    5,
+    10,
+    20
+  ],
+  "block_out_channels": [
+    320,
+    640,
+    1280
+  ],
+  "brushnet_conditioning_channel_order": "rgb",
+  "class_embed_type": null,
+  "conditioning_channels": 5,
+  "conditioning_embedding_out_channels": [
+    16,
+    32,
+    96,
+    256
+  ],
+  "cross_attention_dim": 2048,
+  "down_block_types": [
+    "DownBlock2D",
+    "DownBlock2D",
+    "DownBlock2D"
+  ],
+  "downsample_padding": 1,
+  "encoder_hid_dim": null,
+  "encoder_hid_dim_type": null,
+  "flip_sin_to_cos": true,
+  "freq_shift": 0,
+  "global_pool_conditions": false,
+  "in_channels": 4,
+  "layers_per_block": 2,
+  "mid_block_scale_factor": 1,
+  "mid_block_type": "MidBlock2D",
+  "norm_eps": 1e-05,
+  "norm_num_groups": 32,
+  "num_attention_heads": null,
+  "num_class_embeds": null,
+  "only_cross_attention": false,
+  "projection_class_embeddings_input_dim": 2816,
+  "resnet_time_scale_shift": "default",
+  "transformer_layers_per_block": [
+    1,
+    2,
+    10
+  ],
+  "up_block_types": [
+    "UpBlock2D",
+    "UpBlock2D",
+    "UpBlock2D"
+  ],
+  "upcast_attention": null,
+  "use_linear_projection": true
+}

py/modules/brushnet/config/powerpaint.json

@@ -0,0 +1,57 @@
+{
+  "_class_name": "BrushNetModel",
+  "_diffusers_version": "0.27.2",
+  "act_fn": "silu",
+  "addition_embed_type": null,
+  "addition_embed_type_num_heads": 64,
+  "addition_time_embed_dim": null,
+  "attention_head_dim": 8,
+  "block_out_channels": [
+    320,
+    640,
+    1280,
+    1280
+  ],
+  "brushnet_conditioning_channel_order": "rgb",
+  "class_embed_type": null,
+  "conditioning_channels": 5,
+  "conditioning_embedding_out_channels": [
+    16,
+    32,
+    96,
+    256
+  ],
+  "cross_attention_dim": 768,
+  "down_block_types": [
+    "CrossAttnDownBlock2D",
+    "CrossAttnDownBlock2D",
+    "CrossAttnDownBlock2D",
+    "DownBlock2D"
+  ],
+  "downsample_padding": 1,
+  "encoder_hid_dim": null,
+  "encoder_hid_dim_type": null,
+  "flip_sin_to_cos": true,
+  "freq_shift": 0,
+  "global_pool_conditions": false,
+  "in_channels": 4,
+  "layers_per_block": 2,
+  "mid_block_scale_factor": 1,
+  "mid_block_type": "UNetMidBlock2DCrossAttn",
+  "norm_eps": 1e-05,
+  "norm_num_groups": 32,
+  "num_attention_heads": null,
+  "num_class_embeds": null,
+  "only_cross_attention": false,
+  "projection_class_embeddings_input_dim": null,
+  "resnet_time_scale_shift": "default",
+  "transformer_layers_per_block": 1,
+  "up_block_types": [
+    "UpBlock2D",
+    "CrossAttnUpBlock2D",
+    "CrossAttnUpBlock2D",
+    "CrossAttnUpBlock2D"
+  ],
+  "upcast_attention": false,
+  "use_linear_projection": false
+}

py/modules/brushnet/model_patch.py

@@ -0,0 +1,137 @@
+import torch
+import comfy
+
+# Check and add 'model_patch' to model.model_options['transformer_options']
+def add_model_patch_option(model):
+    if 'transformer_options' not in model.model_options:
+        model.model_options['transformer_options'] = {}
+    to = model.model_options['transformer_options']
+    if "model_patch" not in to:
+        to["model_patch"] = {}
+    return to
+
+
+# Patch model with model_function_wrapper
+def patch_model_function_wrapper(model, forward_patch, remove=False):
+    def brushnet_model_function_wrapper(apply_model_method, options_dict):
+        to = options_dict['c']['transformer_options']
+
+        control = None
+        if 'control' in options_dict['c']:
+            control = options_dict['c']['control']
+
+        x = options_dict['input']
+        timestep = options_dict['timestep']
+
+        # check if there are patches to execute
+        if 'model_patch' not in to or 'forward' not in to['model_patch']:
+            return apply_model_method(x, timestep, **options_dict['c'])
+
+        mp = to['model_patch']
+        unet = mp['unet']
+
+        all_sigmas = mp['all_sigmas']
+        sigma = to['sigmas'][0].item()
+        total_steps = all_sigmas.shape[0] - 1
+        step = torch.argmin((all_sigmas - sigma).abs()).item()
+
+        mp['step'] = step
+        mp['total_steps'] = total_steps
+
+        # comfy.model_base.apply_model
+        xc = model.model.model_sampling.calculate_input(timestep, x)
+        if 'c_concat' in options_dict['c'] and options_dict['c']['c_concat'] is not None:
+            xc = torch.cat([xc] + [options_dict['c']['c_concat']], dim=1)
+        t = model.model.model_sampling.timestep(timestep).float()
+        # execute all patches
+        for method in mp['forward']:
+            method(unet, xc, t, to, control)
+
+        return apply_model_method(x, timestep, **options_dict['c'])
+
+    if "model_function_wrapper" in model.model_options and model.model_options["model_function_wrapper"]:
+        print('BrushNet is going to replace existing model_function_wrapper:',
+              model.model_options["model_function_wrapper"])
+    model.set_model_unet_function_wrapper(brushnet_model_function_wrapper)
+
+    to = add_model_patch_option(model)
+    mp = to['model_patch']
+
+    if isinstance(model.model.model_config, comfy.supported_models.SD15):
+        mp['SDXL'] = False
+    elif isinstance(model.model.model_config, comfy.supported_models.SDXL):
+        mp['SDXL'] = True
+    else:
+        print('Base model type: ', type(model.model.model_config))
+        raise Exception("Unsupported model type: ", type(model.model.model_config))
+
+    if 'forward' not in mp:
+        mp['forward'] = []
+
+    if remove:
+        if forward_patch in mp['forward']:
+            mp['forward'].remove(forward_patch)
+    else:
+        mp['forward'].append(forward_patch)
+
+    mp['unet'] = model.model.diffusion_model
+    mp['step'] = 0
+    mp['total_steps'] = 1
+
+    # apply patches to code
+    if comfy.samplers.sample.__doc__ is None or 'BrushNet' not in comfy.samplers.sample.__doc__:
+        comfy.samplers.original_sample = comfy.samplers.sample
+        comfy.samplers.sample = modified_sample
+
+    if comfy.ldm.modules.diffusionmodules.openaimodel.apply_control.__doc__ is None or \
+            'BrushNet' not in comfy.ldm.modules.diffusionmodules.openaimodel.apply_control.__doc__:
+        comfy.ldm.modules.diffusionmodules.openaimodel.original_apply_control = comfy.ldm.modules.diffusionmodules.openaimodel.apply_control
+        comfy.ldm.modules.diffusionmodules.openaimodel.apply_control = modified_apply_control
+
+
+# Model needs current step number and cfg at inference step. It is possible to write a custom KSampler but I'd like to use ComfyUI's one.
+# The first versions had modified_common_ksampler, but it broke custom KSampler nodes
+def modified_sample(model, noise, positive, negative, cfg, device, sampler, sigmas, model_options={},
+                    latent_image=None, denoise_mask=None, callback=None, disable_pbar=False, seed=None):
+    ''' Modified by BrushNet nodes'''
+    cfg_guider = comfy.samplers.CFGGuider(model)
+    cfg_guider.set_conds(positive, negative)
+    cfg_guider.set_cfg(cfg)
+
+    ### Modified part ######################################################################
+    to = add_model_patch_option(model)
+    to['model_patch']['all_sigmas'] = sigmas
+    #######################################################################################
+
+    return cfg_guider.sample(noise, latent_image, sampler, sigmas, denoise_mask, callback, disable_pbar, seed)
+
+# To use Controlnet with RAUNet it is much easier to modify apply_control a little
+def modified_apply_control(h, control, name):
+    '''Modified by BrushNet nodes'''
+    if control is not None and name in control and len(control[name]) > 0:
+        ctrl = control[name].pop()
+        if ctrl is not None:
+            if h.shape[2] != ctrl.shape[2] or h.shape[3] != ctrl.shape[3]:
+                ctrl = torch.nn.functional.interpolate(ctrl, size=(h.shape[2], h.shape[3]), mode='bicubic').to(
+                    h.dtype).to(h.device)
+            try:
+                h += ctrl
+            except:
+                print.warning("warning control could not be applied {} {}".format(h.shape, ctrl.shape))
+    return h
+
+def add_model_patch(model):
+    to = add_model_patch_option(model)
+    mp = to['model_patch']
+    if "brushnet" in mp:
+        if isinstance(model.model.model_config, comfy.supported_models.SD15):
+            mp['SDXL'] = False
+        elif isinstance(model.model.model_config, comfy.supported_models.SDXL):
+            mp['SDXL'] = True
+        else:
+            print('Base model type: ', type(model.model.model_config))
+            raise Exception("Unsupported model type: ", type(model.model.model_config))
+
+        mp['unet'] = model.model.diffusion_model
+        mp['step'] = 0
+        mp['total_steps'] = 1

py/modules/brushnet/powerpaint_utils.py

@@ -0,0 +1,467 @@
+import copy
+import random
+
+import torch
+import torch.nn as nn
+from transformers import CLIPTokenizer
+from typing import Any, List, Optional, Union
+
+
+class TokenizerWrapper:
+    """Tokenizer wrapper for CLIPTokenizer. Only support CLIPTokenizer
+    currently. This wrapper is modified from https://github.com/huggingface/dif
+    fusers/blob/e51f19aee82c8dd874b715a09dbc521d88835d68/src/diffusers/loaders.
+    py#L358  # noqa.
+
+    Args:
+        from_pretrained (Union[str, os.PathLike], optional): The *model id*
+            of a pretrained model or a path to a *directory* containing
+            model weights and config. Defaults to None.
+        from_config (Union[str, os.PathLike], optional): The *model id*
+            of a pretrained model or a path to a *directory* containing
+            model weights and config. Defaults to None.
+
+        *args, **kwargs: If `from_pretrained` is passed, *args and **kwargs
+            will be passed to `from_pretrained` function. Otherwise, *args
+            and **kwargs will be used to initialize the model by
+            `self._module_cls(*args, **kwargs)`.
+    """
+
+    def __init__(self, tokenizer: CLIPTokenizer):
+        self.wrapped = tokenizer
+        self.token_map = {}
+
+    def __getattr__(self, name: str) -> Any:
+        if name in self.__dict__:
+            return getattr(self, name)
+        # if name == "wrapped":
+        #    return getattr(self, 'wrapped')#super().__getattr__("wrapped")
+
+        try:
+            return getattr(self.wrapped, name)
+        except AttributeError:
+            raise AttributeError(
+                "'name' cannot be found in both "
+                f"'{self.__class__.__name__}' and "
+                f"'{self.__class__.__name__}.tokenizer'."
+            )
+
+    def try_adding_tokens(self, tokens: Union[str, List[str]], *args, **kwargs):
+        """Attempt to add tokens to the tokenizer.
+
+        Args:
+            tokens (Union[str, List[str]]): The tokens to be added.
+        """
+        num_added_tokens = self.wrapped.add_tokens(tokens, *args, **kwargs)
+        assert num_added_tokens != 0, (
+            f"The tokenizer already contains the token {tokens}. Please pass "
+            "a different `placeholder_token` that is not already in the "
+            "tokenizer."
+        )
+
+    def get_token_info(self, token: str) -> dict:
+        """Get the information of a token, including its start and end index in
+        the current tokenizer.
+
+        Args:
+            token (str): The token to be queried.
+
+        Returns:
+            dict: The information of the token, including its start and end
+                index in current tokenizer.
+        """
+        token_ids = self.__call__(token).input_ids
+        start, end = token_ids[1], token_ids[-2] + 1
+        return {"name": token, "start": start, "end": end}
+
+    def add_placeholder_token(self, placeholder_token: str, *args, num_vec_per_token: int = 1, **kwargs):
+        """Add placeholder tokens to the tokenizer.
+
+        Args:
+            placeholder_token (str): The placeholder token to be added.
+            num_vec_per_token (int, optional): The number of vectors of
+                the added placeholder token.
+            *args, **kwargs: The arguments for `self.wrapped.add_tokens`.
+        """
+        output = []
+        if num_vec_per_token == 1:
+            self.try_adding_tokens(placeholder_token, *args, **kwargs)
+            output.append(placeholder_token)
+        else:
+            output = []
+            for i in range(num_vec_per_token):
+                ith_token = placeholder_token + f"_{i}"
+                self.try_adding_tokens(ith_token, *args, **kwargs)
+                output.append(ith_token)
+
+        for token in self.token_map:
+            if token in placeholder_token:
+                raise ValueError(
+                    f"The tokenizer already has placeholder token {token} "
+                    f"that can get confused with {placeholder_token} "
+                    "keep placeholder tokens independent"
+                )
+        self.token_map[placeholder_token] = output
+
+    def replace_placeholder_tokens_in_text(
+            self, text: Union[str, List[str]], vector_shuffle: bool = False, prop_tokens_to_load: float = 1.0
+    ) -> Union[str, List[str]]:
+        """Replace the keywords in text with placeholder tokens. This function
+        will be called in `self.__call__` and `self.encode`.
+
+        Args:
+            text (Union[str, List[str]]): The text to be processed.
+            vector_shuffle (bool, optional): Whether to shuffle the vectors.
+                Defaults to False.
+            prop_tokens_to_load (float, optional): The proportion of tokens to
+                be loaded. If 1.0, all tokens will be loaded. Defaults to 1.0.
+
+        Returns:
+            Union[str, List[str]]: The processed text.
+        """
+        if isinstance(text, list):
+            output = []
+            for i in range(len(text)):
+                output.append(self.replace_placeholder_tokens_in_text(text[i], vector_shuffle=vector_shuffle))
+            return output
+
+        for placeholder_token in self.token_map:
+            if placeholder_token in text:
+                tokens = self.token_map[placeholder_token]
+                tokens = tokens[: 1 + int(len(tokens) * prop_tokens_to_load)]
+                if vector_shuffle:
+                    tokens = copy.copy(tokens)
+                    random.shuffle(tokens)
+                text = text.replace(placeholder_token, " ".join(tokens))
+        return text
+
+    def replace_text_with_placeholder_tokens(self, text: Union[str, List[str]]) -> Union[str, List[str]]:
+        """Replace the placeholder tokens in text with the original keywords.
+        This function will be called in `self.decode`.
+
+        Args:
+            text (Union[str, List[str]]): The text to be processed.
+
+        Returns:
+            Union[str, List[str]]: The processed text.
+        """
+        if isinstance(text, list):
+            output = []
+            for i in range(len(text)):
+                output.append(self.replace_text_with_placeholder_tokens(text[i]))
+            return output
+
+        for placeholder_token, tokens in self.token_map.items():
+            merged_tokens = " ".join(tokens)
+            if merged_tokens in text:
+                text = text.replace(merged_tokens, placeholder_token)
+        return text
+
+    def __call__(
+            self,
+            text: Union[str, List[str]],
+            *args,
+            vector_shuffle: bool = False,
+            prop_tokens_to_load: float = 1.0,
+            **kwargs,
+    ):
+        """The call function of the wrapper.
+
+        Args:
+            text (Union[str, List[str]]): The text to be tokenized.
+            vector_shuffle (bool, optional): Whether to shuffle the vectors.
+                Defaults to False.
+            prop_tokens_to_load (float, optional): The proportion of tokens to
+                be loaded. If 1.0, all tokens will be loaded. Defaults to 1.0
+            *args, **kwargs: The arguments for `self.wrapped.__call__`.
+        """
+        replaced_text = self.replace_placeholder_tokens_in_text(
+            text, vector_shuffle=vector_shuffle, prop_tokens_to_load=prop_tokens_to_load
+        )
+
+        return self.wrapped.__call__(replaced_text, *args, **kwargs)
+
+    def encode(self, text: Union[str, List[str]], *args, **kwargs):
+        """Encode the passed text to token index.
+
+        Args:
+            text (Union[str, List[str]]): The text to be encode.
+            *args, **kwargs: The arguments for `self.wrapped.__call__`.
+        """
+        replaced_text = self.replace_placeholder_tokens_in_text(text)
+        return self.wrapped(replaced_text, *args, **kwargs)
+
+    def decode(self, token_ids, return_raw: bool = False, *args, **kwargs) -> Union[str, List[str]]:
+        """Decode the token index to text.
+
+        Args:
+            token_ids: The token index to be decoded.
+            return_raw: Whether keep the placeholder token in the text.
+                Defaults to False.
+            *args, **kwargs: The arguments for `self.wrapped.decode`.
+
+        Returns:
+            Union[str, List[str]]: The decoded text.
+        """
+        text = self.wrapped.decode(token_ids, *args, **kwargs)
+        if return_raw:
+            return text
+        replaced_text = self.replace_text_with_placeholder_tokens(text)
+        return replaced_text
+
+    def __repr__(self):
+        """The representation of the wrapper."""
+        s = super().__repr__()
+        prefix = f"Wrapped Module Class: {self._module_cls}\n"
+        prefix += f"Wrapped Module Name: {self._module_name}\n"
+        if self._from_pretrained:
+            prefix += f"From Pretrained: {self._from_pretrained}\n"
+        s = prefix + s
+        return s
+
+
+class EmbeddingLayerWithFixes(nn.Module):
+    """The revised embedding layer to support external embeddings. This design
+    of this class is inspired by https://github.com/AUTOMATIC1111/stable-
+    diffusion-webui/blob/22bcc7be428c94e9408f589966c2040187245d81/modules/sd_hi
+    jack.py#L224  # noqa.
+
+    Args:
+        wrapped (nn.Emebdding): The embedding layer to be wrapped.
+        external_embeddings (Union[dict, List[dict]], optional): The external
+            embeddings added to this layer. Defaults to None.
+    """
+
+    def __init__(self, wrapped: nn.Embedding, external_embeddings: Optional[Union[dict, List[dict]]] = None):
+        super().__init__()
+        self.wrapped = wrapped
+        self.num_embeddings = wrapped.weight.shape[0]
+
+        self.external_embeddings = []
+        if external_embeddings:
+            self.add_embeddings(external_embeddings)
+
+        self.trainable_embeddings = nn.ParameterDict()
+
+    @property
+    def weight(self):
+        """Get the weight of wrapped embedding layer."""
+        return self.wrapped.weight
+
+    def check_duplicate_names(self, embeddings: List[dict]):
+        """Check whether duplicate names exist in list of 'external
+        embeddings'.
+
+        Args:
+            embeddings (List[dict]): A list of embedding to be check.
+        """
+        names = [emb["name"] for emb in embeddings]
+        assert len(names) == len(set(names)), (
+            "Found duplicated names in 'external_embeddings'. Name list: " f"'{names}'"
+        )
+
+    def check_ids_overlap(self, embeddings):
+        """Check whether overlap exist in token ids of 'external_embeddings'.
+
+        Args:
+            embeddings (List[dict]): A list of embedding to be check.
+        """
+        ids_range = [[emb["start"], emb["end"], emb["name"]] for emb in embeddings]
+        ids_range.sort()  # sort by 'start'
+        # check if 'end' has overlapping
+        for idx in range(len(ids_range) - 1):
+            name1, name2 = ids_range[idx][-1], ids_range[idx + 1][-1]
+            assert ids_range[idx][1] <= ids_range[idx + 1][0], (
+                f"Found ids overlapping between embeddings '{name1}' " f"and '{name2}'."
+            )
+
+    def add_embeddings(self, embeddings: Optional[Union[dict, List[dict]]]):
+        """Add external embeddings to this layer.
+        Use case:
+        Args:
+            embeddings (Union[dict, list[dict]]): The external embeddings to
+                be added. Each dict must contain the following 4 fields: 'name'
+                (the name of this embedding), 'embedding' (the embedding
+                tensor), 'start' (the start token id of this embedding), 'end'
+                (the end token id of this embedding). For example:
+                `{name: NAME, start: START, end: END, embedding: torch.Tensor}`
+        """
+        if isinstance(embeddings, dict):
+            embeddings = [embeddings]
+
+        self.external_embeddings += embeddings
+        self.check_duplicate_names(self.external_embeddings)
+        self.check_ids_overlap(self.external_embeddings)
+
+        # set for trainable
+        added_trainable_emb_info = []
+        for embedding in embeddings:
+            trainable = embedding.get("trainable", False)
+            if trainable:
+                name = embedding["name"]
+                embedding["embedding"] = torch.nn.Parameter(embedding["embedding"])
+                self.trainable_embeddings[name] = embedding["embedding"]
+                added_trainable_emb_info.append(name)
+
+        added_emb_info = [emb["name"] for emb in embeddings]
+        added_emb_info = ", ".join(added_emb_info)
+        print(f"Successfully add external embeddings: {added_emb_info}.", "current")
+
+        if added_trainable_emb_info:
+            added_trainable_emb_info = ", ".join(added_trainable_emb_info)
+            print("Successfully add trainable external embeddings: " f"{added_trainable_emb_info}", "current")
+
+    def replace_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:
+        """Replace external input ids to 0.
+
+        Args:
+            input_ids (torch.Tensor): The input ids to be replaced.
+
+        Returns:
+            torch.Tensor: The replaced input ids.
+        """
+        input_ids_fwd = input_ids.clone()
+        input_ids_fwd[input_ids_fwd >= self.num_embeddings] = 0
+        return input_ids_fwd
+
+    def replace_embeddings(
+            self, input_ids: torch.Tensor, embedding: torch.Tensor, external_embedding: dict
+    ) -> torch.Tensor:
+        """Replace external embedding to the embedding layer. Noted that, in
+        this function we use `torch.cat` to avoid inplace modification.
+
+        Args:
+            input_ids (torch.Tensor): The original token ids. Shape like
+                [LENGTH, ].
+            embedding (torch.Tensor): The embedding of token ids after
+                `replace_input_ids` function.
+            external_embedding (dict): The external embedding to be replaced.
+
+        Returns:
+            torch.Tensor: The replaced embedding.
+        """
+        new_embedding = []
+
+        name = external_embedding["name"]
+        start = external_embedding["start"]
+        end = external_embedding["end"]
+        target_ids_to_replace = [i for i in range(start, end)]
+        ext_emb = external_embedding["embedding"].to(embedding.device)
+
+        # do not need to replace
+        if not (input_ids == start).any():
+            return embedding
+
+        # start replace
+        s_idx, e_idx = 0, 0
+        while e_idx < len(input_ids):
+            if input_ids[e_idx] == start:
+                if e_idx != 0:
+                    # add embedding do not need to replace
+                    new_embedding.append(embedding[s_idx:e_idx])
+
+                # check if the next embedding need to replace is valid
+                actually_ids_to_replace = [int(i) for i in input_ids[e_idx: e_idx + end - start]]
+                assert actually_ids_to_replace == target_ids_to_replace, (
+                    f"Invalid 'input_ids' in position: {s_idx} to {e_idx}. "
+                    f"Expect '{target_ids_to_replace}' for embedding "
+                    f"'{name}' but found '{actually_ids_to_replace}'."
+                )
+
+                new_embedding.append(ext_emb)
+
+                s_idx = e_idx + end - start
+                e_idx = s_idx + 1
+            else:
+                e_idx += 1
+
+        if e_idx == len(input_ids):
+            new_embedding.append(embedding[s_idx:e_idx])
+
+        return torch.cat(new_embedding, dim=0)
+
+    def forward(self, input_ids: torch.Tensor, external_embeddings: Optional[List[dict]] = None, out_dtype = None):
+        """The forward function.
+
+        Args:
+            input_ids (torch.Tensor): The token ids shape like [bz, LENGTH] or
+                [LENGTH, ].
+            external_embeddings (Optional[List[dict]]): The external
+                embeddings. If not passed, only `self.external_embeddings`
+                will be used.  Defaults to None.
+
+        input_ids: shape like [bz, LENGTH] or [LENGTH].
+        """
+        assert input_ids.ndim in [1, 2]
+        if input_ids.ndim == 1:
+            input_ids = input_ids.unsqueeze(0)
+
+        if external_embeddings is None and not self.external_embeddings:
+            return self.wrapped(input_ids, out_dtype=out_dtype)
+
+        input_ids_fwd = self.replace_input_ids(input_ids)
+        inputs_embeds = self.wrapped(input_ids_fwd)
+
+        vecs = []
+
+        if external_embeddings is None:
+            external_embeddings = []
+        elif isinstance(external_embeddings, dict):
+            external_embeddings = [external_embeddings]
+        embeddings = self.external_embeddings + external_embeddings
+
+        for input_id, embedding in zip(input_ids, inputs_embeds):
+            new_embedding = embedding
+            for external_embedding in embeddings:
+                new_embedding = self.replace_embeddings(input_id, new_embedding, external_embedding)
+            vecs.append(new_embedding)
+
+        return torch.stack(vecs).to(out_dtype)
+
+
+def add_tokens(
+        tokenizer, text_encoder, placeholder_tokens: list, initialize_tokens: list = None,
+        num_vectors_per_token: int = 1
+):
+    """Add token for training.
+
+    # TODO: support add tokens as dict, then we can load pretrained tokens.
+    """
+    if initialize_tokens is not None:
+        assert len(initialize_tokens) == len(
+            placeholder_tokens
+        ), "placeholder_token should be the same length as initialize_token"
+    for ii in range(len(placeholder_tokens)):
+        tokenizer.add_placeholder_token(placeholder_tokens[ii], num_vec_per_token=num_vectors_per_token)
+
+    # text_encoder.set_embedding_layer()
+    embedding_layer = text_encoder.text_model.embeddings.token_embedding
+    text_encoder.text_model.embeddings.token_embedding = EmbeddingLayerWithFixes(embedding_layer)
+    embedding_layer = text_encoder.text_model.embeddings.token_embedding
+
+    assert embedding_layer is not None, (
+        "Do not support get embedding layer for current text encoder. " "Please check your configuration."
+    )
+    initialize_embedding = []
+    if initialize_tokens is not None:
+        for ii in range(len(placeholder_tokens)):
+            init_id = tokenizer(initialize_tokens[ii]).input_ids[1]
+            temp_embedding = embedding_layer.weight[init_id]
+            initialize_embedding.append(temp_embedding[None, ...].repeat(num_vectors_per_token, 1))
+    else:
+        for ii in range(len(placeholder_tokens)):
+            init_id = tokenizer("a").input_ids[1]
+            temp_embedding = embedding_layer.weight[init_id]
+            len_emb = temp_embedding.shape[0]
+            init_weight = (torch.rand(num_vectors_per_token, len_emb) - 0.5) / 2.0
+            initialize_embedding.append(init_weight)
+
+    # initialize_embedding  = torch.cat(initialize_embedding,dim=0)
+
+    token_info_all = []
+    for ii in range(len(placeholder_tokens)):
+        token_info = tokenizer.get_token_info(placeholder_tokens[ii])
+        token_info["embedding"] = initialize_embedding[ii]
+        token_info["trainable"] = True
+        token_info_all.append(token_info)
+    embedding_layer.add_embeddings(token_info_all)

py/modules/dit/__init__.py

@@ -0,0 +1,2 @@
+#credit to city96 for this module
+#from https://github.com/city96/ComfyUI_ExtraModels/

py/modules/dit/config.py

@@ -0,0 +1,120 @@
+"""
+List of all DiT model types / settings
+"""
+sampling_settings = {
+	"beta_schedule" : "sqrt_linear",
+	"linear_start"  : 0.0001,
+	"linear_end"    : 0.02,
+	"timesteps"     : 1000,
+}
+
+dit_conf = {
+	"XL/2": { # DiT_XL_2
+		"unet_config": {
+			"depth"       :   28,
+			"num_heads"   :   16,
+			"patch_size"  :    2,
+			"hidden_size" : 1152,
+		},
+		"sampling_settings" : sampling_settings,
+	},
+	"XL/4": { # DiT_XL_4
+		"unet_config": {
+			"depth"       :   28,
+			"num_heads"   :   16,
+			"patch_size"  :    4,
+			"hidden_size" : 1152,
+		},
+		"sampling_settings" : sampling_settings,
+	},
+	"XL/8": { # DiT_XL_8
+		"unet_config": {
+			"depth"       :   28,
+			"num_heads"   :   16,
+			"patch_size"  :    8,
+			"hidden_size" : 1152,
+		},
+		"sampling_settings" : sampling_settings,
+	},
+	"L/2": { # DiT_L_2
+		"unet_config": {
+			"depth"       :   24,
+			"num_heads"   :   16,
+			"patch_size"  :    2,
+			"hidden_size" : 1024,
+		},
+		"sampling_settings" : sampling_settings,
+	},
+	"L/4": { # DiT_L_4
+		"unet_config": {
+			"depth"       :   24,
+			"num_heads"   :   16,
+			"patch_size"  :    4,
+			"hidden_size" : 1024,
+		},
+		"sampling_settings" : sampling_settings,
+	},
+	"L/8": { # DiT_L_8
+		"unet_config": {
+			"depth"       :   24,
+			"num_heads"   :   16,
+			"patch_size"  :    8,
+			"hidden_size" : 1024,
+		},
+		"sampling_settings" : sampling_settings,
+	},
+	"B/2": { # DiT_B_2
+		"unet_config": {
+			"depth"       :   12,
+			"num_heads"   :   12,
+			"patch_size"  :    2,
+			"hidden_size" :  768,
+		},
+		"sampling_settings" : sampling_settings,
+	},
+	"B/4": { # DiT_B_4
+		"unet_config": {
+			"depth"       :   12,
+			"num_heads"   :   12,
+			"patch_size"  :    4,
+			"hidden_size" :  768,
+		},
+		"sampling_settings" : sampling_settings,
+	},
+	"B/8": { # DiT_B_8
+		"unet_config": {
+			"depth"       :   12,
+			"num_heads"   :   12,
+			"patch_size"  :    8,
+			"hidden_size" :  768,
+		},
+		"sampling_settings" : sampling_settings,
+	},
+	"S/2": { # DiT_S_2
+		"unet_config": {
+			"depth"       :   12,
+			"num_heads"   :    6,
+			"patch_size"  :    2,
+			"hidden_size" :  384,
+		},
+		"sampling_settings" : sampling_settings,
+	},
+	"S/4": { # DiT_S_4
+		"unet_config": {
+			"depth"       :   12,
+			"num_heads"   :    6,
+			"patch_size"  :    4,
+			"hidden_size" :  384,
+		},
+		"sampling_settings" : sampling_settings,
+	},
+	"S/8": { # DiT_S_8
+		"unet_config": {
+			"depth"       :   12,
+			"num_heads"   :    6,
+			"patch_size"  :    8,
+			"hidden_size" :  384,
+		},
+		"sampling_settings" : sampling_settings,
+	},
+}

py/modules/dit/pixArt/LICENSE-Pixart

@@ -0,0 +1,661 @@
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+our General Public Licenses are intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU Affero General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero General Public License from time to time.  Such new versions
+will be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU Affero General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU Affero General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published
+    by the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU AGPL, see
+<https://www.gnu.org/licenses/>.

py/modules/dit/pixArt/config.py

@@ -0,0 +1,139 @@
+"""
+List of all PixArt model types / settings
+"""
+sampling_settings = {
+	"beta_schedule" : "sqrt_linear",
+	"linear_start"  : 0.0001,
+	"linear_end"    : 0.02,
+	"timesteps"     : 1000,
+}
+
+pixart_conf = {
+	"PixArtMS_XL_2": { # models/PixArtMS
+		"target": "PixArtMS",
+		"unet_config": {
+			"input_size"  : 1024//8,
+			"depth"       :   28,
+			"num_heads"   :   16,
+			"patch_size"  :    2,
+			"hidden_size" : 1152,
+			"pe_interpolation": 2,
+		},
+		"sampling_settings" : sampling_settings,
+	},
+	"PixArtMS_Sigma_XL_2": {
+		"target": "PixArtMSSigma",
+		"unet_config": {
+			"input_size"  : 1024//8,
+			"token_num"   :  300,
+			"depth"       :   28,
+			"num_heads"   :   16,
+			"patch_size"  :    2,
+			"hidden_size" : 1152,
+			"micro_condition": False,
+			"pe_interpolation": 2,
+			"model_max_length": 300,
+		},
+		"sampling_settings" : sampling_settings,
+	},
+	"PixArtMS_Sigma_XL_2_900M": {
+		"target": "PixArtMSSigma",
+		"unet_config": {
+			"input_size": 1024 // 8,
+			"token_num": 300,
+			"depth": 42,
+			"num_heads": 16,
+			"patch_size": 2,
+			"hidden_size": 1152,
+			"micro_condition": False,
+			"pe_interpolation": 2,
+			"model_max_length": 300,
+		},
+		"sampling_settings": sampling_settings,
+	},
+	"PixArtMS_Sigma_XL_2_2K": {
+		"target": "PixArtMSSigma",
+		"unet_config": {
+			"input_size"  : 2048//8,
+			"token_num"   :  300,
+			"depth"       :   28,
+			"num_heads"   :   16,
+			"patch_size"  :    2,
+			"hidden_size" : 1152,
+			"micro_condition": False,
+			"pe_interpolation": 4,
+			"model_max_length": 300,
+		},
+		"sampling_settings" : sampling_settings,
+	},
+	"PixArt_XL_2": { # models/PixArt
+		"target": "PixArt",
+		"unet_config": {
+			"input_size"  :  512//8,
+			"token_num"   :  120,
+			"depth"       :   28,
+			"num_heads"   :   16,
+			"patch_size"  :    2,
+			"hidden_size" : 1152,
+			"pe_interpolation": 1,
+		},
+		"sampling_settings" : sampling_settings,
+	},
+}
+
+pixart_conf.update({ # controlnet models
+	"ControlPixArtHalf": {
+		"target": "ControlPixArtHalf",
+		"unet_config": pixart_conf["PixArt_XL_2"]["unet_config"],
+		"sampling_settings": pixart_conf["PixArt_XL_2"]["sampling_settings"],
+	},
+	"ControlPixArtMSHalf": {
+		"target": "ControlPixArtMSHalf",
+		"unet_config": pixart_conf["PixArtMS_XL_2"]["unet_config"],
+		"sampling_settings": pixart_conf["PixArtMS_XL_2"]["sampling_settings"],
+	}
+})
+
+pixart_res = {
+	"PixArtMS_XL_2": { # models/PixArtMS 1024x1024
+		'0.25': [512, 2048], '0.26': [512, 1984], '0.27': [512, 1920], '0.28': [512, 1856],
+		'0.32': [576, 1792], '0.33': [576, 1728], '0.35': [576, 1664], '0.40': [640, 1600],
+		'0.42': [640, 1536], '0.48': [704, 1472], '0.50': [704, 1408], '0.52': [704, 1344],
+		'0.57': [768, 1344], '0.60': [768, 1280], '0.68': [832, 1216], '0.72': [832, 1152],
+		'0.78': [896, 1152], '0.82': [896, 1088], '0.88': [960, 1088], '0.94': [960, 1024],
+		'1.00': [1024,1024], '1.07': [1024, 960], '1.13': [1088, 960], '1.21': [1088, 896],
+		'1.29': [1152, 896], '1.38': [1152, 832], '1.46': [1216, 832], '1.67': [1280, 768],
+		'1.75': [1344, 768], '2.00': [1408, 704], '2.09': [1472, 704], '2.40': [1536, 640],
+		'2.50': [1600, 640], '2.89': [1664, 576], '3.00': [1728, 576], '3.11': [1792, 576],
+		'3.62': [1856, 512], '3.75': [1920, 512], '3.88': [1984, 512], '4.00': [2048, 512],
+	},
+	"PixArt_XL_2": { # models/PixArt 512x512
+		'0.25': [256,1024], '0.26': [256, 992], '0.27': [256, 960], '0.28': [256, 928],
+		'0.32': [288, 896], '0.33': [288, 864], '0.35': [288, 832], '0.40': [320, 800],
+		'0.42': [320, 768], '0.48': [352, 736], '0.50': [352, 704], '0.52': [352, 672],
+		'0.57': [384, 672], '0.60': [384, 640], '0.68': [416, 608], '0.72': [416, 576],
+		'0.78': [448, 576], '0.82': [448, 544], '0.88': [480, 544], '0.94': [480, 512],
+		'1.00': [512, 512], '1.07': [512, 480], '1.13': [544, 480], '1.21': [544, 448],
+		'1.29': [576, 448], '1.38': [576, 416], '1.46': [608, 416], '1.67': [640, 384],
+		'1.75': [672, 384], '2.00': [704, 352], '2.09': [736, 352], '2.40': [768, 320],
+		'2.50': [800, 320], '2.89': [832, 288], '3.00': [864, 288], '3.11': [896, 288],
+		'3.62': [928, 256], '3.75': [960, 256], '3.88': [992, 256], '4.00': [1024,256]
+	},
+	"PixArtMS_Sigma_XL_2_2K": {
+		'0.25': [1024, 4096], '0.26': [1024, 3968], '0.27': [1024, 3840], '0.28': [1024, 3712],
+		'0.32': [1152, 3584], '0.33': [1152, 3456], '0.35': [1152, 3328], '0.40': [1280, 3200],
+		'0.42': [1280, 3072], '0.48': [1408, 2944], '0.50': [1408, 2816], '0.52': [1408, 2688],
+		'0.57': [1536, 2688], '0.60': [1536, 2560], '0.68': [1664, 2432], '0.72': [1664, 2304],
+		'0.78': [1792, 2304], '0.82': [1792, 2176], '0.88': [1920, 2176], '0.94': [1920, 2048],
+		'1.00': [2048, 2048], '1.07': [2048, 1920], '1.13': [2176, 1920], '1.21': [2176, 1792],
+		'1.29': [2304, 1792], '1.38': [2304, 1664], '1.46': [2432, 1664], '1.67': [2560, 1536],
+		'1.75': [2688, 1536], '2.00': [2816, 1408], '2.09': [2944, 1408], '2.40': [3072, 1280],
+		'2.50': [3200, 1280], '2.89': [3328, 1152], '3.00': [3456, 1152], '3.11': [3584, 1152],
+		'3.62': [3712, 1024], '3.75': [3840, 1024], '3.88': [3968, 1024], '4.00': [4096, 1024]
+	}
+}
+# These should be the same
+pixart_res.update({
+	"PixArtMS_Sigma_XL_2": pixart_res["PixArtMS_XL_2"],
+	"PixArtMS_Sigma_XL_2_512": pixart_res["PixArt_XL_2"],
+})

py/modules/dit/pixArt/diffusers_convert.py

@@ -0,0 +1,216 @@
+# For using the diffusers format weights
+#  Based on the original ComfyUI function +
+#  https://github.com/PixArt-alpha/PixArt-alpha/blob/master/tools/convert_pixart_alpha_to_diffusers.py
+import torch
+
+conversion_map_ms = [  # for multi_scale_train (MS)
+    # Resolution
+    ("csize_embedder.mlp.0.weight", "adaln_single.emb.resolution_embedder.linear_1.weight"),
+    ("csize_embedder.mlp.0.bias", "adaln_single.emb.resolution_embedder.linear_1.bias"),
+    ("csize_embedder.mlp.2.weight", "adaln_single.emb.resolution_embedder.linear_2.weight"),
+    ("csize_embedder.mlp.2.bias", "adaln_single.emb.resolution_embedder.linear_2.bias"),
+    # Aspect ratio
+    ("ar_embedder.mlp.0.weight", "adaln_single.emb.aspect_ratio_embedder.linear_1.weight"),
+    ("ar_embedder.mlp.0.bias", "adaln_single.emb.aspect_ratio_embedder.linear_1.bias"),
+    ("ar_embedder.mlp.2.weight", "adaln_single.emb.aspect_ratio_embedder.linear_2.weight"),
+    ("ar_embedder.mlp.2.bias", "adaln_single.emb.aspect_ratio_embedder.linear_2.bias"),
+]
+
+
+def get_depth(state_dict):
+    return sum(key.endswith('.attn1.to_k.bias') for key in state_dict.keys())
+
+
+def get_lora_depth(state_dict):
+    return sum(key.endswith('.attn1.to_k.lora_A.weight') for key in state_dict.keys())
+
+
+def get_conversion_map(state_dict):
+    conversion_map = [  # main SD conversion map (PixArt reference, HF Diffusers)
+        # Patch embeddings
+        ("x_embedder.proj.weight", "pos_embed.proj.weight"),
+        ("x_embedder.proj.bias", "pos_embed.proj.bias"),
+        # Caption projection
+        ("y_embedder.y_embedding", "caption_projection.y_embedding"),
+        ("y_embedder.y_proj.fc1.weight", "caption_projection.linear_1.weight"),
+        ("y_embedder.y_proj.fc1.bias", "caption_projection.linear_1.bias"),
+        ("y_embedder.y_proj.fc2.weight", "caption_projection.linear_2.weight"),
+        ("y_embedder.y_proj.fc2.bias", "caption_projection.linear_2.bias"),
+        # AdaLN-single LN
+        ("t_embedder.mlp.0.weight", "adaln_single.emb.timestep_embedder.linear_1.weight"),
+        ("t_embedder.mlp.0.bias", "adaln_single.emb.timestep_embedder.linear_1.bias"),
+        ("t_embedder.mlp.2.weight", "adaln_single.emb.timestep_embedder.linear_2.weight"),
+        ("t_embedder.mlp.2.bias", "adaln_single.emb.timestep_embedder.linear_2.bias"),
+        # Shared norm
+        ("t_block.1.weight", "adaln_single.linear.weight"),
+        ("t_block.1.bias", "adaln_single.linear.bias"),
+        # Final block
+        ("final_layer.linear.weight", "proj_out.weight"),
+        ("final_layer.linear.bias", "proj_out.bias"),
+        ("final_layer.scale_shift_table", "scale_shift_table"),
+    ]
+
+    # Add actual transformer blocks
+    for depth in range(get_depth(state_dict)):
+        # Transformer blocks
+        conversion_map += [
+            (f"blocks.{depth}.scale_shift_table", f"transformer_blocks.{depth}.scale_shift_table"),
+            # Projection
+            (f"blocks.{depth}.attn.proj.weight", f"transformer_blocks.{depth}.attn1.to_out.0.weight"),
+            (f"blocks.{depth}.attn.proj.bias", f"transformer_blocks.{depth}.attn1.to_out.0.bias"),
+            # Feed-forward
+            (f"blocks.{depth}.mlp.fc1.weight", f"transformer_blocks.{depth}.ff.net.0.proj.weight"),
+            (f"blocks.{depth}.mlp.fc1.bias", f"transformer_blocks.{depth}.ff.net.0.proj.bias"),
+            (f"blocks.{depth}.mlp.fc2.weight", f"transformer_blocks.{depth}.ff.net.2.weight"),
+            (f"blocks.{depth}.mlp.fc2.bias", f"transformer_blocks.{depth}.ff.net.2.bias"),
+            # Cross-attention (proj)
+            (f"blocks.{depth}.cross_attn.proj.weight", f"transformer_blocks.{depth}.attn2.to_out.0.weight"),
+            (f"blocks.{depth}.cross_attn.proj.bias", f"transformer_blocks.{depth}.attn2.to_out.0.bias"),
+        ]
+    return conversion_map
+
+
+def find_prefix(state_dict, target_key):
+    prefix = ""
+    for k in state_dict.keys():
+        if k.endswith(target_key):
+            prefix = k.split(target_key)[0]
+            break
+    return prefix
+
+
+def convert_state_dict(state_dict):
+    if "adaln_single.emb.resolution_embedder.linear_1.weight" in state_dict.keys():
+        cmap = get_conversion_map(state_dict) + conversion_map_ms
+    else:
+        cmap = get_conversion_map(state_dict)
+
+    missing = [k for k, v in cmap if v not in state_dict]
+    new_state_dict = {k: state_dict[v] for k, v in cmap if k not in missing}
+    matched = list(v for k, v in cmap if v in state_dict.keys())
+
+    for depth in range(get_depth(state_dict)):
+        for wb in ["weight", "bias"]:
+            # Self Attention
+            key = lambda a: f"transformer_blocks.{depth}.attn1.to_{a}.{wb}"
+            new_state_dict[f"blocks.{depth}.attn.qkv.{wb}"] = torch.cat((
+                state_dict[key('q')], state_dict[key('k')], state_dict[key('v')]
+            ), dim=0)
+            matched += [key('q'), key('k'), key('v')]
+
+            # Cross-attention (linear)
+            key = lambda a: f"transformer_blocks.{depth}.attn2.to_{a}.{wb}"
+            new_state_dict[f"blocks.{depth}.cross_attn.q_linear.{wb}"] = state_dict[key('q')]
+            new_state_dict[f"blocks.{depth}.cross_attn.kv_linear.{wb}"] = torch.cat((
+                state_dict[key('k')], state_dict[key('v')]
+            ), dim=0)
+            matched += [key('q'), key('k'), key('v')]
+
+    if len(matched) < len(state_dict):
+        print(f"PixArt: UNET conversion has leftover keys! ({len(matched)} vs {len(state_dict)})")
+        print(list(set(state_dict.keys()) - set(matched)))
+
+    if len(missing) > 0:
+        print(f"PixArt: UNET conversion has missing keys!")
+        print(missing)
+
+    return new_state_dict
+
+
+# Same as above but for LoRA weights:
+def convert_lora_state_dict(state_dict, peft=True):
+    # koyha
+    rep_ak = lambda x: x.replace(".weight", ".lora_down.weight")
+    rep_bk = lambda x: x.replace(".weight", ".lora_up.weight")
+    rep_pk = lambda x: x.replace(".weight", ".alpha")
+    if peft:  # peft
+        rep_ap = lambda x: x.replace(".weight", ".lora_A.weight")
+        rep_bp = lambda x: x.replace(".weight", ".lora_B.weight")
+        rep_pp = lambda x: x.replace(".weight", ".alpha")
+
+        prefix = find_prefix(state_dict, "adaln_single.linear.lora_A.weight")
+        state_dict = {k[len(prefix):]: v for k, v in state_dict.items()}
+    else:  # OneTrainer
+        rep_ap = lambda x: x.replace(".", "_")[:-7] + ".lora_down.weight"
+        rep_bp = lambda x: x.replace(".", "_")[:-7] + ".lora_up.weight"
+        rep_pp = lambda x: x.replace(".", "_")[:-7] + ".alpha"
+
+        prefix = "lora_transformer_"
+        t5_marker = "lora_te_encoder"
+        t5_keys = []
+        for key in list(state_dict.keys()):
+            if key.startswith(prefix):
+                state_dict[key[len(prefix):]] = state_dict.pop(key)
+            elif t5_marker in key:
+                t5_keys.append(state_dict.pop(key))
+        if len(t5_keys) > 0:
+            print(f"Text Encoder not supported for PixArt LoRA, ignoring {len(t5_keys)} keys")
+
+    cmap = []
+    cmap_unet = get_conversion_map(state_dict) + conversion_map_ms  # todo: 512 model
+    for k, v in cmap_unet:
+        if v.endswith(".weight"):
+            cmap.append((rep_ak(k), rep_ap(v)))
+            cmap.append((rep_bk(k), rep_bp(v)))
+            if not peft:
+                cmap.append((rep_pk(k), rep_pp(v)))
+
+    missing = [k for k, v in cmap if v not in state_dict]
+    new_state_dict = {k: state_dict[v] for k, v in cmap if k not in missing}
+    matched = list(v for k, v in cmap if v in state_dict.keys())
+
+    lora_depth = get_lora_depth(state_dict)
+    for fp, fk in ((rep_ap, rep_ak), (rep_bp, rep_bk)):
+        for depth in range(lora_depth):
+            # Self Attention
+            key = lambda a: fp(f"transformer_blocks.{depth}.attn1.to_{a}.weight")
+            new_state_dict[fk(f"blocks.{depth}.attn.qkv.weight")] = torch.cat((
+                state_dict[key('q')], state_dict[key('k')], state_dict[key('v')]
+            ), dim=0)
+
+            matched += [key('q'), key('k'), key('v')]
+            if not peft:
+                akey = lambda a: rep_pp(f"transformer_blocks.{depth}.attn1.to_{a}.weight")
+                new_state_dict[rep_pk((f"blocks.{depth}.attn.qkv.weight"))] = state_dict[akey("q")]
+                matched += [akey('q'), akey('k'), akey('v')]
+
+            # Self Attention projection?
+            key = lambda a: fp(f"transformer_blocks.{depth}.attn1.to_{a}.weight")
+            new_state_dict[fk(f"blocks.{depth}.attn.proj.weight")] = state_dict[key('out.0')]
+            matched += [key('out.0')]
+
+            # Cross-attention (linear)
+            key = lambda a: fp(f"transformer_blocks.{depth}.attn2.to_{a}.weight")
+            new_state_dict[fk(f"blocks.{depth}.cross_attn.q_linear.weight")] = state_dict[key('q')]
+            new_state_dict[fk(f"blocks.{depth}.cross_attn.kv_linear.weight")] = torch.cat((
+                state_dict[key('k')], state_dict[key('v')]
+            ), dim=0)
+            matched += [key('q'), key('k'), key('v')]
+            if not peft:
+                akey = lambda a: rep_pp(f"transformer_blocks.{depth}.attn2.to_{a}.weight")
+                new_state_dict[rep_pk((f"blocks.{depth}.cross_attn.q_linear.weight"))] = state_dict[akey("q")]
+                new_state_dict[rep_pk((f"blocks.{depth}.cross_attn.kv_linear.weight"))] = state_dict[akey("k")]
+                matched += [akey('q'), akey('k'), akey('v')]
+
+            # Cross Attention projection?
+            key = lambda a: fp(f"transformer_blocks.{depth}.attn2.to_{a}.weight")
+            new_state_dict[fk(f"blocks.{depth}.cross_attn.proj.weight")] = state_dict[key('out.0')]
+            matched += [key('out.0')]
+
+            key = fp(f"transformer_blocks.{depth}.ff.net.0.proj.weight")
+            new_state_dict[fk(f"blocks.{depth}.mlp.fc1.weight")] = state_dict[key]
+            matched += [key]
+
+            key = fp(f"transformer_blocks.{depth}.ff.net.2.weight")
+            new_state_dict[fk(f"blocks.{depth}.mlp.fc2.weight")] = state_dict[key]
+            matched += [key]
+
+    if len(matched) < len(state_dict):
+        print(f"PixArt: LoRA conversion has leftover keys! ({len(matched)} vs {len(state_dict)})")
+        print(list(set(state_dict.keys()) - set(matched)))
+
+    if len(missing) > 0:
+        print(f"PixArt: LoRA conversion has missing keys! (probably)")
+        print(missing)
+
+    return new_state_dict

py/modules/dit/pixArt/loader.py

@@ -0,0 +1,331 @@
+import os
+import json
+import copy
+import torch
+import math
+import comfy.supported_models_base
+import comfy.latent_formats
+import comfy.model_patcher
+import comfy.model_base
+import comfy.utils
+import comfy.conds
+from comfy import model_management
+from .diffusers_convert import convert_state_dict, convert_lora_state_dict
+
+# checkpointbf
+class EXM_PixArt(comfy.supported_models_base.BASE):
+    unet_config = {}
+    unet_extra_config = {}
+    latent_format = comfy.latent_formats.SD15
+
+    def __init__(self, model_conf):
+        self.model_target = model_conf.get("target")
+        self.unet_config = model_conf.get("unet_config", {})
+        self.sampling_settings = model_conf.get("sampling_settings", {})
+        self.latent_format = self.latent_format()
+        # UNET is handled by extension
+        self.unet_config["disable_unet_model_creation"] = True
+
+    def model_type(self, state_dict, prefix=""):
+        return comfy.model_base.ModelType.EPS
+
+
+class EXM_PixArt_Model(comfy.model_base.BaseModel):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def extra_conds(self, **kwargs):
+        out = super().extra_conds(**kwargs)
+
+        img_hw = kwargs.get("img_hw", None)
+        if img_hw is not None:
+            out["img_hw"] = comfy.conds.CONDRegular(torch.tensor(img_hw))
+
+        aspect_ratio = kwargs.get("aspect_ratio", None)
+        if aspect_ratio is not None:
+            out["aspect_ratio"] = comfy.conds.CONDRegular(torch.tensor(aspect_ratio))
+
+        cn_hint = kwargs.get("cn_hint", None)
+        if cn_hint is not None:
+            out["cn_hint"] = comfy.conds.CONDRegular(cn_hint)
+
+        return out
+
+
+def load_pixart(model_path, model_conf=None):
+    state_dict = comfy.utils.load_torch_file(model_path)
+    state_dict = state_dict.get("model", state_dict)
+
+    # prefix
+    for prefix in ["model.diffusion_model.", ]:
+        if any(True for x in state_dict if x.startswith(prefix)):
+            state_dict = {k[len(prefix):]: v for k, v in state_dict.items()}
+
+    # diffusers
+    if "adaln_single.linear.weight" in state_dict:
+        state_dict = convert_state_dict(state_dict)  # Diffusers
+
+    # guess auto config
+    if model_conf is None:
+        model_conf = guess_pixart_config(state_dict)
+
+    parameters = comfy.utils.calculate_parameters(state_dict)
+    unet_dtype = model_management.unet_dtype(model_params=parameters)
+    load_device = comfy.model_management.get_torch_device()
+    offload_device = comfy.model_management.unet_offload_device()
+
+    # ignore fp8/etc and use directly for now
+    manual_cast_dtype = model_management.unet_manual_cast(unet_dtype, load_device)
+    if manual_cast_dtype:
+        print(f"PixArt: falling back to {manual_cast_dtype}")
+        unet_dtype = manual_cast_dtype
+
+    model_conf = EXM_PixArt(model_conf)  # convert to object
+    model = EXM_PixArt_Model(  # same as comfy.model_base.BaseModel
+        model_conf,
+        model_type=comfy.model_base.ModelType.EPS,
+        device=model_management.get_torch_device()
+    )
+
+    if model_conf.model_target == "PixArtMS":
+        from .models.PixArtMS import PixArtMS
+        model.diffusion_model = PixArtMS(**model_conf.unet_config)
+    elif model_conf.model_target == "PixArt":
+        from .models.PixArt import PixArt
+        model.diffusion_model = PixArt(**model_conf.unet_config)
+    elif model_conf.model_target == "PixArtMSSigma":
+        from .models.PixArtMS import PixArtMS
+        model.diffusion_model = PixArtMS(**model_conf.unet_config)
+        model.latent_format = comfy.latent_formats.SDXL()
+    elif model_conf.model_target == "ControlPixArtMSHalf":
+        from .models.PixArtMS import PixArtMS
+        from .models.pixart_controlnet import ControlPixArtMSHalf
+        model.diffusion_model = PixArtMS(**model_conf.unet_config)
+        model.diffusion_model = ControlPixArtMSHalf(model.diffusion_model)
+    elif model_conf.model_target == "ControlPixArtHalf":
+        from .models.PixArt import PixArt
+        from .models.pixart_controlnet import ControlPixArtHalf
+        model.diffusion_model = PixArt(**model_conf.unet_config)
+        model.diffusion_model = ControlPixArtHalf(model.diffusion_model)
+    else:
+        raise NotImplementedError(f"Unknown model target '{model_conf.model_target}'")
+
+    m, u = model.diffusion_model.load_state_dict(state_dict, strict=False)
+    if len(m) > 0: print("Missing UNET keys", m)
+    if len(u) > 0: print("Leftover UNET keys", u)
+    model.diffusion_model.dtype = unet_dtype
+    model.diffusion_model.eval()
+    model.diffusion_model.to(unet_dtype)
+
+    model_patcher = comfy.model_patcher.ModelPatcher(
+        model,
+        load_device=load_device,
+        offload_device=offload_device,
+    )
+    return model_patcher
+
+
+def guess_pixart_config(sd):
+    """
+    Guess config based on converted state dict.
+    """
+    # Shared settings based on DiT_XL_2 - could be enumerated
+    config = {
+        "num_heads": 16,  # get from attention
+        "patch_size": 2,  # final layer I guess?
+        "hidden_size": 1152,  # pos_embed.shape[2]
+    }
+    config["depth"] = sum([key.endswith(".attn.proj.weight") for key in sd.keys()]) or 28
+
+    try:
+        # this is not present in the diffusers version for sigma?
+        config["model_max_length"] = sd["y_embedder.y_embedding"].shape[0]
+    except KeyError:
+        # need better logic to guess this
+        config["model_max_length"] = 300
+
+    if "pos_embed" in sd:
+        config["input_size"] = int(math.sqrt(sd["pos_embed"].shape[1])) * config["patch_size"]
+        config["pe_interpolation"] = config["input_size"] // (512 // 8)  # dumb guess
+
+    target_arch = "PixArtMS"
+    if config["model_max_length"] == 300:
+        # Sigma
+        target_arch = "PixArtMSSigma"
+        config["micro_condition"] = False
+        if "input_size" not in config:
+            # The diffusers weights for 1K/2K are exactly the same...?
+            # replace patch embed logic with HyDiT?
+            print(f"PixArt: diffusers weights - 2K model will be broken, use manual loading!")
+            config["input_size"] = 1024 // 8
+    else:
+        # Alpha
+        if "csize_embedder.mlp.0.weight" in sd:
+            # MS (microconds)
+            target_arch = "PixArtMS"
+            config["micro_condition"] = True
+            if "input_size" not in config:
+                config["input_size"] = 1024 // 8
+                config["pe_interpolation"] = 2
+        else:
+            # PixArt
+            target_arch = "PixArt"
+            if "input_size" not in config:
+                config["input_size"] = 512 // 8
+                config["pe_interpolation"] = 1
+
+    print("PixArt guessed config:", target_arch, config)
+    return {
+        "target": target_arch,
+        "unet_config": config,
+        "sampling_settings": {
+            "beta_schedule": "sqrt_linear",
+            "linear_start": 0.0001,
+            "linear_end": 0.02,
+            "timesteps": 1000,
+        }
+    }
+
+# lora
+class EXM_PixArt_ModelPatcher(comfy.model_patcher.ModelPatcher):
+    def calculate_weight(self, patches, weight, key):
+        """
+        This is almost the same as the comfy function, but stripped down to just the LoRA patch code.
+        The problem with the original code is the q/k/v keys being combined into one for the attention.
+        In the diffusers code, they're treated as separate keys, but in the reference code they're recombined (q+kv|qkv).
+        This means, for example, that the [1152,1152] weights become [3456,1152] in the state dict.
+        The issue with this is that the LoRA weights are [128,1152],[1152,128] and become [384,1162],[3456,128] instead.
+
+        This is the best thing I could think of that would fix that, but it's very fragile.
+         - Check key shape to determine if it needs the fallback logic
+         - Cut the input into parts based on the shape (undoing the torch.cat)
+         - Do the matrix multiplication logic
+         - Recombine them to match the expected shape
+        """
+        for p in patches:
+            alpha = p[0]
+            v = p[1]
+            strength_model = p[2]
+            if strength_model != 1.0:
+                weight *= strength_model
+
+            if isinstance(v, list):
+                v = (self.calculate_weight(v[1:], v[0].clone(), key),)
+
+            if len(v) == 2:
+                patch_type = v[0]
+                v = v[1]
+
+            if patch_type == "lora":
+                mat1 = comfy.model_management.cast_to_device(v[0], weight.device, torch.float32)
+                mat2 = comfy.model_management.cast_to_device(v[1], weight.device, torch.float32)
+                if v[2] is not None:
+                    alpha *= v[2] / mat2.shape[0]
+                try:
+                    mat1 = mat1.flatten(start_dim=1)
+                    mat2 = mat2.flatten(start_dim=1)
+
+                    ch1 = mat1.shape[0] // mat2.shape[1]
+                    ch2 = mat2.shape[0] // mat1.shape[1]
+                    ### Fallback logic for shape mismatch ###
+                    if mat1.shape[0] != mat2.shape[1] and ch1 == ch2 and (mat1.shape[0] / mat2.shape[1]) % 1 == 0:
+                        mat1 = mat1.chunk(ch1, dim=0)
+                        mat2 = mat2.chunk(ch1, dim=0)
+                        weight += torch.cat(
+                            [alpha * torch.mm(mat1[x], mat2[x]) for x in range(ch1)],
+                            dim=0,
+                        ).reshape(weight.shape).type(weight.dtype)
+                    else:
+                        weight += (alpha * torch.mm(mat1, mat2)).reshape(weight.shape).type(weight.dtype)
+                except Exception as e:
+                    print("ERROR", key, e)
+        return weight
+
+    def clone(self):
+        n = EXM_PixArt_ModelPatcher(self.model, self.load_device, self.offload_device, self.size, self.current_device,
+                                    weight_inplace_update=self.weight_inplace_update)
+        n.patches = {}
+        for k in self.patches:
+            n.patches[k] = self.patches[k][:]
+
+        n.object_patches = self.object_patches.copy()
+        n.model_options = copy.deepcopy(self.model_options)
+        n.model_keys = self.model_keys
+        return n
+
+
+def replace_model_patcher(model):
+    n = EXM_PixArt_ModelPatcher(
+        model=model.model,
+        size=model.size,
+        load_device=model.load_device,
+        offload_device=model.offload_device,
+        current_device=model.current_device,
+        weight_inplace_update=model.weight_inplace_update,
+    )
+    n.patches = {}
+    for k in model.patches:
+        n.patches[k] = model.patches[k][:]
+
+    n.object_patches = model.object_patches.copy()
+    n.model_options = copy.deepcopy(model.model_options)
+    return n
+
+
+def find_peft_alpha(path):
+    def load_json(json_path):
+        with open(json_path) as f:
+            data = json.load(f)
+        alpha = data.get("lora_alpha")
+        alpha = alpha or data.get("alpha")
+        if not alpha:
+            print(" Found config but `lora_alpha` is missing!")
+        else:
+            print(f" Found config at {json_path} [alpha:{alpha}]")
+        return alpha
+
+    # For some weird reason peft doesn't include the alpha in the actual model
+    print("PixArt: Warning! This is a PEFT LoRA. Trying to find config...")
+    files = [
+        f"{os.path.splitext(path)[0]}.json",
+        f"{os.path.splitext(path)[0]}.config.json",
+        os.path.join(os.path.dirname(path), "adapter_config.json"),
+    ]
+    for file in files:
+        if os.path.isfile(file):
+            return load_json(file)
+
+    print(" Missing config/alpha! assuming alpha of 8. Consider converting it/adding a config json to it.")
+    return 8.0
+
+
+def load_pixart_lora(model, lora, lora_path, strength):
+    k_back = lambda x: x.replace(".lora_up.weight", "")
+    # need to convert the actual weights for this to work.
+    if any(True for x in lora.keys() if x.endswith("adaln_single.linear.lora_A.weight")):
+        lora = convert_lora_state_dict(lora, peft=True)
+        alpha = find_peft_alpha(lora_path)
+        lora.update({f"{k_back(x)}.alpha": torch.tensor(alpha) for x in lora.keys() if "lora_up" in x})
+    else:  # OneTrainer
+        lora = convert_lora_state_dict(lora, peft=False)
+
+    key_map = {k_back(x): f"diffusion_model.{k_back(x)}.weight" for x in lora.keys() if "lora_up" in x}  # fake
+
+    loaded = comfy.lora.load_lora(lora, key_map)
+    if model is not None:
+        # switch to custom model patcher when using LoRAs
+        if isinstance(model, EXM_PixArt_ModelPatcher):
+            new_modelpatcher = model.clone()
+        else:
+            new_modelpatcher = replace_model_patcher(model)
+        k = new_modelpatcher.add_patches(loaded, strength)
+    else:
+        k = ()
+        new_modelpatcher = None
+
+    k = set(k)
+    for x in loaded:
+        if (x not in k):
+            print("NOT LOADED", x)
+
+    return new_modelpatcher

py/modules/dit/pixArt/models/PixArt.py

@@ -0,0 +1,250 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+# --------------------------------------------------------
+# References:
+# GLIDE: https://github.com/openai/glide-text2im
+# MAE: https://github.com/facebookresearch/mae/blob/main/models_mae.py
+# --------------------------------------------------------
+import math
+import torch
+import torch.nn as nn
+import os
+import numpy as np
+from timm.models.layers import DropPath
+from timm.models.vision_transformer import PatchEmbed, Mlp
+
+
+from .utils import auto_grad_checkpoint, to_2tuple
+from .PixArt_blocks import t2i_modulate, CaptionEmbedder, AttentionKVCompress, MultiHeadCrossAttention, T2IFinalLayer, TimestepEmbedder, LabelEmbedder, FinalLayer
+
+
+class PixArtBlock(nn.Module):
+    """
+    A PixArt block with adaptive layer norm (adaLN-single) conditioning.
+    """
+    def __init__(self, hidden_size, num_heads, mlp_ratio=4.0, drop_path=0, input_size=None, sampling=None, sr_ratio=1, qk_norm=False, **block_kwargs):
+        super().__init__()
+        self.norm1 = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6)
+        self.attn = AttentionKVCompress(
+            hidden_size, num_heads=num_heads, qkv_bias=True, sampling=sampling, sr_ratio=sr_ratio,
+            qk_norm=qk_norm, **block_kwargs
+        )
+        self.cross_attn = MultiHeadCrossAttention(hidden_size, num_heads, **block_kwargs)
+        self.norm2 = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6)
+        # to be compatible with lower version pytorch
+        approx_gelu = lambda: nn.GELU(approximate="tanh")
+        self.mlp = Mlp(in_features=hidden_size, hidden_features=int(hidden_size * mlp_ratio), act_layer=approx_gelu, drop=0)
+        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
+        self.scale_shift_table = nn.Parameter(torch.randn(6, hidden_size) / hidden_size ** 0.5)
+        self.sampling = sampling
+        self.sr_ratio = sr_ratio
+
+    def forward(self, x, y, t, mask=None, **kwargs):
+        B, N, C = x.shape
+
+        shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = (self.scale_shift_table[None] + t.reshape(B, 6, -1)).chunk(6, dim=1)
+        x = x + self.drop_path(gate_msa * self.attn(t2i_modulate(self.norm1(x), shift_msa, scale_msa)).reshape(B, N, C))
+        x = x + self.cross_attn(x, y, mask)
+        x = x + self.drop_path(gate_mlp * self.mlp(t2i_modulate(self.norm2(x), shift_mlp, scale_mlp)))
+
+        return x
+
+
+### Core PixArt Model ###
+class PixArt(nn.Module):
+    """
+    Diffusion model with a Transformer backbone.
+    """
+    def __init__(
+            self,
+            input_size=32,
+            patch_size=2,
+            in_channels=4,
+            hidden_size=1152,
+            depth=28,
+            num_heads=16,
+            mlp_ratio=4.0,
+            class_dropout_prob=0.1,
+            pred_sigma=True,
+            drop_path: float = 0.,
+            caption_channels=4096,
+            pe_interpolation=1.0,
+            pe_precision=None,
+            config=None,
+            model_max_length=120,
+            qk_norm=False,
+            kv_compress_config=None,
+            **kwargs,
+    ):
+        super().__init__()
+        self.pred_sigma = pred_sigma
+        self.in_channels = in_channels
+        self.out_channels = in_channels * 2 if pred_sigma else in_channels
+        self.patch_size = patch_size
+        self.num_heads = num_heads
+        self.pe_interpolation = pe_interpolation
+        self.pe_precision = pe_precision
+        self.depth = depth
+
+        self.x_embedder = PatchEmbed(input_size, patch_size, in_channels, hidden_size, bias=True)
+        self.t_embedder = TimestepEmbedder(hidden_size)
+        num_patches = self.x_embedder.num_patches
+        self.base_size = input_size // self.patch_size
+        # Will use fixed sin-cos embedding:
+        self.register_buffer("pos_embed", torch.zeros(1, num_patches, hidden_size))
+
+        approx_gelu = lambda: nn.GELU(approximate="tanh")
+        self.t_block = nn.Sequential(
+            nn.SiLU(),
+            nn.Linear(hidden_size, 6 * hidden_size, bias=True)
+        )
+        self.y_embedder = CaptionEmbedder(
+            in_channels=caption_channels, hidden_size=hidden_size, uncond_prob=class_dropout_prob,
+            act_layer=approx_gelu, token_num=model_max_length
+		)
+        drop_path = [x.item() for x in torch.linspace(0, drop_path, depth)]  # stochastic depth decay rule
+        self.kv_compress_config = kv_compress_config
+        if kv_compress_config is None:
+            self.kv_compress_config = {
+                'sampling': None,
+                'scale_factor': 1,
+                'kv_compress_layer': [],
+            }
+        self.blocks = nn.ModuleList([
+            PixArtBlock(
+                hidden_size, num_heads, mlp_ratio=mlp_ratio, drop_path=drop_path[i],
+                input_size=(input_size // patch_size, input_size // patch_size),
+                sampling=self.kv_compress_config['sampling'],
+                sr_ratio=int(
+                    self.kv_compress_config['scale_factor']
+                ) if i in self.kv_compress_config['kv_compress_layer'] else 1,
+                qk_norm=qk_norm,
+            )
+            for i in range(depth)
+        ])
+        self.final_layer = T2IFinalLayer(hidden_size, patch_size, self.out_channels)
+
+    def forward_raw(self, x, t, y, mask=None, data_info=None):
+        """
+        Original forward pass of PixArt.
+        x: (N, C, H, W) tensor of spatial inputs (images or latent representations of images)
+        t: (N,) tensor of diffusion timesteps
+        y: (N, 1, 120, C) tensor of class labels
+        """
+        x = x.to(self.dtype)
+        timestep = t.to(self.dtype)
+        y = y.to(self.dtype)
+        pos_embed = self.pos_embed.to(self.dtype)
+        self.h, self.w = x.shape[-2]//self.patch_size, x.shape[-1]//self.patch_size
+        x = self.x_embedder(x) + pos_embed  # (N, T, D), where T = H * W / patch_size ** 2
+        t = self.t_embedder(timestep.to(x.dtype))  # (N, D)
+        t0 = self.t_block(t)
+        y = self.y_embedder(y, self.training)  # (N, 1, L, D)
+        if mask is not None:
+            if mask.shape[0] != y.shape[0]:
+                mask = mask.repeat(y.shape[0] // mask.shape[0], 1)
+            mask = mask.squeeze(1).squeeze(1)
+            y = y.squeeze(1).masked_select(mask.unsqueeze(-1) != 0).view(1, -1, x.shape[-1])
+            y_lens = mask.sum(dim=1).tolist()
+        else:
+            y_lens = [y.shape[2]] * y.shape[0]
+            y = y.squeeze(1).view(1, -1, x.shape[-1])
+        for block in self.blocks:
+            x = auto_grad_checkpoint(block, x, y, t0, y_lens)  # (N, T, D) #support grad checkpoint
+        x = self.final_layer(x, t)  # (N, T, patch_size ** 2 * out_channels)
+        x = self.unpatchify(x)  # (N, out_channels, H, W)
+        return x
+
+    def forward(self, x, timesteps, context, y=None, **kwargs):
+        """
+        Forward pass that adapts comfy input to original forward function
+        x: (N, C, H, W) tensor of spatial inputs (images or latent representations of images)
+        timesteps: (N,) tensor of diffusion timesteps
+        context: (N, 1, 120, C) conditioning
+        y: extra conditioning.
+        """
+        ## Still accepts the input w/o that dim but returns garbage
+        if len(context.shape) == 3:
+            context = context.unsqueeze(1)
+
+        ## run original forward pass
+        out = self.forward_raw(
+            x = x.to(self.dtype),
+            t = timesteps.to(self.dtype),
+            y = context.to(self.dtype),
+        )
+
+        ## only return EPS
+        out = out.to(torch.float)
+        eps, rest = out[:, :self.in_channels], out[:, self.in_channels:]
+        return eps
+
+    def unpatchify(self, x):
+        """
+        x: (N, T, patch_size**2 * C)
+        imgs: (N, H, W, C)
+        """
+        c = self.out_channels
+        p = self.x_embedder.patch_size[0]
+        h = w = int(x.shape[1] ** 0.5)
+        assert h * w == x.shape[1]
+
+        x = x.reshape(shape=(x.shape[0], h, w, p, p, c))
+        x = torch.einsum('nhwpqc->nchpwq', x)
+        imgs = x.reshape(shape=(x.shape[0], c, h * p, h * p))
+        return imgs
+
+
+def get_2d_sincos_pos_embed(embed_dim, grid_size, cls_token=False, extra_tokens=0, pe_interpolation=1.0, base_size=16):
+    """
+    grid_size: int of the grid height and width
+    return:
+    pos_embed: [grid_size*grid_size, embed_dim] or [1+grid_size*grid_size, embed_dim] (w/ or w/o cls_token)
+    """
+    if isinstance(grid_size, int):
+        grid_size = to_2tuple(grid_size)
+    grid_h = np.arange(grid_size[0], dtype=np.float32) / (grid_size[0]/base_size) / pe_interpolation
+    grid_w = np.arange(grid_size[1], dtype=np.float32) / (grid_size[1]/base_size) / pe_interpolation
+    grid = np.meshgrid(grid_w, grid_h)  # here w goes first
+    grid = np.stack(grid, axis=0)
+    grid = grid.reshape([2, 1, grid_size[1], grid_size[0]])
+
+    pos_embed = get_2d_sincos_pos_embed_from_grid(embed_dim, grid)
+    if cls_token and extra_tokens > 0:
+        pos_embed = np.concatenate([np.zeros([extra_tokens, embed_dim]), pos_embed], axis=0)
+    return pos_embed.astype(np.float32)
+
+
+def get_2d_sincos_pos_embed_from_grid(embed_dim, grid):
+    assert embed_dim % 2 == 0
+
+    # use half of dimensions to encode grid_h
+    emb_h = get_1d_sincos_pos_embed_from_grid(embed_dim // 2, grid[0])  # (H*W, D/2)
+    emb_w = get_1d_sincos_pos_embed_from_grid(embed_dim // 2, grid[1])  # (H*W, D/2)
+
+    emb = np.concatenate([emb_h, emb_w], axis=1)  # (H*W, D)
+    return emb
+
+
+def get_1d_sincos_pos_embed_from_grid(embed_dim, pos):
+    """
+    embed_dim: output dimension for each position
+    pos: a list of positions to be encoded: size (M,)
+    out: (M, D)
+    """
+    assert embed_dim % 2 == 0
+    omega = np.arange(embed_dim // 2, dtype=np.float64)
+    omega /= embed_dim / 2.
+    omega = 1. / 10000 ** omega  # (D/2,)
+
+    pos = pos.reshape(-1)  # (M,)
+    out = np.einsum('m,d->md', pos, omega)  # (M, D/2), outer product
+
+    emb_sin = np.sin(out)  # (M, D/2)
+    emb_cos = np.cos(out)  # (M, D/2)
+
+    emb = np.concatenate([emb_sin, emb_cos], axis=1)  # (M, D)
+    return emb

py/modules/dit/pixArt/models/PixArtMS.py

@@ -0,0 +1,273 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+# --------------------------------------------------------
+# References:
+# GLIDE: https://github.com/openai/glide-text2im
+# MAE: https://github.com/facebookresearch/mae/blob/main/models_mae.py
+# --------------------------------------------------------
+import torch
+import torch.nn as nn
+from tqdm import tqdm
+from timm.models.layers import DropPath
+from timm.models.vision_transformer import Mlp
+
+from .utils import auto_grad_checkpoint, to_2tuple
+from .PixArt_blocks import t2i_modulate, CaptionEmbedder, AttentionKVCompress, MultiHeadCrossAttention, T2IFinalLayer, TimestepEmbedder, SizeEmbedder
+from .PixArt import PixArt, get_2d_sincos_pos_embed
+
+
+class PatchEmbed(nn.Module):
+    """
+    2D Image to Patch Embedding
+    """
+    def __init__(
+            self,
+            patch_size=16,
+            in_chans=3,
+            embed_dim=768,
+            norm_layer=None,
+            flatten=True,
+            bias=True,
+    ):
+        super().__init__()
+        patch_size = to_2tuple(patch_size)
+        self.patch_size = patch_size
+        self.flatten = flatten
+        self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size, bias=bias)
+        self.norm = norm_layer(embed_dim) if norm_layer else nn.Identity()
+
+    def forward(self, x):
+        x = self.proj(x)
+        if self.flatten:
+            x = x.flatten(2).transpose(1, 2)  # BCHW -> BNC
+        x = self.norm(x)
+        return x
+
+
+class PixArtMSBlock(nn.Module):
+    """
+    A PixArt block with adaptive layer norm zero (adaLN-Zero) conditioning.
+    """
+    def __init__(self, hidden_size, num_heads, mlp_ratio=4.0, drop_path=0., input_size=None,
+                 sampling=None, sr_ratio=1, qk_norm=False, **block_kwargs):
+        super().__init__()
+        self.hidden_size = hidden_size
+        self.norm1 = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6)
+        self.attn = AttentionKVCompress(
+            hidden_size, num_heads=num_heads, qkv_bias=True, sampling=sampling, sr_ratio=sr_ratio,
+            qk_norm=qk_norm, **block_kwargs
+        )
+        self.cross_attn = MultiHeadCrossAttention(hidden_size, num_heads, **block_kwargs)
+        self.norm2 = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6)
+        # to be compatible with lower version pytorch
+        approx_gelu = lambda: nn.GELU(approximate="tanh")
+        self.mlp = Mlp(in_features=hidden_size, hidden_features=int(hidden_size * mlp_ratio), act_layer=approx_gelu, drop=0)
+        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
+        self.scale_shift_table = nn.Parameter(torch.randn(6, hidden_size) / hidden_size ** 0.5)
+
+    def forward(self, x, y, t, mask=None, HW=None, **kwargs):
+        B, N, C = x.shape
+
+        shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = (self.scale_shift_table[None] + t.reshape(B, 6, -1)).chunk(6, dim=1)
+        x = x + self.drop_path(gate_msa * self.attn(t2i_modulate(self.norm1(x), shift_msa, scale_msa), HW=HW))
+        x = x + self.cross_attn(x, y, mask)
+        x = x + self.drop_path(gate_mlp * self.mlp(t2i_modulate(self.norm2(x), shift_mlp, scale_mlp)))
+
+        return x
+
+
+### Core PixArt Model ###
+class PixArtMS(PixArt):
+    """
+    Diffusion model with a Transformer backbone.
+    """
+    def __init__(
+            self,
+            input_size=32,
+            patch_size=2,
+            in_channels=4,
+            hidden_size=1152,
+            depth=28,
+            num_heads=16,
+            mlp_ratio=4.0,
+            class_dropout_prob=0.1,
+            learn_sigma=True,
+            pred_sigma=True,
+            drop_path: float = 0.,
+            caption_channels=4096,
+            pe_interpolation=None,
+            pe_precision=None,
+            config=None,
+            model_max_length=120,
+            micro_condition=True,
+            qk_norm=False,
+            kv_compress_config=None,
+            **kwargs,
+    ):
+        super().__init__(
+            input_size=input_size,
+            patch_size=patch_size,
+            in_channels=in_channels,
+            hidden_size=hidden_size,
+            depth=depth,
+            num_heads=num_heads,
+            mlp_ratio=mlp_ratio,
+            class_dropout_prob=class_dropout_prob,
+            learn_sigma=learn_sigma,
+            pred_sigma=pred_sigma,
+            drop_path=drop_path,
+            pe_interpolation=pe_interpolation,
+            config=config,
+            model_max_length=model_max_length,
+            qk_norm=qk_norm,
+            kv_compress_config=kv_compress_config,
+            **kwargs,
+        )
+        self.dtype = torch.get_default_dtype()
+        self.h = self.w = 0
+        approx_gelu = lambda: nn.GELU(approximate="tanh")
+        self.t_block = nn.Sequential(
+            nn.SiLU(),
+            nn.Linear(hidden_size, 6 * hidden_size, bias=True)
+        )
+        self.x_embedder = PatchEmbed(patch_size, in_channels, hidden_size, bias=True)
+        self.y_embedder = CaptionEmbedder(in_channels=caption_channels, hidden_size=hidden_size, uncond_prob=class_dropout_prob, act_layer=approx_gelu, token_num=model_max_length)
+        self.micro_conditioning = micro_condition
+        if self.micro_conditioning:
+            self.csize_embedder = SizeEmbedder(hidden_size//3)  # c_size embed
+            self.ar_embedder = SizeEmbedder(hidden_size//3)     # aspect ratio embed
+        drop_path = [x.item() for x in torch.linspace(0, drop_path, depth)]  # stochastic depth decay rule
+        if kv_compress_config is None:
+            kv_compress_config = {
+                'sampling': None,
+                'scale_factor': 1,
+                'kv_compress_layer': [],
+            }
+        self.blocks = nn.ModuleList([
+            PixArtMSBlock(
+                hidden_size, num_heads, mlp_ratio=mlp_ratio, drop_path=drop_path[i],
+                input_size=(input_size // patch_size, input_size // patch_size),
+                sampling=kv_compress_config['sampling'],
+                sr_ratio=int(kv_compress_config['scale_factor']) if i in kv_compress_config['kv_compress_layer'] else 1,
+                qk_norm=qk_norm,
+            )
+            for i in range(depth)
+        ])
+        self.final_layer = T2IFinalLayer(hidden_size, patch_size, self.out_channels)
+
+    def forward_raw(self, x, t, y, mask=None, data_info=None, **kwargs):
+        """
+        Original forward pass of PixArt.
+        x: (N, C, H, W) tensor of spatial inputs (images or latent representations of images)
+        t: (N,) tensor of diffusion timesteps
+        y: (N, 1, 120, C) tensor of class labels
+        """
+        bs = x.shape[0]
+        x = x.to(self.dtype)
+        timestep = t.to(self.dtype)
+        y = y.to(self.dtype)
+        
+        pe_interpolation = self.pe_interpolation
+        if pe_interpolation is None or self.pe_precision is not None:
+            # calculate pe_interpolation on-the-fly
+            pe_interpolation = round((x.shape[-1]+x.shape[-2])/2.0 / (512/8.0), self.pe_precision or 0)
+
+        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), pe_interpolation=pe_interpolation,
+                base_size=self.base_size
+            )
+        ).unsqueeze(0).to(device=x.device, dtype=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)
+
+        if self.micro_conditioning:
+            c_size, ar = data_info['img_hw'].to(self.dtype), data_info['aspect_ratio'].to(self.dtype)
+            csize = self.csize_embedder(c_size, bs)  # (N, D)
+            ar = self.ar_embedder(ar, bs)  # (N, D)
+            t = t + torch.cat([csize, ar], dim=1)
+
+        t0 = self.t_block(t)
+        y = self.y_embedder(y, self.training)  # (N, D)
+
+        if mask is not None:
+            if mask.shape[0] != y.shape[0]:
+                mask = mask.repeat(y.shape[0] // mask.shape[0], 1)
+            mask = mask.squeeze(1).squeeze(1)
+            y = y.squeeze(1).masked_select(mask.unsqueeze(-1) != 0).view(1, -1, x.shape[-1])
+            y_lens = mask.sum(dim=1).tolist()
+        else:
+            y_lens = [y.shape[2]] * y.shape[0]
+            y = y.squeeze(1).view(1, -1, x.shape[-1])
+        for block in self.blocks:
+            x = auto_grad_checkpoint(block, x, y, t0, y_lens, (self.h, self.w), **kwargs)  # (N, T, D) #support grad checkpoint
+
+        x = self.final_layer(x, t)  # (N, T, patch_size ** 2 * out_channels)
+        x = self.unpatchify(x)  # (N, out_channels, H, W)
+        
+        return x
+
+    def forward(self, x, timesteps, context, img_hw=None, aspect_ratio=None, **kwargs):
+        """
+        Forward pass that adapts comfy input to original forward function
+        x: (N, C, H, W) tensor of spatial inputs (images or latent representations of images)
+        timesteps: (N,) tensor of diffusion timesteps
+        context: (N, 1, 120, C) conditioning
+        img_hw: height|width conditioning
+        aspect_ratio: aspect ratio conditioning
+        """
+        ## size/ar from cond with fallback based on the latent image shape.
+        bs = x.shape[0]
+        data_info = {}
+        if img_hw is None:
+            data_info["img_hw"] = torch.tensor(
+                [[x.shape[2]*8, x.shape[3]*8]],
+                dtype=self.dtype,
+                device=x.device
+            ).repeat(bs, 1)
+        else:
+            data_info["img_hw"] = img_hw.to(dtype=x.dtype, device=x.device)
+        if aspect_ratio is None or True:
+            data_info["aspect_ratio"] = torch.tensor(
+                [[x.shape[2]/x.shape[3]]],
+                dtype=self.dtype,
+                device=x.device
+            ).repeat(bs, 1)
+        else:
+            data_info["aspect_ratio"] = aspect_ratio.to(dtype=x.dtype, device=x.device)
+
+        ## Still accepts the input w/o that dim but returns garbage
+        if len(context.shape) == 3:
+            context = context.unsqueeze(1)
+
+        ## run original forward pass
+        out = self.forward_raw(
+            x = x.to(self.dtype),
+            t = timesteps.to(self.dtype),
+            y = context.to(self.dtype),
+            data_info=data_info,
+        )
+
+        ## only return EPS
+        out = out.to(torch.float)
+        eps, rest = out[:, :self.in_channels], out[:, self.in_channels:]
+        return eps
+
+    def unpatchify(self, x):
+        """
+        x: (N, T, patch_size**2 * C)
+        imgs: (N, H, W, C)
+        """
+        c = self.out_channels
+        p = self.x_embedder.patch_size[0]
+        assert self.h * self.w == x.shape[1]
+
+        x = x.reshape(shape=(x.shape[0], self.h, self.w, p, p, c))
+        x = torch.einsum('nhwpqc->nchpwq', x)
+        imgs = x.reshape(shape=(x.shape[0], c, self.h * p, self.w * p))
+        return imgs

py/modules/dit/pixArt/models/PixArt_blocks.py

@@ -0,0 +1,477 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+# --------------------------------------------------------
+# References:
+# GLIDE: https://github.com/openai/glide-text2im
+# MAE: https://github.com/facebookresearch/mae/blob/main/models_mae.py
+# --------------------------------------------------------
+import math
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from timm.models.vision_transformer import Mlp, Attention as Attention_
+from einops import rearrange
+
+from comfy import model_management
+if model_management.xformers_enabled():
+    import xformers
+    import xformers.ops
+else:
+    print("""
+########################################
+ PixArt: Not using xformers!
+  Expect images to be non-deterministic!
+  Batch sizes > 1 are most likely broken
+########################################
+""")
+
+def modulate(x, shift, scale):
+    return x * (1 + scale.unsqueeze(1)) + shift.unsqueeze(1)
+
+def t2i_modulate(x, shift, scale):
+    return x * (1 + scale) + shift
+
+class MultiHeadCrossAttention(nn.Module):
+    def __init__(self, d_model, num_heads, attn_drop=0., proj_drop=0., **block_kwargs):
+        super(MultiHeadCrossAttention, self).__init__()
+        assert d_model % num_heads == 0, "d_model must be divisible by num_heads"
+
+        self.d_model = d_model
+        self.num_heads = num_heads
+        self.head_dim = d_model // num_heads
+
+        self.q_linear = nn.Linear(d_model, d_model)
+        self.kv_linear = nn.Linear(d_model, d_model*2)
+        self.attn_drop = nn.Dropout(attn_drop)
+        self.proj = nn.Linear(d_model, d_model)
+        self.proj_drop = nn.Dropout(proj_drop)
+
+    def forward(self, x, cond, mask=None):
+        # query/value: img tokens; key: condition; mask: if padding tokens
+        B, N, C = x.shape
+
+        q = self.q_linear(x).view(1, -1, self.num_heads, self.head_dim)
+        kv = self.kv_linear(cond).view(1, -1, 2, self.num_heads, self.head_dim)
+        k, v = kv.unbind(2)
+
+        if model_management.xformers_enabled():
+            attn_bias = None
+            if mask is not None:
+                attn_bias = xformers.ops.fmha.BlockDiagonalMask.from_seqlens([N] * B, mask)
+            x = xformers.ops.memory_efficient_attention(
+                q, k, v,
+                p=self.attn_drop.p,
+                attn_bias=attn_bias
+            )
+        else:
+            q, k, v = map(lambda t: t.permute(0, 2, 1, 3),(q, k, v),)
+            attn_mask = None
+            if mask is not None and len(mask) > 1:
+
+                # Create equivalent of xformer diagonal block mask, still only correct for square masks
+                # But depth doesn't matter as tensors can expand in that dimension
+                attn_mask_template = torch.ones(
+                    [q.shape[2] // B, mask[0]],
+                    dtype=torch.bool,
+                    device=q.device
+                )
+                attn_mask = torch.block_diag(attn_mask_template)
+
+                # create a mask on the diagonal for each mask in the batch
+                for n in range(B - 1):
+                    attn_mask = torch.block_diag(attn_mask, attn_mask_template)
+
+            x = torch.nn.functional.scaled_dot_product_attention(
+                q, k, v,
+                attn_mask=attn_mask,
+                dropout_p=self.attn_drop.p
+            ).permute(0, 2, 1, 3).contiguous()
+        x = x.view(B, -1, C)
+        x = self.proj(x)
+        x = self.proj_drop(x)
+        return x
+
+
+class AttentionKVCompress(Attention_):
+    """Multi-head Attention block with KV token compression and qk norm."""
+
+    def __init__(
+        self,
+        dim,
+        num_heads=8,
+        qkv_bias=True,
+        sampling='conv',
+        sr_ratio=1,
+        qk_norm=False,
+        **block_kwargs,
+    ):
+        """
+        Args:
+            dim (int): Number of input channels.
+            num_heads (int): Number of attention heads.
+            qkv_bias (bool:  If True, add a learnable bias to query, key, value.
+        """
+        super().__init__(dim, num_heads=num_heads, qkv_bias=qkv_bias, **block_kwargs)
+
+        self.sampling=sampling    # ['conv', 'ave', 'uniform', 'uniform_every']
+        self.sr_ratio = sr_ratio
+        if sr_ratio > 1 and sampling == 'conv':
+            # Avg Conv Init.
+            self.sr = nn.Conv2d(dim, dim, groups=dim, kernel_size=sr_ratio, stride=sr_ratio)
+            self.sr.weight.data.fill_(1/sr_ratio**2)
+            self.sr.bias.data.zero_()
+            self.norm = nn.LayerNorm(dim)
+        if qk_norm:
+            self.q_norm = nn.LayerNorm(dim)
+            self.k_norm = nn.LayerNorm(dim)
+        else:
+            self.q_norm = nn.Identity()
+            self.k_norm = nn.Identity()
+
+    def downsample_2d(self, tensor, H, W, scale_factor, sampling=None):
+        if sampling is None or scale_factor == 1:
+            return tensor
+        B, N, C = tensor.shape
+
+        if sampling == 'uniform_every':
+            return tensor[:, ::scale_factor], int(N // scale_factor)
+
+        tensor = tensor.reshape(B, H, W, C).permute(0, 3, 1, 2)
+        new_H, new_W = int(H / scale_factor), int(W / scale_factor)
+        new_N = new_H * new_W
+
+        if sampling == 'ave':
+            tensor = F.interpolate(
+                tensor, scale_factor=1 / scale_factor, mode='nearest'
+            ).permute(0, 2, 3, 1)
+        elif sampling == 'uniform':
+            tensor = tensor[:, :, ::scale_factor, ::scale_factor].permute(0, 2, 3, 1)
+        elif sampling == 'conv':
+            tensor = self.sr(tensor).reshape(B, C, -1).permute(0, 2, 1)
+            tensor = self.norm(tensor)
+        else:
+            raise ValueError
+
+        return tensor.reshape(B, new_N, C).contiguous(), new_N
+
+    def forward(self, x, mask=None, HW=None, block_id=None):
+        B, N, C = x.shape # 2 4096 1152
+        new_N = N
+        if HW is None:
+            H = W = int(N ** 0.5)
+        else:
+            H, W = HW
+        qkv = self.qkv(x).reshape(B, N, 3, C)
+
+        q, k, v = qkv.unbind(2)
+        dtype = q.dtype
+        q = self.q_norm(q)
+        k = self.k_norm(k)
+
+        # KV compression
+        if self.sr_ratio > 1:
+            k, new_N = self.downsample_2d(k, H, W, self.sr_ratio, sampling=self.sampling)
+            v, new_N = self.downsample_2d(v, H, W, self.sr_ratio, sampling=self.sampling)
+
+        q = q.reshape(B, N, self.num_heads, C // self.num_heads).to(dtype)
+        k = k.reshape(B, new_N, self.num_heads, C // self.num_heads).to(dtype)
+        v = v.reshape(B, new_N, self.num_heads, C // self.num_heads).to(dtype)
+
+        attn_bias = None
+        if mask is not None:
+            attn_bias = torch.zeros([B * self.num_heads, q.shape[1], k.shape[1]], dtype=q.dtype, device=q.device)
+            attn_bias.masked_fill_(mask.squeeze(1).repeat(self.num_heads, 1, 1) == 0, float('-inf'))
+        # Switch between torch / xformers attention
+        if model_management.xformers_enabled():
+            x = xformers.ops.memory_efficient_attention(
+                q, k, v,
+                p=self.attn_drop.p,
+                attn_bias=attn_bias
+            )
+        else:
+            q, k, v = map(lambda t: t.transpose(1, 2),(q, k, v),)
+            x = torch.nn.functional.scaled_dot_product_attention(
+                q, k, v,
+                dropout_p=self.attn_drop.p,
+                attn_mask=attn_bias
+            ).transpose(1, 2).contiguous()
+        x = x.view(B, N, C)
+        x = self.proj(x)
+        x = self.proj_drop(x)
+        return x
+
+
+#################################################################################
+#   AMP attention with fp32 softmax to fix loss NaN problem during training     #
+#################################################################################
+class Attention(Attention_):
+    def forward(self, x):
+        B, N, C = x.shape
+        qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
+        q, k, v = qkv.unbind(0)  # make torchscript happy (cannot use tensor as tuple)
+        use_fp32_attention = getattr(self, 'fp32_attention', False)
+        if use_fp32_attention:
+            q, k = q.float(), k.float()
+        with torch.cuda.amp.autocast(enabled=not use_fp32_attention):
+            attn = (q @ k.transpose(-2, -1)) * self.scale
+            attn = attn.softmax(dim=-1)
+
+        attn = self.attn_drop(attn)
+
+        x = (attn @ v).transpose(1, 2).reshape(B, N, C)
+        x = self.proj(x)
+        x = self.proj_drop(x)
+        return x
+
+
+class FinalLayer(nn.Module):
+    """
+    The final layer of PixArt.
+    """
+
+    def __init__(self, hidden_size, patch_size, out_channels):
+        super().__init__()
+        self.norm_final = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6)
+        self.linear = nn.Linear(hidden_size, patch_size * patch_size * out_channels, bias=True)
+        self.adaLN_modulation = nn.Sequential(
+            nn.SiLU(),
+            nn.Linear(hidden_size, 2 * hidden_size, bias=True)
+        )
+
+    def forward(self, x, c):
+        shift, scale = self.adaLN_modulation(c).chunk(2, dim=1)
+        x = modulate(self.norm_final(x), shift, scale)
+        x = self.linear(x)
+        return x
+
+
+class T2IFinalLayer(nn.Module):
+    """
+    The final layer of PixArt.
+    """
+
+    def __init__(self, hidden_size, patch_size, out_channels):
+        super().__init__()
+        self.norm_final = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6)
+        self.linear = nn.Linear(hidden_size, patch_size * patch_size * out_channels, bias=True)
+        self.scale_shift_table = nn.Parameter(torch.randn(2, hidden_size) / hidden_size ** 0.5)
+        self.out_channels = out_channels
+
+    def forward(self, x, t):
+        shift, scale = (self.scale_shift_table[None] + t[:, None]).chunk(2, dim=1)
+        x = t2i_modulate(self.norm_final(x), shift, scale)
+        x = self.linear(x)
+        return x
+
+
+class MaskFinalLayer(nn.Module):
+    """
+    The final layer of PixArt.
+    """
+
+    def __init__(self, final_hidden_size, c_emb_size, patch_size, out_channels):
+        super().__init__()
+        self.norm_final = nn.LayerNorm(final_hidden_size, elementwise_affine=False, eps=1e-6)
+        self.linear = nn.Linear(final_hidden_size, patch_size * patch_size * out_channels, bias=True)
+        self.adaLN_modulation = nn.Sequential(
+            nn.SiLU(),
+            nn.Linear(c_emb_size, 2 * final_hidden_size, bias=True)
+        )
+    def forward(self, x, t):
+        shift, scale = self.adaLN_modulation(t).chunk(2, dim=1)
+        x = modulate(self.norm_final(x), shift, scale)
+        x = self.linear(x)
+        return x
+
+
+class DecoderLayer(nn.Module):
+    """
+    The final layer of PixArt.
+    """
+
+    def __init__(self, hidden_size, decoder_hidden_size):
+        super().__init__()
+        self.norm_decoder = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6)
+        self.linear = nn.Linear(hidden_size, decoder_hidden_size, bias=True)
+        self.adaLN_modulation = nn.Sequential(
+            nn.SiLU(),
+            nn.Linear(hidden_size, 2 * hidden_size, bias=True)
+        )
+    def forward(self, x, t):
+        shift, scale = self.adaLN_modulation(t).chunk(2, dim=1)
+        x = modulate(self.norm_decoder(x), shift, scale)
+        x = self.linear(x)
+        return x
+
+
+#################################################################################
+#               Embedding Layers for Timesteps and Class Labels                 #
+#################################################################################
+class TimestepEmbedder(nn.Module):
+    """
+    Embeds scalar timesteps into vector representations.
+    """
+
+    def __init__(self, hidden_size, frequency_embedding_size=256):
+        super().__init__()
+        self.mlp = nn.Sequential(
+            nn.Linear(frequency_embedding_size, hidden_size, bias=True),
+            nn.SiLU(),
+            nn.Linear(hidden_size, hidden_size, bias=True),
+        )
+        self.frequency_embedding_size = frequency_embedding_size
+
+    @staticmethod
+    def timestep_embedding(t, dim, max_period=10000):
+        """
+        Create sinusoidal timestep embeddings.
+        :param t: 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, D) Tensor of positional embeddings.
+        """
+        # https://github.com/openai/glide-text2im/blob/main/glide_text2im/nn.py
+        half = dim // 2
+        freqs = torch.exp(
+            -math.log(max_period) * torch.arange(start=0, end=half, dtype=torch.float32, device=t.device) / half)
+        args = t[:, 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)
+        return embedding
+
+    def forward(self, t):
+        t_freq = self.timestep_embedding(t, self.frequency_embedding_size)
+        t_emb = self.mlp(t_freq.to(t.dtype))
+        return t_emb
+
+
+class SizeEmbedder(TimestepEmbedder):
+    """
+    Embeds scalar timesteps into vector representations.
+    """
+
+    def __init__(self, hidden_size, frequency_embedding_size=256):
+        super().__init__(hidden_size=hidden_size, frequency_embedding_size=frequency_embedding_size)
+        self.mlp = nn.Sequential(
+            nn.Linear(frequency_embedding_size, hidden_size, bias=True),
+            nn.SiLU(),
+            nn.Linear(hidden_size, hidden_size, bias=True),
+        )
+        self.frequency_embedding_size = frequency_embedding_size
+        self.outdim = hidden_size
+
+    def forward(self, s, bs):
+        if s.ndim == 1:
+            s = s[:, None]
+        assert s.ndim == 2
+        if s.shape[0] != bs:
+            s = s.repeat(bs//s.shape[0], 1)
+            assert s.shape[0] == bs
+        b, dims = s.shape[0], s.shape[1]
+        s = rearrange(s, "b d -> (b d)")
+        s_freq = self.timestep_embedding(s, self.frequency_embedding_size)
+        s_emb = self.mlp(s_freq.to(s.dtype))
+        s_emb = rearrange(s_emb, "(b d) d2 -> b (d d2)", b=b, d=dims, d2=self.outdim)
+        return s_emb
+
+
+class LabelEmbedder(nn.Module):
+    """
+    Embeds class labels into vector representations. Also handles label dropout for classifier-free guidance.
+    """
+
+    def __init__(self, num_classes, hidden_size, dropout_prob):
+        super().__init__()
+        use_cfg_embedding = dropout_prob > 0
+        self.embedding_table = nn.Embedding(num_classes + use_cfg_embedding, hidden_size)
+        self.num_classes = num_classes
+        self.dropout_prob = dropout_prob
+
+    def token_drop(self, labels, force_drop_ids=None):
+        """
+        Drops labels to enable classifier-free guidance.
+        """
+        if force_drop_ids is None:
+            drop_ids = torch.rand(labels.shape[0]).cuda() < self.dropout_prob
+        else:
+            drop_ids = force_drop_ids == 1
+        labels = torch.where(drop_ids, self.num_classes, labels)
+        return labels
+
+    def forward(self, labels, train, force_drop_ids=None):
+        use_dropout = self.dropout_prob > 0
+        if (train and use_dropout) or (force_drop_ids is not None):
+            labels = self.token_drop(labels, force_drop_ids)
+        embeddings = self.embedding_table(labels)
+        return embeddings
+
+
+class CaptionEmbedder(nn.Module):
+    """
+    Embeds class labels into vector representations. Also handles label dropout for classifier-free guidance.
+    """
+
+    def __init__(self, in_channels, hidden_size, uncond_prob, act_layer=nn.GELU(approximate='tanh'), token_num=120):
+        super().__init__()
+        self.y_proj = Mlp(in_features=in_channels, hidden_features=hidden_size, out_features=hidden_size, act_layer=act_layer, drop=0)
+        self.register_buffer("y_embedding", nn.Parameter(torch.randn(token_num, in_channels) / in_channels ** 0.5))
+        self.uncond_prob = uncond_prob
+
+    def token_drop(self, caption, force_drop_ids=None):
+        """
+        Drops labels to enable classifier-free guidance.
+        """
+        if force_drop_ids is None:
+            drop_ids = torch.rand(caption.shape[0]).cuda() < self.uncond_prob
+        else:
+            drop_ids = force_drop_ids == 1
+        caption = torch.where(drop_ids[:, None, None, None], self.y_embedding, caption)
+        return caption
+
+    def forward(self, caption, train, force_drop_ids=None):
+        if train:
+            assert caption.shape[2:] == self.y_embedding.shape
+        use_dropout = self.uncond_prob > 0
+        if (train and use_dropout) or (force_drop_ids is not None):
+            caption = self.token_drop(caption, force_drop_ids)
+        caption = self.y_proj(caption)
+        return caption
+
+
+class CaptionEmbedderDoubleBr(nn.Module):
+    """
+    Embeds class labels into vector representations. Also handles label dropout for classifier-free guidance.
+    """
+
+    def __init__(self, in_channels, hidden_size, uncond_prob, act_layer=nn.GELU(approximate='tanh'), token_num=120):
+        super().__init__()
+        self.proj = Mlp(in_features=in_channels, hidden_features=hidden_size, out_features=hidden_size, act_layer=act_layer, drop=0)
+        self.embedding = nn.Parameter(torch.randn(1, in_channels) / 10 ** 0.5)
+        self.y_embedding = nn.Parameter(torch.randn(token_num, in_channels) / 10 ** 0.5)
+        self.uncond_prob = uncond_prob
+
+    def token_drop(self, global_caption, caption, force_drop_ids=None):
+        """
+        Drops labels to enable classifier-free guidance.
+        """
+        if force_drop_ids is None:
+            drop_ids = torch.rand(global_caption.shape[0]).cuda() < self.uncond_prob
+        else:
+            drop_ids = force_drop_ids == 1
+        global_caption = torch.where(drop_ids[:, None], self.embedding, global_caption)
+        caption = torch.where(drop_ids[:, None, None, None], self.y_embedding, caption)
+        return global_caption, caption
+
+    def forward(self, caption, train, force_drop_ids=None):
+        assert caption.shape[2: ] == self.y_embedding.shape
+        global_caption = caption.mean(dim=2).squeeze()
+        use_dropout = self.uncond_prob > 0
+        if (train and use_dropout) or (force_drop_ids is not None):
+            global_caption, caption = self.token_drop(global_caption, caption, force_drop_ids)
+        y_embed = self.proj(global_caption)
+        return y_embed, caption

py/modules/dit/pixArt/models/pixart_controlnet.py

@@ -0,0 +1,312 @@
+import re
+import torch
+import torch.nn as nn
+
+from copy import deepcopy
+from torch import Tensor
+from torch.nn import Module, Linear, init
+from typing import Any, Mapping
+
+from .PixArt import PixArt, get_2d_sincos_pos_embed
+from .PixArtMS import PixArtMSBlock, PixArtMS
+from .utils import auto_grad_checkpoint
+
+# The implementation of ControlNet-Half architrecture
+# https://github.com/lllyasviel/ControlNet/discussions/188
+class ControlT2IDitBlockHalf(Module):
+    def __init__(self, base_block: PixArtMSBlock, block_index: 0) -> None:
+        super().__init__()
+        self.copied_block = deepcopy(base_block)
+        self.block_index = block_index
+
+        for p in self.copied_block.parameters():
+            p.requires_grad_(True)
+
+        self.copied_block.load_state_dict(base_block.state_dict())
+        self.copied_block.train()
+        
+        self.hidden_size = hidden_size = base_block.hidden_size
+        if self.block_index == 0:
+            self.before_proj = Linear(hidden_size, hidden_size)
+            init.zeros_(self.before_proj.weight)
+            init.zeros_(self.before_proj.bias)
+        self.after_proj = Linear(hidden_size, hidden_size) 
+        init.zeros_(self.after_proj.weight)
+        init.zeros_(self.after_proj.bias)
+
+    def forward(self, x, y, t, mask=None, c=None):
+        
+        if self.block_index == 0:
+            # the first block
+            c = self.before_proj(c)
+            c = self.copied_block(x + c, y, t, mask)
+            c_skip = self.after_proj(c)
+        else:
+            # load from previous c and produce the c for skip connection
+            c = self.copied_block(c, y, t, mask)
+            c_skip = self.after_proj(c)
+        
+        return c, c_skip
+        
+
+# The implementation of ControlPixArtHalf net
+class ControlPixArtHalf(Module):
+    # only support single res model
+    def __init__(self, base_model: PixArt, copy_blocks_num: int = 13) -> None:
+        super().__init__()
+        self.dtype = torch.get_default_dtype()
+        self.base_model = base_model.eval()
+        self.controlnet = []
+        self.copy_blocks_num = copy_blocks_num
+        self.total_blocks_num = len(base_model.blocks)
+        for p in self.base_model.parameters():
+            p.requires_grad_(False)
+
+        # Copy first copy_blocks_num block
+        for i in range(copy_blocks_num):
+            self.controlnet.append(ControlT2IDitBlockHalf(base_model.blocks[i], i))
+        self.controlnet = nn.ModuleList(self.controlnet)
+    
+    def __getattr__(self, name: str) -> Tensor or Module:
+        if name in ['forward', 'forward_with_dpmsolver', 'forward_with_cfg', 'forward_c', 'load_state_dict']:
+            return self.__dict__[name]
+        elif name in ['base_model', 'controlnet']:
+            return super().__getattr__(name)
+        else:
+            return getattr(self.base_model, name)
+
+    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)
+        return self.x_embedder(c) + pos_embed if c is not None else c
+
+    # def forward(self, x, t, c, **kwargs):
+    #     return self.base_model(x, t, c=self.forward_c(c), **kwargs)
+    def forward_raw(self, x, timestep, y, mask=None, data_info=None, c=None, **kwargs):
+        # modify the original PixArtMS forward function
+        if c is not None:
+            c = c.to(self.dtype)
+            c = self.forward_c(c)
+        """
+        Forward pass of PixArt.
+        x: (N, C, H, W) tensor of spatial inputs (images or latent representations of images)
+        t: (N,) tensor of diffusion timesteps
+        y: (N, 1, 120, C) tensor of class labels
+        """
+        x = x.to(self.dtype)
+        timestep = timestep.to(self.dtype)
+        y = y.to(self.dtype)
+        pos_embed = self.pos_embed.to(self.dtype)
+        self.h, self.w = x.shape[-2]//self.patch_size, x.shape[-1]//self.patch_size
+        x = self.x_embedder(x) + pos_embed  # (N, T, D), where T = H * W / patch_size ** 2
+        t = self.t_embedder(timestep.to(x.dtype))  # (N, D)
+        t0 = self.t_block(t)
+        y = self.y_embedder(y, self.training)  # (N, 1, L, D)
+        if mask is not None:
+            if mask.shape[0] != y.shape[0]:
+                mask = mask.repeat(y.shape[0] // mask.shape[0], 1)
+            mask = mask.squeeze(1).squeeze(1)
+            y = y.squeeze(1).masked_select(mask.unsqueeze(-1) != 0).view(1, -1, x.shape[-1])
+            y_lens = mask.sum(dim=1).tolist()
+        else:
+            y_lens = [y.shape[2]] * y.shape[0]
+            y = y.squeeze(1).view(1, -1, x.shape[-1])
+
+        # define the first layer
+        x = auto_grad_checkpoint(self.base_model.blocks[0], x, y, t0, y_lens, **kwargs)  # (N, T, D) #support grad checkpoint
+
+        if c is not None:
+            # update c
+            for index in range(1, self.copy_blocks_num + 1):
+                c, c_skip = auto_grad_checkpoint(self.controlnet[index - 1], x, y, t0, y_lens, c, **kwargs)
+                x = auto_grad_checkpoint(self.base_model.blocks[index], x + c_skip, y, t0, y_lens, **kwargs)
+        
+            # update x
+            for index in range(self.copy_blocks_num + 1, self.total_blocks_num):
+                x = auto_grad_checkpoint(self.base_model.blocks[index], x, y, t0, y_lens, **kwargs)
+        else:
+            for index in range(1, self.total_blocks_num):
+                x = auto_grad_checkpoint(self.base_model.blocks[index], x, y, t0, y_lens, **kwargs)
+
+        x = self.final_layer(x, t)  # (N, T, patch_size ** 2 * out_channels)
+        x = self.unpatchify(x)  # (N, out_channels, H, W)
+        return x
+
+    def forward(self, x, timesteps, context, cn_hint=None, **kwargs):
+        """
+        Forward pass that adapts comfy input to original forward function
+        x: (N, C, H, W) tensor of spatial inputs (images or latent representations of images)
+        timesteps: (N,) tensor of diffusion timesteps
+        context: (N, 1, 120, C) conditioning
+        cn_hint: controlnet hint
+        """
+        ## Still accepts the input w/o that dim but returns garbage
+        if len(context.shape) == 3:
+            context = context.unsqueeze(1)
+
+        ## run original forward pass
+        out = self.forward_raw(
+            x = x.to(self.dtype),
+            timestep = timesteps.to(self.dtype),
+            y = context.to(self.dtype),
+            c = cn_hint,
+        )
+
+        ## only return EPS
+        out = out.to(torch.float)
+        eps, rest = out[:, :self.in_channels], out[:, self.in_channels:]
+        return eps
+
+    def forward_with_dpmsolver(self, x, t, y, data_info, c, **kwargs):
+        model_out = self.forward_raw(x, t, y, data_info=data_info, c=c, **kwargs)
+        return model_out.chunk(2, dim=1)[0]
+
+    # def forward_with_dpmsolver(self, x, t, y, data_info, c, **kwargs):
+    #     return self.base_model.forward_with_dpmsolver(x, t, y, data_info=data_info, c=self.forward_c(c), **kwargs)
+
+    def forward_with_cfg(self, x, t, y, cfg_scale, data_info, c, **kwargs):
+        return self.base_model.forward_with_cfg(x, t, y, cfg_scale, data_info, c=self.forward_c(c), **kwargs)
+
+    def load_state_dict(self, state_dict: Mapping[str, Any], strict: bool = True):
+        if all((k.startswith('base_model') or k.startswith('controlnet')) for k in state_dict.keys()):
+            return super().load_state_dict(state_dict, strict)
+        else:
+            new_key = {}
+            for k in state_dict.keys():
+                new_key[k] = re.sub(r"(blocks\.\d+)(.*)", r"\1.base_block\2", k)
+            for k, v in new_key.items():
+                if k != v:
+                    print(f"replace {k} to {v}")
+                    state_dict[v] = state_dict.pop(k)
+
+            return self.base_model.load_state_dict(state_dict, strict)
+    
+    def unpatchify(self, x):
+        """
+        x: (N, T, patch_size**2 * C)
+        imgs: (N, H, W, C)
+        """
+        c = self.out_channels
+        p = self.x_embedder.patch_size[0]
+        assert self.h * self.w == x.shape[1]
+
+        x = x.reshape(shape=(x.shape[0], self.h, self.w, p, p, c))
+        x = torch.einsum('nhwpqc->nchpwq', x)
+        imgs = x.reshape(shape=(x.shape[0], c, self.h * p, self.w * p))
+        return imgs
+
+    # @property
+    # def dtype(self):
+        ## 返回模型参数的数据类型
+        # return next(self.parameters()).dtype
+
+
+# The implementation for PixArtMS_Half + 1024 resolution
+class ControlPixArtMSHalf(ControlPixArtHalf):
+    # support multi-scale res model (multi-scale model can also be applied to single reso training & inference)
+    def __init__(self, base_model: PixArtMS, copy_blocks_num: int = 13) -> None:
+        super().__init__(base_model=base_model, copy_blocks_num=copy_blocks_num)
+
+    def forward_raw(self, x, timestep, y, mask=None, data_info=None, c=None, **kwargs):
+        # modify the original PixArtMS forward function
+        """
+        Forward pass of PixArt.
+        x: (N, C, H, W) tensor of spatial inputs (images or latent representations of images)
+        t: (N,) tensor of diffusion timesteps
+        y: (N, 1, 120, C) tensor of class labels
+        """
+        if c is not None:
+            c = c.to(self.dtype)
+            c = self.forward_c(c)
+        bs = x.shape[0]
+        x = x.to(self.dtype)
+        timestep = timestep.to(self.dtype)
+        y = y.to(self.dtype)
+        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)
+        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)
+        ar = self.ar_embedder(ar, bs)  # (N, D)
+        t = t + torch.cat([csize, ar], dim=1)
+        t0 = self.t_block(t)
+        y = self.y_embedder(y, self.training)  # (N, D)
+        if mask is not None:
+            if mask.shape[0] != y.shape[0]:
+                mask = mask.repeat(y.shape[0] // mask.shape[0], 1)
+            mask = mask.squeeze(1).squeeze(1)
+            y = y.squeeze(1).masked_select(mask.unsqueeze(-1) != 0).view(1, -1, x.shape[-1])
+            y_lens = mask.sum(dim=1).tolist()
+        else:
+            y_lens = [y.shape[2]] * y.shape[0]
+            y = y.squeeze(1).view(1, -1, x.shape[-1])
+
+        # define the first layer
+        x = auto_grad_checkpoint(self.base_model.blocks[0], x, y, t0, y_lens, **kwargs)  # (N, T, D) #support grad checkpoint
+
+        if c is not None:
+            # update c
+            for index in range(1, self.copy_blocks_num + 1):
+                c, c_skip = auto_grad_checkpoint(self.controlnet[index - 1], x, y, t0, y_lens, c, **kwargs)
+                x = auto_grad_checkpoint(self.base_model.blocks[index], x + c_skip, y, t0, y_lens, **kwargs)
+        
+            # update x
+            for index in range(self.copy_blocks_num + 1, self.total_blocks_num):
+                x = auto_grad_checkpoint(self.base_model.blocks[index], x, y, t0, y_lens, **kwargs)
+        else:
+            for index in range(1, self.total_blocks_num):
+                x = auto_grad_checkpoint(self.base_model.blocks[index], x, y, t0, y_lens, **kwargs)
+
+        x = self.final_layer(x, t)  # (N, T, patch_size ** 2 * out_channels)
+        x = self.unpatchify(x)  # (N, out_channels, H, W)
+        return x
+
+    def forward(self, x, timesteps, context, img_hw=None, aspect_ratio=None, cn_hint=None, **kwargs):
+        """
+        Forward pass that adapts comfy input to original forward function
+        x: (N, C, H, W) tensor of spatial inputs (images or latent representations of images)
+        timesteps: (N,) tensor of diffusion timesteps
+        context: (N, 1, 120, C) conditioning
+        img_hw: height|width conditioning
+        aspect_ratio: aspect ratio conditioning
+        cn_hint: controlnet hint
+        """
+        ## size/ar from cond with fallback based on the latent image shape.
+        bs = x.shape[0]
+        data_info = {}
+        if img_hw is None:
+            data_info["img_hw"] = torch.tensor(
+                [[x.shape[2]*8, x.shape[3]*8]],
+                dtype=self.dtype,
+                device=x.device
+            ).repeat(bs, 1)
+        else:
+            data_info["img_hw"] = img_hw.to(x.dtype)
+        if aspect_ratio is None or True:
+            data_info["aspect_ratio"] = torch.tensor(
+                [[x.shape[2]/x.shape[3]]],
+                dtype=self.dtype,
+                device=x.device
+            ).repeat(bs, 1)
+        else:
+            data_info["aspect_ratio"] = aspect_ratio.to(x.dtype)
+
+        ## Still accepts the input w/o that dim but returns garbage
+        if len(context.shape) == 3:
+            context = context.unsqueeze(1)
+
+        ## run original forward pass
+        out = self.forward_raw(
+            x = x.to(self.dtype),
+            timestep = timesteps.to(self.dtype),
+            y = context.to(self.dtype),
+            c = cn_hint,
+            data_info=data_info,
+        )
+
+        ## only return EPS
+        out = out.to(torch.float)
+        eps, rest = out[:, :self.in_channels], out[:, self.in_channels:]
+        return eps

py/modules/dit/pixArt/models/utils.py

@@ -0,0 +1,122 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.utils.checkpoint import checkpoint, checkpoint_sequential
+from collections.abc import Iterable
+from itertools import repeat
+
+def _ntuple(n):
+    def parse(x):
+        if isinstance(x, Iterable) and not isinstance(x, str):
+            return x
+        return tuple(repeat(x, n))
+    return parse
+
+to_1tuple = _ntuple(1)
+to_2tuple = _ntuple(2)
+
+def set_grad_checkpoint(model, use_fp32_attention=False, gc_step=1):
+    assert isinstance(model, nn.Module)
+
+    def set_attr(module):
+        module.grad_checkpointing = True
+        module.fp32_attention = use_fp32_attention
+        module.grad_checkpointing_step = gc_step
+    model.apply(set_attr)
+
+def auto_grad_checkpoint(module, *args, **kwargs):
+    if getattr(module, 'grad_checkpointing', False):
+        if isinstance(module, Iterable):
+            gc_step = module[0].grad_checkpointing_step
+            return checkpoint_sequential(module, gc_step, *args, **kwargs)
+        else:
+            return checkpoint(module, *args, **kwargs)
+    return module(*args, **kwargs)
+
+def checkpoint_sequential(functions, step, input, *args, **kwargs):
+
+    # Hack for keyword-only parameter in a python 2.7-compliant way
+    preserve = kwargs.pop('preserve_rng_state', True)
+    if kwargs:
+        raise ValueError("Unexpected keyword arguments: " + ",".join(arg for arg in kwargs))
+
+    def run_function(start, end, functions):
+        def forward(input):
+            for j in range(start, end + 1):
+                input = functions[j](input, *args)
+            return input
+        return forward
+
+    if isinstance(functions, torch.nn.Sequential):
+        functions = list(functions.children())
+
+    # the last chunk has to be non-volatile
+    end = -1
+    segment = len(functions) // step
+    for start in range(0, step * (segment - 1), step):
+        end = start + step - 1
+        input = checkpoint(run_function(start, end, functions), input, preserve_rng_state=preserve)
+    return run_function(end + 1, len(functions) - 1, functions)(input)
+
+def get_rel_pos(q_size, k_size, rel_pos):
+    """
+    Get relative positional embeddings according to the relative positions of
+        query and key sizes.
+    Args:
+        q_size (int): size of query q.
+        k_size (int): size of key k.
+        rel_pos (Tensor): relative position embeddings (L, C).
+
+    Returns:
+        Extracted positional embeddings according to relative positions.
+    """
+    max_rel_dist = int(2 * max(q_size, k_size) - 1)
+    # Interpolate rel pos if needed.
+    if rel_pos.shape[0] != max_rel_dist:
+        # Interpolate rel pos.
+        rel_pos_resized = F.interpolate(
+            rel_pos.reshape(1, rel_pos.shape[0], -1).permute(0, 2, 1),
+            size=max_rel_dist,
+            mode="linear",
+        )
+        rel_pos_resized = rel_pos_resized.reshape(-1, max_rel_dist).permute(1, 0)
+    else:
+        rel_pos_resized = rel_pos
+
+    # Scale the coords with short length if shapes for q and k are different.
+    q_coords = torch.arange(q_size)[:, None] * max(k_size / q_size, 1.0)
+    k_coords = torch.arange(k_size)[None, :] * max(q_size / k_size, 1.0)
+    relative_coords = (q_coords - k_coords) + (k_size - 1) * max(q_size / k_size, 1.0)
+
+    return rel_pos_resized[relative_coords.long()]
+
+def add_decomposed_rel_pos(attn, q, rel_pos_h, rel_pos_w, q_size, k_size):
+    """
+    Calculate decomposed Relative Positional Embeddings from :paper:`mvitv2`.
+    https://github.com/facebookresearch/mvit/blob/19786631e330df9f3622e5402b4a419a263a2c80/mvit/models/attention.py   # noqa B950
+    Args:
+        attn (Tensor): attention map.
+        q (Tensor): query q in the attention layer with shape (B, q_h * q_w, C).
+        rel_pos_h (Tensor): relative position embeddings (Lh, C) for height axis.
+        rel_pos_w (Tensor): relative position embeddings (Lw, C) for width axis.
+        q_size (Tuple): spatial sequence size of query q with (q_h, q_w).
+        k_size (Tuple): spatial sequence size of key k with (k_h, k_w).
+
+    Returns:
+        attn (Tensor): attention map with added relative positional embeddings.
+    """
+    q_h, q_w = q_size
+    k_h, k_w = k_size
+    Rh = get_rel_pos(q_h, k_h, rel_pos_h)
+    Rw = get_rel_pos(q_w, k_w, rel_pos_w)
+
+    B, _, dim = q.shape
+    r_q = q.reshape(B, q_h, q_w, dim)
+    rel_h = torch.einsum("bhwc,hkc->bhwk", r_q, Rh)
+    rel_w = torch.einsum("bhwc,wkc->bhwk", r_q, Rw)
+
+    attn = (
+        attn.view(B, q_h, q_w, k_h, k_w) + rel_h[:, :, :, :, None] + rel_w[:, :, :, None, :]
+    ).view(B, q_h * q_w, k_h * k_w)
+
+    return attn

py/modules/dit/utils.py

@@ -0,0 +1,38 @@
+import torch
+from comfy import model_management
+
+def string_to_dtype(s="none", mode=None):
+	s = s.lower().strip()
+	if s in ["default", "as-is"]:
+		return None
+	elif s in ["auto", "auto (comfy)"]:
+		if mode == "vae":
+			return model_management.vae_device()
+		elif mode == "text_encoder":
+			return model_management.text_encoder_dtype()
+		elif mode == "unet":
+			return model_management.unet_dtype()
+		else:
+			raise NotImplementedError(f"Unknown dtype mode '{mode}'")
+	elif s in ["none", "auto (hf)", "auto (hf/bnb)"]:
+		return None
+	elif s in ["fp32", "float32", "float"]:
+		return torch.float32
+	elif s in ["bf16", "bfloat16"]:
+		return torch.bfloat16
+	elif s in ["fp16", "float16", "half"]:
+		return torch.float16
+	elif "fp8" in s or "float8" in s:
+		if "e5m2" in s:
+			return torch.float8_e5m2
+		elif "e4m3" in s:
+			return torch.float8_e4m3fn
+		else:
+			raise NotImplementedError(f"Unknown 8bit dtype '{s}'")
+	elif "bnb" in s:
+		assert s in ["bnb8bit", "bnb4bit"], f"Unknown bnb mode '{s}'"
+		return s
+	elif s is None:
+		return None
+	else:
+		raise NotImplementedError(f"Unknown dtype '{s}'")

py/modules/fooocus/__init__.py

@@ -0,0 +1,139 @@
+#credit to Acly for this module
+#from https://github.com/Acly/comfyui-inpaint-nodes
+import torch
+import torch.nn.functional as F
+import comfy
+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
+
+class InpaintHead(torch.nn.Module):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.head = torch.nn.Parameter(torch.empty(size=(320, 5, 3, 3), device="cpu"))
+
+    def __call__(self, x):
+        x = F.pad(x, (1, 1, 1, 1), "replicate")
+        return F.conv2d(x, weight=self.head)
+
+# injected_model_patcher_calculate_weight = False
+# original_calculate_weight = None
+
+class applyFooocusInpaint:
+    def calculate_weight_patched(self, patches, weight, key, intermediate_dtype=torch.float32):
+        remaining = []
+
+        for p in patches:
+            alpha = p[0]
+            v = p[1]
+
+            is_fooocus_patch = isinstance(v, tuple) and len(v) == 2 and v[0] == "fooocus"
+            if not is_fooocus_patch:
+                remaining.append(p)
+                continue
+
+            if alpha != 0.0:
+                v = v[1]
+                w1 = cast_to_device(v[0], weight.device, torch.float32)
+                if w1.shape == weight.shape:
+                    w_min = cast_to_device(v[1], weight.device, torch.float32)
+                    w_max = cast_to_device(v[2], weight.device, torch.float32)
+                    w1 = (w1 / 255.0) * (w_max - w_min) + w_min
+                    weight += alpha * cast_to_device(w1, weight.device, weight.dtype)
+                else:
+                    print(
+                        f"[ApplyFooocusInpaint] Shape mismatch {key}, weight not merged ({w1.shape} != {weight.shape})"
+                    )
+
+        if len(remaining) > 0:
+            return self.original_calculate_weight(remaining, weight, key, intermediate_dtype)
+        return weight
+
+    def __enter__(self):
+        try:
+            print("[comfyui-easy-use] Injecting patched comfy.lora.calculate_weight.calculate_weight")
+            self.original_calculate_weight = comfy.lora.calculate_weight
+            comfy.lora.calculate_weight = self.calculate_weight_patched
+        except AttributeError:
+            print("[comfyui-easy-use] Injecting patched comfy.model_patcher.ModelPatcher.calculate_weight")
+            self.original_calculate_weight = ModelPatcher.calculate_weight
+            ModelPatcher.calculate_weight = self.calculate_weight_patched
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        try:
+            comfy.lora.calculate_weight = self.original_calculate_weight
+        except:
+            ModelPatcher.calculate_weight = self.original_calculate_weight
+
+# def inject_patched_calculate_weight():
+#     global injected_model_patcher_calculate_weight
+#     if not injected_model_patcher_calculate_weight:
+#         try:
+#             print("[comfyui-easy-use] Injecting patched comfy.lora.calculate_weight.calculate_weight")
+#             original_calculate_weight = comfy.lora.calculate_weight
+#             comfy.lora.original_calculate_weight = original_calculate_weight
+#             comfy.lora.calculate_weight = calculate_weight_patched
+#         except AttributeError:
+#             print("[comfyui-easy-use] Injecting patched comfy.model_patcher.ModelPatcher.calculate_weight")
+#             original_calculate_weight = ModelPatcher.calculate_weight
+#             ModelPatcher.original_calculate_weight = original_calculate_weight
+#             ModelPatcher.calculate_weight = calculate_weight_patched
+#         injected_model_patcher_calculate_weight = True
+
+
+class InpaintWorker:
+    def __init__(self, node_name):
+        self.node_name = node_name if node_name is not None else ""
+
+    def load_fooocus_patch(self, lora: dict, to_load: dict):
+        patch_dict = {}
+        loaded_keys = set()
+        for key in to_load.values():
+            if value := lora.get(key, None):
+                patch_dict[key] = ("fooocus", value)
+                loaded_keys.add(key)
+
+        not_loaded = sum(1 for x in lora if x not in loaded_keys)
+        if not_loaded > 0:
+            log_node_info(self.node_name,
+                f"{len(loaded_keys)} Lora keys loaded, {not_loaded} remaining keys not found in model."
+            )
+        return patch_dict
+
+    def _input_block_patch(self, h: torch.Tensor, transformer_options: dict):
+        if transformer_options["block"][1] == 0:
+            if self._inpaint_block is None or self._inpaint_block.shape != h.shape:
+                assert self._inpaint_head_feature is not None
+                batch = h.shape[0] // self._inpaint_head_feature.shape[0]
+                self._inpaint_block = self._inpaint_head_feature.to(h).repeat(batch, 1, 1, 1)
+            h = h + self._inpaint_block
+        return h
+
+    def patch(self, model, latent, patch):
+        base_model: BaseModel = model.model
+        latent_pixels = base_model.process_latent_in(latent["samples"])
+        noise_mask = latent["noise_mask"].round()
+        latent_mask = F.max_pool2d(noise_mask, (8, 8)).round().to(latent_pixels)
+
+        inpaint_head_model, inpaint_lora = patch
+        feed = torch.cat([latent_mask, latent_pixels], dim=1)
+        inpaint_head_model.to(device=feed.device, dtype=feed.dtype)
+        self._inpaint_head_feature = inpaint_head_model(feed)
+        self._inpaint_block = None
+
+        lora_keys = comfy.lora.model_lora_keys_unet(model.model, {})
+        lora_keys.update({x: x for x in base_model.state_dict().keys()})
+        loaded_lora = self.load_fooocus_patch(inpaint_lora, lora_keys)
+
+        m = model.clone()
+        m.set_model_input_block_patch(self._input_block_patch)
+        patched = m.add_patches(loaded_lora, 1.0)
+        m.model_options['transformer_options']['fooocus'] = True
+        not_patched_count = sum(1 for x in loaded_lora if x not in patched)
+        if not_patched_count > 0:
+            log_node_error(self.node_name, f"Failed to patch {not_patched_count} keys")
+
+        # inject_patched_calculate_weight()
+        return (m,)

py/modules/human_parsing/run_parsing.py

@@ -0,0 +1,109 @@
+import numpy as np
+import torch
+from PIL import Image
+from .parsing_api import onnx_inference
+from ...libs.utils import install_package
+
+class HumanParsing:
+    def __init__(self, model_path):
+        self.model_path = model_path
+        self.session = None
+
+    def __call__(self, input_image, mask_components):
+        if self.session is None:
+            install_package('onnxruntime')
+            import onnxruntime as ort
+
+            session_options = ort.SessionOptions()
+            session_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+            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=['CUDAExecutionProvider', 'CPUExecutionProvider'])
+
+        parsed_image, mask = onnx_inference(self.session, input_image, mask_components)
+        return parsed_image, mask
+
+
+class HumanParts:
+
+    def __init__(self, model_path):
+        self.model_path = model_path
+        self.session = None
+        # self.classes_dict = {
+        #     "background": 0,
+        #     "hair": 2,
+        #     "glasses": 4,
+        #     "top-clothes": 5,
+        #     "bottom-clothes": 9,
+        #     "torso-skin": 10,
+        #     "face": 13,
+        #     "left-arm": 14,
+        #     "right-arm": 15,
+        #     "left-leg": 16,
+        #     "right-leg": 17,
+        #     "left-foot": 18,
+        #     "right-foot": 19,
+        # },
+        self.classes = [0, 13, 2, 4, 5, 9, 10, 14, 15, 16, 17, 18, 19]
+
+
+    def __call__(self, input_image, mask_components):
+        if self.session is None:
+            install_package('onnxruntime')
+            import onnxruntime as ort
+
+            self.session = ort.InferenceSession(self.model_path, providers=['TensorrtExecutionProvider', 'CUDAExecutionProvider', 'CPUExecutionProvider'])
+
+        mask, = self.get_mask(self.session, input_image, 0, mask_components)
+        return mask
+
+    def get_mask(self, model, image, rotation, mask_components):
+        image = image.squeeze(0)
+        image_np = image.numpy() * 255
+
+        pil_image = Image.fromarray(image_np.astype(np.uint8))
+        original_size = pil_image.size  # to resize the mask later
+        # resize to 512x512 as the model expects
+        pil_image = pil_image.resize((512, 512))
+        center = (256, 256)
+
+        if rotation != 0:
+            pil_image = pil_image.rotate(rotation, center=center)
+
+        # normalize the image
+        image_np = np.array(pil_image).astype(np.float32) / 127.5 - 1
+        image_np = np.expand_dims(image_np, axis=0)
+
+        # use the onnx model to get the mask
+        input_name = model.get_inputs()[0].name
+        output_name = model.get_outputs()[0].name
+        result = model.run([output_name], {input_name: image_np})
+        result = np.array(result[0]).argmax(axis=3).squeeze(0)
+
+        score: int = 0
+
+        mask = np.zeros_like(result)
+        for class_index in mask_components:
+            detected = result == self.classes[class_index]
+            mask[detected] = 255
+            score += mask.sum()
+
+        # back to the original size
+        mask_image = Image.fromarray(mask.astype(np.uint8), mode="L")
+        if rotation != 0:
+            mask_image = mask_image.rotate(-rotation, center=center)
+
+        mask_image = mask_image.resize(original_size)
+
+        # and back to numpy...
+        mask = np.array(mask_image).astype(np.float32) / 255
+
+        # add 2 dimensions to match the expected output
+        mask = np.expand_dims(mask, axis=0)
+        mask = np.expand_dims(mask, axis=0)
+        # ensure to return a "binary mask_image"
+
+        del image_np, result  # free up memory, maybe not necessary
+
+        return (torch.from_numpy(mask.astype(np.uint8)),)