From 7ee6e411dfffc0f6e775752477e8b5d97f7db073 Mon Sep 17 00:00:00 2001 From: fang-rongcan Date: Fri, 6 Jun 2025 16:34:30 +0800 Subject: [PATCH 1/5] opensoraplan1.0 adaptation --- MindIE/MultiModal/OpenSoraPlan-1.0/README.md | 376 ++++++ .../inference_opensora_plan.py | 166 +++ .../OpenSoraPlan-1.0/opensoraplan/__init__.py | 40 + .../opensoraplan/acceleration/__init__.py | 18 + .../acceleration/dit_cache_common.py | 133 +++ .../acceleration/open_sora_plan_dit_cache.py | 166 +++ .../opensoraplan/config_utils.py | 70 ++ .../opensoraplan/layers/__init__.py | 33 + .../opensoraplan/layers/attention.py | 157 +++ .../opensoraplan/layers/conv.py | 140 +++ .../opensoraplan/layers/ops.py | 43 + .../opensoraplan/layers/resnet_block.py | 101 ++ .../opensoraplan/layers/updownsample.py | 204 ++++ .../opensoraplan/layers/utils.py | 145 +++ .../opensoraplan/models/__init__.py | 15 + .../opensoraplan/models/causalvae/__init__.py | 17 + .../models/causalvae/modeling_causalvae.py | 643 +++++++++++ .../opensoraplan/models/comm.py | 144 +++ .../opensoraplan/models/latte/__init__.py | 17 + .../models/latte/latte_modules.py | 1024 +++++++++++++++++ .../models/latte/modeling_latte.py | 557 +++++++++ .../opensoraplan/models/model_load_utils.py | 30 + .../opensoraplan/models/parallel_mgr.py | 64 ++ .../opensoraplan/pipeline/__init__.py | 17 + .../opensoraplan/pipeline/compile_pipe.py | 47 + .../pipeline/open_sora_plan_pipeline.py | 744 ++++++++++++ .../opensoraplan/pipeline/pipeline_utils.py | 170 +++ .../opensoraplan/schedulers/.gitkeep | 0 .../opensoraplan/schedulers/__init__.py | 15 + .../schedulers/scheduler_optimizer.py | 49 + .../opensoraplan/utils/.gitkeep | 0 .../opensoraplan/utils/__init__.py | 19 + .../opensoraplan/utils/log.py | 20 + .../opensoraplan/utils/utils.py | 152 +++ .../OpenSoraPlan-1.0/requirements.txt | 47 + .../tests/configs/configmixin.json | 4 + .../tests/configs/invalid.json | 1 + .../scheduler_config_invalid_test.json | 5 + .../tests/configs/scheduler_config_test.json | 6 + .../tests/models/test_causalvae.py | 121 ++ .../tests/pipeline/spiece.model | Bin 0 -> 791656 bytes .../pipeline/test_opensora_plan_pipeline.py | 136 +++ .../OpenSoraPlan-1.0/tests/run_test.sh | 33 + .../OpenSoraPlan-1.0/tests/t2v_sora.txt | 48 + .../tests/test_config_utils.py | 91 ++ 45 files changed, 6028 insertions(+) create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/README.md create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/inference_opensora_plan.py create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/__init__.py create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/acceleration/__init__.py create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/acceleration/dit_cache_common.py create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/acceleration/open_sora_plan_dit_cache.py create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/config_utils.py create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/layers/__init__.py create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/layers/attention.py create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/layers/conv.py create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/layers/ops.py create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/layers/resnet_block.py create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/layers/updownsample.py create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/layers/utils.py create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/__init__.py create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/causalvae/__init__.py create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/causalvae/modeling_causalvae.py create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/comm.py create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/latte/__init__.py create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/latte/latte_modules.py create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/latte/modeling_latte.py create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/model_load_utils.py create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/parallel_mgr.py create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/pipeline/__init__.py create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/pipeline/compile_pipe.py create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/pipeline/open_sora_plan_pipeline.py create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/pipeline/pipeline_utils.py create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/schedulers/.gitkeep create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/schedulers/__init__.py create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/schedulers/scheduler_optimizer.py create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/utils/.gitkeep create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/utils/__init__.py create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/utils/log.py create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/utils/utils.py create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/requirements.txt create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/tests/configs/configmixin.json create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/tests/configs/invalid.json create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/tests/configs/scheduler_config_invalid_test.json create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/tests/configs/scheduler_config_test.json create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/tests/models/test_causalvae.py create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/tests/pipeline/spiece.model create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/tests/pipeline/test_opensora_plan_pipeline.py create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/tests/run_test.sh create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/tests/t2v_sora.txt create mode 100644 MindIE/MultiModal/OpenSoraPlan-1.0/tests/test_config_utils.py diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/README.md b/MindIE/MultiModal/OpenSoraPlan-1.0/README.md new file mode 100644 index 0000000000..3f720edd76 --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/README.md @@ -0,0 +1,376 @@ +# MindIE SD + +## 一、介绍 +MindIE SD是MindIE的视图生成推理模型套件，其目标是为稳定扩散（Stable Diffusion, SD）系列大模型推理任务提供在昇腾硬件及其软件栈上的端到端解决方案，软件系统内部集成各功能模块，对外呈现统一的编程接口。 + +## 二、安装依赖 + +MindIE-SD其依赖组件为driver驱动包、firmware固件包、CANN开发套件包、推理引擎MindIE包，使用MindIE-SD前请提前安装这些依赖。 + +| 简称 | 安装包全名 | 默认安装路径 | 版本约束 | +| --------------- |---------------------------------------------------------------------------|--------------------------------------|-----------------------------------| +| driver驱动包 | 昇腾310P处理器对应驱动软件包：Ascend-hdk-310p-npu-driver_\{version\}\_{os}\-{arch}.run | /usr/local/Ascend | 24.0.rc1及以上 | +| firmware固件包 | 昇腾310P处理器对应固件软件包：Ascend-hdk-310p-npu-firmware_\{version\}.run | /usr/local/Ascend | 24.0.rc1及以上 | +| CANN开发套件包 | Ascend-cann-toolkit\_{version}_linux-{arch}.run | /usr/local/Ascend/ascend-toolkit/latest | 8.0.RC1及以上 | +| 推理引擎MindIE包 | Ascend-mindie\_\{version}_linux-\{arch}.run | /usr/local/Ascend/mindie/latest | 和mindietorch严格配套使用 | +| torch | Python的whl包：torch-{version}-cp310-cp310-{os}_{arch}.whl | - | Python版本3.10.x，torch版本支持2.1.0 | + +- {version}为软件包版本 +- {os}为系统名称，如Linux +- {arch}为架构名称，如x86_64 + +### 2.1 安装驱动和固件 + +1. 获取地址 +- [800I A2](https://www.hiascend.com/hardware/firmware-drivers/community?product=4&model=32&cann=8.0.RC1.beta1&driver=1.0.RC1.alpha) +- [Duo卡](https://www.hiascend.com/hardware/firmware-drivers/community?product=2&model=17&cann=8.0.RC2.alpha002&driver=1.0.22.alpha) +2. [安装指导手册](https://www.hiascend.com/document/detail/zh/CANNCommunityEdition/80RC2alpha002/softwareinst/instg/instg_0019.html) +### 2.2 CANN开发套件包+kernel包+MindIE包下载 +1. 下载： +- [800I A2](https://www.hiascend.com/developer/download/community/result?module=pt+ie+cann&product=4&model=32) +- [Duo卡](https://www.hiascend.com/developer/download/community/result?module=pt+ie+cann&product=2&model=17) +2. [环境准备指导](https://www.hiascend.com/document/detail/zh/CANNCommunityEdition/80RC2alpha002/softwareinst/instg/instg_0001.html) + +3. 快速安装： +- CANN开发套件包+kernel包安装 +```commandline +# 增加软件包可执行权限，{version}表示软件版本号，{arch}表示CPU架构，{soc}表示昇腾AI处理器的版本。 +chmod +x ./Ascend-cann-toolkit_{version}_linux-{arch}.run +chmod +x ./Ascend-cann-kernels-{soc}_{version}_linux.run +# 校验软件包安装文件的一致性和完整性 +./Ascend-cann-toolkit_{version}_linux-{arch}.run --check +./Ascend-cann-kernels-{soc}_{version}_linux.run --check +# 安装 +./Ascend-cann-toolkit_{version}_linux-{arch}.run --install +./Ascend-cann-kernels-{soc}_{version}_linux.run --install + +# 设置环境变量 +source /usr/local/Ascend/ascend-toolkit/set_env.sh +``` +- MindIE包安装 +```commandline +# 增加软件包可执行权限，{version}表示软件版本号，{arch}表示CPU架构。 +chmod +x ./Ascend-mindie_${version}_linux-${arch}.run +./Ascend-mindie_${version}_linux-${arch}.run --check + +# 方式一：默认路径安装 +./Ascend-mindie_${version}_linux-${arch}.run --install +# 设置环境变量 +cd /usr/local/Ascend/mindie && source set_env.sh + +# 方式二：指定路径安装 +./Ascend-mindie_${version}_linux-${arch}.run --install-path=${AieInstallPath} +# 设置环境变量 +cd ${AieInstallPath}/mindie && source set_env.sh +``` + +- MindIE SD不需要单独安装，安装MindIE时将会自动安装 +- torch_npu 安装: +下载 pytorch_v{pytorchversion}_py{pythonversion}.tar.gz +```commandline +tar -xzvf pytorch_v{pytorchversion}_py{pythonversion}.tar.gz +# 解压后，会有whl包 +pip install torch_npu-{pytorchversion}.xxxx.{arch}.whl +``` + +### 2.3 pytorch框架(支持版本为：2.1.0) +[安装包下载](https://download.pytorch.org/whl/cpu/torch/) + +使用pip安装 +```shell +# {version}表示软件版本号，{arch}表示CPU架构。 +pip install torch-${version}-cp310-cp310-linux_${arch}.whl +``` + +## 三、OpenSora1.2使用 + +### 3.1 权重及配置文件说明 +#### 3.1.1 下载子模型权重 +首先需要下载以下子模型权重和配置文件：text_encoder、tokenizer、transformer、vae、scheduler + +1.text_encoder: +- 下载配置文件和权重文件，下载链接： +```shell + https://huggingface.co/DeepFloyd/t5-v1_1-xxl/tree/main +``` +下载后重命名文件夹为text_encoder + +2.tokenizer: +将上述下载的text_encoder的权重和配置文件中的tokenizer_config.json和spiece.model拷贝并单独存放至另一个文件夹，重命名文件夹为tokenizer + +3.transformer： +- 下载配置文件和权重文件，下载链接： +```shell +https://huggingface.co/hpcai-tech/OpenSora-STDiT-v3/tree/main +``` +下载后重命名文件夹为transformer + +4.vae： +vae需要下载两部分权重:VAE和VAE_2d + +(1) VAE +- 按以下链接下载权重和配置文件，并修改配置文件的architectures和model_type字段为VideoAutoencoder。参考MindIE-SD/examples/open-sora/vae/config.json。 +```shell +https://huggingface.co/hpcai-tech/OpenSora-VAE-v1.2/tree/main +``` +下载后重命名文件夹为vae + +(2) VAE_2d： +- 按以下链接下载配置文件和权重文件，在上述vae文件夹下新建vae_2d/vae目录，并将下载的权重文件放置在路径下。 +```shell +https://huggingface.co/PixArt-alpha/pixart_sigma_sdxlvae_T5_diffusers/tree/main +``` +5.scheduler: +- 采样器无需权重文件，配置文件参考MindIE-SD/examples/open-sora/scheduler/scheduler_config.json设置，并放置在scheduler文件夹下。 + +#### 3.1.2 配置Pipeline +1. 新建model_index.json配置文件，参考MindIE-SD/examples/open-sora-plan/model_index.json，与其他子模型文件夹同级目录。并将整体Pipeline权重文件夹命名为OpenSora1.2。 + +2. 配置完成后示例如下。 +```commandline +|----OpenSora1.2 +| |---- model_index.json +| |---- scheduler +| | |---- scheduler_config.json +| |---- text_encoder +| | |---- config.json +| | |---- pytorch_model-00001-of-00002.bin +| | |---- pytorch_model-00002-of-00002.bin +| | |---- pytorch_model.bin.index.json +| | |---- special_tokens_map.json +| | |---- spiece.model +| | |---- tokenizer_config.json +| |---- tokenizer +| | |---- spiece.model +| | |---- tokenizer_config.json +| |---- transformer +| | |---- config.json +| | |---- model.safetensors +| |---- vae +| | |---- config.json +| | |---- model.safetensors +| | |---- vae_2d +| | | |---- vae +| | | | |---- config.json +| | | | |---- diffusion_pytorch_model.safetensors +``` + +### 3.2 安装依赖库 +进入MindIE-SD路径，安装MindIE-SD的依赖库。 +``` +pip install -r requirements.txt +``` +安装colossalai。 colossalai0.4.4 版本会自动安装高版本torch, 所以要单独安装。 +``` +pip install colossalai==0.4.4 --no-deps +``` +### 3.3 单卡性能测试 +设置权重路径 +```shell +path='./path' +``` +执行命令： +```shell +python tests/inference_opensora12.py \ + --path ${path} \ + --device_id 0 \ + --type bf16 \ + --num_frames 32 \ + --image_size 720,1280 \ + --fps 8 +``` +参数说明： +- path: 权重路径，包含vae、text_encoder、Tokenizer、Transformer和Scheduler五个模型的配置文件及权重。 +- device_id: 推理设备ID。 +- type: bf16、fp16。 +- num_frames:总帧数，范围：32, 128。 +- image_size：(720, 1280)、(512, 512)。 +- fps: 每秒帧数：8。 +- test_acc: 使用--test_acc开启全量视频生成，用于精度测试。性能测试时，不开启该参数。 + +### 3.4 多卡性能测试 +设置权重路径 +```shell +path='./path' +``` + +执行命令： +```shell +torchrun --nproc_per_node=4 tests/inference_opensora12.py \ + --path ${path} \ + --type bf16 \ + --num_frames 32 \ + --image_size (720,1280) \ + --fps 8 \ + --enable_sequence_parallelism True +``` +参数说明： +- nproc_per_node: 并行推理的总卡数。 +- enable_sequence_parallelism 开启dsp 多卡并行 +- path: 权重路径，包含vae、text_encoder、Tokenizer、Transformer和Scheduler五个模型的配置文件及权重。 +- type: bf16、fp16。 +- num_frames:总帧数，范围：32, 128。 +- image_size：(720, 1280)、(512, 512)。 +- fps: 每秒帧数：8。 + +精度测试参考第五节Vbench精度测试。 + +## 四、OpenSoraPlan1.0使用 + +### 4.1 权重及配置文件说明 +#### 4.1.1 下载子模型权重 +首先需要下载以下子模型权重：text_encoder、tokenizer、transformer、vae + +1.text_encoder: +- 下载配置文件和权重文件，下载链接： +```shell +https://huggingface.co/DeepFloyd/t5-v1_1-xxl/tree/main +``` +下载后重命名文件夹为text_encoder + +2.tokenizer: +将上述下载的text_encoder的权重和配置文件中的tokenizer_config.json和spiece.model拷贝并单独存放至另一个文件夹，重命名文件夹为tokenizer + +3.transformer： +- 下载配置文件和权重文件，根据需要下载不同分辨率和帧数的权重和配置文件，当前支持17x256x256、65x256x256、65x512x512三种规格，选择一种规格下载即可。下载链接： +```shell +https://huggingface.co/LanguageBind/Open-Sora-Plan-v1.0.0/tree/main +``` +下载完成后重命名文件夹为transformer + +4.vae： +- 下载配置文件和权重文件，下载该链接下的vae文件夹： +```shell +https://huggingface.co/LanguageBind/Open-Sora-Plan-v1.0.0/tree/main +``` + +#### 4.1.2 配置Pipeline +1.新建model_index.json配置文件，参考MindIE-SD/examples/open-sora-plan/model_index.json，与其他子模型文件夹同级目录。并将整体Pipeline权重文件夹命名为Open-Sora-Plan-v1.0.0。 + +2.配置完成后示例如下。 +```commandline +|----Open-Sora-Plan-v1.0.0 +| |---- model_index.json +| |---- text_encoder +| | |---- config.json +| | |---- pytorch_model-00001-of-00002.bin +| | |---- pytorch_model-00002-of-00002.bin +| | |---- pytorch_model.bin.index.json +| | |---- special_tokens_map.json +| | |---- spiece.model +| | |---- tokenizer_config.json +| |---- tokenizer +| | |---- spiece.model +| | |---- tokenizer_config.json +| |---- transformer +| | |---- config.json +| | |---- diffusion_pytorch_model.safetensors +| |---- vae +| | |---- config.json +| | |---- diffusion_pytorch_model.safetensors +``` + +### 4.2 安装依赖库 +进入MindIE-SD/mindiesd/requirements路径，安装open-sora-plan1.0的依赖库。 +``` +pip install -r requirements_opensoraplan.txt +``` +安装colossalai。 colossalai0.4.4 版本会自动安装高版本torch, 所以要单独安装。 +``` +pip install colossalai==0.4.4 --no-deps +``` +### 4.3 单卡性能测试 +设置权重路径 +```shell +model_path='./model_path' +``` +执行命令： +```shell +python tests/inference_opensora_plan.py \ + --model_path ${model_path} \ + --text_prompt tests/t2v_sora.txt \ + --sample_method PNDM \ + --save_img_path ./sample_videos/t2v_PNDM \ + --image_size 512 \ + --fps 24 \ + --guidance_scale 7.5 \ + --num_sampling_steps 250 \ + --seed 5464 +``` +参数说明： +- model_path: 权重路径，包含vae、text_encoder、Tokenizer、Transformer和Scheduler五个模型的配置文件及权重。 +- text_prompt: 输入prompt，可以为list形式或txt文本文件（按行分割）。 +- sample_method：采样器名称，默认PNDM，只支持['DDIM', 'EulerDiscrete', 'DDPM', 'DPMSolverMultistep','DPMSolverSinglestep', 'PNDM', 'HeunDiscrete', 'EulerAncestralDiscrete', 'DEISMultistep', 'KDPM2AncestralDiscrete']。若要使用采样步数优化，则选择"DPMSolverSinglestep"或"DDPM"。 +- save_img_path：生成视频的保存路径，默认./sample_videos/t2v。 +- image_size：生成视频的分辨率，需与下载的transformer权重版本对应，为512或256。 +- fps：生成视频的帧率，默认24。 +- guidance_scale：生成视频中cfg的参数，默认7.5。 +- num_sampling_steps：生成视频采样迭代次数，默认250步。若采用"DPMSolverSinglestep"或"DDPM"采样器，可设置为50步。 +- seed: 随机种子设置。 + +注：若出现"RuntimeError: NPU out of memory."报错，可能是torch_npu最新版本默认把虚拟内存关闭，可尝试设置```export PYTORCH_NPU_ALLOC_CONF=expandable_segments:True```环境变量解决。 + +### 4.4 多卡性能测试 +设置权重路径、并行推理的总卡数 +```shell +model_path='./model_path' +NUM_DEVICES=4 +``` + +执行命令： +```shell +ASCEND_RT_VISIBLE_DEVICES=0,1,2,3 torchrun --nproc_per_node=$NUM_DEVICES tests/inference_opensora_plan.py \ + --model_path ${model_path} \ + --text_prompt tests/t2v_sora.txt \ + --sample_method PNDM \ + --save_img_path ./sample_videos/t2v_PNDM_dsp_$NUM_DEVICES \ + --image_size 512 \ + --fps 24 \ + --guidance_scale 7.5 \ + --num_sampling_steps 250 \ + --seed 5464 \ + --sequence_parallel_size $NUM_DEVICES +``` +参数说明： +- ASCEND_RT_VISIBLE_DEVICES: 指定使用的具体推理设备ID +- nproc_per_node: 并行推理的总卡数。 +- sequence_parallel_size: 序列并行的数量。 +其余参数同上 + +### 4.5 开启patch相似性压缩测试 +设置权重路径 +```shell +model_path='./model_path' +``` +执行命令： +```shell +python tests/inference_opensora_plan.py \ + --model_path ${model_path} \ + --text_prompt tests/t2v_sora.txt \ + --sample_method PNDM \ + --save_img_path ./sample_videos/t2v_PNDM \ + --image_size 512 \ + --fps 24 \ + --guidance_scale 7.5 \ + --num_sampling_steps 250 \ + --use_cache \ + --cache_config 5,27,5,2 \ + --cfg_last_step 150 \ + --seed 5464 +``` +参数说明： +- use_cache: 是否开启DiT-Cache，不设置则不开启。 +- cache_config: DiT-Cache的配置参数，需设置4个数值，分别为start_block_idx, end_block_idx, start_step, step_interval。 +- cfg_last_step：开启跳过cfg计算的步数。 +其余参数同上。 + +精度测试参考第五节Vbench精度测试。 + +## 五、Vbench精度测试(基于gpu) +1、视频生成完成后，精度测试推荐使用业界常用的VBench(Video Benchmark)工具，详见如下链接： +```shell +https://github.com/Vchitect/VBench +``` +2、当前主要评估指标为[subject_consistency, imaging_quality, aesthetic_quality, overall_consistency, motion_smoothness]。 + +注：vbench各精度指标平均下降不超过1%可认为该视频质量无下降。 diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/inference_opensora_plan.py b/MindIE/MultiModal/OpenSoraPlan-1.0/inference_opensora_plan.py new file mode 100644 index 0000000000..a9f9d42167 --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/inference_opensora_plan.py @@ -0,0 +1,166 @@ +#!/usr/bin/env python +# coding=utf-8 +# Copyright 2024 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os +import sys +import time +import argparse +import logging + +import torch +import torch_npu +from torchvision.utils import save_image +import imageio +import colossalai + +sys.path.append(os.path.split(sys.path[0])[0]) + +from opensoraplan import OpenSoraPlanPipeline +from opensoraplan import compile_pipe, get_scheduler, set_parallel_manager +from opensoraplan import CacheConfig, OpenSoraPlanDiTCacheManager + +MASTER_PORT = '42043' + + +def main(args): + torch.manual_seed(args.seed) + torch.npu.manual_seed(args.seed) + torch.npu.manual_seed_all(args.seed) + torch.set_grad_enabled(False) + device = "npu" if torch.npu.is_available() else "cpu" + + sp_size = args.sequence_parallel_size + if sp_size == 1: + os.environ['RANK'] = '0' + os.environ['LOCAL_RANK'] = '0' + os.environ['WORLD_SIZE'] = '1' + os.environ['MASTER_ADDR'] = 'localhost' + os.environ['MASTER_PORT'] = MASTER_PORT + colossalai.launch_from_torch({}, seed=args.seed) + set_parallel_manager(sp_size=args.sequence_parallel_size, sp_axis=0) + + if args.force_images: + ext = 'jpg' + else: + ext = 'mp4' + scheduler = get_scheduler(args.sample_method) + # load the pipeline model weights and config + videogen_pipeline = OpenSoraPlanPipeline.from_pretrained(model_path=args.model_path, + image_size=args.image_size, + scheduler=scheduler, + dtype=torch.float16, + vae_stride=args.vae_stride) + # prepare the cache_manager + cache_nums = [int(i) for i in args.cache_config.split(',')] + if len(cache_nums) != 4: + raise ValueError("cache_config num length must equals 4.") + cache_manager = OpenSoraPlanDiTCacheManager( + CacheConfig(cache_nums[0], cache_nums[1], cache_nums[2], cache_nums[3], args.use_cache)) + # compile pipeline and set the cache_manager and cfg_last_step + videogen_pipeline = compile_pipe(videogen_pipeline, cache_manager, args.cfg_last_step) + + if not os.path.exists(args.save_img_path): + os.makedirs(args.save_img_path) + + # read the prompt contents + if not isinstance(args.text_prompt, list): + args.text_prompt = [args.text_prompt] + if len(args.text_prompt) == 1 and args.text_prompt[0].endswith('txt'): + text_prompt = open(args.text_prompt[0], 'r').readlines() + args.text_prompt = [i.strip() for i in text_prompt] + args.text_prompt = args.text_prompt + + time_list = [] + # pipeline inference + for idx, prompt in enumerate(args.text_prompt): + torch_npu.npu.synchronize() + start_time = time.time() + torch.manual_seed(args.seed) + torch.npu.manual_seed(args.seed) + torch.npu.manual_seed_all(args.seed) + logging.info('Processing the (%s) prompt', prompt) + videos = videogen_pipeline(prompt, + num_inference_steps=args.num_sampling_steps, + guidance_scale=args.guidance_scale, + enable_temporal_attentions=not args.force_images, + num_images_per_prompt=1, + ).video + if videogen_pipeline.transformer.cache_manager.cal_block_num != 0: + ratio = ( + videogen_pipeline.transformer.cache_manager.all_block_num + / videogen_pipeline.transformer.cache_manager.cal_block_num + ) + else: + raise ZeroDivisionError("transformer cal_block_num can not be zero.") + logging.info("cal_block_ratio: %.2f, %d, %d", + ratio, videogen_pipeline.transformer.cache_manager.cal_block_num, + videogen_pipeline.transformer.cache_manager.all_block_num) + torch_npu.npu.synchronize() + time_list.append(time.time() - start_time) + try: + if args.force_images: + videos = videos[:, 0].permute(0, 3, 1, 2) # b t h w c -> b c h w + save_image( + videos / 255.0, + os.path.join( + args.save_img_path, + prompt.replace(' ', '_')[:100] + + f'{args.sample_method}_gs{args.guidance_scale}_s{args.num_sampling_steps}.{ext}', + ), + nrow=1, normalize=True, value_range=(0, 1) + ) # t c h w + else: + imageio.mimwrite( + os.path.join( + args.save_img_path, + f'sample_{idx}_{args.sample_method}_gs{args.guidance_scale}_s{args.num_sampling_steps}.{ext}' + ), videos[0], + fps=args.fps, quality=9) # highest quality is 10, lowest is 0 + logging.info('Saving sample_%d for %s %d steps success!!!', \ + idx, args.sample_method, args.num_sampling_steps) + except IOError as e: + logging.error('Error when saving sample_%d for %s %d steps for %s!!!', \ + idx, args.sample_method, args.num_sampling_steps, prompt) + sys.exit('An error occured and the program will exit.') + + logging.info("time_list: %s", time_list) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--model_path", type=str, default='/data1/models/Open-Sora-Plan-v1.0.0') + parser.add_argument("--save_img_path", type=str, default="./sample_videos/t2v") + parser.add_argument("--guidance_scale", type=float, default=7.5) + parser.add_argument("--sample_method", type=str, default="PNDM") + parser.add_argument("--num_sampling_steps", type=int, default=250) + parser.add_argument("--image_size", type=int, default=512) + parser.add_argument("--fps", type=int, default=24) + parser.add_argument("--run_time", type=int, default=0) + parser.add_argument("--seed", type=int, default=2333) + parser.add_argument("--vae_stride", type=int, default=8) + parser.add_argument("--cache_config", type=str, default="5,27,5,2") + parser.add_argument('--use_cache', action='store_true') + parser.add_argument("--cfg_last_step", type=int, default=10000) + parser.add_argument("--text_prompt", nargs='+') + parser.add_argument('--force_images', action='store_true') + parser.add_argument('--sequence_parallel_size', type=int, default=1) + args_input = parser.parse_args() + + if not os.path.exists(args_input.model_path): + logging.warning('WARNING:wrong model_path given !!!') + sys.exit('An error occured and the program will exit.') + + main(args_input) diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/__init__.py b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/__init__.py new file mode 100644 index 0000000000..ee4d85ed37 --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/__init__.py @@ -0,0 +1,40 @@ +#!/usr/bin/env python +# coding=utf-8 +# Copyright 2024 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +__all__ = [ + 'ConfigMixin', + 'compile_pipe', + 'LatteT2V', + 'LatteParams', + 'CausalVAEModelWrapper', + 'OpenSoraPlanPipeline', + 'set_parallel_manager', + 'get_scheduler', + 'CacheConfig', + 'OpenSoraPlanDiTCacheManager' +] + +from .config_utils import ConfigMixin +from .pipeline.compile_pipe import compile_pipe + +from .models.latte.modeling_latte import LatteT2V, LatteParams +from .models.causalvae.modeling_causalvae import CausalVAEModelWrapper +from .pipeline.open_sora_plan_pipeline import OpenSoraPlanPipeline +from .models.parallel_mgr import set_parallel_manager +from .schedulers.scheduler_optimizer import get_scheduler +from .acceleration.dit_cache_common import CacheConfig +from .acceleration.open_sora_plan_dit_cache import OpenSoraPlanDiTCacheManager diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/acceleration/__init__.py b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/acceleration/__init__.py new file mode 100644 index 0000000000..1cc6b36093 --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/acceleration/__init__.py @@ -0,0 +1,18 @@ +#!/usr/bin/env python +# coding=utf-8 +# Copyright 2024 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from .dit_cache_common import CacheConfig +from .open_sora_plan_dit_cache import OpenSoraPlanDiTCacheManager \ No newline at end of file diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/acceleration/dit_cache_common.py b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/acceleration/dit_cache_common.py new file mode 100644 index 0000000000..3c89f2fa58 --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/acceleration/dit_cache_common.py @@ -0,0 +1,133 @@ +#!/usr/bin/env python +# coding=utf-8 +# Copyright 2024 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Optional, List, Union +from dataclasses import dataclass +import torch +import torch.nn as nn + + +@dataclass +class CacheConfig: + start_block_idx: int = 0 + end_block_idx: int = 0 + start_step: int = 0 + step_interval: int = 2 + use_cache: bool = False + use_cache_encoder: bool = False + + def __post_init__(self): + if not isinstance(self.start_block_idx, int): + raise TypeError(f"Expected int for start_block_idx, but got {type(self.start_block_idx).__name__}") + if not isinstance(self.end_block_idx, int): + raise TypeError(f"Expected int for end_block_idx, but got {type(self.end_block_idx).__name__}") + if not isinstance(self.start_step, int): + raise TypeError(f"Expected int for start_step, but got {type(self.start_step).__name__}") + if not isinstance(self.step_interval, int): + raise TypeError(f"Expected int for step_interval, but got {type(self.step_interval).__name__}") + if not isinstance(self.use_cache, bool): + raise TypeError(f"Expected bool for use_cache, but got {type(self.use_cache).__name__}") + if not isinstance(self.use_cache_encoder, bool): + raise TypeError(f"Expected bool for use_cache_encoder, but got {type(self.use_cache_encoder).__name__}") + + +class DiTCacheManager: + def __init__( + self, + cache_config: CacheConfig + ): + """ + DiTCache plugin for the DiT models. Use this class to enable model cache quickly. + Args: + start_block_idx: (`int`) + The index of the block where chaching starts. + end_block_idx: (`int`) + The index of the block where chaching starts. + start_step: (`int`) + The index of the DiT denoising step where caching starts. + step_interval: (`int`) + Interval of caching steps fot DiT denoising. + use_cache_encoder: (`bool`) + Whether the DiT models need to compute encoder_hidden_states. + """ + self.start_block_idx = cache_config.start_block_idx + self.end_block_idx = cache_config.end_block_idx + self.start_step = cache_config.start_step + self.step_interval = cache_config.step_interval + self.use_cache = cache_config.use_cache + self.use_cache_encoder = cache_config.use_cache_encoder + + self.cache_hidden_states = None + self.cache_encoder_hidden_states = None + + if self.start_block_idx > self.end_block_idx: + raise ValueError("start_block_idx should not be larger than end_block_idx") + + def __call__( + self, + current_step: int, + block_list: Union[List[nn.ModuleList], List[List[nn.ModuleList]]], + hidden_states: torch.Tensor, + encoder_hidden_states: Optional[torch.Tensor] = None, + **kwargs + ): + # If current_step is less than cache start step, execute all blocks sequentially. + if (current_step < self.start_step) or (not self.use_cache): + for blocks in zip(*block_list): + hidden_states, encoder_hidden_states = self._forward_blocks(blocks, hidden_states, + encoder_hidden_states, **kwargs) + # go into cache step interval + else: + cache_hidden_states = torch.zeros_like(hidden_states) + cache_encoder_hidden_states = torch.zeros_like(encoder_hidden_states) + for block_idx, blocks in enumerate(zip(*block_list)): + # when current_step is exactly on the step_interval, compute and record the cache. + if current_step % self.step_interval == self.start_step % self.step_interval: + # record the tensor before DiT denoising. + if block_idx == self.start_block_idx: + cache_hidden_states = hidden_states.clone() + if self.use_cache_encoder: + cache_encoder_hidden_states = encoder_hidden_states.clone() + + hidden_states, encoder_hidden_states = self._forward_blocks(blocks, hidden_states, + encoder_hidden_states, **kwargs) + # cache the denoising difference. + if block_idx == (self.end_block_idx - 1): + self.cache_hidden_states = hidden_states - cache_hidden_states + if self.use_cache_encoder: + self.cache_encoder_hidden_states = encoder_hidden_states - cache_encoder_hidden_states + else: + # if block_idx is not in the interval using cache, execute all blocks sequentially. + if block_idx < self.start_block_idx or block_idx >= self.end_block_idx: + hidden_states, encoder_hidden_states = self._forward_blocks(blocks, hidden_states, + encoder_hidden_states, **kwargs) + # skip intermediate steps until the end_block_idx, overlay the cached denoising difference. + elif block_idx == (self.end_block_idx - 1): + hidden_states += self.cache_hidden_states + if self.use_cache_encoder: + encoder_hidden_states += self.cache_encoder_hidden_states + + return hidden_states + + def _forward_blocks(self, blocks, hidden_states, encoder_hidden_states, **kwargs): + for block in blocks: + results = block(hidden_states, encoder_hidden_states=encoder_hidden_states, **kwargs) + if self.use_cache_encoder: + hidden_states, encoder_hidden_states = results + else: + hidden_states = results + + return hidden_states, encoder_hidden_states diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/acceleration/open_sora_plan_dit_cache.py b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/acceleration/open_sora_plan_dit_cache.py new file mode 100644 index 0000000000..2a00579c77 --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/acceleration/open_sora_plan_dit_cache.py @@ -0,0 +1,166 @@ +#!/usr/bin/env python +# coding=utf-8 +# Copyright 2024 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import List, Union +from einops import rearrange, repeat +import torch +import torch.nn as nn +from opensoraplan.models.comm import ( + all_to_all_with_pad, + get_spatial_pad, + get_temporal_pad, +) +from opensoraplan.models.parallel_mgr import ( + get_sequence_parallel_group, + use_sequence_parallel +) +from .dit_cache_common import CacheConfig, DiTCacheManager + +SLICE_TEMPORAL_PATTERN = '(b T) S d -> b T S d' +CHANGE_TF_PATTERN = '(b t) f d -> (b f) t d' + + +class OpenSoraPlanDiTCacheManager(DiTCacheManager): + def __init__( + self, + cache_config: CacheConfig, + ): + if not isinstance(cache_config, CacheConfig): + raise TypeError(f"Expected CacheConfig for cache_config, but got {type(cache_config).__name__}") + super().__init__(cache_config) + self.temp_pos_embed = None + self.all_block_num = 0 + self.cal_block_num = 0 + self.delta_cache = None + + def __call__( + self, + current_step: int, + block_list: Union[List[nn.ModuleList], List[List[nn.ModuleList]]], + hidden_states: torch.Tensor, + **kwargs + ): + num_blocks = len(block_list[0]) + if self.start_block_idx < 0 or self.start_block_idx > num_blocks: + raise ValueError("start_block_idx is invalid, out of range [0, num_blocks]") + if self.end_block_idx < 0 or self.end_block_idx > num_blocks: + raise ValueError("end_block_idx is invalid, out of range [0, num_blocks]") + # If current_step is less than cache start step, execute all blocks sequentially. + if (current_step < self.start_step) or (not self.use_cache): + self.all_block_num += (num_blocks * 2) + hidden_states = self._forward_blocks(0, num_blocks, block_list, hidden_states, **kwargs) + # go into cache step interval + else: + self.all_block_num += (num_blocks * 2) + # infer [0, start_block_idx) + hidden_states = self._forward_blocks(0, self.start_block_idx, block_list, hidden_states, **kwargs) + # infer [start_block_idx, end_block_idx) + hidden_states_before_cache = hidden_states.clone() + if current_step % self.step_interval == self.start_step % self.step_interval: + hidden_states = self._forward_blocks(self.start_block_idx, self.end_block_idx, block_list, + hidden_states, **kwargs) + self.delta_cache = hidden_states - hidden_states_before_cache + else: + if self.delta_cache.shape == hidden_states_before_cache.shape: + hidden_states = hidden_states_before_cache + self.delta_cache + else: + hidden_states = self._forward_blocks(self.start_block_idx, self.end_block_idx, block_list, + hidden_states, **kwargs) + hidden_states = self._forward_blocks(self.end_block_idx, num_blocks, block_list, + hidden_states, **kwargs) + + return hidden_states + + def _forward_blocks(self, start_idx, end_idx, block_list, hidden_states, **kwargs): + attention_mask = kwargs.get("attention_mask") + encoder_hidden_states_spatial = kwargs.get("encoder_hidden_states_spatial") + encoder_attention_mask = kwargs.get("encoder_attention_mask") + timestep_spatial = kwargs.get("timestep_spatial") + timestep_temp = kwargs.get("timestep_temp") + cross_attention_kwargs = kwargs.get("cross_attention_kwargs") + class_labels = kwargs.get("class_labels") + input_batch_size = kwargs.get("input_batch_size") + enable_temporal_attentions = kwargs.get("enable_temporal_attentions") + t_dim = kwargs.get("t_dim") + s_dim = kwargs.get("s_dim") + timestep = kwargs.get("timestep") + for i, (spatial_block, temp_block) in enumerate( + zip(block_list[0][start_idx:end_idx], block_list[1][start_idx:end_idx])): + self.cal_block_num += input_batch_size + hidden_states = spatial_block( + hidden_states, + attention_mask, + encoder_hidden_states_spatial, + encoder_attention_mask, + timestep_spatial, + cross_attention_kwargs, + class_labels, + ) + + if enable_temporal_attentions: + if use_sequence_parallel(): + hidden_states = rearrange(hidden_states, SLICE_TEMPORAL_PATTERN, T=t_dim, + S=s_dim).contiguous() + hidden_states, s_dim, t_dim = self._dynamic_switch(hidden_states, s_dim, t_dim, + temporal_to_spatial=True) + timestep_temp = repeat(timestep, 'b d -> (b p) d', p=s_dim).contiguous() + + # b c f h w, f = 16 + 4 + hidden_states = rearrange(hidden_states, '(b T) S d -> (b S) T d', b=input_batch_size).contiguous() + + if start_idx + i == 0: + hidden_states = hidden_states + self.temp_pos_embed + + hidden_states = temp_block( + hidden_states, + None, # attention_mask + None, # encoder_hidden_states + None, # encoder_attention_mask + timestep_temp, + cross_attention_kwargs, + class_labels, + ) + + hidden_states = rearrange(hidden_states, CHANGE_TF_PATTERN, + b=input_batch_size).contiguous() + if use_sequence_parallel(): + hidden_states = rearrange(hidden_states, SLICE_TEMPORAL_PATTERN, T=t_dim, + S=s_dim).contiguous() + hidden_states, s_dim, t_dim = self._dynamic_switch(hidden_states, s_dim, t_dim, + temporal_to_spatial=False) + return hidden_states + + def _dynamic_switch(self, x, s, t, temporal_to_spatial: bool): + if temporal_to_spatial: + scatter_dim, gather_dim = 2, 1 + scatter_pad = get_spatial_pad() + gather_pad = get_temporal_pad() + else: + scatter_dim, gather_dim = 1, 2 + scatter_pad = get_temporal_pad() + gather_pad = get_spatial_pad() + + x = all_to_all_with_pad( + x, + get_sequence_parallel_group(), + scatter_dim=scatter_dim, + gather_dim=gather_dim, + scatter_pad=scatter_pad, + gather_pad=gather_pad, + ) + new_s, new_t = x.shape[2], x.shape[1] + x = rearrange(x, "b t s d -> (b t) s d") + return x, new_s, new_t diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/config_utils.py b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/config_utils.py new file mode 100644 index 0000000000..02cfc2e4ee --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/config_utils.py @@ -0,0 +1,70 @@ +#!/usr/bin/env python +# coding=utf-8 +# Copyright(C) 2024. Huawei Technologies Co.,Ltd. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License + +import os +import json +import inspect +from typing import Dict, Tuple +from .utils.log import logger + + +class ConfigMixin: + config_name = None + + @classmethod + def load_config(cls, model_path, **kwargs) -> Tuple[Dict, Dict]: + if cls.config_name is None: + logger.error("config_name is not defined.") + raise ValueError("config_name is not defined.") + + if model_path is None: + logger.error("model_path must not be None") + raise ValueError("model_path must not be None") + + model_path = os.path.abspath(model_path) + config_path = os.path.join(model_path, cls.config_name) + if not (os.path.exists(config_path) and os.path.isfile(config_path)): + logger.error("%s is not found in %s!", cls.config_name, model_path) + raise ValueError("%s is not found in %s!" % (cls.config_name, model_path)) + + config_dict = _load_json_dict(config_path) + + # get all required parameters + all_parameters = inspect.signature(cls.__init__).parameters + + init_keys = set(dict(all_parameters)) + init_keys.remove("self") + if 'kwargs' in init_keys: + init_keys.remove('kwargs') + + init_dict = {} + for key in init_keys: + # if key in config, use config + if key in config_dict: + init_dict[key] = config_dict.pop(key) + # if key in kwargs, use kwargs, this may rewrite config_dict + if key in kwargs: + init_dict[key] = kwargs.pop(key) + in_keys = set(init_dict.keys()) + if len(init_keys - in_keys) > 0: + logger.warning("%s was not found in config and kwargs! Use default values.", init_keys - in_keys) + return init_dict, config_dict + + +def _load_json_dict(config_path): + with open(config_path, "r", encoding="utf-8") as reader: + data = reader.read() + return json.loads(data, strict=False) \ No newline at end of file diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/layers/__init__.py b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/layers/__init__.py new file mode 100644 index 0000000000..59c2de987e --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/layers/__init__.py @@ -0,0 +1,33 @@ +#!/usr/bin/env python +# coding=utf-8 +# Copyright 2024 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from .attention import ( + AttnBlock3D, + AttnBlock, + LinAttnBlock, + LinearAttention, +) +from .conv import CausalConv3d, Conv2d +from .resnet_block import ResnetBlock2D, ResnetBlock3D +from .ops import nonlinearity, normalize +from .updownsample import ( + SpatialDownsample2x, + SpatialUpsample2x, + TimeDownsample2x, + TimeUpsample2x, + TimeDownsampleRes2x, + TimeUpsampleRes2x, +) \ No newline at end of file diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/layers/attention.py b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/layers/attention.py new file mode 100644 index 0000000000..0d49b682dd --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/layers/attention.py @@ -0,0 +1,157 @@ +#!/usr/bin/env python +# coding=utf-8 +# Copyright 2024 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import torch.nn as nn +import torch +from einops import rearrange +from opensoraplan.utils.log import logger +from .ops import video_to_image, normalize +from .conv import CausalConv3d + +ATTN_TYPE_VANILLA = "vanilla" +ATTN_TYPE_VANILLA3D = "vanilla3D" +ATTN_TYPE_LINEAR = "linear" +ATTN_TYPE_NONE = "none" + + +class LinearAttention(nn.Module): + def __init__(self, dim, heads=4, dim_head=32): + super().__init__() + self.heads = heads + hidden_dim = dim_head * heads + self.to_qkv = nn.Conv2d(dim, hidden_dim * 3, 1, bias=False) + self.to_out = nn.Conv2d(hidden_dim, dim, 1) + + 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 LinAttnBlock(LinearAttention): + """to match AttnBlock usage""" + + def __init__(self, in_channels): + super().__init__(dim=in_channels, heads=1, dim_head=in_channels) + + +class AttnBlock3D(nn.Module): + """Compatible with old versions, there are issues, use with caution.""" + + def __init__(self, in_channels): + super().__init__() + self.in_channels = in_channels + + self.norm = normalize(in_channels) + self.q = CausalConv3d(in_channels, in_channels, kernel_size=1, stride=1) + self.k = CausalConv3d(in_channels, in_channels, kernel_size=1, stride=1) + self.v = CausalConv3d(in_channels, in_channels, kernel_size=1, stride=1) + self.proj_out = CausalConv3d(in_channels, in_channels, kernel_size=1, stride=1) + + 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, t, h, w = q.shape + q = q.reshape(b * t, c, h * w) + q = q.permute(0, 2, 1) # b,hw,c + k = k.reshape(b * t, c, h * w) # b,c,hw + w_ = torch.bmm(q, k) # b,hw,hw w[b,i,j]=sum_c q[b,i,c]k[b,c,j] + w_ = w_ * (int(c) ** (-0.5)) + w_ = torch.nn.functional.softmax(w_, dim=2) + + # attend to values + v = v.reshape(b * t, c, h * w) + w_ = w_.permute(0, 2, 1) # b,hw,hw (first hw of k, second of q) + h_ = torch.bmm(v, w_) # b, c,hw (hw of q) h_[b,c,j] = sum_i v[b,c,i] w_[b,i,j] + h_ = h_.reshape(b, c, t, h, w) + + h_ = self.proj_out(h_) + + return x + h_ + + +class AttnBlock(nn.Module): + def __init__(self, in_channels): + super().__init__() + self.in_channels = in_channels + + self.norm = normalize(in_channels) + self.q = torch.nn.Conv2d(in_channels, in_channels, kernel_size=1, stride=1, padding=0) + self.k = torch.nn.Conv2d( + in_channels, in_channels, kernel_size=1, stride=1, padding=0 + ) + self.v = torch.nn.Conv2d( + in_channels, in_channels, kernel_size=1, stride=1, padding=0 + ) + self.proj_out = torch.nn.Conv2d( + in_channels, in_channels, kernel_size=1, stride=1, padding=0 + ) + + @video_to_image + 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 = q.reshape(b, c, h * w) + q = q.permute(0, 2, 1) # b,hw,c + k = k.reshape(b, c, h * w) # b,c,hw + w_ = torch.bmm(q, k) # b,hw,hw w[b,i,j]=sum_c q[b,i,c]k[b,c,j] + w_ = w_ * (int(c) ** (-0.5)) + w_ = torch.nn.functional.softmax(w_, dim=2) + + # attend to values + v = v.reshape(b, c, h * w) + w_ = w_.permute(0, 2, 1) # b,hw,hw (first hw of k, second of q) + h_ = torch.bmm(v, w_) # b, c,hw (hw of q) h_[b,c,j] = sum_i v[b,c,i] w_[b,i,j] + h_ = h_.reshape(b, c, h, w) + + h_ = self.proj_out(h_) + + return x + h_ + + +def make_attn(in_channels, attn_type=ATTN_TYPE_VANILLA): + if attn_type not in [ATTN_TYPE_VANILLA, ATTN_TYPE_LINEAR, ATTN_TYPE_NONE, ATTN_TYPE_VANILLA3D]: + logger.error(f"attn_type {attn_type} unknown") + raise ValueError + logger.info(f"making attention of type '{attn_type}' with {in_channels} in_channels") + if attn_type == "vanilla": + return AttnBlock(in_channels) + elif attn_type == "vanilla3D": + return AttnBlock3D(in_channels) + elif attn_type == "none": + return nn.Identity(in_channels) + else: + return LinAttnBlock(in_channels) diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/layers/conv.py b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/layers/conv.py new file mode 100644 index 0000000000..3bcd7c3201 --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/layers/conv.py @@ -0,0 +1,140 @@ +#!/usr/bin/env python +# coding=utf-8 +# Copyright 2024 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os +import math +from typing import Union, Tuple +import torch.nn as nn +import torch.nn.functional as F +import torch +from opensoraplan.utils.log import logger +from .ops import cast_tuple +from .ops import video_to_image + + +class Conv2d(nn.Conv2d): + def __init__( + self, + in_channels: int, + out_channels: int, + kernel_size: Union[int, Tuple[int]] = 3, + stride: Union[int, Tuple[int]] = 1, + padding: Union[str, int, Tuple[int]] = 0, + dilation: Union[int, Tuple[int]] = 1, + groups: int = 1, + bias: bool = True, + padding_mode: str = "zeros", + device=None, + dtype=None, + ) -> None: + super().__init__( + in_channels, + out_channels, + kernel_size, + stride, + padding, + dilation, + groups, + bias, + padding_mode, + device, + dtype, + ) + + @video_to_image + def forward(self, x): + return super().forward(x) + + +class CausalConv3d(nn.Module): + def __init__( + self, chan_in, chan_out, kernel_size: Union[int, Tuple[int, int, int]], init_method="random", **kwargs + ): + super().__init__() + self.kernel_size = cast_tuple(kernel_size, 3) + self.time_kernel_size = self.kernel_size[0] + self.chan_in = chan_in + self.chan_out = chan_out + stride = kwargs.pop("stride", 1) + padding = kwargs.pop("padding", 0) + padding = list(cast_tuple(padding, 3)) + padding[0] = 0 + stride = cast_tuple(stride, 3) + self.conv = nn.Conv3d(chan_in, chan_out, self.kernel_size, stride=stride, padding=padding) + self._init_weights(init_method) + self.embed_dim = self.chan_out + self.patch_size = self.kernel_size + self.stride = stride + self.padding = padding + + def forward(self, x): + # 1 + 16 16 as video, 1 as image + first_frame_pad = x[:, :, :1, :, :].repeat( + (1, 1, self.time_kernel_size - 1, 1, 1) + ) # b c t h w + x = torch.concatenate((first_frame_pad, x), dim=2) + + def generate_random_conv3d_output(input_shape, out_channels, kernel_size, stride, padding): + n, _, d, h, w = input_shape + k_d, k_h, k_w = kernel_size + s_d, s_h, s_w = stride + p_d, p_h, p_w = padding + + d_out = math.floor((d + 2 * p_d - k_d) / s_d + 1) + h_out = math.floor((h + 2 * p_h - k_h) / s_h + 1) + w_out = math.floor((w + 2 * p_w - k_w) / s_w + 1) + + output_shape = (n, out_channels, d_out, h_out, w_out) + return torch.rand(output_shape, dtype=x.dtype, device=x.device) + + if os.getenv("VASCEND", "0") == "1": # "1"仿真环境 + x = generate_random_conv3d_output(x.shape, self.embed_dim, self.patch_size, self.stride, self.padding) + return x + else: + return self.conv(x) + + def _init_weights(self, init_method): + ks = torch.tensor(self.kernel_size) + if init_method == "avg": + if not (self.kernel_size[1] == 1 and self.kernel_size[2] == 1): + logger.error("only support temporal up/down sample") + raise ValueError + if self.chan_in != self.chan_out: + logger.error("chan_in must be equal to chan_out") + raise ValueError + weight = torch.zeros((self.chan_out, self.chan_in, *self.kernel_size)) + + eyes = torch.concat( + [ + torch.eye(self.chan_in).unsqueeze(-1) * 1 / 3, + torch.eye(self.chan_in).unsqueeze(-1) * 1 / 3, + torch.eye(self.chan_in).unsqueeze(-1) * 1 / 3, + ], + dim=-1, + ) + weight[:, :, :, 0, 0] = eyes + + self.conv.weight = nn.Parameter( + weight, + requires_grad=True, + ) + elif init_method == "zero": + self.conv.weight = nn.Parameter( + torch.zeros((self.chan_out, self.chan_in, *self.kernel_size)), + requires_grad=True, + ) + if self.conv.bias is not None: + nn.init.constant_(self.conv.bias, 0) \ No newline at end of file diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/layers/ops.py b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/layers/ops.py new file mode 100644 index 0000000000..b8e0ecfc62 --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/layers/ops.py @@ -0,0 +1,43 @@ +#!/usr/bin/env python +# coding=utf-8 +# Copyright 2024 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import torch +from einops import rearrange + + +def video_to_image(func): + def wrapper(self, x, *args, **kwargs): + if x.dim() == 5: + t = x.shape[2] + x = rearrange(x, "b c t h w -> (b t) c h w") + x = func(self, x, *args, **kwargs) + x = rearrange(x, "(b t) c h w -> b c t h w", t=t) + return x + return wrapper + + +def nonlinearity(x): + return x * torch.sigmoid(x) + + +def cast_tuple(t, length=1): + return t if isinstance(t, tuple) else ((t,) * length) + + +def normalize(in_channels, num_groups=32): + return torch.nn.GroupNorm( + num_groups=num_groups, num_channels=in_channels, eps=1e-6, affine=True + ) \ No newline at end of file diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/layers/resnet_block.py b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/layers/resnet_block.py new file mode 100644 index 0000000000..59aaed288b --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/layers/resnet_block.py @@ -0,0 +1,101 @@ +#!/usr/bin/env python +# coding=utf-8 +# Copyright 2024 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import torch +import torch.nn as nn +from .ops import nonlinearity, video_to_image, normalize +from .conv import CausalConv3d + + +class ResnetBlock2D(nn.Module): + def __init__(self, *, in_channels, out_channels=None, conv_shortcut=False, + dropout): + super().__init__() + self.in_channels = in_channels + self.out_channels = in_channels if out_channels is None else out_channels + self.use_conv_shortcut = conv_shortcut + + self.norm1 = normalize(in_channels) + self.conv1 = torch.nn.Conv2d( + in_channels, out_channels, kernel_size=3, stride=1, padding=1 + ) + self.norm2 = normalize(out_channels) + self.dropout = torch.nn.Dropout(dropout) + self.conv2 = torch.nn.Conv2d( + out_channels, out_channels, kernel_size=3, stride=1, padding=1 + ) + if self.in_channels != self.out_channels: + if self.use_conv_shortcut: + self.conv_shortcut = torch.nn.Conv2d( + in_channels, out_channels, kernel_size=3, stride=1, padding=1 + ) + else: + self.nin_shortcut = torch.nn.Conv2d( + in_channels, out_channels, kernel_size=1, stride=1, padding=0 + ) + + @video_to_image + def forward(self, x): + h = x + h = self.norm1(h) + h = nonlinearity(h) + h = self.conv1(h) + h = self.norm2(h) + h = nonlinearity(h) + h = self.dropout(h) + h = self.conv2(h) + if self.in_channels != self.out_channels: + if self.use_conv_shortcut: + x = self.conv_shortcut(x) + else: + x = self.nin_shortcut(x) + x = x + h + return x + + +class ResnetBlock3D(nn.Module): + def __init__(self, *, in_channels, out_channels=None, conv_shortcut=False, dropout): + super().__init__() + self.in_channels = in_channels + self.out_channels = in_channels if out_channels is None else out_channels + self.use_conv_shortcut = conv_shortcut + + self.norm1 = normalize(in_channels) + self.conv1 = CausalConv3d(in_channels, out_channels, 3, padding=1) + self.norm2 = normalize(out_channels) + self.dropout = torch.nn.Dropout(dropout) + self.conv2 = CausalConv3d(out_channels, out_channels, 3, padding=1) + if self.in_channels != self.out_channels: + if self.use_conv_shortcut: + self.conv_shortcut = CausalConv3d(in_channels, out_channels, 3, padding=1) + else: + self.nin_shortcut = CausalConv3d(in_channels, out_channels, 1, padding=0) + + def forward(self, x): + h = x + h = self.norm1(h) + h = nonlinearity(h) + h = self.conv1(h) + h = self.norm2(h) + h = nonlinearity(h) + h = self.dropout(h) + h = self.conv2(h) + if self.in_channels != self.out_channels: + if self.use_conv_shortcut: + x = self.conv_shortcut(x) + else: + x = self.nin_shortcut(x) + return x + h \ No newline at end of file diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/layers/updownsample.py b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/layers/updownsample.py new file mode 100644 index 0000000000..5c058a91e8 --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/layers/updownsample.py @@ -0,0 +1,204 @@ +#!/usr/bin/env python +# coding=utf-8 +# Copyright 2024 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os +from typing import Union, Tuple +import torch +import torch.nn as nn +import torch.nn.functional as F +from einops import rearrange +from .ops import cast_tuple +from .conv import CausalConv3d + + +class SpatialDownsample2x(nn.Module): + def __init__( + self, + chan_in, + chan_out, + kernel_size: Union[int, Tuple[int]] = (3, 3), + stride: Union[int, Tuple[int]] = (2, 2), + ): + super().__init__() + kernel_size = cast_tuple(kernel_size, 2) + stride = cast_tuple(stride, 2) + self.chan_in = chan_in + self.chan_out = chan_out + self.kernel_size = kernel_size + self.conv = CausalConv3d( + self.chan_in, + self.chan_out, + (1,) + self.kernel_size, + stride=(1,) + stride, + padding=0 + ) + + def forward(self, x): + pad = (0, 1, 0, 1, 0, 0) + x = torch.nn.functional.pad(x, pad, mode="constant", value=0) + x = self.conv(x) + return x + + +def mock_interpolate(input_tensor, scale_factor, mode="nearest"): + """ + 仿真 interpolate函数,返回一个具有正确shape 的随机数张量。 + + :param input_tensor: 输入张量（可以使三维或者四维） + :param scale_factor: 缩放因子，元组形式 (height_scale, width_scale) 或者单个数值 + :param mode: 插值模式(仅用于兼容性， 不影响仿真的输出) + :return: 具有预期形状的随机数张量 + """ + # 获取输入张量的形状 + input_shape = input_tensor.shape + ndim = len(input_shape) + + if ndim == 4: + # 四维张量(batch_size, channels, height, width) + batch_size, channels, height, width = input_shape + output_height = int(height * scale_factor[0]) + output_width = int(width * scale_factor[1]) + output_shape = (batch_size, channels, output_height, output_width) + elif ndim == 3: + # 三维张量(batch_size, length, feature_dim) + batch_size, length, feature_dim = input_shape + if isinstance(scale_factor, tuple): + output_length = int(length * scale_factor[0]) + else: + output_length = int(length * scale_factor) + output_shape = (batch_size, output_length, feature_dim) + else: + raise ValueError("仅支持三维或四维张量") + + # 创建一个具有预期形状的随机数张量 + output_tensor = torch.randn(output_shape) + + return output_tensor + + +class SpatialUpsample2x(nn.Module): + def __init__( + self, + chan_in, + chan_out, + kernel_size: Union[int, Tuple[int]] = (3, 3), + stride: Union[int, Tuple[int]] = (1, 1), + ): + super().__init__() + self.chan_in = chan_in + self.chan_out = chan_out + self.kernel_size = kernel_size + self.conv = CausalConv3d( + self.chan_in, + self.chan_out, + (1,) + self.kernel_size, + stride=(1,) + stride, + padding=1 + ) + + def forward(self, x): + t = x.shape[2] + x = rearrange(x, "b c t h w -> b (c t) h w") + if os.getenv("VASCEND", "0") == "1": # "1"仿真环境 + x = mock_interpolate(x, scale_factor=(2, 2), mode="nearest") + else: + x = F.interpolate(x, scale_factor=(2, 2), mode="nearest") + x = rearrange(x, "b (c t) h w -> b c t h w", t=t) + x = self.conv(x) + return x + + +class TimeDownsample2x(nn.Module): + def __init__( + self, + chan_in, + chan_out, + kernel_size: int = 3 + ): + super().__init__() + self.kernel_size = kernel_size + self.conv = nn.AvgPool3d((kernel_size, 1, 1), stride=(2, 1, 1)) + + def forward(self, x): + first_frame_pad = x[:, :, :1, :, :].repeat( + (1, 1, self.kernel_size - 1, 1, 1) + ) + x = torch.concatenate((first_frame_pad, x), dim=2) + return self.conv(x) + + +class TimeUpsample2x(nn.Module): + def __init__( + self, + chan_in, + chan_out + ): + super().__init__() + + def forward(self, x): + if x.size(2) > 1: + x, x_ = x[:, :, :1], x[:, :, 1:] + x_ = F.interpolate(x_, scale_factor=(2, 1, 1), mode='trilinear') + x = torch.concat([x, x_], dim=2) + return x + + +class TimeDownsampleRes2x(nn.Module): + def __init__( + self, + in_channels, + out_channels, + kernel_size: int = 3, + mix_factor: float = 2, + ): + super().__init__() + self.kernel_size = cast_tuple(kernel_size, 3) + self.avg_pool = nn.AvgPool3d((kernel_size, 1, 1), stride=(2, 1, 1)) + self.conv = nn.Conv3d( + in_channels, out_channels, self.kernel_size, stride=(2, 1, 1), padding=(0, 1, 1) + ) + self.mix_factor = torch.nn.Parameter(torch.Tensor([mix_factor])) + + def forward(self, x): + alpha = torch.sigmoid(self.mix_factor) + first_frame_pad = x[:, :, :1, :, :].repeat( + (1, 1, self.kernel_size[0] - 1, 1, 1) + ) + x = torch.concatenate((first_frame_pad, x), dim=2) + return alpha * self.avg_pool(x) + (1 - alpha) * self.conv(x) + + +class TimeUpsampleRes2x(nn.Module): + def __init__( + self, + in_channels, + out_channels, + kernel_size: int = 3, + mix_factor: float = 2, + ): + super().__init__() + self.conv = CausalConv3d( + in_channels, out_channels, kernel_size, padding=1 + ) + self.mix_factor = torch.nn.Parameter(torch.Tensor([mix_factor])) + + def forward(self, x): + alpha = torch.sigmoid(self.mix_factor) + if x.size(2) > 1: + x, x_ = x[:, :, :1], x[:, :, 1:] + x_ = F.interpolate(x_, scale_factor=(2, 1, 1), mode='trilinear') + x = torch.concat([x, x_], dim=2) + return alpha * x + (1 - alpha) * self.conv(x) diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/layers/utils.py b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/layers/utils.py new file mode 100644 index 0000000000..e71a947546 --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/layers/utils.py @@ -0,0 +1,145 @@ +#!/usr/bin/env python +# coding=utf-8 +# Copyright 2024 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import importlib +import torch +import torch.nn as nn +import numpy as np + + +def rearrange(x: torch.Tensor, datatype, t, s): + rearrange_function = { + 'B (T S) C -> (B S) T C': rearrange_b_ts_c_2_bs_t_c, + '(B S) T C -> B (T S) C': rearrange_bs_t_c_2_b_ts_c, + 'B (T S) C -> (B T) S C': rearrange_b_ts_c_2_bt_s_c, + '(B T) S C -> B (T S) C': rearrange_bt_s_c_2_b_ts_c, + 'B (T S) C -> B T S C': rearrange_b_ts_c_2_b_t_s_c, + 'B T S C -> B (T S) C': rearrange_b_t_s_c_2_b_ts_c, + } + rearrange_func = rearrange_function.get(datatype, None) + if rearrange_func is None: + raise ValueError(f"Unsupported rearrange type: {datatype}") + return rearrange_func(x, t, s) + + +def rearrange_b_ts_c_2_bs_t_c(x, t, s): + shape = x.shape + x = x.view(shape[0], t, s, shape[-1]) + x = x.transpose(1, 2) + return x.reshape(shape[0] * s, t, shape[-1]) + + +def rearrange_bs_t_c_2_b_ts_c(x, t, s): + shape = x.shape + x = x.view(-1, s, t, shape[-1]) + x = x.transpose(1, 2) + return x.reshape(-1, t * s, shape[-1]) + + +def rearrange_b_ts_c_2_bt_s_c(x, t, s): + shape = x.shape + return x.reshape(-1, s, shape[-1]) + + +def rearrange_bt_s_c_2_b_ts_c(x, t, s): + shape = x.shape + return x.reshape(-1, t * s, shape[-1]) + + +def rearrange_b_ts_c_2_b_t_s_c(x, t, s): + shape = x.shape + return x.reshape(shape[0], t, s, shape[-1]) + + +def rearrange_b_t_s_c_2_b_ts_c(x, t, s): + shape = x.shape + return x.reshape(shape[0], t * s, shape[-1]) + + +def rearrange_flatten_t(x): + x_shape = x.shape + x = x.transpose(1, 2) + return x.view((x_shape[0] * x_shape[2]), x_shape[1], x_shape[3], x_shape[4]) + + +def rearrange_unflatten_t(x, b): + x_shape = x.shape + x = x.view(b, x_shape[0] // b, x_shape[1], x_shape[2], x_shape[3]) + return x.transpose(1, 2) + + +def get_2d_sincos_pos_embed( + embed_dim, grid_size, cls_token=False, interpolation_scale=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) + """ + extra_tokens = 0 + if isinstance(grid_size, int): + grid_size = (grid_size, grid_size) + + grid_h = np.arange(grid_size[0], dtype=np.float32) / (grid_size[0] / base_size) / interpolation_scale + grid_w = np.arange(grid_size[1], dtype=np.float32) / (grid_size[1] / base_size) / interpolation_scale + 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 + + +def get_2d_sincos_pos_embed_from_grid(embed_dim, grid): + if embed_dim % 2 != 0: + raise ValueError("embed_dim must be divisible by 2") + + # 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( + embed_dim, length, interpolation_scale=1.0, base_size=16 +): + pos = torch.arange(0, length).unsqueeze(1) / interpolation_scale + pos_embed = get_1d_sincos_pos_embed_from_grid(embed_dim, pos) + return pos_embed + + +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) + """ + if embed_dim % 2 != 0: + raise ValueError("embed_dim must be divisible by 2") + + omega = np.arange(embed_dim // 2, dtype=np.float64) + omega /= embed_dim / 2.0 + omega = 1.0 / 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 \ No newline at end of file diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/__init__.py b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/__init__.py new file mode 100644 index 0000000000..30af36f396 --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/__init__.py @@ -0,0 +1,15 @@ +#!/usr/bin/env python +# coding=utf-8 +# Copyright 2024 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/causalvae/__init__.py b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/causalvae/__init__.py new file mode 100644 index 0000000000..572fef02cf --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/causalvae/__init__.py @@ -0,0 +1,17 @@ +#!/usr/bin/env python +# coding=utf-8 +# Copyright 2024 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from .modeling_causalvae import CausalVAEModelWrapper \ No newline at end of file diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/causalvae/modeling_causalvae.py b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/causalvae/modeling_causalvae.py new file mode 100644 index 0000000000..abb3400a9b --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/causalvae/modeling_causalvae.py @@ -0,0 +1,643 @@ +#!/usr/bin/env python +# coding=utf-8 +# Copyright 2024 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os +import logging +from typing import Tuple, Optional, Union +import glob +import importlib +import torch +import torch.nn as nn +import numpy as np +from einops import rearrange +import pytorch_lightning as pl +from diffusers.configuration_utils import register_to_config +from diffusers import ModelMixin, ConfigMixin +from opensoraplan.layers import nonlinearity, normalize +from opensoraplan.utils.utils import path_check + +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger(__name__) + +Module = str +MODULES_BASE = "opensoraplan.layers." +SPATIAL_DOWNSAMPLE = "Downsample" +RESNET_BLOCK_2D = "ResnetBlock2D" +RESNET_BLOCK_3D = "ResnetBlock3D" +SPATIAL_UPSAMPLE_2X = "SpatialUpsample2x" +SPATIAL_DOWNSAMPLE_2X = "SpatialDownsample2x" +TIME_DOWNSAMPLE_2X = "TimeDownsample2x" +CAUSAL_CONV_3D = "CausalConv3d" +LATENTS_SCALING_FACTOR = 0.18215 + + +def resolve_str_to_obj(str_val, append=True): + if append: + str_val = MODULES_BASE + str_val + module_name, class_name = str_val.rsplit('.', 1) + module = importlib.import_module(module_name) + return getattr(module, class_name) + + +class VideoBaseAePl(pl.LightningModule, ModelMixin, ConfigMixin): + config_name = "config.json" + + def __init__(self, *args, **kwargs) -> None: + super().__init__(*args, **kwargs) + + @property + def num_training_steps(self) -> int: + """Total training steps inferred from datamodule and devices.""" + if self.trainer.max_steps: + return self.trainer.max_steps + + limit_batches = self.trainer.limit_train_batches + batches = len(self.train_dataloader()) + batches = min(batches, limit_batches) if isinstance(limit_batches, int) else int(limit_batches * batches) + + num_devices = max(1, self.trainer.num_gpus, self.trainer.num_processes) + if self.trainer.tpu_cores: + num_devices = max(num_devices, self.trainer.tpu_cores) + + effective_accum = self.trainer.accumulate_grad_batches * num_devices + return (batches // effective_accum) * self.trainer.max_epochs + + @classmethod + def from_pretrained(cls, pretrained_model_name_or_path: Optional[Union[str, os.PathLike]], **kwargs): + ckpt_files = glob.glob(os.path.join(pretrained_model_name_or_path, '*.ckpt')) + if ckpt_files: + # Adapt to PyTorch Lightning + last_ckpt_file = ckpt_files[-1] + config_file = os.path.join(pretrained_model_name_or_path, cls.config_name) + model = cls.from_config(config_file) + logger.info("init from %s", last_ckpt_file) + model.init_from_ckpt(last_ckpt_file) + return model + else: + return super().from_pretrained(pretrained_model_name_or_path, **kwargs) + + +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): + x = self.mean + self.std * torch.randn(self.mean.shape).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 + + +class Encoder(nn.Module): + def __init__( + self, + z_channels: int, + hidden_size: int, + hidden_size_mult: Tuple[int] = (1, 2, 4, 4), + attn_resolutions: Tuple[int] = (16,), + conv_in: Module = "Conv2d", + conv_out: Module = "CasualConv3d", + attention: Module = "AttnBlock", + resnet_blocks: Tuple[Module] = ( + RESNET_BLOCK_2D, + RESNET_BLOCK_2D, + RESNET_BLOCK_2D, + RESNET_BLOCK_3D, + ), + spatial_downsample: Tuple[Module] = ( + SPATIAL_DOWNSAMPLE, + SPATIAL_DOWNSAMPLE, + SPATIAL_DOWNSAMPLE, + "", + ), + temporal_downsample: Tuple[Module] = ("", "", "TimeDownsampleRes2x", ""), + mid_resnet: Module = RESNET_BLOCK_3D, + dropout: float = 0.0, + resolution: int = 256, + num_res_blocks: int = 2, + double_z: bool = True, + ) -> None: + super().__init__() + if len(resnet_blocks) != len(hidden_size_mult): + logger.error("resnet_blocks size does not equal to hidden_size_mult size.") + raise ValueError + # ---- Config ---- + self.num_resolutions = len(hidden_size_mult) + self.resolution = resolution + self.num_res_blocks = num_res_blocks + + # ---- In ---- + self.conv_in = resolve_str_to_obj(conv_in)( + 3, hidden_size, kernel_size=3, stride=1, padding=1 + ) + + # ---- Downsample ---- + curr_res = resolution + in_ch_mult = (1,) + tuple(hidden_size_mult) + self.in_ch_mult = in_ch_mult + self.down = nn.ModuleList() + for i_level in range(self.num_resolutions): + block = nn.ModuleList() + attn = nn.ModuleList() + block_in = hidden_size * in_ch_mult[i_level] + block_out = hidden_size * hidden_size_mult[i_level] + for _ in range(self.num_res_blocks): + block.append( + resolve_str_to_obj(resnet_blocks[i_level])( + in_channels=block_in, + out_channels=block_out, + dropout=dropout, + ) + ) + block_in = block_out + if curr_res in attn_resolutions: + attn.append(resolve_str_to_obj(attention)(block_in)) + down = nn.Module() + down.block = block + down.attn = attn + if spatial_downsample[i_level]: + down.downsample = resolve_str_to_obj(spatial_downsample[i_level])( + block_in, block_in + ) + curr_res = curr_res // 2 + if temporal_downsample[i_level]: + down.time_downsample = resolve_str_to_obj(temporal_downsample[i_level])( + block_in, block_in + ) + self.down.append(down) + + # ---- Mid ---- + self.mid = nn.Module() + self.mid.block_1 = resolve_str_to_obj(mid_resnet)( + in_channels=block_in, + out_channels=block_in, + dropout=dropout, + ) + self.mid.attn_1 = resolve_str_to_obj(attention)(block_in) + self.mid.block_2 = resolve_str_to_obj(mid_resnet)( + in_channels=block_in, + out_channels=block_in, + dropout=dropout, + ) + # ---- Out ---- + self.norm_out = normalize(block_in) + self.conv_out = resolve_str_to_obj(conv_out)( + block_in, + 2 * z_channels if double_z else z_channels, + kernel_size=3, + stride=1, + padding=1, + ) + + def forward(self, x): + hs = [self.conv_in(x)] + for i_level in range(self.num_resolutions): + for i_block in range(self.num_res_blocks): + h = self.down[i_level].block[i_block](hs[-1]) + if len(self.down[i_level].attn) > 0: + h = self.down[i_level].attn[i_block](h) + hs.append(h) + if hasattr(self.down[i_level], "downsample"): + hs.append(self.down[i_level].downsample(hs[-1])) + if hasattr(self.down[i_level], "time_downsample"): + hs_down = self.down[i_level].time_downsample(hs[-1]) + hs.append(hs_down) + + h = self.mid.block_1(h) + h = self.mid.attn_1(h) + h = self.mid.block_2(h) + + h = self.norm_out(h) + h = nonlinearity(h) + h = self.conv_out(h) + return h + + +class Decoder(nn.Module): + def __init__( + self, + z_channels: int, + hidden_size: int, + hidden_size_mult: Tuple[int] = (1, 2, 4, 4), + attn_resolutions: Tuple[int] = (16,), + conv_in: Module = "Conv2d", + conv_out: Module = "CasualConv3d", + attention: Module = "AttnBlock", + resnet_blocks: Tuple[Module] = ( + RESNET_BLOCK_3D, + RESNET_BLOCK_3D, + RESNET_BLOCK_3D, + RESNET_BLOCK_3D, + ), + spatial_upsample: Tuple[Module] = ( + "", + SPATIAL_UPSAMPLE_2X, + SPATIAL_UPSAMPLE_2X, + SPATIAL_UPSAMPLE_2X, + ), + temporal_upsample: Tuple[Module] = ("", "", "", "TimeUpsampleRes2x"), + mid_resnet: Module = RESNET_BLOCK_3D, + dropout: float = 0.0, + resolution: int = 256, + num_res_blocks: int = 2, + ): + super().__init__() + # ---- Config ---- + self.num_resolutions = len(hidden_size_mult) + self.resolution = resolution + self.num_res_blocks = num_res_blocks + + # ---- In ---- + block_in = hidden_size * hidden_size_mult[self.num_resolutions - 1] + curr_res = resolution // 2 ** (self.num_resolutions - 1) + self.conv_in = resolve_str_to_obj(conv_in)( + z_channels, block_in, kernel_size=3, padding=1 + ) + + # ---- Mid ---- + self.mid = nn.Module() + self.mid.block_1 = resolve_str_to_obj(mid_resnet)( + in_channels=block_in, + out_channels=block_in, + dropout=dropout, + ) + self.mid.attn_1 = resolve_str_to_obj(attention)(block_in) + self.mid.block_2 = resolve_str_to_obj(mid_resnet)( + in_channels=block_in, + out_channels=block_in, + dropout=dropout, + ) + + # ---- Upsample ---- + self.up = nn.ModuleList() + for i_level in reversed(range(self.num_resolutions)): + block = nn.ModuleList() + attn = nn.ModuleList() + block_out = hidden_size * hidden_size_mult[i_level] + for _ in range(self.num_res_blocks + 1): + block.append( + resolve_str_to_obj(resnet_blocks[i_level])( + in_channels=block_in, + out_channels=block_out, + dropout=dropout, + ) + ) + block_in = block_out + if curr_res in attn_resolutions: + attn.append(resolve_str_to_obj(attention)(block_in)) + up = nn.Module() + up.block = block + up.attn = attn + if spatial_upsample[i_level]: + up.upsample = resolve_str_to_obj(spatial_upsample[i_level])( + block_in, block_in + ) + curr_res = curr_res * 2 + if temporal_upsample[i_level]: + up.time_upsample = resolve_str_to_obj(temporal_upsample[i_level])( + block_in, block_in + ) + self.up.insert(0, up) + + # ---- Out ---- + self.norm_out = normalize(block_in) + self.conv_out = resolve_str_to_obj(conv_out)( + block_in, 3, kernel_size=3, padding=1 + ) + + def forward(self, z): + h = self.conv_in(z) + h = self.mid.block_1(h) + h = self.mid.attn_1(h) + h = self.mid.block_2(h) + + for i_level in reversed(range(self.num_resolutions)): + for i_block in range(self.num_res_blocks + 1): + h = self.up[i_level].block[i_block](h) + if len(self.up[i_level].attn) > 0: + h = self.up[i_level].attn[i_block](h) + if hasattr(self.up[i_level], "upsample"): + h = self.up[i_level].upsample(h) + if hasattr(self.up[i_level], "time_upsample"): + h = self.up[i_level].time_upsample(h) + + h = self.norm_out(h) + h = nonlinearity(h) + h = self.conv_out(h) + return h + + +class CausalVAEModel(VideoBaseAePl): + @register_to_config + def __init__( + self, + lr: float = 1e-5, + hidden_size: int = 128, + z_channels: int = 4, + hidden_size_mult: Tuple[int] = (1, 2, 4, 4), + attn_resolutions: Tuple[int] = None, + dropout: float = 0.0, + resolution: int = 256, + double_z: bool = True, + embed_dim: int = 4, + num_res_blocks: int = 2, + q_conv: str = CAUSAL_CONV_3D, + encoder_conv_in: Module = CAUSAL_CONV_3D, + encoder_conv_out: Module = CAUSAL_CONV_3D, + encoder_attention: Module = "AttnBlock3D", + encoder_resnet_blocks: Tuple[Module] = ( + RESNET_BLOCK_3D, + RESNET_BLOCK_3D, + RESNET_BLOCK_3D, + RESNET_BLOCK_3D, + ), + encoder_spatial_downsample: Tuple[Module] = ( + SPATIAL_DOWNSAMPLE_2X, + SPATIAL_DOWNSAMPLE_2X, + SPATIAL_DOWNSAMPLE_2X, + "", + ), + encoder_temporal_downsample: Tuple[Module] = ( + "", + TIME_DOWNSAMPLE_2X, + TIME_DOWNSAMPLE_2X, + "", + ), + encoder_mid_resnet: Module = RESNET_BLOCK_3D, + decoder_conv_in: Module = CAUSAL_CONV_3D, + decoder_conv_out: Module = CAUSAL_CONV_3D, + decoder_attention: Module = "AttnBlock3D", + decoder_resnet_blocks: Tuple[Module] = ( + RESNET_BLOCK_3D, + RESNET_BLOCK_3D, + RESNET_BLOCK_3D, + RESNET_BLOCK_3D, + ), + decoder_spatial_upsample: Tuple[Module] = ( + "", + SPATIAL_UPSAMPLE_2X, + SPATIAL_UPSAMPLE_2X, + SPATIAL_UPSAMPLE_2X, + ), + decoder_temporal_upsample: Tuple[Module] = ("", "", "TimeUpsample2x", "TimeUpsample2x"), + decoder_mid_resnet: Module = RESNET_BLOCK_3D, + ) -> None: + super().__init__() + self.tile_sample_min_size = 256 + self.tile_sample_min_size_t = 65 + self.tile_latent_min_size = int(self.tile_sample_min_size / (2 ** (len(hidden_size_mult) - 1))) + self.tile_overlap_factor = 0.25 + self.use_tiling = False + + self.learning_rate = lr + self.lr_g_factor = 1.0 + + self.encoder = Encoder( + z_channels=z_channels, + hidden_size=hidden_size, + hidden_size_mult=hidden_size_mult, + attn_resolutions=attn_resolutions, + conv_in=encoder_conv_in, + conv_out=encoder_conv_out, + attention=encoder_attention, + resnet_blocks=encoder_resnet_blocks, + spatial_downsample=encoder_spatial_downsample, + temporal_downsample=encoder_temporal_downsample, + mid_resnet=encoder_mid_resnet, + dropout=dropout, + resolution=resolution, + num_res_blocks=num_res_blocks, + double_z=double_z, + ) + + self.decoder = Decoder( + z_channels=z_channels, + hidden_size=hidden_size, + hidden_size_mult=hidden_size_mult, + attn_resolutions=attn_resolutions, + conv_in=decoder_conv_in, + conv_out=decoder_conv_out, + attention=decoder_attention, + resnet_blocks=decoder_resnet_blocks, + spatial_upsample=decoder_spatial_upsample, + temporal_upsample=decoder_temporal_upsample, + mid_resnet=decoder_mid_resnet, + dropout=dropout, + resolution=resolution, + num_res_blocks=num_res_blocks, + ) + + quant_conv_cls = resolve_str_to_obj(q_conv) + self.quant_conv = quant_conv_cls(2 * z_channels, 2 * embed_dim, 1) + self.post_quant_conv = quant_conv_cls(embed_dim, z_channels, 1) + self.patch_size = (1, 8, 8) + + def encode(self, x): + if self.use_tiling and ( + x.shape[-1] > self.tile_sample_min_size + or x.shape[-2] > self.tile_sample_min_size + ): + return self.tiled_encode2d(x) + h = self.encoder(x) + moments = self.quant_conv(h) + posterior = DiagonalGaussianDistribution(moments) + return posterior + + def decode(self, z): + if self.use_tiling and ( + z.shape[-1] > self.tile_latent_min_size + or z.shape[-2] > self.tile_latent_min_size + ): + return self.tiled_decode2d(z) + z = self.post_quant_conv(z) + dec = self.decoder(z) + return dec + + def forward(self, model_inputs, sample_posterior=True): + posterior = self.encode(model_inputs) + if sample_posterior: + z = posterior.sample() + else: + z = posterior.mode() + dec = self.decode(z) + return dec, posterior + + def blend_v( + self, a: torch.Tensor, b: torch.Tensor, blend_extent: int + ) -> torch.Tensor: + blend_extent = min(a.shape[3], b.shape[3], blend_extent) + alphas = torch.linspace(0, 1, blend_extent, device=a.device).view(-1, 1).expand(-1, a.shape[4]) + b[:, :, :, :blend_extent, :] = ( + a[:, :, :, -blend_extent:, :] * (1 - alphas) + b[:, :, :, :blend_extent, :] * alphas) + return b + + def blend_h( + self, a: torch.Tensor, b: torch.Tensor, blend_extent: int + ) -> torch.Tensor: + blend_extent = min(a.shape[4], b.shape[4], blend_extent) + alphas = torch.linspace(0, 1, blend_extent, device=a.device).expand(a.shape[3], -1) + b[:, :, :, :, :blend_extent] = ( + a[:, :, :, :, -blend_extent:] * (1 - alphas) + b[:, :, :, :, :blend_extent] * alphas) + return b + + def tiled_encode2d(self, x): + overlap_size = int(self.tile_sample_min_size * (1 - self.tile_overlap_factor)) + blend_extent = int(self.tile_latent_min_size * self.tile_overlap_factor) + row_limit = self.tile_latent_min_size - blend_extent + + # Split the image into 512x512 tiles and encode them separately. + rows = [] + for i in range(0, x.shape[3], overlap_size): + row = [] + for j in range(0, x.shape[4], overlap_size): + tile = x[ + :, + :, + :, + i: i + self.tile_sample_min_size, + j: j + self.tile_sample_min_size, + ] + tile = self.encoder(tile) + tile = self.quant_conv(tile) + row.append(tile) + rows.append(row) + result_rows = [] + for i, row in enumerate(rows): + result_row = [] + for j, tile in enumerate(row): + # blend the above tile and the left tile + # to the current tile and add the current tile to the result row + if i > 0: + tile = self.blend_v(rows[i - 1][j], tile, blend_extent) + if j > 0: + tile = self.blend_h(row[j - 1], tile, blend_extent) + result_row.append(tile[:, :, :, :row_limit, :row_limit]) + result_rows.append(torch.cat(result_row, dim=4)) + + moments = torch.cat(result_rows, dim=3) + posterior = DiagonalGaussianDistribution(moments) + + return posterior + + def tiled_decode2d(self, z): + + overlap_size = int(self.tile_latent_min_size * (1 - self.tile_overlap_factor)) + blend_extent = int(self.tile_sample_min_size * self.tile_overlap_factor) + row_limit = self.tile_sample_min_size - blend_extent + + # Split z into overlapping 64x64 tiles and decode them separately. + # The tiles have an overlap to avoid seams between tiles. + rows = [] + for i in range(0, z.shape[3], overlap_size): + row = [] + for j in range(0, z.shape[4], overlap_size): + tile = z[ + :, + :, + :, + i: i + self.tile_latent_min_size, + j: j + self.tile_latent_min_size, + ] + tile = self.post_quant_conv(tile) + decoded = self.decoder(tile) + row.append(decoded) + rows.append(row) + result_rows = [] + for i, row in enumerate(rows): + result_row = [] + for j, tile in enumerate(row): + # blend the above tile and the left tile + # to the current tile and add the current tile to the result row + if i > 0: + tile = self.blend_v(rows[i - 1][j], tile, blend_extent) + if j > 0: + tile = self.blend_h(row[j - 1], tile, blend_extent) + result_row.append(tile[:, :, :, :row_limit, :row_limit]) + result_rows.append(torch.cat(result_row, dim=4)) + + dec = torch.cat(result_rows, dim=3) + return dec + + def enable_tiling(self, use_tiling: bool = True): + self.use_tiling = use_tiling + + def disable_tiling(self): + self.enable_tiling(False) + + def init_from_ckpt(self, path, ignore_keys, remove_loss=True): + sd = torch.load(path, map_location="cpu") + if "state_dict" in sd: + sd = sd["state_dict"] + keys = list(sd.keys()) + for k in keys: + for ik in ignore_keys: + if k.startswith(ik): + logger.error("Deleting key %s from state_dict.", k) + del sd[k] + if remove_loss and "loss" in k: + del sd[k] + self.load_state_dict(sd, strict=False) + + +class CausalVAEModelWrapper(nn.Module): + def __init__(self, vae, latent_size): + super(CausalVAEModelWrapper, self).__init__() + self.vae = vae + self.latent_size = latent_size + + @classmethod + def from_pretrained(cls, model_path, latent_size, cache_dir, **kwargs): + real_path = path_check(model_path) + if len(latent_size) != 2 or latent_size[0] <= 0 or latent_size[1] <= 0: + raise ValueError("latent_size shape or value is invalid.") + causal_vae = CausalVAEModel.from_pretrained(real_path, cache_dir=cache_dir, **kwargs) + return cls(causal_vae, latent_size) + + def decode(self, x): + x = self.vae.decode(x / LATENTS_SCALING_FACTOR) + x = rearrange(x, 'b c t h w -> b t c h w').contiguous() + return x diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/comm.py b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/comm.py new file mode 100644 index 0000000000..aee624d833 --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/comm.py @@ -0,0 +1,144 @@ +#!/usr/bin/env python +# coding=utf-8 +# Copyright 2024 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. +# -------------------------------------------------------- +# References: +# DSP : https://github.com/NUS-HPC-AI-Lab/VideoSys +# -------------------------------------------------------- + +from dataclasses import dataclass +import logging +import torch +import torch.distributed as dist +from opensoraplan.models.parallel_mgr import get_sequence_parallel_size + +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger(__name__) + + +@dataclass +class SplitParams: + input_: torch.Tensor + dim: int + grad_scale: str + pad: int + + +def _all_to_all_func(input_, world_size, process_group, scatter_dim=2, gather_dim=1): + input_list = [t.contiguous() for t in torch.tensor_split(input_, world_size, scatter_dim)] + output_list = [torch.empty_like(input_list[0]) for _ in range(world_size)] + dist.all_to_all(output_list, input_list, group=process_group) + return torch.cat(output_list, dim=gather_dim).contiguous() + + +def split_sequence(input_, process_group: dist.ProcessGroup, dim: int, pad: int): + world_size = dist.get_world_size(process_group) + rank = dist.get_rank(process_group) + if world_size == 1: + return input_ + + if pad > 0: + pad_size = list(input_.shape) + pad_size[dim] = pad + input_ = torch.cat([input_, torch.zeros(pad_size, dtype=input_.dtype, device=input_.device)], dim=dim) + + dim_size = input_.size(dim) + if dim_size % world_size != 0: + logger.error(f"dim_size ( %d ) is not divisible by world_size ( %d )", dim_size, world_size) + raise ValueError(f"dim_size ({dim_size}) is not divisible by world_size ({world_size})") + tensor_list = torch.split(input_, dim_size // world_size, dim=dim) + output = tensor_list[rank].contiguous() + return output + + +def gather_sequence(input_, process_group: dist.ProcessGroup, dim: int, pad: int): + input_ = input_.contiguous() + world_size = dist.get_world_size(process_group) + rank = dist.get_rank(process_group) + if world_size == 1: + return input_ + + #all gather + tensor_list = [torch.empty_like(input_) for _ in range(world_size)] + torch.distributed.all_gather(tensor_list, input_, group=process_group) + + #concat + output = torch.cat(tensor_list, dim=dim) + + if pad > 0: + output = output.narrow(dim, 0, output.size(dim) - pad) + + return output + +# ====== +# Pad +# ====== + +SPTIAL_PAD = 0 +TEMPORAL_PAD = 0 + + +def set_spatial_pad(dim_size: int): + sp_size = get_sequence_parallel_size() + pad = (sp_size - (dim_size % sp_size)) % sp_size + global SPTIAL_PAD + SPTIAL_PAD = pad + + +def get_spatial_pad() -> int: + return SPTIAL_PAD + + +def set_temporal_pad(dim_size: int): + sp_size = get_sequence_parallel_size() + pad = (sp_size - (dim_size % sp_size)) % sp_size + global TEMPORAL_PAD + TEMPORAL_PAD = pad + + +def get_temporal_pad() -> int: + return TEMPORAL_PAD + + +def all_to_all_with_pad( + input_: torch.Tensor, + process_group: dist.ProcessGroup, + **kwargs +): + scatter_dim = kwargs.get("scatter_dim", 2) + gather_dim = kwargs.get("gather_dim", 1) + scatter_pad = kwargs.get("scatter_pad", 0) + gather_pad = kwargs.get("gather_pad", 0) + + if scatter_pad > 0: + pad_shape = list(input_.shape) + pad_shape[scatter_dim] = scatter_pad + pad_tensor = torch.zeros(pad_shape, device=input_.device, dtype=input_.dtype) + input_ = torch.cat([input_, pad_tensor], dim=scatter_dim) + + world_size = dist.get_world_size(process_group) + if input_.shape[scatter_dim] % world_size != 0: + logger.error(f"dim_size ( %d ) is not divisible by world_size ( %d )", input_.shape[scatter_dim], world_size) + raise ValueError(f"dim_size ({input_.shape[scatter_dim]}) is not divisible by world_size ({world_size})") + + input_ = _all_to_all_func(input_, world_size, process_group, scatter_dim, gather_dim) + + if gather_pad > 0: + input_ = input_.narrow(gather_dim, 0, input_.size(gather_dim) - gather_pad) + + return input_ diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/latte/__init__.py b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/latte/__init__.py new file mode 100644 index 0000000000..746552433e --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/latte/__init__.py @@ -0,0 +1,17 @@ +#!/usr/bin/env python +# coding=utf-8 +# Copyright 2024 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from .modeling_latte import LatteT2V \ No newline at end of file diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/latte/latte_modules.py b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/latte/latte_modules.py new file mode 100644 index 0000000000..9ab3e9fb14 --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/latte/latte_modules.py @@ -0,0 +1,1024 @@ +#!/usr/bin/env python +# coding=utf-8 +# Copyright 2024 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os +from dataclasses import dataclass +from importlib import import_module +from typing import Any, Dict, Optional, Tuple, Callable +from diffusers.utils import USE_PEFT_BACKEND, BaseOutput, deprecate, is_xformers_available +from diffusers.models.lora import LoRACompatibleLinear + +import torch +import torch.nn.functional as F +from torch import nn +from diffusers.utils.torch_utils import maybe_allow_in_graph +from diffusers.models.embeddings import SinusoidalPositionalEmbedding, TimestepEmbedding, Timesteps +from diffusers.models.normalization import AdaLayerNorm, AdaLayerNormZero +from diffusers.models.attention_processor import SpatialNorm, LORA_ATTENTION_PROCESSORS, \ + CustomDiffusionAttnProcessor, CustomDiffusionXFormersAttnProcessor, CustomDiffusionAttnProcessor2_0, \ + AttnAddedKVProcessor, AttnAddedKVProcessor2_0, SlicedAttnAddedKVProcessor, XFormersAttnAddedKVProcessor, \ + LoRAAttnAddedKVProcessor, LoRAXFormersAttnProcessor, XFormersAttnProcessor, LoRAAttnProcessor2_0, \ + LoRAAttnProcessor, AttnProcessor, SlicedAttnProcessor, logger +from diffusers.models.activations import GEGLU, GELU, ApproximateGELU +from opensoraplan.layers.utils import get_2d_sincos_pos_embed + +if os.getenv("VASCEND", "0") != "1" and is_xformers_available(): # "1"仿真环境 + import xformers + import xformers.ops +else: + xformers = None + +ATTR_PROCESSOR = "processor" +CUDA_DEVICE = "cuda" +ATTR_SDPA = "scaled_dot_product_attention" + + +@maybe_allow_in_graph +class Attention(nn.Module): + def __init__( + self, + query_dim: int, + cross_attention_dim: Optional[int] = None, + heads: int = 8, + dim_head: int = 64, + dropout: float = 0.0, + bias: bool = False, + upcast_attention: bool = False, + upcast_softmax: bool = False, + cross_attention_norm: Optional[str] = None, + cross_attention_norm_num_groups: int = 32, + added_kv_proj_dim: Optional[int] = None, + norm_num_groups: Optional[int] = None, + spatial_norm_dim: Optional[int] = None, + out_bias: bool = True, + scale_qk: bool = True, + only_cross_attention: bool = False, + eps: float = 1e-5, + rescale_output_factor: float = 1.0, + residual_connection: bool = False, + _from_deprecated_attn_block: bool = False, + processor: Optional["AttnProcessor"] = None, + attention_mode: str = 'xformers', + ): + super().__init__() + self.inner_dim = dim_head * heads + self.cross_attention_dim = cross_attention_dim if cross_attention_dim is not None else query_dim + self.upcast_attention = upcast_attention + self.upcast_softmax = upcast_softmax + self.rescale_output_factor = rescale_output_factor + self.residual_connection = residual_connection + self.dropout = dropout + + # we make use of this private variable to know whether this class is loaded + # with an deprecated state dict so that we can convert it on the fly + self._from_deprecated_attn_block = _from_deprecated_attn_block + + self.scale_qk = scale_qk + self.scale = dim_head**-0.5 if self.scale_qk else 1.0 + + self.heads = heads + # for slice_size > 0 the attention score computation + # is split across the batch axis to save memory + # You can set slice_size with `set_attention_slice` + self.sliceable_head_dim = heads + + self.added_kv_proj_dim = added_kv_proj_dim + self.only_cross_attention = only_cross_attention + + if self.added_kv_proj_dim is None and self.only_cross_attention: + raise ValueError( + "`only_cross_attention` can only be set to True if `added_kv_proj_dim` is not None. Make sure to set " + "either `only_cross_attention=False` or define `added_kv_proj_dim`." + ) + + if norm_num_groups is not None: + self.group_norm = nn.GroupNorm(num_channels=query_dim, num_groups=norm_num_groups, eps=eps, affine=True) + else: + self.group_norm = None + + if spatial_norm_dim is not None: + self.spatial_norm = SpatialNorm(f_channels=query_dim, zq_channels=spatial_norm_dim) + else: + self.spatial_norm = None + + if cross_attention_norm is None: + self.norm_cross = None + elif cross_attention_norm == "layer_norm": + self.norm_cross = nn.LayerNorm(self.cross_attention_dim) + elif cross_attention_norm == "group_norm": + if self.added_kv_proj_dim is not None: + # The given `encoder_hidden_states` are initially of shape + # (batch_size, seq_len, added_kv_proj_dim) before being projected + # to (batch_size, seq_len, cross_attention_dim). The norm is applied + # before the projection, so we need to use `added_kv_proj_dim` as + # the number of channels for the group norm. + norm_cross_num_channels = added_kv_proj_dim + else: + norm_cross_num_channels = self.cross_attention_dim + + self.norm_cross = nn.GroupNorm( + num_channels=norm_cross_num_channels, num_groups=cross_attention_norm_num_groups, eps=1e-5, affine=True + ) + else: + raise ValueError( + f"unknown cross_attention_norm: {cross_attention_norm}. Should be None, 'layer_norm' or 'group_norm'" + ) + + if USE_PEFT_BACKEND: + linear_cls = nn.Linear + else: + linear_cls = LoRACompatibleLinear + + self.to_q = linear_cls(query_dim, self.inner_dim, bias=bias) + + if not self.only_cross_attention: + # only relevant for the `AddedKVProcessor` classes + self.to_k = linear_cls(self.cross_attention_dim, self.inner_dim, bias=bias) + self.to_v = linear_cls(self.cross_attention_dim, self.inner_dim, bias=bias) + else: + self.to_k = None + self.to_v = None + + if self.added_kv_proj_dim is not None: + self.add_k_proj = linear_cls(added_kv_proj_dim, self.inner_dim) + self.add_v_proj = linear_cls(added_kv_proj_dim, self.inner_dim) + + self.to_out = nn.ModuleList([]) + self.to_out.append(linear_cls(self.inner_dim, query_dim, bias=out_bias)) + self.to_out.append(nn.Dropout(dropout)) + + # set attention processor + # We use the AttnProcessor2_0 by default when torch 2.x is used which uses + # torch.nn.functional.scaled_dot_product_attention for native Flash/memory_efficient_attention + # but only if it has the default `scale` argument. + if processor is None: + processor = ( + AttnProcessor2(attention_mode) if + hasattr(F, ATTR_SDPA) and self.scale_qk else AttnProcessor() + ) + self.set_processor(processor) + + def set_processor(self, processor: "AttnProcessor", _remove_lora: bool = False) -> None: + condition_processor = not USE_PEFT_BACKEND and hasattr(self, ATTR_PROCESSOR) + condition_lora = _remove_lora and self.to_q.lora_layer is not None + if condition_processor and condition_lora: + deprecate( + "set_processor to offload LoRA", + "0.26.0", + "In detail, removing LoRA layers via calling `set_default_attn_processor` is deprecated. " + "Please make sure to call `pipe.unload_lora_weights()` instead.", + ) + + for module in self.modules(): + if hasattr(module, "set_lora_layer"): + module.set_lora_layer(None) + + # if current processor is in `self._modules` and if passed `processor` is not, we need to + # pop `processor` from `self._modules` + if ( + hasattr(self, ATTR_PROCESSOR) + and isinstance(self.processor, torch.nn.Module) + and not isinstance(processor, torch.nn.Module) + ): + logger.info(f"You are removing possibly trained weights of {self.processor} with {processor}") + self._modules.pop(ATTR_PROCESSOR) + + self.processor = processor + + def forward( + self, + hidden_states: torch.FloatTensor, + encoder_hidden_states: Optional[torch.FloatTensor] = None, + attention_mask: Optional[torch.FloatTensor] = None, + **cross_attention_kwargs, + ) -> torch.Tensor: + # The `Attention` class can call different attention processors / attention functions + # here we simply pass along all tensors to the selected processor class + # For standard processors that are defined here, `**cross_attention_kwargs` is empty + return self.processor( + self, + hidden_states, + encoder_hidden_states=encoder_hidden_states, + attention_mask=attention_mask, + **cross_attention_kwargs, + ) + + def prepare_attention_mask( + self, attention_mask: torch.Tensor, target_length: int, batch_size: int, out_dim: int = 3 + ) -> torch.Tensor: + head_size = self.heads + if attention_mask is None: + return attention_mask + + current_length: int = attention_mask.shape[-1] + if current_length != target_length: + if attention_mask.device.type == "mps": + # HACK: MPS: Does not support padding by greater than dimension of input tensor. + # Instead, we can manually construct the padding tensor. + padding_shape = (attention_mask.shape[0], attention_mask.shape[1], target_length) + padding = torch.zeros(padding_shape, dtype=attention_mask.dtype, device=attention_mask.device) + attention_mask = torch.cat([attention_mask, padding], dim=2) + else: + attention_mask = F.pad(attention_mask, (0, target_length), value=0.0) + + if out_dim == 3: + if attention_mask.shape[0] < batch_size * head_size: + attention_mask = attention_mask.repeat_interleave(head_size, dim=0) + elif out_dim == 4: + attention_mask = attention_mask.unsqueeze(1) + attention_mask = attention_mask.repeat_interleave(head_size, dim=1) + + return attention_mask + + def norm_encoder_hidden_states(self, encoder_hidden_states: torch.Tensor) -> torch.Tensor: + if self.norm_cross is None: + raise ValueError("self.norm_cross must be defined to call self.norm_encoder_hidden_states") + + if isinstance(self.norm_cross, nn.LayerNorm): + encoder_hidden_states = self.norm_cross(encoder_hidden_states) + elif isinstance(self.norm_cross, nn.GroupNorm): + # Group norm norms along the channels dimension and expects input to be in the shape of (N, C, *). + # In this case, we want to norm along the hidden dimension, so we need to move + # the shape (batch_size, sequence_length, hidden_size) to (batch_size, hidden_size, sequence_length) + encoder_hidden_states = encoder_hidden_states.transpose(1, 2) + encoder_hidden_states = self.norm_cross(encoder_hidden_states) + encoder_hidden_states = encoder_hidden_states.transpose(1, 2) + else: + raise ValueError + + return encoder_hidden_states + + +class AttnProcessor2: + r""" + Processor for implementing scaled dot-product attention (enabled by default if you're using PyTorch 2.0). + """ + + def __init__(self, attention_mode='xformers'): + self.attention_mode = attention_mode + if not hasattr(F, ATTR_SDPA): + raise ImportError("AttnProcessor2 requires PyTorch 2.0, to use it, please upgrade PyTorch to 2.0.") + + def __call__( + self, + attn: Attention, + hidden_states: torch.FloatTensor, + encoder_hidden_states: Optional[torch.FloatTensor] = None, + attention_mask: Optional[torch.FloatTensor] = None, + temb: Optional[torch.FloatTensor] = None, + scale: float = 1.0, + ) -> torch.FloatTensor: + residual = hidden_states + + args = () if USE_PEFT_BACKEND else (scale,) + + if attn.spatial_norm is not None: + hidden_states = attn.spatial_norm(hidden_states, temb) + + input_ndim = hidden_states.ndim + + if input_ndim == 4: + batch_size, channel, height, width = hidden_states.shape + hidden_states = hidden_states.view(batch_size, channel, height * width).transpose(1, 2) + + batch_size, sequence_length, _ = ( + hidden_states.shape if encoder_hidden_states is None else encoder_hidden_states.shape + ) + + if attention_mask is not None: + attention_mask = attn.prepare_attention_mask(attention_mask, sequence_length, batch_size) + # scaled_dot_product_attention expects attention_mask shape to be + # the shape like (batch, heads, source_length, target_length) + attention_mask = attention_mask.view(batch_size, attn.heads, -1, attention_mask.shape[-1]) + + if attn.group_norm is not None: + hidden_states = attn.group_norm(hidden_states.transpose(1, 2)).transpose(1, 2) + + args = () if USE_PEFT_BACKEND else (scale,) + query = attn.to_q(hidden_states, *args) + + if encoder_hidden_states is None: + encoder_hidden_states = hidden_states + elif attn.norm_cross: + encoder_hidden_states = attn.norm_encoder_hidden_states(encoder_hidden_states) + + key = attn.to_k(encoder_hidden_states, *args) + value = attn.to_v(encoder_hidden_states, *args) + + inner_dim = key.shape[-1] + head_dim = inner_dim // attn.heads + + query = query.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2) + + key = key.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2) + value = value.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2) + + # the output of sdp = (batch, num_heads, seq_len, head_dim) + if self.attention_mode == 'flash': + if (attention_mask is not None) and (not torch.all(attention_mask.bool())): + raise ValueError("flash-attn do not support attention_mask") + with torch.backends.cuda.sdp_kernel(enable_math=False, enable_flash=True, enable_mem_efficient=False): + hidden_states = F.scaled_dot_product_attention( + query, key, value, dropout_p=0.0, is_causal=False + ) + elif self.attention_mode == 'xformers': + with torch.backends.cuda.sdp_kernel(enable_math=False, enable_flash=False, enable_mem_efficient=True): + if os.getenv("VASCEND", "0") == "1": # "1"仿真环境 + hidden_states = query + else: + hidden_states = F.scaled_dot_product_attention( + query, key, value, attn_mask=attention_mask, dropout_p=0.0, is_causal=False + ) + elif self.attention_mode == 'math': + hidden_states = F.scaled_dot_product_attention( + query, key, value, attn_mask=attention_mask, dropout_p=0.0, is_causal=False + ) + else: + raise NotImplementedError(f'Found attention_mode: {self.attention_mode}') + hidden_states = hidden_states.transpose(1, 2).reshape(batch_size, -1, attn.heads * head_dim) + hidden_states = hidden_states.to(query.dtype) + + # linear proj + hidden_states = attn.to_out[0](hidden_states, *args) + # dropout + hidden_states = attn.to_out[1](hidden_states) + + if input_ndim == 4: + hidden_states = hidden_states.transpose(-1, -2).reshape(batch_size, channel, height, width) + + if attn.residual_connection: + hidden_states = hidden_states + residual + + hidden_states = hidden_states / attn.rescale_output_factor + + return hidden_states + + +@maybe_allow_in_graph +class GatedSelfAttentionDense(nn.Module): + def __init__(self, query_dim: int, context_dim: int, n_heads: int, d_head: int): + super().__init__() + + # we need a linear projection since we need cat visual feature and obj feature + self.linear = nn.Linear(context_dim, query_dim) + + self.attn = Attention(query_dim=query_dim, heads=n_heads, dim_head=d_head) + self.ff = FeedForward(query_dim, activation_fn="geglu") + + self.norm1 = nn.LayerNorm(query_dim) + self.norm2 = nn.LayerNorm(query_dim) + + self.register_parameter("alpha_attn", nn.Parameter(torch.tensor(0.0))) + self.register_parameter("alpha_dense", nn.Parameter(torch.tensor(0.0))) + + self.enabled = True + + def forward(self, x: torch.Tensor, objs: torch.Tensor) -> torch.Tensor: + if not self.enabled: + return x + + n_visual = x.shape[1] + objs = self.linear(objs) + + x = x + self.alpha_attn.tanh() * self.attn(self.norm1(torch.cat([x, objs], dim=1)))[:, :n_visual, :] + x = x + self.alpha_dense.tanh() * self.ff(self.norm2(x)) + + return x + + +class FeedForward(nn.Module): + def __init__( + self, + dim: int, + dim_out: Optional[int] = None, + mult: int = 4, + dropout: float = 0.0, + activation_fn: str = "geglu", + final_dropout: bool = False, + ): + super().__init__() + inner_dim = int(dim * mult) + dim_out = dim_out if dim_out is not None else dim + linear_cls = LoRACompatibleLinear if not USE_PEFT_BACKEND else nn.Linear + + if activation_fn == "gelu": + act_fn = GELU(dim, inner_dim) + if activation_fn == "gelu-approximate": + act_fn = GELU(dim, inner_dim, approximate="tanh") + elif activation_fn == "geglu": + act_fn = GEGLU(dim, inner_dim) + elif activation_fn == "geglu-approximate": + act_fn = ApproximateGELU(dim, inner_dim) + + self.net = nn.ModuleList([]) + # project in + self.net.append(act_fn) + # project dropout + self.net.append(nn.Dropout(dropout)) + # project out + self.net.append(linear_cls(inner_dim, dim_out)) + # FF as used in Vision Transformer, MLP-Mixer, etc. have a final dropout + if final_dropout: + self.net.append(nn.Dropout(dropout)) + + def forward(self, hidden_states: torch.Tensor, scale: float = 1.0) -> torch.Tensor: + compatible_cls = (GEGLU,) if USE_PEFT_BACKEND else (GEGLU, LoRACompatibleLinear) + for module in self.net: + if isinstance(module, compatible_cls): + hidden_states = module(hidden_states, scale) + else: + hidden_states = module(hidden_states) + return hidden_states + + +@maybe_allow_in_graph +class BasicTransformerBlockTemporal(nn.Module): + def __init__( + self, + dim: int, + num_attention_heads: int, + attention_head_dim: int, + dropout=0.0, + cross_attention_dim: Optional[int] = None, + activation_fn: str = "geglu", + num_embeds_ada_norm: Optional[int] = None, + attention_bias: bool = False, + only_cross_attention: bool = False, + double_self_attention: bool = False, + upcast_attention: bool = False, + norm_elementwise_affine: bool = True, + norm_type: str = "layer_norm", # 'layer_norm', 'ada_norm', 'ada_norm_zero', 'ada_norm_single' + norm_eps: float = 1e-5, + final_dropout: bool = False, + attention_type: str = "default", + positional_embeddings: Optional[str] = None, + num_positional_embeddings: Optional[int] = None, + attention_mode: str = "xformers", + ): + super().__init__() + self.only_cross_attention = only_cross_attention + + self.use_ada_layer_norm_zero = (num_embeds_ada_norm is not None) and norm_type == "ada_norm_zero" + self.use_ada_layer_norm = (num_embeds_ada_norm is not None) and norm_type == "ada_norm" + self.use_ada_layer_norm_single = norm_type == "ada_norm_single" + self.use_layer_norm = norm_type == "layer_norm" + + if norm_type in ("ada_norm", "ada_norm_zero") and num_embeds_ada_norm is None: + raise ValueError( + f"`norm_type` is set to {norm_type}, but `num_embeds_ada_norm` is not defined. Please make sure to" + f" define `num_embeds_ada_norm` if setting `norm_type` to {norm_type}." + ) + + if positional_embeddings and (num_positional_embeddings is None): + raise ValueError( + "If `positional_embedding` type is defined, `num_positition_embeddings` must also be defined." + ) + + if positional_embeddings == "sinusoidal": + self.pos_embed = SinusoidalPositionalEmbedding(dim, max_seq_length=num_positional_embeddings) + else: + self.pos_embed = None + + # Define 3 blocks. Each block has its own normalization layer. + # 1. Self-Attn + if self.use_ada_layer_norm: + self.norm1 = AdaLayerNorm(dim, num_embeds_ada_norm) + elif self.use_ada_layer_norm_zero: + self.norm1 = AdaLayerNormZero(dim, num_embeds_ada_norm) + else: + self.norm1 = nn.LayerNorm(dim, elementwise_affine=norm_elementwise_affine, eps=norm_eps) + + self.attn1 = Attention( + query_dim=dim, + heads=num_attention_heads, + dim_head=attention_head_dim, + dropout=dropout, + bias=attention_bias, + cross_attention_dim=cross_attention_dim if only_cross_attention else None, + upcast_attention=upcast_attention, + attention_mode=attention_mode + ) + + # 3. Feed-forward + self.norm3 = nn.LayerNorm(dim, elementwise_affine=norm_elementwise_affine, eps=norm_eps) + + self.ff = FeedForward(dim, dropout=dropout, activation_fn=activation_fn, final_dropout=final_dropout) + + # 4. Fuser + if attention_type == "gated" or attention_type == "gated-text-image": + self.fuser = GatedSelfAttentionDense(dim, cross_attention_dim, num_attention_heads, attention_head_dim) + + # 5. Scale-shift for PixArt-Alpha. + if self.use_ada_layer_norm_single: + self.scale_shift_table = nn.Parameter(torch.randn(6, dim) / dim ** 0.5) + + # let chunk size default to None + self._chunk_size = None + self._chunk_dim = 0 + + def forward( + self, + hidden_states: torch.FloatTensor, + attention_mask: Optional[torch.FloatTensor] = None, + encoder_hidden_states: Optional[torch.FloatTensor] = None, + encoder_attention_mask: Optional[torch.FloatTensor] = None, + timestep: Optional[torch.LongTensor] = None, + cross_attention_kwargs: Dict[str, Any] = None, + class_labels: Optional[torch.LongTensor] = None, + ) -> torch.FloatTensor: + # Notice that normalization is always applied before the real computation in the following blocks. + # 0. Self-Attention + batch_size = hidden_states.shape[0] + + if self.use_ada_layer_norm: + norm_hidden_states = self.norm1(hidden_states, timestep) + elif self.use_ada_layer_norm_zero: + norm_hidden_states, gate_msa, shift_mlp, scale_mlp, gate_mlp = self.norm1( + hidden_states, timestep, class_labels, hidden_dtype=hidden_states.dtype + ) + elif self.use_layer_norm: + norm_hidden_states = self.norm1(hidden_states) + elif self.use_ada_layer_norm_single: + shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = ( + self.scale_shift_table[None] + timestep.reshape(batch_size, 6, -1) + ).chunk(6, dim=1) + if os.getenv("VASCEND", "0") == "1": # "1"仿真环境 + norm_hidden_states = hidden_states + else: + norm_hidden_states = self.norm1(hidden_states) + norm_hidden_states = norm_hidden_states * (1 + scale_msa) + shift_msa + norm_hidden_states = norm_hidden_states.squeeze(1) + else: + raise ValueError("Incorrect norm used") + + if self.pos_embed is not None: + norm_hidden_states = self.pos_embed(norm_hidden_states) + + # 1. Retrieve lora scale. + lora_scale = cross_attention_kwargs.get("scale", 1.0) if cross_attention_kwargs is not None else 1.0 + + # 2. Prepare GLIGEN inputs + cross_attention_kwargs = cross_attention_kwargs.copy() if cross_attention_kwargs is not None else {} + gligen_kwargs = cross_attention_kwargs.pop("gligen", None) + + attn_output = self.attn1( + norm_hidden_states, + encoder_hidden_states=encoder_hidden_states if self.only_cross_attention else None, + attention_mask=attention_mask, + **cross_attention_kwargs, + ) + if self.use_ada_layer_norm_zero: + attn_output = gate_msa.unsqueeze(1) * attn_output + elif self.use_ada_layer_norm_single: + attn_output = gate_msa * attn_output + + hidden_states = attn_output + hidden_states + if hidden_states.ndim == 4: + hidden_states = hidden_states.squeeze(1) + + # 2.5 GLIGEN Control + if gligen_kwargs is not None: + hidden_states = self.fuser(hidden_states, gligen_kwargs["objs"]) + + # 4. Feed-forward + if self.use_ada_layer_norm_zero: + norm_hidden_states = norm_hidden_states * (1 + scale_mlp[:, None]) + shift_mlp[:, None] + + if self.use_ada_layer_norm_single: + if os.getenv("VASCEND", "0") == "1": # "1"仿真环境 + norm_hidden_states = hidden_states + else: + norm_hidden_states = self.norm3(hidden_states) + norm_hidden_states = norm_hidden_states * (1 + scale_mlp) + shift_mlp + + if self._chunk_size is not None: + # "feed_forward_chunk_size" can be used to save memory + if norm_hidden_states.shape[self._chunk_dim] % self._chunk_size != 0: + raise ValueError( + f"`hidden_states` dimension to be chunked: {norm_hidden_states.shape[self._chunk_dim]} " + f"has to be divisible by chunk size: {self._chunk_size}. Make sure to set an appropriate " + f"`chunk_size` when calling `unet.enable_forward_chunking`." + ) + + num_chunks = norm_hidden_states.shape[self._chunk_dim] // self._chunk_size + ff_output = torch.cat( + [ + self.ff(hid_slice, scale=lora_scale) + for hid_slice in norm_hidden_states.chunk(num_chunks, dim=self._chunk_dim) + ], + dim=self._chunk_dim, + ) + else: + ff_output = self.ff(norm_hidden_states, scale=lora_scale) + + if self.use_ada_layer_norm_zero: + ff_output = gate_mlp.unsqueeze(1) * ff_output + elif self.use_ada_layer_norm_single: + ff_output = gate_mlp * ff_output + + hidden_states = ff_output + hidden_states + if hidden_states.ndim == 4: + hidden_states = hidden_states.squeeze(1) + + return hidden_states + + +@maybe_allow_in_graph +class BasicTransformerBlock(nn.Module): + def __init__( + self, + dim: int, + num_attention_heads: int, + attention_head_dim: int, + dropout=0.0, + cross_attention_dim: Optional[int] = None, + activation_fn: str = "geglu", + num_embeds_ada_norm: Optional[int] = None, + attention_bias: bool = False, + only_cross_attention: bool = False, + double_self_attention: bool = False, + upcast_attention: bool = False, + norm_elementwise_affine: bool = True, + norm_type: str = "layer_norm", # 'layer_norm', 'ada_norm', 'ada_norm_zero', 'ada_norm_single' + norm_eps: float = 1e-5, + final_dropout: bool = False, + attention_type: str = "default", + positional_embeddings: Optional[str] = None, + num_positional_embeddings: Optional[int] = None, + attention_mode: str = "xformers" + ): + super().__init__() + self.only_cross_attention = only_cross_attention + + self.use_ada_layer_norm_zero = (num_embeds_ada_norm is not None) and norm_type == "ada_norm_zero" + self.use_ada_layer_norm = (num_embeds_ada_norm is not None) and norm_type == "ada_norm" + self.use_ada_layer_norm_single = norm_type == "ada_norm_single" + self.use_layer_norm = norm_type == "layer_norm" + + if norm_type in ("ada_norm", "ada_norm_zero") and num_embeds_ada_norm is None: + raise ValueError( + f"`norm_type` is set to {norm_type}, but `num_embeds_ada_norm` is not defined. Please make sure to" + f" define `num_embeds_ada_norm` if setting `norm_type` to {norm_type}." + ) + + if positional_embeddings and (num_positional_embeddings is None): + raise ValueError( + "If `positional_embedding` type is defined, `num_positition_embeddings` must also be defined." + ) + + if positional_embeddings == "sinusoidal": + self.pos_embed = SinusoidalPositionalEmbedding(dim, max_seq_length=num_positional_embeddings) + else: + self.pos_embed = None + + # Define 3 blocks. Each block has its own normalization layer. + # 1. Self-Attn + if self.use_ada_layer_norm: + self.norm1 = AdaLayerNorm(dim, num_embeds_ada_norm) + elif self.use_ada_layer_norm_zero: + self.norm1 = AdaLayerNormZero(dim, num_embeds_ada_norm) + else: + self.norm1 = nn.LayerNorm(dim, elementwise_affine=norm_elementwise_affine, eps=norm_eps) + + self.attn1 = Attention( + query_dim=dim, + heads=num_attention_heads, + dim_head=attention_head_dim, + dropout=dropout, + bias=attention_bias, + cross_attention_dim=cross_attention_dim if only_cross_attention else None, + upcast_attention=upcast_attention, + attention_mode=attention_mode + ) + + # 2. Cross-Attn + if cross_attention_dim is not None or double_self_attention: + # We currently only use AdaLayerNormZero for self attention where there will only be one attention block. + # I.e. the number of returned modulation chunks from AdaLayerZero would not make sense if returned during + # the second cross attention block. + self.norm2 = ( + AdaLayerNorm(dim, num_embeds_ada_norm) + if self.use_ada_layer_norm + else nn.LayerNorm(dim, elementwise_affine=norm_elementwise_affine, eps=norm_eps) + ) + self.attn2 = Attention( + query_dim=dim, + cross_attention_dim=cross_attention_dim if not double_self_attention else None, + heads=num_attention_heads, + dim_head=attention_head_dim, + dropout=dropout, + bias=attention_bias, + upcast_attention=upcast_attention, + attention_mode='xformers', # only xformers support attention_mask + ) # is self-attn if encoder_hidden_states is none + else: + self.norm2 = None + self.attn2 = None + + # 3. Feed-forward + if not self.use_ada_layer_norm_single: + self.norm3 = nn.LayerNorm(dim, elementwise_affine=norm_elementwise_affine, eps=norm_eps) + + self.ff = FeedForward( + dim, + dropout=dropout, + activation_fn=activation_fn, + final_dropout=final_dropout, + ) + + # 4. Fuser + if attention_type == "gated" or attention_type == "gated-text-image": + self.fuser = GatedSelfAttentionDense(dim, cross_attention_dim, num_attention_heads, attention_head_dim) + + # 5. Scale-shift for PixArt-Alpha. + if self.use_ada_layer_norm_single: + self.scale_shift_table = nn.Parameter(torch.randn(6, dim) / dim**0.5) + + # let chunk size default to None + self._chunk_size = None + self._chunk_dim = 0 + + def forward( + self, + hidden_states: torch.FloatTensor, + attention_mask: Optional[torch.FloatTensor] = None, + encoder_hidden_states: Optional[torch.FloatTensor] = None, + encoder_attention_mask: Optional[torch.FloatTensor] = None, + timestep: Optional[torch.LongTensor] = None, + cross_attention_kwargs: Dict[str, Any] = None, + class_labels: Optional[torch.LongTensor] = None, + ) -> torch.FloatTensor: + # Notice that normalization is always applied before the real computation in the following blocks. + # 0. Self-Attention + batch_size = hidden_states.shape[0] + + if self.use_ada_layer_norm: + norm_hidden_states = self.norm1(hidden_states, timestep) + elif self.use_ada_layer_norm_zero: + norm_hidden_states, gate_msa, shift_mlp, scale_mlp, gate_mlp = self.norm1( + hidden_states, timestep, class_labels, hidden_dtype=hidden_states.dtype + ) + elif self.use_layer_norm: + norm_hidden_states = self.norm1(hidden_states) + elif self.use_ada_layer_norm_single: + shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = ( + self.scale_shift_table[None] + timestep.reshape(batch_size, 6, -1) + ).chunk(6, dim=1) + if os.getenv("VASCEND", "0") == "1": # "1"仿真环境 + norm_hidden_states = hidden_states + else: + norm_hidden_states = self.norm1(hidden_states) + norm_hidden_states = norm_hidden_states * (1 + scale_msa) + shift_msa + norm_hidden_states = norm_hidden_states.squeeze(1) + else: + raise ValueError("Incorrect norm used") + + if self.pos_embed is not None: + norm_hidden_states = self.pos_embed(norm_hidden_states) + + # 1. Retrieve lora scale. + lora_scale = cross_attention_kwargs.get("scale", 1.0) if cross_attention_kwargs is not None else 1.0 + + # 2. Prepare GLIGEN inputs + cross_attention_kwargs = cross_attention_kwargs.copy() if cross_attention_kwargs is not None else {} + gligen_kwargs = cross_attention_kwargs.pop("gligen", None) + + attn_output = self.attn1( + norm_hidden_states, + encoder_hidden_states=encoder_hidden_states if self.only_cross_attention else None, + attention_mask=attention_mask, + **cross_attention_kwargs, + ) + if self.use_ada_layer_norm_zero: + attn_output = gate_msa.unsqueeze(1) * attn_output + elif self.use_ada_layer_norm_single: + attn_output = gate_msa * attn_output + + hidden_states = attn_output + hidden_states + if hidden_states.ndim == 4: + hidden_states = hidden_states.squeeze(1) + + # 2.5 GLIGEN Control + if gligen_kwargs is not None: + hidden_states = self.fuser(hidden_states, gligen_kwargs["objs"]) + + # 3. Cross-Attention + if self.attn2 is not None: + if self.use_ada_layer_norm: + norm_hidden_states = self.norm2(hidden_states, timestep) + elif self.use_ada_layer_norm_zero or self.use_layer_norm: + norm_hidden_states = self.norm2(hidden_states) + elif self.use_ada_layer_norm_single: + norm_hidden_states = hidden_states + else: + raise ValueError("Incorrect norm") + + if self.pos_embed is not None and self.use_ada_layer_norm_single is False: + norm_hidden_states = self.pos_embed(norm_hidden_states) + + attn_output = self.attn2( + norm_hidden_states, + encoder_hidden_states=encoder_hidden_states, + attention_mask=encoder_attention_mask, + **cross_attention_kwargs, + ) + hidden_states = attn_output + hidden_states + + # 4. Feed-forward + if not self.use_ada_layer_norm_single: + if os.getenv("VASCEND", "0") == "1": # "1"仿真环境 + norm_hidden_states = hidden_states + else: + norm_hidden_states = self.norm3(hidden_states) + + if self.use_ada_layer_norm_zero: + norm_hidden_states = norm_hidden_states * (1 + scale_mlp[:, None]) + shift_mlp[:, None] + + if self.use_ada_layer_norm_single: + norm_hidden_states = self.norm2(hidden_states) + norm_hidden_states = norm_hidden_states * (1 + scale_mlp) + shift_mlp + + if self._chunk_size is not None: + # "feed_forward_chunk_size" can be used to save memory + ff_output = _chunked_feed_forward( + self.ff, norm_hidden_states, self._chunk_dim, self._chunk_size, lora_scale=lora_scale + ) + else: + ff_output = self.ff(norm_hidden_states, scale=lora_scale) + + if self.use_ada_layer_norm_zero: + ff_output = gate_mlp.unsqueeze(1) * ff_output + elif self.use_ada_layer_norm_single: + ff_output = gate_mlp * ff_output + + hidden_states = ff_output + hidden_states + if hidden_states.ndim == 4: + hidden_states = hidden_states.squeeze(1) + + return hidden_states + + +class CombinedTimestepSizeEmbeddings(nn.Module): + def __init__(self, embedding_dim, size_emb_dim, use_additional_conditions: bool = False): + super().__init__() + + self.outdim = size_emb_dim + self.time_proj = Timesteps(num_channels=256, flip_sin_to_cos=True, downscale_freq_shift=0) + self.timestep_embedder = TimestepEmbedding(in_channels=256, time_embed_dim=embedding_dim) + + self.use_additional_conditions = use_additional_conditions + if use_additional_conditions: + self.use_additional_conditions = True + self.additional_condition_proj = Timesteps(num_channels=256, flip_sin_to_cos=True, downscale_freq_shift=0) + self.resolution_embedder = TimestepEmbedding(in_channels=256, time_embed_dim=size_emb_dim) + self.aspect_ratio_embedder = TimestepEmbedding(in_channels=256, time_embed_dim=size_emb_dim) + + def apply_condition(self, size: torch.Tensor, batch_size: int, embedder: nn.Module): + if size.ndim == 1: + size = size[:, None] + + if size.shape[0] != batch_size: + size = size.repeat(batch_size // size.shape[0], 1) + if size.shape[0] != batch_size: + raise ValueError(f"`batch_size` should be {size.shape[0]} but found {batch_size}.") + + current_batch_size, dims = size.shape[0], size.shape[1] + size = size.reshape(-1) + size_freq = self.additional_condition_proj(size).to(size.dtype) + + size_emb = embedder(size_freq) + size_emb = size_emb.reshape(current_batch_size, dims * self.outdim) + return size_emb + + def forward(self, timestep, resolution, aspect_ratio, batch_size, hidden_dtype): + timesteps_proj = self.time_proj(timestep) + timesteps_emb = self.timestep_embedder(timesteps_proj.to(dtype=hidden_dtype)) # (N, D) + + if self.use_additional_conditions: + resolution = self.apply_condition(resolution, batch_size=batch_size, embedder=self.resolution_embedder) + aspect_ratio = self.apply_condition( + aspect_ratio, batch_size=batch_size, embedder=self.aspect_ratio_embedder + ) + conditioning = timesteps_emb + torch.cat([resolution, aspect_ratio], dim=1) + else: + conditioning = timesteps_emb + + return conditioning + + +class CaptionProjection(nn.Module): + def __init__(self, in_features, hidden_size, num_tokens=120): + super().__init__() + self.linear_1 = nn.Linear(in_features=in_features, out_features=hidden_size, bias=True) + self.act_1 = nn.GELU(approximate="tanh") + self.linear_2 = nn.Linear(in_features=hidden_size, out_features=hidden_size, bias=True) + self.register_buffer("y_embedding", nn.Parameter(torch.randn(num_tokens, in_features) / in_features**0.5)) + + def forward(self, caption, force_drop_ids=None): + hidden_states = self.linear_1(caption) + hidden_states = self.act_1(hidden_states) + hidden_states = self.linear_2(hidden_states) + return hidden_states + + +class PatchEmbed(nn.Module): + """2D Image to Patch Embedding""" + def __init__( + self, + height=224, + width=224, + patch_size=16, + in_channels=3, + embed_dim=768, + layer_norm=False, + flatten=True, + bias=True, + interpolation_scale=1, + ): + super().__init__() + + num_patches = (height // patch_size) * (width // patch_size) + self.flatten = flatten + self.layer_norm = layer_norm + + self.proj = nn.Conv2d( + in_channels, embed_dim, kernel_size=(patch_size, patch_size), stride=patch_size, bias=bias + ) + if layer_norm: + self.norm = nn.LayerNorm(embed_dim, elementwise_affine=False, eps=1e-6) + else: + self.norm = None + + self.patch_size = patch_size + self.height, self.width = height // patch_size, width // patch_size + self.base_size = height // patch_size + self.interpolation_scale = interpolation_scale + pos_embed = get_2d_sincos_pos_embed( + embed_dim, int(num_patches**0.5), base_size=self.base_size, interpolation_scale=self.interpolation_scale + ) + self.register_buffer("pos_embed", torch.from_numpy(pos_embed).float().unsqueeze(0), persistent=False) + + def forward(self, latent): + height, width = latent.shape[-2] // self.patch_size, latent.shape[-1] // self.patch_size + + latent = self.proj(latent) + if self.flatten: + latent = latent.flatten(2).transpose(1, 2) # BCHW -> BNC + if self.layer_norm: + latent = self.norm(latent) + + if self.height != height or self.width != width: + pos_embed = get_2d_sincos_pos_embed( + embed_dim=self.pos_embed.shape[-1], + grid_size=(height, width), + base_size=self.base_size, + interpolation_scale=self.interpolation_scale, + ) + pos_embed = torch.from_numpy(pos_embed) + pos_embed = pos_embed.float().unsqueeze(0).to(latent.device) + else: + pos_embed = self.pos_embed + + return (latent + pos_embed).to(latent.dtype) + + +class AdaLayerNormSingle(nn.Module): + def __init__(self, embedding_dim: int, use_additional_conditions: bool = False): + super().__init__() + + self.emb = CombinedTimestepSizeEmbeddings( + embedding_dim, size_emb_dim=embedding_dim // 3, use_additional_conditions=use_additional_conditions + ) + + self.silu = nn.SiLU() + self.linear = nn.Linear(embedding_dim, 6 * embedding_dim, bias=True) + + def forward( + self, + timestep: torch.Tensor, + added_cond_kwargs: Dict[str, torch.Tensor] = None, + batch_size: int = None, + hidden_dtype: Optional[torch.dtype] = None, + ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]: + # No modulation happening here. + embedded_timestep = self.emb(timestep, batch_size=batch_size, hidden_dtype=hidden_dtype, resolution=None, + aspect_ratio=None) + return self.linear(self.silu(embedded_timestep)), embedded_timestep + + +@dataclass +class Transformer3DModelOutput(BaseOutput): + sample: torch.FloatTensor diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/latte/modeling_latte.py b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/latte/modeling_latte.py new file mode 100644 index 0000000000..7307b4a5d3 --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/latte/modeling_latte.py @@ -0,0 +1,557 @@ +#!/usr/bin/env python +# coding=utf-8 +# Copyright 2024 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os +from typing import Any, Dict, Optional +from dataclasses import dataclass +from einops import rearrange, repeat +import torch +import torch.nn.functional as F +from torch import nn +from diffusers.utils import USE_PEFT_BACKEND, deprecate +from diffusers.models.embeddings import ImagePositionalEmbeddings +from diffusers.configuration_utils import ConfigMixin, register_to_config +from diffusers.models.modeling_utils import ModelMixin +from diffusers.models.lora import LoRACompatibleConv, LoRACompatibleLinear + +from opensoraplan.layers.utils import get_1d_sincos_pos_embed +from opensoraplan.utils.log import logger +from opensoraplan.models.parallel_mgr import ( + get_sequence_parallel_group, + use_sequence_parallel +) +from opensoraplan.models.comm import ( + all_to_all_with_pad, + gather_sequence, + get_spatial_pad, + get_temporal_pad, + set_spatial_pad, + set_temporal_pad, + split_sequence, +) +from opensoraplan.acceleration.dit_cache_common import CacheConfig +from opensoraplan.acceleration.open_sora_plan_dit_cache import OpenSoraPlanDiTCacheManager + +from .latte_modules import PatchEmbed, BasicTransformerBlock, BasicTransformerBlockTemporal, AdaLayerNormSingle, \ + Transformer3DModelOutput, CaptionProjection + +ADA_NORM_SINGLE = "ada_norm_single" +SLICE_TEMPORAL_PATTERN = '(b T) S d -> b T S d' +CHANGE_TF_PATTERN = '(b t) f d -> (b f) t d' + + +@dataclass +class LatteParams: + hidden_states: torch.Tensor + timestep: Optional[torch.LongTensor] = None + encoder_hidden_states: Optional[torch.Tensor] = None + added_cond_kwargs: Dict[str, torch.Tensor] = None + enable_temporal_attentions: bool = True + class_labels: Optional[torch.LongTensor] = None + cross_attention_kwargs: Dict[str, Any] = None + attention_mask: Optional[torch.Tensor] = None + encoder_attention_mask: Optional[torch.Tensor] = None + use_image_num: int = 0 + return_dict: bool = False + + +class LatteT2V(ModelMixin, ConfigMixin): + _supports_gradient_checkpointing = True + + """ + A 2D Transformer model for image-like data. + + Parameters: + num_attention_heads (`int`, *optional*, defaults to 16): The number of heads to use for multi-head attention. + attention_head_dim (`int`, *optional*, defaults to 88): The number of channels in each head. + in_channels (`int`, *optional*): + The number of channels in the input and output (specify if the input is **continuous**). + num_layers (`int`, *optional*, defaults to 1): The number of layers of Transformer blocks to use. + dropout (`float`, *optional*, defaults to 0.0): The dropout probability to use. + cross_attention_dim (`int`, *optional*): The number of `encoder_hidden_states` dimensions to use. + sample_size (`int`, *optional*): The width of the latent images (specify if the input is **discrete**). + This is fixed during training since it is used to learn a number of position embeddings. + num_vector_embeds (`int`, *optional*): + The number of classes of the vector embeddings of the latent pixels (specify if the input is **discrete**). + Includes the class for the masked latent pixel. + activation_fn (`str`, *optional*, defaults to `"geglu"`): Activation function to use in feed-forward. + num_embeds_ada_norm ( `int`, *optional*): + The number of diffusion steps used during training. Pass if at least one of the norm_layers is + `AdaLayerNorm`. This is fixed during training since it is used to learn a number of embeddings that are + added to the hidden states. + + During inference, you can denoise for up to but not more steps than `num_embeds_ada_norm`. + attention_bias (`bool`, *optional*): + Configure if the `TransformerBlocks` attention should contain a bias parameter. + """ + + @register_to_config + def __init__( + self, + num_attention_heads: int = 16, + patch_size_t: int = 1, + attention_head_dim: int = 88, + in_channels: Optional[int] = None, + out_channels: Optional[int] = None, + num_layers: int = 1, + dropout: float = 0.0, + norm_num_groups: int = 32, + cross_attention_dim: Optional[int] = None, + attention_bias: bool = False, + sample_size: Optional[int] = None, + num_vector_embeds: Optional[int] = None, + patch_size: Optional[int] = None, + activation_fn: str = "geglu", + num_embeds_ada_norm: Optional[int] = None, + use_linear_projection: bool = False, + only_cross_attention: bool = False, + double_self_attention: bool = False, + upcast_attention: bool = False, + norm_type: str = "layer_norm", + norm_elementwise_affine: bool = True, + norm_eps: float = 1e-5, + attention_type: str = "default", + caption_channels: int = None, + video_length: int = 17, + attention_mode: str = 'flash' + ): + super().__init__() + self.use_linear_projection = use_linear_projection + self.num_attention_heads = num_attention_heads + self.attention_head_dim = attention_head_dim + inner_dim = num_attention_heads * attention_head_dim + self.video_length = video_length + + conv_cls = nn.Conv2d if USE_PEFT_BACKEND else LoRACompatibleConv + linear_cls = nn.Linear if USE_PEFT_BACKEND else LoRACompatibleLinear + + # 1. Transformer2DModel can process both standard continuous images of shape `(batch_size, num_channels, + # width, height)` as well as quantized image embeddings of shape `(batch_size, num_image_vectors)` + # Define whether input is continuous or discrete depending on configuration + self.is_input_continuous = (in_channels is not None) and (patch_size is None) + self.is_input_vectorized = num_vector_embeds is not None + self.is_input_patches = in_channels is not None and patch_size is not None + self.cache_manager = OpenSoraPlanDiTCacheManager(CacheConfig()) + + if norm_type == "layer_norm" and num_embeds_ada_norm is not None: + deprecation_message = ( + f"The configuration file of this model: {self.__class__} is outdated. `norm_type` is either not set or" + " incorrectly set to `'layer_norm'`.Make sure to set `norm_type` to `'ada_norm'` in the config." + " Please make sure to update the config accordingly as leaving `norm_type` might led to incorrect" + " results in future versions. If you have downloaded this checkpoint from the Hugging Face Hub, it" + " would be very nice if you could open a Pull request for the `transformer/config.json` file" + ) + deprecate("norm_type!=num_embeds_ada_norm", "1.0.0", deprecation_message, standard_warn=False) + norm_type = "ada_norm" + + if self.is_input_continuous and self.is_input_vectorized: + raise ValueError( + f"Cannot define both `in_channels`: {in_channels} and `num_vector_embeds`: {num_vector_embeds}. Make" + " sure that either `in_channels` or `num_vector_embeds` is None." + ) + elif self.is_input_vectorized and self.is_input_patches: + raise ValueError( + f"Cannot define both `num_vector_embeds`: {num_vector_embeds} and `patch_size`: {patch_size}. Make" + " sure that either `num_vector_embeds` or `num_patches` is None." + ) + elif not self.is_input_continuous and not self.is_input_vectorized and not self.is_input_patches: + raise ValueError( + f"Has to define `in_channels`: {in_channels}, `num_vector_embeds`: {num_vector_embeds}, or patch_size:" + f" {patch_size}. Make sure that `in_channels`, `num_vector_embeds` or `num_patches` is not None." + ) + + # 2. Define input layers + if self.is_input_continuous: + self.in_channels = in_channels + + self.norm = torch.nn.GroupNorm(num_groups=norm_num_groups, num_channels=in_channels, eps=1e-6, affine=True) + if use_linear_projection: + self.proj_in = linear_cls(in_channels, inner_dim) + else: + self.proj_in = conv_cls(in_channels, inner_dim, kernel_size=1, stride=1, padding=0) + elif self.is_input_vectorized: + if sample_size is None or num_vector_embeds is None: + logger.error("Transformer2DModel over discrete input must provide sample_size and num_embed") + raise ValueError + + self.height = sample_size[0] + self.width = sample_size[1] + self.num_vector_embeds = num_vector_embeds + self.num_latent_pixels = self.height * self.width + + self.latent_image_embedding = ImagePositionalEmbeddings( + num_embed=num_vector_embeds, embed_dim=inner_dim, height=self.height, width=self.width + ) + elif self.is_input_patches: + if sample_size is None: + logger.error("Transformer2DModel over patched input must provide sample_size") + raise ValueError + + self.height = sample_size[0] + self.width = sample_size[1] + + self.patch_size = patch_size + interpolation_scale = self.config.sample_size[0] // 64 # => 64 (= 512 pixart) has interpolation scale 1 + interpolation_scale = max(interpolation_scale, 1) + self.pos_embed = PatchEmbed( + height=sample_size[0], + width=sample_size[1], + patch_size=patch_size, + in_channels=in_channels, + embed_dim=inner_dim, + interpolation_scale=interpolation_scale, + ) + + # 3. Define transformers blocks, spatial attention + self.transformer_blocks = nn.ModuleList( + [ + BasicTransformerBlock( + inner_dim, + num_attention_heads, + attention_head_dim, + dropout=dropout, + cross_attention_dim=cross_attention_dim, + activation_fn=activation_fn, + num_embeds_ada_norm=num_embeds_ada_norm, + attention_bias=attention_bias, + only_cross_attention=only_cross_attention, + double_self_attention=double_self_attention, + upcast_attention=upcast_attention, + norm_type=norm_type, + norm_elementwise_affine=norm_elementwise_affine, + norm_eps=norm_eps, + attention_type=attention_type, + attention_mode=attention_mode + ) + for d in range(num_layers) + ] + ) + + # Define temporal transformers blocks + self.temporal_transformer_blocks = nn.ModuleList( + [ + BasicTransformerBlockTemporal( # one attention + inner_dim, + num_attention_heads, # num_attention_heads + attention_head_dim, # attention_head_dim 72 + dropout=dropout, + cross_attention_dim=None, + activation_fn=activation_fn, + num_embeds_ada_norm=num_embeds_ada_norm, + attention_bias=attention_bias, + only_cross_attention=only_cross_attention, + double_self_attention=False, + upcast_attention=upcast_attention, + norm_type=norm_type, + norm_elementwise_affine=norm_elementwise_affine, + norm_eps=norm_eps, + attention_type=attention_type, + attention_mode=attention_mode + ) + for d in range(num_layers) + ] + ) + + # 4. Define output layers + self.out_channels = in_channels if out_channels is None else out_channels + if self.is_input_continuous: + if use_linear_projection: + self.proj_out = linear_cls(inner_dim, in_channels) + else: + self.proj_out = conv_cls(inner_dim, in_channels, kernel_size=1, stride=1, padding=0) + elif self.is_input_vectorized: + self.norm_out = nn.LayerNorm(inner_dim) + self.out = nn.Linear(inner_dim, self.num_vector_embeds - 1) + elif self.is_input_patches and norm_type != ADA_NORM_SINGLE: + self.norm_out = nn.LayerNorm(inner_dim, elementwise_affine=False, eps=1e-6) + self.proj_out_1 = nn.Linear(inner_dim, 2 * inner_dim) + self.proj_out_2 = nn.Linear(inner_dim, patch_size * patch_size * self.out_channels) + elif self.is_input_patches and norm_type == ADA_NORM_SINGLE: + self.norm_out = nn.LayerNorm(inner_dim, elementwise_affine=False, eps=1e-6) + self.scale_shift_table = nn.Parameter(torch.randn(2, inner_dim) / inner_dim ** 0.5) + self.proj_out = nn.Linear(inner_dim, patch_size * patch_size * self.out_channels) + + # 5. PixArt-Alpha blocks. + self.adaln_single = None + self.use_additional_conditions = False + if norm_type == ADA_NORM_SINGLE: + # additional conditions until we find better name + self.adaln_single = AdaLayerNormSingle(inner_dim, use_additional_conditions=self.use_additional_conditions) + + self.caption_projection = None + if caption_channels is not None: + self.caption_projection = CaptionProjection(in_features=caption_channels, hidden_size=inner_dim) + + self.gradient_checkpointing = False + + interpolation_scale = self.config.video_length // 5 # => 5 (= 5 our causalvideovae) has interpolation scale 1 + interpolation_scale = max(interpolation_scale, 1) + temp_pos_embed = get_1d_sincos_pos_embed(inner_dim, video_length, interpolation_scale=interpolation_scale) + self.register_buffer("temp_pos_embed", torch.from_numpy(temp_pos_embed).float().unsqueeze(0), persistent=False) + + def forward( + self, + latte_params: LatteParams, + t_idx: torch.Tensor = 0, + ): + hidden_states = latte_params.hidden_states + timestep = latte_params.timestep + encoder_hidden_states = latte_params.encoder_hidden_states + added_cond_kwargs = latte_params.added_cond_kwargs + enable_temporal_attentions = latte_params.enable_temporal_attentions + class_labels = latte_params.class_labels + cross_attention_kwargs = latte_params.cross_attention_kwargs + attention_mask = latte_params.attention_mask + encoder_attention_mask = latte_params.encoder_attention_mask + use_image_num = latte_params.use_image_num + return_dict = latte_params.return_dict + + input_batch_size, c, frame, h, w = hidden_states.shape + frame = frame - use_image_num + hidden_states = rearrange(hidden_states, 'b c f h w -> (b f) c h w').contiguous() + # ensure attention_mask is a bias, and give it a singleton query_tokens dimension. + # we may have done this conversion already, e.g. if we came here via UNet2DConditionModel#forward. + # we can tell by counting dims; if ndim == 2: it's a mask rather than a bias. + # expects mask of shape: [batch, key_tokens] + # adds singleton query_tokens dimension:[batch, 1, key_tokens] + # this helps to broadcast it as a bias over attention scores, which will be in one of the following shapes: + # [batch, heads, query_tokens, key_tokens] (e.g. torch sdp attn) + # [batch * heads, query_tokens, key_tokens] (e.g. xformers or classic attn) + if attention_mask is not None and attention_mask.ndim == 2: + # assume that mask is expressed as: + # (1 = keep, 0 = discard) + # convert mask into a bias that can be added to attention scores: + # (keep = +0, discard = -10000.0) + attention_mask = (1 - attention_mask.to(hidden_states.dtype)) * -10000.0 + attention_mask = attention_mask.unsqueeze(1) + attention_mask = attention_mask.to(self.dtype) + # 1 + 4, 1 -> video condition, 4 -> image condition + # convert encoder_attention_mask to a bias the same way we do for attention_mask + if encoder_attention_mask is not None and encoder_attention_mask.ndim == 2: # ndim == 2 means no image joint + encoder_attention_mask = (1 - encoder_attention_mask.to(hidden_states.dtype)) * -10000.0 + encoder_attention_mask = encoder_attention_mask.unsqueeze(1) + encoder_attention_mask = repeat(encoder_attention_mask, 'b 1 l -> (b f) 1 l', f=frame).contiguous() + encoder_attention_mask = encoder_attention_mask.to(self.dtype) + elif encoder_attention_mask is not None and encoder_attention_mask.ndim == 3: # ndim == 3 means image joint + encoder_attention_mask = (1 - encoder_attention_mask.to(hidden_states.dtype)) * -10000.0 + encoder_attention_mask_video = encoder_attention_mask[:, :1, ...] + encoder_attention_mask_video = repeat(encoder_attention_mask_video, 'b 1 l -> b (1 f) l', + f=frame).contiguous() + encoder_attention_mask_image = encoder_attention_mask[:, 1:, ...] + encoder_attention_mask = torch.cat([encoder_attention_mask_video, encoder_attention_mask_image], dim=1) + encoder_attention_mask = rearrange(encoder_attention_mask, 'b n l -> (b n) l').contiguous().unsqueeze(1) + encoder_attention_mask = encoder_attention_mask.to(self.dtype) + + # Retrieve lora scale. + lora_scale = cross_attention_kwargs.get("scale", 1.0) if cross_attention_kwargs is not None else 1.0 + + # 1. Input + if self.is_input_patches: # here + height, width = hidden_states.shape[-2] // self.patch_size, hidden_states.shape[-1] // self.patch_size + num_patches = height * width + + hidden_states = self.pos_embed(hidden_states.to(self.dtype)) # alrady add positional embeddings + + if self.adaln_single is not None: + if self.use_additional_conditions and added_cond_kwargs is None: + raise ValueError( + "`added_cond_kwargs` cannot be None when using additional conditions for `adaln_single`." + ) + batch_size = input_batch_size + timestep, embedded_timestep = self.adaln_single( + timestep, added_cond_kwargs, batch_size=batch_size, hidden_dtype=hidden_states.dtype + ) + + t_dim = frame + use_image_num + s_dim = num_patches + # shard over the sequence dim if sp is enabled + if use_sequence_parallel(): + set_temporal_pad(t_dim) + set_spatial_pad(s_dim) + hidden_states = rearrange(hidden_states, SLICE_TEMPORAL_PATTERN, T=t_dim, S=s_dim).contiguous() + hidden_states = split_sequence(hidden_states, get_sequence_parallel_group(), dim=1, pad=get_temporal_pad()) + t_dim = hidden_states.shape[1] + hidden_states = rearrange(hidden_states, 'b T S d -> (b T) S d', T=t_dim, S=s_dim).contiguous() + + # 2. Blocks + if self.caption_projection is not None: + batch_size = hidden_states.shape[0] + encoder_hidden_states = self.caption_projection(encoder_hidden_states.to(self.dtype)) # 3 120 1152 + + if use_image_num != 0 and self.training: + encoder_hidden_states_video = encoder_hidden_states[:, :1, ...] + encoder_hidden_states_video = repeat(encoder_hidden_states_video, 'b 1 t d -> b (1 f) t d', + f=frame).contiguous() + encoder_hidden_states_image = encoder_hidden_states[:, 1:, ...] + encoder_hidden_states = torch.cat([encoder_hidden_states_video, encoder_hidden_states_image], dim=1) + encoder_hidden_states_spatial = rearrange(encoder_hidden_states, 'b f t d -> (b f) t d').contiguous() + else: + encoder_hidden_states_spatial = repeat(encoder_hidden_states, 'b t d -> (b f) t d', + f=t_dim).contiguous() + + # prepare timesteps for spatial and temporal block + timestep_spatial = repeat(timestep, 'b d -> (b f) d', f=t_dim).contiguous() + timestep_temp = repeat(timestep, 'b d -> (b p) d', p=num_patches).contiguous() + + if self.training: + for i, (spatial_block, temp_block) in enumerate(zip(self.transformer_blocks, + self.temporal_transformer_blocks)): + if self.gradient_checkpointing: + hidden_states = torch.utils.checkpoint.checkpoint( + spatial_block, + hidden_states, + attention_mask, + encoder_hidden_states_spatial, + encoder_attention_mask, + timestep_spatial, + cross_attention_kwargs, + class_labels, + use_reentrant=False, + ) + + if enable_temporal_attentions: + hidden_states = rearrange(hidden_states, + '(b f) t d -> (b t) f d', + b=input_batch_size).contiguous() + + if use_image_num != 0: # image-video join training + hidden_states_video = hidden_states[:, :frame, ...] + hidden_states_image = hidden_states[:, frame:, ...] + + if i == 0: + hidden_states_video = hidden_states_video + self.temp_pos_embed + + hidden_states_video = torch.utils.checkpoint.checkpoint( + temp_block, + hidden_states_video, + None, # attention_mask + None, # encoder_hidden_states + None, # encoder_attention_mask + timestep_temp, + cross_attention_kwargs, + class_labels, + use_reentrant=False, + ) + + hidden_states = torch.cat([hidden_states_video, hidden_states_image], dim=1) + hidden_states = rearrange(hidden_states, CHANGE_TF_PATTERN, + b=input_batch_size).contiguous() + + else: + if i == 0: + hidden_states = hidden_states + self.temp_pos_embed + + hidden_states = torch.utils.checkpoint.checkpoint( + temp_block, + hidden_states, + None, # attention_mask + None, # encoder_hidden_states + None, # encoder_attention_mask + timestep_temp, + cross_attention_kwargs, + class_labels, + use_reentrant=False, + ) + + hidden_states = rearrange(hidden_states, CHANGE_TF_PATTERN, + b=input_batch_size).contiguous() + else: + block_list = [self.transformer_blocks, self.temporal_transformer_blocks] + self.cache_manager.temp_pos_embed = self.temp_pos_embed + hidden_states = self.cache_manager(t_idx, block_list, hidden_states, + attention_mask=attention_mask, + encoder_hidden_states_spatial=encoder_hidden_states_spatial, + encoder_attention_mask=encoder_attention_mask, + timestep_spatial=timestep_spatial, + timestep_temp=timestep_temp, + cross_attention_kwargs=cross_attention_kwargs, + class_labels=class_labels, + input_batch_size=input_batch_size, + enable_temporal_attentions=enable_temporal_attentions, + t_dim=t_dim, + s_dim=s_dim, + timestep=timestep) + + if use_sequence_parallel(): + hidden_states = rearrange(hidden_states, "(B T) S C -> B T S C", B=input_batch_size, T=t_dim, S=s_dim) + hidden_states = gather_sequence(hidden_states, get_sequence_parallel_group(), dim=1, pad=get_temporal_pad()) + t_dim, s_dim = hidden_states.shape[1], hidden_states.shape[2] + hidden_states = rearrange(hidden_states, "B T S C -> (B T) S C", T=t_dim, S=s_dim) + + if self.is_input_patches: + if self.config.norm_type != ADA_NORM_SINGLE: + conditioning = self.transformer_blocks[0].norm1.emb( + timestep, class_labels, hidden_dtype=hidden_states.dtype + ) + shift, scale = self.proj_out_1(F.silu(conditioning)).chunk(2, dim=1) + hidden_states = self.norm_out(hidden_states) * (1 + scale[:, None]) + shift[:, None] + hidden_states = self.proj_out_2(hidden_states) + elif self.config.norm_type == ADA_NORM_SINGLE: + embedded_timestep = repeat(embedded_timestep, 'b d -> (b f) d', f=frame + use_image_num).contiguous() + shift, scale = (self.scale_shift_table[None] + embedded_timestep[:, None]).chunk(2, dim=1) + if os.getenv("VASCEND", "0") != "1": # "1"仿真环境 + hidden_states = self.norm_out(hidden_states) + # Modulation + hidden_states = hidden_states * (1 + scale) + shift + hidden_states = self.proj_out(hidden_states) + + # unpatchify + if self.adaln_single is None: + height = width = int(hidden_states.shape[1] ** 0.5) + hidden_states = hidden_states.reshape( + shape=(-1, height, width, self.patch_size, self.patch_size, self.out_channels) + ) + hidden_states = torch.einsum("nhwpqc->nchpwq", hidden_states) + output = hidden_states.reshape( + shape=(-1, self.out_channels, height * self.patch_size, width * self.patch_size) + ) + output = rearrange(output, '(b f) c h w -> b c f h w', b=input_batch_size).contiguous() + + if not return_dict: + return (output,) + + return Transformer3DModelOutput(sample=output) + + def _dynamic_switch(self, x, s, t, temporal_to_spatial: bool): + if temporal_to_spatial: + scatter_dim, gather_dim = 2, 1 + scatter_pad = get_spatial_pad() + gather_pad = get_temporal_pad() + else: + scatter_dim, gather_dim = 1, 2 + scatter_pad = get_temporal_pad() + gather_pad = get_spatial_pad() + + x = all_to_all_with_pad( + x, + get_sequence_parallel_group(), + scatter_dim=scatter_dim, + gather_dim=gather_dim, + scatter_pad=scatter_pad, + gather_pad=gather_pad, + ) + new_s, new_t = x.shape[2], x.shape[1] + x = rearrange(x, "b t s d -> (b t) s d") + return x, new_s, new_t + + def _set_gradient_checkpointing(self, module, value=False): + self.gradient_checkpointing = value + + +def latte_t2v_8b(**kwargs): + return LatteT2V(num_layers=56, attention_head_dim=72, num_attention_heads=32, patch_size_t=1, patch_size=2, + norm_type=ADA_NORM_SINGLE, caption_channels=4096, cross_attention_dim=2304, sample_size=[64, 64], + in_channels=4, out_channels=8, **kwargs) \ No newline at end of file diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/model_load_utils.py b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/model_load_utils.py new file mode 100644 index 0000000000..8d4f191caf --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/model_load_utils.py @@ -0,0 +1,30 @@ +#!/usr/bin/env python +# coding=utf-8 +# Copyright(C) 2024. Huawei Technologies Co.,Ltd. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License + +import os +import torch +import safetensors.torch + +SAFETENSORS_EXTENSION = "safetensors" + + +def load_state_dict(model_path): + name = os.path.basename(model_path).split('.')[-1] # get weights name + if name == SAFETENSORS_EXTENSION: # diffuser model use same name + return safetensors.torch.load_file(model_path, device="cpu") # first load on cpu + else: + # to support hf shard model weights + return torch.load(model_path, map_location="cpu") # first load on cpu diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/parallel_mgr.py b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/parallel_mgr.py new file mode 100644 index 0000000000..f70bed20ab --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/parallel_mgr.py @@ -0,0 +1,64 @@ +#!/usr/bin/env python +# coding=utf-8 +# Copyright 2024 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. +# -------------------------------------------------------- +# References: +# DSP : https://github.com/NUS-HPC-AI-Lab/VideoSys +# -------------------------------------------------------- + +from dataclasses import dataclass +import torch.distributed as dist +from colossalai.cluster.process_group_mesh import ProcessGroupMesh +from torch.distributed import ProcessGroup + +PARALLEL_MANAGER = None + + +class ParallelManager(ProcessGroupMesh): + def __init__(self, sp_size, sp_axis): + super().__init__(sp_size) + self.sp_size = sp_size + self.sp_axis = sp_axis + self.sp_group: ProcessGroup = self.get_group_along_axis(sp_axis) + self.sp_rank = dist.get_rank(self.sp_group) + self.enable_sp = sp_size > 1 + + +def set_parallel_manager(sp_size, sp_axis): + global PARALLEL_MANAGER + PARALLEL_MANAGER = ParallelManager(sp_size, sp_axis) + + +def get_sequence_parallel_group(): + return PARALLEL_MANAGER.sp_group + + +def get_sequence_parallel_size(): + return PARALLEL_MANAGER.sp_size + + +def get_sequence_parallel_rank(): + return PARALLEL_MANAGER.sp_rank + + +def use_sequence_parallel(): + return PARALLEL_MANAGER.enable_sp + + +def get_parallel_manager(): + return PARALLEL_MANAGER diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/pipeline/__init__.py b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/pipeline/__init__.py new file mode 100644 index 0000000000..a73c00977a --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/pipeline/__init__.py @@ -0,0 +1,17 @@ +#!/usr/bin/env python +# coding=utf-8 +# Copyright 2024 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from .compile_pipe import compile_pipe \ No newline at end of file diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/pipeline/compile_pipe.py b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/pipeline/compile_pipe.py new file mode 100644 index 0000000000..576e965ab9 --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/pipeline/compile_pipe.py @@ -0,0 +1,47 @@ +#!/usr/bin/env python +# coding=utf-8 +# Copyright(C) 2024. Huawei Technologies Co.,Ltd. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from ..utils import is_npu_available +from ..acceleration.dit_cache_common import DiTCacheManager + +CFG_MAX_STEP = 10000 + + +def compile_pipe(pipe, cache_manager: DiTCacheManager = None, + cfg_last_step: int = CFG_MAX_STEP): + if not isinstance(cfg_last_step, int): + raise TypeError(f"Expected int for cfg_last_step, but got {type(cfg_last_step).__name__}") + + if is_npu_available(): + device = 'npu' + if hasattr(pipe, "text_encoder"): + pipe.text_encoder.to(device) + else: + raise TypeError("Please input valid pipeline") + if hasattr(pipe, "transformer"): + pipe.transformer.to(device) + if hasattr(pipe, "vae"): + pipe.vae.to(device) + + if cache_manager is not None: + if not hasattr(cache_manager, "use_cache"): + raise TypeError("Please input valid cache_manager") + pipe.transformer.cache_manager = cache_manager + if cfg_last_step != CFG_MAX_STEP: + pipe.cfg_last_step = cfg_last_step + return pipe + else: + raise RuntimeError("NPU is not available.") diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/pipeline/open_sora_plan_pipeline.py b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/pipeline/open_sora_plan_pipeline.py new file mode 100644 index 0000000000..3710da219a --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/pipeline/open_sora_plan_pipeline.py @@ -0,0 +1,744 @@ +#!/usr/bin/env python +# coding=utf-8 +# Copyright 2024 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Callable, List, Optional, Tuple, Union +import re +from dataclasses import dataclass +import html +import inspect +import urllib.parse as ul + +import torch +import torch_npu +from transformers import T5EncoderModel, T5Tokenizer + +from diffusers.models import AutoencoderKL, Transformer2DModel +from diffusers.schedulers import DPMSolverMultistepScheduler +from diffusers.utils import ( + BACKENDS_MAPPING, + is_bs4_available, + is_ftfy_available, + replace_example_docstring, +) +from diffusers.utils.torch_utils import randn_tensor +from diffusers.utils import BaseOutput +from opensoraplan.utils.log import logger +from opensoraplan import LatteParams +from .pipeline_utils import OpenSoraPlanPipelineBase + +TENSOR_TYPE_PT = "pt" +SUPPORT_VIDEO_LEN = [5, 17] +SUPPORT_IMAGE_SIZE = [256, 512] + + +if is_bs4_available(): + from bs4 import BeautifulSoup + +if is_ftfy_available(): + import ftfy + +EXAMPLE_DOC_STRING = """ + Examples: + ```py + >>> import torch + >>> from diffusers import PixArtAlphaPipeline + + >>> # You can replace the checkpoint id with "PixArt-alpha/PixArt-XL-2-512x512" too. + >>> pipe = PixArtAlphaPipeline.from_pretrained("PixArt-alpha/PixArt-XL-2-1024-MS", torch_dtype=torch.float16) + >>> # Enable memory optimizations. + >>> pipe.enable_model_cpu_offload() + + >>> prompt = "A small cactus with a happy face in the Sahara desert." + >>> image = pipe(prompt).images[0] + ``` +""" + + +@dataclass +class LatentsParams: + batch_size: int + num_channels_latents: int + video_length: int + height: int + width: int + dtype: torch.dtype + device: torch.device + + +@dataclass +class InputParams: + prompt: str + height: int + width: int + negative_prompt: str + callback_steps: int + + +@dataclass +class VideoPipelineOutput(BaseOutput): + video: torch.Tensor + + +class OpenSoraPlanPipeline(OpenSoraPlanPipelineBase): + r""" + pipeline for text-to-image generation using PixArt-Alpha. + + This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods the + library implements for all the pipelines (such as downloading or saving, running on a particular device, etc.) + + Args: + vae ([`AutoencoderKL`]): + Variational Auto-Encoder (VAE) Model to encode and decode images to and from latent representations. + text_encoder ([`T5EncoderModel`]): + Frozen text-encoder. PixArt-Alpha uses + [T5](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5EncoderModel), specifically the + [t5-v1_1-xxl](https://huggingface.co/PixArt-alpha/PixArt-alpha/tree/main/t5-v1_1-xxl) variant. + tokenizer (`T5Tokenizer`): + Tokenizer of class + [T5Tokenizer](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5Tokenizer). + transformer ([`Transformer2DModel`]): + A text conditioned `Transformer2DModel` to denoise the encoded image latents. + scheduler ([`SchedulerMixin`]): + A scheduler to be used in combination with `transformer` to denoise the encoded image latents. + """ + bad_punct_regex = re.compile( + r"[" + "#®•©™&@·º½¾¿¡§~" + "\)" + "\(" + "\]" + "\[" + "\}" + "\{" + "\|" + "\\" + "\/" + "\*" + r"]{1,}" + ) # noqa + + _optional_components = ["tokenizer", "text_encoder"] + model_cpu_offload_seq = "text_encoder->transformer->vae" + + def __init__( + self, + tokenizer: T5Tokenizer, + text_encoder: T5EncoderModel, + vae: AutoencoderKL, + transformer: Transformer2DModel, + scheduler: DPMSolverMultistepScheduler, + video_length: int = 17, + image_size: int = 256 + ): + super().__init__() + if video_length not in SUPPORT_VIDEO_LEN: + raise ValueError("Input video_length is not supported.") + + if image_size not in SUPPORT_IMAGE_SIZE: + raise ValueError("Input image_size is not supported.") + + torch.set_grad_enabled(False) + + self.text_encoder = text_encoder + self.tokenizer = tokenizer + self.transformer = transformer + self.vae = vae + self.scheduler = scheduler + self.video_length = video_length + self.image_size = image_size + self.cfg_last_step = 10000 + + @torch.no_grad() + @replace_example_docstring(EXAMPLE_DOC_STRING) + def __call__( + self, + prompt: Union[str, List[str]] = None, + num_inference_steps: int = 20, + guidance_scale: float = 4.5, + num_images_per_prompt: Optional[int] = 1, + enable_temporal_attentions: bool = True, + ) -> Union[VideoPipelineOutput, Tuple]: + """ + Function invoked when calling the pipeline for generation. + + Args: + prompt (`str` or `List[str]`, *optional*): + The prompt or prompts to guide the image generation. If not defined, one has to pass `prompt_embeds`. + instead. + num_inference_steps (`int`, *optional*, defaults to 100): + The number of denoising steps. More denoising steps usually lead to a higher quality image at the + expense of slower inference. + guidance_scale (`float`, *optional*, defaults to 7.0): + Guidance scale as defined in [Classifier-Free Diffusion Guidance](https://arxiv.org/abs/2207.12598). + `guidance_scale` is defined as `w` of equation 2. of [Imagen + Paper](https://arxiv.org/pdf/2205.11487.pdf). Guidance scale is enabled by setting `guidance_scale > + 1`. Higher guidance scale encourages to generate images that are closely linked to the text `prompt`, + usually at the expense of lower image quality. + num_images_per_prompt (`int`, *optional*, defaults to 1): + The number of images to generate per prompt. + enable_temporal_attentions (`bool`, *optional*, defaults to True): + Whether to enable temporal attentions, if force images, the value should be set False. + Examples: + + Returns: + [`~pipelines.ImagePipelineOutput`] or `tuple`: + If `return_dict` is `True`, [`~pipelines.ImagePipelineOutput`] is returned, otherwise a `tuple` is + returned where the first element is a list with the generated images + """ + # 1. Check inputs. Raise error if not correct + negative_prompt = "" + eta = 0.0 + generator = None + latents = None + prompt_embeds = None + negative_prompt_embeds = None + output_type = "pil" + return_dict = True + callback = None + callback_steps = 1 + clean_caption = True + mask_feature = True + + height = width = self.image_size + input_params = InputParams(prompt, height, width, negative_prompt, callback_steps) + self._check_inputs(input_params, prompt_embeds, negative_prompt_embeds) + if num_inference_steps < 4 or num_inference_steps > 300: + raise ValueError("num_inference_steps should be in the range of [4, 300].") + if self.transformer.cache_manager.start_step < 0 or \ + self.transformer.cache_manager.start_step > (num_inference_steps - 1): + raise ValueError("start_step should be in the range of [0, num_inference_steps-1]") + if self.transformer.cache_manager.step_interval < 1 or \ + self.transformer.cache_manager.step_interval > (num_inference_steps - 2): + raise ValueError("step_interval should be in the range of [1, num_inference_steps-2]") + if num_images_per_prompt < 1 or num_images_per_prompt > 100: + raise ValueError("num_images_per_prompt should be in the range of [1, 100].") + if self.cfg_last_step < 0: + raise ValueError("cfg_last_step should be not less than 0.") + + # 2. Default height and width to transformer + if prompt is not None and isinstance(prompt, str): + batch_size = 1 + elif prompt is not None and isinstance(prompt, list): + batch_size = len(prompt) + else: + batch_size = prompt_embeds.shape[0] + + device = self.text_encoder.device or self._execution_device + + # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2) + # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1` + # corresponds to doing no classifier free guidance. + do_classifier_free_guidance = guidance_scale > 1.0 + + # 3. Encode input prompt + prompt_embeds, negative_prompt_embeds = self._encode_prompt( + prompt, + do_classifier_free_guidance, + negative_prompt=negative_prompt, + num_images_per_prompt=num_images_per_prompt, + device=device, + prompt_embeds=prompt_embeds, + negative_prompt_embeds=negative_prompt_embeds, + clean_caption=clean_caption, + mask_feature=mask_feature, + ) + torch.npu.empty_cache() + + if do_classifier_free_guidance: + prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds], dim=0) + + # 4. Prepare timesteps + self.scheduler.set_timesteps(num_inference_steps, device=device) + timesteps = self.scheduler.timesteps + + # 5. Prepare latents. + latent_channels = self.transformer.config.in_channels + latents_params = LatentsParams(batch_size * num_images_per_prompt, latent_channels, self.video_length, + height, width, prompt_embeds.dtype, device) + latents = self._prepare_latents(latents_params, generator, latents) + + # 6. Prepare extra step kwargs. + extra_step_kwargs = self._prepare_extra_step_kwargs(generator, eta) + + # 6.1 Prepare micro-conditions. + added_cond_kwargs = {"resolution": None, "aspect_ratio": None} + + # 7. Denoising loop + num_warmup_steps = max(len(timesteps) - num_inference_steps * self.scheduler.order, 0) + + with self.progress_bar(total=num_inference_steps) as progress_bar: + for i, t in enumerate(timesteps): + if i == self.cfg_last_step: + prompt_embeds = prompt_embeds[1:2] + if i >= self.cfg_last_step: + do_classifier_free_guidance = False + + latent_model_input = torch.cat([latents] * 2) if do_classifier_free_guidance else latents + latent_model_input = self.scheduler.scale_model_input(latent_model_input, t) + + current_timestep = t + if not torch.is_tensor(current_timestep): + # This would be a good case for the `match` statement (Python 3.10+) + is_mps = latent_model_input.device.type == "mps" + if isinstance(current_timestep, float): + dtype = torch.float32 if is_mps else torch.float64 + else: + dtype = torch.int32 if is_mps else torch.int64 + current_timestep = torch.tensor([current_timestep], dtype=dtype, device=latent_model_input.device) + elif len(current_timestep.shape) == 0: + current_timestep = current_timestep[None].to(latent_model_input.device) + # broadcast to batch dimension in a way that's compatible with ONNX/Core ML + current_timestep = current_timestep.expand(latent_model_input.shape[0]) + + latte_params = LatteParams( + hidden_states=latent_model_input, + encoder_hidden_states=prompt_embeds, + timestep=current_timestep, + added_cond_kwargs=added_cond_kwargs, + enable_temporal_attentions=enable_temporal_attentions, + ) + # predict noise model_output + noise_pred = self.transformer( + latte_params, + t_idx=i, + )[0] + + # perform guidance + if do_classifier_free_guidance: + noise_pred_uncond, noise_pred_text = noise_pred.chunk(2) + noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond) + + # learned sigma + if self.transformer.config.out_channels // 2 == latent_channels: + noise_pred = noise_pred.chunk(2, dim=1)[0] + else: + noise_pred = noise_pred + + # compute previous image: x_t -> x_t-1 + latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs, return_dict=False)[0] + + # call the callback, if provided + if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0): + progress_bar.update() + if callback is not None and i % callback_steps == 0: + step_idx = i // getattr(self.scheduler, "order", 1) + callback(step_idx, t, latents) + + if not output_type == 'latents': + video = self._decode_latents(latents) + else: + video = latents + return VideoPipelineOutput(video=video) + + if not return_dict: + return (video,) + + return VideoPipelineOutput(video=video) + + # Adapted from https://github.com/PixArt-alpha/PixArt-alpha/blob/master/diffusion/model/utils.py + def _mask_text_embeddings(self, emb, mask): + if emb.shape[0] == 1: + keep_index = mask.sum().item() + return emb[:, :, :keep_index, :], keep_index # 1, 120, 4096 -> 1 7 4096 + else: + masked_feature = emb * mask[:, None, :, None] # 1 120 4096 + return masked_feature, emb.shape[2] + + # Adapted from diffusers.pipelines.deepfloyd_if.pipeline_if.encode_prompt + def _encode_prompt( + self, + prompt: Union[str, List[str]], + do_classifier_free_guidance: bool = True, + negative_prompt: str = "", + num_images_per_prompt: int = 1, + device: Optional[torch.device] = None, + prompt_embeds: Optional[torch.FloatTensor] = None, + negative_prompt_embeds: Optional[torch.FloatTensor] = None, + clean_caption: bool = False, + mask_feature: bool = True, + ): + r""" + Encodes the prompt into text encoder hidden states. + + Args: + prompt (`str` or `List[str]`, *optional*): + prompt to be encoded + negative_prompt (`str` or `List[str]`, *optional*): + The prompt not to guide the image generation. If not defined, one has to pass `negative_prompt_embeds` + instead. Ignored when not using guidance (i.e., ignored if `guidance_scale` is less than `1`). For + PixArt-Alpha, this should be "". + do_classifier_free_guidance (`bool`, *optional*, defaults to `True`): + whether to use classifier free guidance or not + num_images_per_prompt (`int`, *optional*, defaults to 1): + number of images that should be generated per prompt + device: (`torch.device`, *optional*): + torch device to place the resulting embeddings on + prompt_embeds (`torch.FloatTensor`, *optional*): + Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not + provided, text embeddings will be generated from `prompt` input argument. + negative_prompt_embeds (`torch.FloatTensor`, *optional*): + Pre-generated negative text embeddings. For PixArt-Alpha, it's should be the embeddings of the "" + string. + clean_caption (bool, defaults to `False`): + If `True`, the function will preprocess and clean the provided caption before encoding. + mask_feature: (bool, defaults to `True`): + If `True`, the function will mask the text embeddings. + """ + embeds_initially_provided = prompt_embeds is not None and negative_prompt_embeds is not None + + if device is None: + device = self.text_encoder.device or self._execution_device + + if prompt is not None and isinstance(prompt, str): + batch_size = 1 + elif prompt is not None and isinstance(prompt, list): + batch_size = len(prompt) + else: + batch_size = prompt_embeds.shape[0] + + # See Section 3.1. of the paper. + max_length = 300 + + if prompt_embeds is None: + prompt = self._text_preprocessing(prompt, clean_caption=clean_caption) + text_inputs = self.tokenizer( + prompt, + padding="max_length", + max_length=max_length, + truncation=True, + return_attention_mask=True, + add_special_tokens=True, + return_tensors=TENSOR_TYPE_PT, + ) + text_input_ids = text_inputs.input_ids + untruncated_ids = self.tokenizer(prompt, padding="longest", return_tensors=TENSOR_TYPE_PT).input_ids + + if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal( + text_input_ids, untruncated_ids + ): + removed_text = self.tokenizer.batch_decode(untruncated_ids[:, max_length - 1: -1]) + logger.warning( + "The following part of your input was truncated because the model can only handle sequences up to" + f" {max_length} tokens: {removed_text}" + ) + + attention_mask = text_inputs.attention_mask.to(device) + prompt_embeds_attention_mask = attention_mask + + prompt_embeds = self.text_encoder(text_input_ids.to(device), attention_mask=attention_mask) + prompt_embeds = prompt_embeds[0] + else: + prompt_embeds_attention_mask = torch.ones_like(prompt_embeds) + + if self.text_encoder is not None: + dtype = self.text_encoder.dtype + elif self.transformer is not None: + dtype = self.transformer.dtype + else: + dtype = None + + prompt_embeds = prompt_embeds.to(dtype=dtype, device=device) + + bs_embed, seq_len, _ = prompt_embeds.shape + # duplicate text embeddings and attention mask for each generation per prompt, using mps friendly method + prompt_embeds = prompt_embeds.repeat(1, num_images_per_prompt, 1) + prompt_embeds = prompt_embeds.view(bs_embed * num_images_per_prompt, seq_len, -1) + prompt_embeds_attention_mask = prompt_embeds_attention_mask.view(bs_embed, -1) + prompt_embeds_attention_mask = prompt_embeds_attention_mask.repeat(num_images_per_prompt, 1) + + # get unconditional embeddings for classifier free guidance + if do_classifier_free_guidance and negative_prompt_embeds is None: + uncond_tokens = [negative_prompt] * batch_size + uncond_tokens = self._text_preprocessing(uncond_tokens, clean_caption=clean_caption) + max_length = prompt_embeds.shape[1] + uncond_input = self.tokenizer( + uncond_tokens, + padding="max_length", + max_length=max_length, + truncation=True, + return_attention_mask=True, + add_special_tokens=True, + return_tensors=TENSOR_TYPE_PT, + ) + attention_mask = uncond_input.attention_mask.to(device) + + negative_prompt_embeds = self.text_encoder( + uncond_input.input_ids.to(device), + attention_mask=attention_mask, + ) + negative_prompt_embeds = negative_prompt_embeds[0] + + if do_classifier_free_guidance: + # duplicate unconditional embeddings for each generation per prompt, using mps friendly method + seq_len = negative_prompt_embeds.shape[1] + + negative_prompt_embeds = negative_prompt_embeds.to(dtype=dtype, device=device) + + negative_prompt_embeds = negative_prompt_embeds.repeat(1, num_images_per_prompt, 1) + negative_prompt_embeds = negative_prompt_embeds.view(batch_size * num_images_per_prompt, seq_len, -1) + + # For classifier free guidance, we need to do two forward passes. + # Here we concatenate the unconditional and text embeddings into a single batch + # to avoid doing two forward passes + else: + negative_prompt_embeds = None + + # Perform additional masking. + if mask_feature and not embeds_initially_provided: + prompt_embeds = prompt_embeds.unsqueeze(1) + masked_prompt_embeds, keep_indices = self._mask_text_embeddings(prompt_embeds, prompt_embeds_attention_mask) + masked_prompt_embeds = masked_prompt_embeds.squeeze(1) + masked_negative_prompt_embeds = ( + negative_prompt_embeds[:, :keep_indices, :] if negative_prompt_embeds is not None else None + ) + + return masked_prompt_embeds, masked_negative_prompt_embeds + + return prompt_embeds, negative_prompt_embeds + + # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline. + # prepare_extra_step_kwargs + def _prepare_extra_step_kwargs(self, generator, eta): + # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature + # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers. + # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502 + # and should be between [0, 1] + + accepts_eta = "eta" in set(inspect.signature(self.scheduler.step).parameters.keys()) + extra_step_kwargs = {} + if accepts_eta: + extra_step_kwargs["eta"] = eta + + # check if the scheduler accepts generator + accepts_generator = "generator" in set(inspect.signature(self.scheduler.step).parameters.keys()) + if accepts_generator: + extra_step_kwargs["generator"] = generator + return extra_step_kwargs + + def _check_inputs( + self, + inpt_params, + prompt_embeds=None, + negative_prompt_embeds=None, + ): + if inpt_params.height % 8 != 0 or inpt_params.width % 8 != 0: + raise ValueError(f"`height` and `width` have to be divisible by 8 but are " + f"{inpt_params.height} and {inpt_params.width}.") + + callback_not_none = ((inpt_params.callback_steps is not None) and + (not isinstance(inpt_params.callback_steps, int) or inpt_params.callback_steps <= 0)) + if (inpt_params.callback_steps is None) or callback_not_none: + raise ValueError( + f"`callback_steps` has to be a positive integer but is {inpt_params.callback_steps} of type" + f" {type(inpt_params.callback_steps)}." + ) + + if inpt_params.prompt is not None and prompt_embeds is not None: + raise ValueError( + f"Cannot forward both `prompt`: {inpt_params.prompt} and `prompt_embeds`: {prompt_embeds}. " + f"Please make sure to only forward one of the two." + ) + elif inpt_params.prompt is None and prompt_embeds is None: + raise ValueError( + "Provide either `prompt` or `prompt_embeds`. Cannot leave both `prompt` and `prompt_embeds` undefined." + ) + elif inpt_params.prompt is not None and (not isinstance(inpt_params.prompt, str) and + not isinstance(inpt_params.prompt, list)): + raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(inpt_params.prompt)}") + + if inpt_params.prompt is not None and negative_prompt_embeds is not None: + raise ValueError( + f"Cannot forward both `prompt`: {inpt_params.prompt} and `negative_prompt_embeds`:" + f" {negative_prompt_embeds}. Please make sure to only forward one of the two." + ) + + if inpt_params.negative_prompt is not None and negative_prompt_embeds is not None: + raise ValueError( + f"Cannot forward both `negative_prompt`: {inpt_params.negative_prompt} and `negative_prompt_embeds`:" + f" {negative_prompt_embeds}. Please make sure to only forward one of the two." + ) + + if prompt_embeds is not None and negative_prompt_embeds is not None: + if prompt_embeds.shape != negative_prompt_embeds.shape: + raise ValueError( + "`prompt_embeds` and `negative_prompt_embeds` must have the same shape when passed directly, but" + f" got: `prompt_embeds` {prompt_embeds.shape} != `negative_prompt_embeds`" + f" {negative_prompt_embeds.shape}." + ) + + # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.prepare_latents + def _prepare_latents(self, latents_params, generator, latents=None): + shape = ( + latents_params.batch_size, + latents_params.num_channels_latents, + latents_params.video_length, + self.vae.latent_size[0], + self.vae.latent_size[1] + ) + if isinstance(generator, list) and len(generator) != latents_params.batch_size: + raise ValueError( + f"You have passed a list of generators of length {len(generator)}, but requested an effective batch" + f" size of {latents_params.batch_size}. Make sure the batch size matches the length of the generators." + ) + + if latents is None: + latents = randn_tensor(shape, generator=generator, device=latents_params.device, dtype=latents_params.dtype) + else: + latents = latents.to(latents_params.device) + + # scale the initial noise by the standard deviation required by the scheduler + latents = latents * self.scheduler.init_noise_sigma + return latents + + def _decode_latents(self, latents): + video = self.vae.decode(latents) + video = ((video / 2.0 + 0.5).clamp(0, 1) * 255).to(dtype=torch.uint8).cpu().permute(0, 1, 3, 4, 2).contiguous() + # we always cast to float32 as this does not cause significant overhead and is compatible with bfloa16 + return video + + # Copied from diffusers.pipelines.deepfloyd_if.pipeline_if.IFPipeline._text_preprocessing + def _text_preprocessing(self, text, clean_caption=False): + if clean_caption and not is_bs4_available(): + logger.warning(BACKENDS_MAPPING["bs4"][-1].format("Setting `clean_caption=True`")) + logger.warning("Setting `clean_caption` to False...") + clean_caption = False + + if clean_caption and not is_ftfy_available(): + logger.warning(BACKENDS_MAPPING["ftfy"][-1].format("Setting `clean_caption=True`")) + logger.warning("Setting `clean_caption` to False...") + clean_caption = False + + if not isinstance(text, (tuple, list)): + text = [text] + + def process(text: str): + if clean_caption: + text = self._clean_caption(text) + text = self._clean_caption(text) + else: + text = text.lower().strip() + return text + + return [process(t) for t in text] + + # Copied from diffusers.pipelines.deepfloyd_if.pipeline_if.IFPipeline._clean_caption + def _clean_caption(self, caption): + caption = str(caption) + caption = ul.unquote_plus(caption) + caption = caption.strip().lower() + caption = re.sub("", "person", caption) + # urls: + caption = re.sub( + r"\b((?:https?:(?:\/{1,3}|[a-zA-Z0-9%])|[a-zA-Z0-9.\-]+[.]" + r"(?:com|co|ru|net|org|edu|gov|it)[\w/-]*\b\/?(?!@)))", + # noqa + "", + caption, + ) # regex for urls + caption = re.sub( + r"\b((?:www:(?:\/{1,3}|[a-zA-Z0-9%])|[a-zA-Z0-9.\-]+[.](?:com|co|ru|net|org|edu|gov|it)" + r"[\w/-]*\b\/?(?!@)))", + # noqa + "", + caption, + ) # regex for urls + # html: + caption = BeautifulSoup(caption, features="html.parser").text + + # @ + caption = re.sub(r"@[\w\d]+\b", "", caption) + + # 31C0—31EF CJK Strokes + # 31F0—31FF Katakana Phonetic Extensions + # 3200—32FF Enclosed CJK Letters and Months + # 3300—33FF CJK Compatibility + # 3400—4DBF CJK Unified Ideographs Extension A + # 4DC0—4DFF Yijing Hexagram Symbols + # 4E00—9FFF CJK Unified Ideographs + caption = re.sub(r"[\u31c0-\u31ef]+", "", caption) + caption = re.sub(r"[\u31f0-\u31ff]+", "", caption) + caption = re.sub(r"[\u3200-\u32ff]+", "", caption) + caption = re.sub(r"[\u3300-\u33ff]+", "", caption) + caption = re.sub(r"[\u3400-\u4dbf]+", "", caption) + caption = re.sub(r"[\u4dc0-\u4dff]+", "", caption) + caption = re.sub(r"[\u4e00-\u9fff]+", "", caption) + ####################################################### + + # все виды тире / all types of dash --> "-" + caption = re.sub( + r"[\u002D\u058A\u05BE\u1400\u1806\u2010-\u2015\u2E17\u2E1A\u2E3A\u2E3B\u2E40\u301C\u3030" + r"\u30A0\uFE31\uFE32\uFE58\uFE63\uFF0D]+", + # noqa + "-", + caption, + ) + + # кавычки к одному стандарту + caption = re.sub(r"[`´«»“”¨]", '"', caption) + caption = re.sub(r"[‘’]", "'", caption) + + # " + caption = re.sub(r""?", "", caption) + # & + caption = re.sub(r"&", "", caption) + + # ip adresses: + caption = re.sub(r"\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}", " ", caption) + + # article ids: + caption = re.sub(r"\d:\d\d\s+$", "", caption) + + # \n + caption = re.sub(r"\\n", " ", caption) + + # "#123" + caption = re.sub(r"#\d{1,3}\b", "", caption) + # "#12345.." + caption = re.sub(r"#\d{5,}\b", "", caption) + # "123456.." + caption = re.sub(r"\b\d{6,}\b", "", caption) + # filenames: + caption = re.sub(r"[\S]+\.(?:png|jpg|jpeg|bmp|webp|eps|pdf|apk|mp4)", "", caption) + + # + caption = re.sub(r"[\"\']{2,}", r'"', caption) # """AUSVERKAUFT""" + caption = re.sub(r"[\.]{2,}", r" ", caption) # """AUSVERKAUFT""" + + caption = re.sub(self.bad_punct_regex, r" ", caption) # ***AUSVERKAUFT***, #AUSVERKAUFT + caption = re.sub(r"\s+\.\s+", r" ", caption) # " . " + + # this-is-my-cute-cat / this_is_my_cute_cat + regex2 = re.compile(r"(?:\-|\_)") + if len(re.findall(regex2, caption)) > 3: + caption = re.sub(regex2, " ", caption) + + caption = ftfy.fix_text(caption) + caption = html.unescape(html.unescape(caption)) + + caption = re.sub(r"\b[a-zA-Z]{1,3}\d{3,15}\b", "", caption) # jc6640 + caption = re.sub(r"\b[a-zA-Z]+\d+[a-zA-Z]+\b", "", caption) # jc6640vc + caption = re.sub(r"\b\d+[a-zA-Z]+\d+\b", "", caption) # 6640vc231 + + caption = re.sub(r"(worldwide\s+)?(free\s+)?shipping", "", caption) + caption = re.sub(r"(free\s)?download(\sfree)?", "", caption) + caption = re.sub(r"\bclick\b\s(?:for|on)\s\w+", "", caption) + caption = re.sub(r"\b(?:png|jpg|jpeg|bmp|webp|eps|pdf|apk|mp4)(\simage[s]?)?", "", caption) + caption = re.sub(r"\bpage\s+\d+\b", "", caption) + + caption = re.sub(r"\b\d*[a-zA-Z]+\d+[a-zA-Z]+\d+[a-zA-Z\d]*\b", r" ", caption) # j2d1a2a... + + caption = re.sub(r"\b\d+\.?\d*[xх×]\d+\.?\d*\b", "", caption) + + caption = re.sub(r"\b\s+\:\s+", r": ", caption) + caption = re.sub(r"(\D[,\./])\b", r"\1 ", caption) + caption = re.sub(r"\s+", " ", caption) + + caption.strip() + + caption = re.sub(r"^[\"\']([\w\W]+)[\"\']$", r"\1", caption) + caption = re.sub(r"^[\'\_,\-\:;]", r"", caption) + caption = re.sub(r"[\'\_,\-\:\-\+]$", r"", caption) + caption = re.sub(r"^\.\S+$", "", caption) + + return caption.strip() \ No newline at end of file diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/pipeline/pipeline_utils.py b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/pipeline/pipeline_utils.py new file mode 100644 index 0000000000..cb9e6c5553 --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/pipeline/pipeline_utils.py @@ -0,0 +1,170 @@ +#!/usr/bin/env python +# coding=utf-8 +# Copyright 2024 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import os +import inspect +import logging +import importlib +from dataclasses import dataclass + +import torch +from torch import Tensor +from tqdm import tqdm +from diffusers.schedulers import PNDMScheduler + +from opensoraplan.utils.utils import path_check + +from mindiesd import ConfigMixin + +PIPELINE_CONFIG_NAME = "model_index.json" +VAE = 'vae' +TEXT_ENCODER = 'text_encoder' +TOKENIZER = 'tokenizer' +TRANSFORMER = 'transformer' +SCHEDULER = 'scheduler' + +IMAGE_SIZE = 'image_size' +ENABLE_SEQUENCE_PARALLELISM = 'enable_sequence_parallelism' +FPS = 'fps' +DTYPE = 'dtype' +SET_PATCH_PARALLEL = 'set_patch_parallel' +FROM_PRETRAINED = 'from_pretrained' +NUM_SAMPLING_STEPS = 'num_sampling_steps' +REFINE_SERVER_IP = 'refine_server_ip' +REFINE_SERVER_PORT = 'refine_server_port' +MODEL_TYPE = 'model_type' +logger = logging.getLogger(__name__) # init python log + +OPEN_SORA_PLAN_DEFAULT_IMAGE_SIZE = 512 +OPEN_SORA_PLAN_DEFAULT_VIDEO_LENGTH = 17 +OPEN_SORA_PLAN_DEFAULT_CACHE_DIR = "cache_dir" +OPEN_SORA_PLAN_DEFAULT_VAE_STRIDE = 8 +OPEN_SORA_PLAN_DEFAULT_SCHEDULER = PNDMScheduler +OPEN_SORA_PLAN_DEFAULT_DTYPE = torch.float16 + +CACHE_DIR = "cache_dir" +VAE_STRIDE = "vae_stride" +VIDEO_LENGTH = "video_length" + + +class OpenSoraPlanPipelineBase(ConfigMixin): + config_name = PIPELINE_CONFIG_NAME + + def __init__(self): + super().__init__() + if not hasattr(self, "_progress_bar_config"): + self._progress_bar_config = {} + elif not isinstance(self._progress_bar_config, dict): + raise ValueError( + f"`self._progress_bar_config` should be of type `dict`, but is {type(self._progress_bar_config)}." + ) + + @classmethod + def from_pretrained(cls, model_path, **kwargs): + initializers = { + TEXT_ENCODER: init_text_encoder_plan, + VAE: init_vae_plan, + TOKENIZER: init_default_plan + } + + image_size = kwargs.pop(IMAGE_SIZE, OPEN_SORA_PLAN_DEFAULT_IMAGE_SIZE) + dtype = kwargs.pop(DTYPE, OPEN_SORA_PLAN_DEFAULT_DTYPE) + cache_dir = kwargs.pop(CACHE_DIR, OPEN_SORA_PLAN_DEFAULT_CACHE_DIR) + vae_stride = kwargs.pop(VAE_STRIDE, OPEN_SORA_PLAN_DEFAULT_VAE_STRIDE) + if vae_stride != 8: + raise ValueError("Unsupported vae_stride.") + scheduler = kwargs.pop(SCHEDULER, OPEN_SORA_PLAN_DEFAULT_SCHEDULER) + + real_path = path_check(model_path) + init_dict, config_dict = cls.load_config(real_path, **kwargs) + + init_list = [VAE, TEXT_ENCODER, TOKENIZER, TRANSFORMER, SCHEDULER] + pipe_init_dict = {} + model_init_dict = {} + + all_parameters = inspect.signature(cls.__init__).parameters + + required_param = {k: v for k, v in all_parameters.items() if v.default == inspect.Parameter.empty} + expected_modules = set(required_param.keys()) - {"self"} + # init the module from kwargs + passed_module = {k: kwargs.pop(k) for k in expected_modules if k in kwargs} + pipe_init_dict[IMAGE_SIZE] = image_size + model_init_dict[IMAGE_SIZE] = image_size + model_init_dict[DTYPE] = dtype + model_init_dict[CACHE_DIR] = cache_dir + model_init_dict[VAE_STRIDE] = vae_stride + + for key in tqdm(init_list, desc="Loading open-sora-plan-pipeline compenents"): + if key not in init_dict: + raise ValueError(f"Get {key} from init config failed!") + if key in passed_module: + pipe_init_dict[key] = passed_module.pop(key) + else: + modules, cls_name = init_dict[key] + if modules == "mindiesd": + library = importlib.import_module("opensoraplan") + else: + library = importlib.import_module(modules) + class_obj = getattr(library, cls_name) + sub_folder = os.path.join(real_path, key) + + if key == TRANSFORMER: + if pipe_init_dict.get(VAE) is None: + raise ValueError("Cannot get module 'vae' in init list!") + + if pipe_init_dict.get(TEXT_ENCODER) is None: + raise ValueError("Cannot get module 'text_encoder' in init list!") + + pipe_init_dict[key] = class_obj.from_pretrained(sub_folder, cache_dir=model_init_dict[CACHE_DIR], + torch_dtype=model_init_dict[DTYPE], **kwargs) + elif key == SCHEDULER: + pipe_init_dict[key] = scheduler + else: + initializer = initializers.get(key, init_default_plan) + pipe_init_dict[key] = initializer(class_obj, sub_folder, model_init_dict, kwargs) + + if pipe_init_dict.get(TRANSFORMER) is None: + raise ValueError("Cannot get module 'transformer' in init list!") + video_length = pipe_init_dict.get(TRANSFORMER).config.video_length + pipe_init_dict[VIDEO_LENGTH] = video_length + + return cls(**pipe_init_dict) + + def progress_bar(self, iterable=None, total=None): + if iterable is not None: + return tqdm(iterable, **self._progress_bar_config) + elif total is not None: + return tqdm(total=total, **self._progress_bar_config) + else: + raise ValueError("Either `total` or `iterable` has to be defined.") + + +def init_text_encoder_plan(class_obj, sub_folder, model_init_dict, kwargs): + return class_obj.from_pretrained(sub_folder, cache_dir=model_init_dict[CACHE_DIR], + torch_dtype=model_init_dict[DTYPE]) + + +def init_vae_plan(class_obj, sub_folder, model_init_dict, kwargs): + height = width = model_init_dict[IMAGE_SIZE] // model_init_dict[VAE_STRIDE] + latent_size = (height, width) + vae = class_obj.from_pretrained(sub_folder, latent_size, cache_dir=model_init_dict[CACHE_DIR], + **kwargs).to(dtype=model_init_dict[DTYPE]) + return vae + + +def init_default_plan(class_obj, sub_folder, model_init_dict, kwargs): + return class_obj.from_pretrained(sub_folder, **kwargs) \ No newline at end of file diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/schedulers/.gitkeep b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/schedulers/.gitkeep new file mode 100644 index 0000000000..e69de29bb2 diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/schedulers/__init__.py b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/schedulers/__init__.py new file mode 100644 index 0000000000..30af36f396 --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/schedulers/__init__.py @@ -0,0 +1,15 @@ +#!/usr/bin/env python +# coding=utf-8 +# Copyright 2024 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/schedulers/scheduler_optimizer.py b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/schedulers/scheduler_optimizer.py new file mode 100644 index 0000000000..9050ce2cef --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/schedulers/scheduler_optimizer.py @@ -0,0 +1,49 @@ +#!/usr/bin/env python +# coding=utf-8 +# Copyright 2024 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from diffusers.schedulers import (DDIMScheduler, DDPMScheduler, PNDMScheduler, + EulerDiscreteScheduler, DPMSolverMultistepScheduler, + HeunDiscreteScheduler, EulerAncestralDiscreteScheduler, + DEISMultistepScheduler, KDPM2AncestralDiscreteScheduler) +from diffusers.schedulers.scheduling_dpmsolver_singlestep import DPMSolverSinglestepScheduler + + +def get_scheduler(sample_method): + if sample_method == 'DDIM': + scheduler = DDIMScheduler() + elif sample_method == 'EulerDiscrete': + scheduler = EulerDiscreteScheduler() + elif sample_method == 'DDPM': + scheduler = DDPMScheduler() + elif sample_method == 'DPMSolverMultistep': + scheduler = DPMSolverMultistepScheduler() + elif sample_method == 'DPMSolverSinglestep': + scheduler = DPMSolverSinglestepScheduler() + elif sample_method == 'PNDM': + scheduler = PNDMScheduler() + elif sample_method == 'HeunDiscrete': + scheduler = HeunDiscreteScheduler() + elif sample_method == 'EulerAncestralDiscrete': + scheduler = EulerAncestralDiscreteScheduler() + elif sample_method == 'DEISMultistep': + scheduler = DEISMultistepScheduler() + elif sample_method == 'KDPM2AncestralDiscrete': + scheduler = KDPM2AncestralDiscreteScheduler() + else: + raise ValueError('ERROR: wrong sample_method given !!!') + return scheduler + + diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/utils/.gitkeep b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/utils/.gitkeep new file mode 100644 index 0000000000..e69de29bb2 diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/utils/__init__.py b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/utils/__init__.py new file mode 100644 index 0000000000..226b35a409 --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/utils/__init__.py @@ -0,0 +1,19 @@ +#!/usr/bin/env python +# coding=utf-8 +# Copyright 2024 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from .utils import ( + set_random_seed, is_npu_available) diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/utils/log.py b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/utils/log.py new file mode 100644 index 0000000000..eeda409158 --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/utils/log.py @@ -0,0 +1,20 @@ +#!/usr/bin/env python +# coding=utf-8 +# Copyright 2024 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import logging + +logger = logging.getLogger() +logger.setLevel(logging.INFO) \ No newline at end of file diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/utils/utils.py b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/utils/utils.py new file mode 100644 index 0000000000..02c0196381 --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/utils/utils.py @@ -0,0 +1,152 @@ +#!/usr/bin/env python +# coding=utf-8 +# Copyright 2024 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import json +import logging +import multiprocessing +import random +import os +import importlib +import time +from dataclasses import dataclass +from multiprocessing import Manager, shared_memory +from threading import Timer + +import numpy as np +import torch +import torchvision.io as io +import torch.distributed as dist + +import requests + + +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger(__name__) + +MASK_DEFAULT = ["0", "0", "0", "0", "1", "0"] +MAX_SHM_SIZE = 10**9 +OPENAI_CLIENT = None +REFINE_PROMPTS = None +REFINE_PROMPTS_TEMPLATE = """ +You need to refine user's input prompt. The user's input prompt is used for video generation task. You need to refine the user's prompt to make it more suitable for the task. Here are some examples of refined prompts: +{} + +The refined prompt should pay attention to all objects in the video. The description should be useful for AI to re-generate the video. The description should be no more than six sentences. The refined prompt should be in English. +""" +RANDOM_PROMPTS = None +RANDOM_PROMPTS_TEMPLATE = """ +You need to generate one input prompt for video generation task. The prompt should be suitable for the task. Here are some examples of refined prompts: +{} + +The prompt should pay attention to all objects in the video. The description should be useful for AI to re-generate the video. The description should be no more than six sentences. The prompt should be in English. +""" +REFINE_EXAMPLE = [ + "a close - up shot of a woman standing in a room with a white wall and a plant on the left side." + "the woman has curly hair and is wearing a green tank top." + "she is looking to the side with a neutral expression on her face." + "the lighting in the room is soft and appears to be natural, coming from the left side of the frame." + "the focus is on the woman, with the background being out of focus." + "there are no texts or other objects in the video.the style of the video is a simple," + " candid portrait with a shallow depth of field.", + "a serene scene of a pond filled with water lilies.the water is a deep blue, " + "providing a striking contrast to the pink and white flowers that float on its surface." + "the flowers, in full bloom, are the main focus of the video." + "they are scattered across the pond, with some closer to the camera and others further away, " + "creating a sense of depth.the pond is surrounded by lush greenery, adding a touch of nature to the scene." + "the video is taken from a low angle, looking up at the flowers, " + "which gives a unique perspective and emphasizes their beauty." + "the overall composition of the video suggests a peaceful and tranquil setting, likely a garden or a park.", + "a professional setting where a woman is presenting a slide from a presentation." + "she is standing in front of a projector screen, which displays a bar chart." + "the chart is colorful, with bars of different heights, indicating some sort of data comparison." + "the woman is holding a pointer, which she uses to highlight specific parts of the chart." + "she is dressed in a white blouse and black pants, and her hair is styled in a bun." + "the room has a modern design, with a sleek black floor and a white ceiling." + "the lighting is bright, illuminating the woman and the projector screen." + "the focus of the image is on the woman and the projector screen, with the background being out of focus." + "there are no texts visible in the image." + "the relative positions of the objects suggest that the woman is the main subject of the image, " + "and the projector screen is the object of her attention." + "the image does not provide any information about the content of the presentation or the context of the meeting." +] +MAX_NEW_TOKENS = 512 +TEMPERATURE = 1.1 +TOP_P = 0.95 +TOP_K = 100 +SEED = 10 +REPETITION_PENALTY = 1.03 + +TIMEOUT_T = 600 + + +def is_npu_available(): + "Checks if `torch_npu` is installed and potentially if a NPU is in the environment" + if os.getenv("VASCEND", "0") == "1": # "1"仿真环境 + return True + + if importlib.util.find_spec("torch") is None or importlib.util.find_spec("torch_npu") is None: + return False + + import torch_npu + + try: + # Will raise a RuntimeError if no NPU is found + _ = torch.npu.device_count() + return torch.npu.is_available() + except RuntimeError: + return False + + +def set_random_seed(seed): + """Set random seed. + + Args: + seed (int, optional): Seed to be used. + + """ + + random.seed(seed) + np.random.seed(seed) + torch.manual_seed(seed) + return seed + + +def path_check(path: str): + """ + check path + param: path + return: data real path after check + """ + if os.path.islink(path) or path is None: + raise RuntimeError("The path should not be None or a symbolic link file.") + path = os.path.realpath(path) + if not check_owner(path): + raise RuntimeError("The path is not owned by current user or root.") + if not os.path.exists(path): + raise RuntimeError("The path does not exist.") + return path + + +def check_owner(path: str): + """ + check the path owner + param: the input path + return: whether the path owner is current user or not + """ + path_stat = os.stat(path) + path_owner, path_gid = path_stat.st_uid, path_stat.st_gid + user_check = path_owner == os.getuid() and path_owner == os.geteuid() + return path_owner == 0 or path_gid in os.getgroups() or user_check diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/requirements.txt b/MindIE/MultiModal/OpenSoraPlan-1.0/requirements.txt new file mode 100644 index 0000000000..ff5c2e6585 --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/requirements.txt @@ -0,0 +1,47 @@ +torch==2.1.0 +torchvision==0.16.0 +transformers==4.39.1 +accelerate==0.28.0 +albumentations==1.4.0 +av==11.0.0 +einops==0.7.0 +fastapi==0.110.0 +gdown==5.1.0 +h5py==3.10.0 +idna==3.6 +imageio==2.34.0 +matplotlib==3.7.5 +numpy==1.24.4 +omegaconf==2.1.1 +opencv-python==4.9.0.80 +opencv-python-headless==4.9.0.80 +pandas==2.0.3 +pillow==10.2.0 +pydub==0.25.1 +pytorch-lightning==2.2.1 +pytorchvideo==0.1.5 +PyYAML==6.0.1 +regex==2023.12.25 +requests==2.31.0 +scikit-learn==1.3.2 +scipy==1.10.1 +six==1.16.0 +test-tube==0.7.5 +timm==0.9.16 +torchdiffeq==0.2.3 +torchmetrics==1.3.2 +tqdm==4.66.2 +urllib3==2.2.1 +uvicorn==0.27.1 +diffusers==0.27.2 +scikit-video==1.1.11 +imageio-ffmpeg==0.4.9 +sentencepiece==0.1.99 +beautifulsoup4==4.12.3 +ftfy==6.1.3 +moviepy==1.0.3 +wandb==0.16.3 +tensorboard==2.14.0 +pydantic==2.6.4 +gradio==4.0.0 +huggingface-hub==0.25.1 \ No newline at end of file diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/tests/configs/configmixin.json b/MindIE/MultiModal/OpenSoraPlan-1.0/tests/configs/configmixin.json new file mode 100644 index 0000000000..c36d39a62d --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/tests/configs/configmixin.json @@ -0,0 +1,4 @@ +{ + "used_key": "used_key", + "noused_key": "noused_key" +} \ No newline at end of file diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/tests/configs/invalid.json b/MindIE/MultiModal/OpenSoraPlan-1.0/tests/configs/invalid.json new file mode 100644 index 0000000000..ec50e78b0d --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/tests/configs/invalid.json @@ -0,0 +1 @@ +12312312312312354, 123123123123213 \ No newline at end of file diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/tests/configs/scheduler_config_invalid_test.json b/MindIE/MultiModal/OpenSoraPlan-1.0/tests/configs/scheduler_config_invalid_test.json new file mode 100644 index 0000000000..4ea7ff8666 --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/tests/configs/scheduler_config_invalid_test.json @@ -0,0 +1,5 @@ +{ + "num_timesteps": 30, + "num_sampling_steps": 1000, + "sample_method": "UNIFORM_CONSTANT" +} \ No newline at end of file diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/tests/configs/scheduler_config_test.json b/MindIE/MultiModal/OpenSoraPlan-1.0/tests/configs/scheduler_config_test.json new file mode 100644 index 0000000000..ee0c5aae5b --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/tests/configs/scheduler_config_test.json @@ -0,0 +1,6 @@ +{ + "num_timesteps": 30, + "num_sampling_steps": 1000, + "sample_method": "UNIFORM_CONSTANT", + "loc": 0.0 +} \ No newline at end of file diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/tests/models/test_causalvae.py b/MindIE/MultiModal/OpenSoraPlan-1.0/tests/models/test_causalvae.py new file mode 100644 index 0000000000..a31ffadba8 --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/tests/models/test_causalvae.py @@ -0,0 +1,121 @@ +#!/usr/bin/env python +# coding=utf-8 +# Copyright 2024 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import unittest +import os +import sys +import torch +import torch_npu + +import colossalai + +sys.path.append(os.path.split(sys.path[0])[0]) + +from opensoraplan.models.causalvae.modeling_causalvae import DiagonalGaussianDistribution, CausalVAEModel + +SEED = 5464 +MASTER_PORT = '42043' +PROMPT = ["A cat playing with a ball"] + + +class TestDiagonalGaussianDistribution(unittest.TestCase): + def setUp(self): + self.device = torch.device("npu" if torch.npu.is_available() else "cpu") + self.parameters = torch.randn([10, 20, 10, 20]).to(self.device) + self.diagonal_gaussian = DiagonalGaussianDistribution(self.parameters) + + def test_sample(self): + sample = self.diagonal_gaussian.sample() + self.assertEqual(sample.shape, self.parameters[:, :10].shape) + + def test_kl(self): + kl = self.diagonal_gaussian.kl() + self.assertEqual(kl.shape, torch.Size([10])) + + def test_kl_with_other(self): + other_parameters = torch.randn([10, 20, 10, 20]).to(self.device) + other_diagonal_gaussian = DiagonalGaussianDistribution(other_parameters) + kl = self.diagonal_gaussian.kl(other_diagonal_gaussian) + self.assertEqual(kl.shape, torch.Size([10])) + + def test_kl_with_deterministic(self): + other_parameters = torch.randn([10, 20, 10, 20]).to(self.device) + other_diagonal_gaussian = DiagonalGaussianDistribution(other_parameters, deterministic=True) + kl = other_diagonal_gaussian.kl() + self.assertEqual(kl.shape, torch.Size([1])) + + def test_nll(self): + sample = self.diagonal_gaussian.sample() + nll = self.diagonal_gaussian.nll(sample) + self.assertEqual(nll.shape, torch.Size([10])) + + def test_mode(self): + mode = self.diagonal_gaussian.mode() + self.assertEqual(mode.shape, self.parameters[:, :10].shape) + self.assertTrue(torch.allclose(mode, self.diagonal_gaussian.mean, atol=1e-1, rtol=1e-1)) + + +class TestCausalVAEModel(unittest.TestCase): + def setUp(self): + self.device = torch.device("npu" if torch.npu.is_available() else "cpu") + self.model = CausalVAEModel(attn_resolutions=(8,)).to(self.device) + self.path = 'test_checkpoint.pth' + torch.save(self.model.state_dict(), self.path) + + def test_init(self): + self.assertIsInstance(self.model, CausalVAEModel) + + def test_decode(self): + z = torch.randn(1, 4, 4, 8, 8).to(self.device) + dec = self.model.decode(z) + self.assertIsInstance(dec, torch.Tensor) + + def test_blend_v(self): + a = torch.randn(1, 4, 4, 8, 8).to(self.device) + b = torch.randn(1, 4, 4, 8, 8).to(self.device) + blend = self.model.blend_v(a, b, 8) + self.assertIsInstance(blend, torch.Tensor) + + def test_blend_h(self): + a = torch.randn(1, 4, 4, 8, 8).to(self.device) + b = torch.randn(1, 4, 4, 8, 8).to(self.device) + blend = self.model.blend_h(a, b, 8) + self.assertIsInstance(blend, torch.Tensor) + + def test_tiled_decode2d(self): + z = torch.randn(1, 4, 4, 8, 8).to(self.device) + dec = self.model.decode(z) + self.assertIsInstance(dec, torch.Tensor) + + def test_enable_tiling(self): + self.model.enable_tiling() + self.assertTrue(self.model.use_tiling) + + def test_disable_tiling(self): + self.model.disable_tiling() + self.assertFalse(self.model.use_tiling) + + def test_init_from_ckpt(self): + new_model = CausalVAEModel(attn_resolutions=(16,)) + new_model.init_from_ckpt(self.path, ['loss']) + self.assertIsInstance(new_model, CausalVAEModel) + + def tearDown(self): + os.remove(self.path) + + +if __name__ == "__main__": + unittest.main(argv=['first-arg-is-ignored']) diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/tests/pipeline/spiece.model b/MindIE/MultiModal/OpenSoraPlan-1.0/tests/pipeline/spiece.model new file mode 100644 index 0000000000000000000000000000000000000000..4e28ff6ebdf584f5372d9de68867399142435d9a GIT binary patch literal 791656 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

l4{)H$osCy`k*$ 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%0ANl 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[-|zqhBr(43DLpJ^{F=cclsf(4z-Q9fSP_aK zZ3UUOJzs#@Rbpw?9{T1&O#UPb zqKfl>DovvpJg^ThC8{<-;;XN1h(Wn67fzXz7aQoZt`wVged*QUSJIEVFqu^KZ~k_@ zW2P#T;Dz}5Q#jY|skJks@-v`wOx5A&>{t>02IG_zCJJA^HR)-ICBASllvKsoF(aZ!*m=@69&(&rq%@ShA6VVJXJ^4>x3edD4IJ=Tg{e^SD+hjZ_!t9ul_9E77H0{uiJN ziH#|=0Whr?<3zfmq?h3|A}_JT*dYPqRd9;uxX!fKSAWpbej7X0;D3x)>R=^ zSQ6y4r~1tK*hHLD)|=zl>sDdDAT9>l6_y4e@3F&U6FHrs(G@XI$kK0O)2lN+5aBE^ z`D5#eAvWeO1L+9SbK+o|mh*}@XT6kbi4~Uxy25ZPR(3&m5<>wL*pvN-++>D>$Nu;w z1?Y?x(6!(n7Y!St?C0fUk|>8=bj*HPp|{c2If zJn;DCF}Pe7K9VFmeQ}K_=XpwUo$Bu8Ge3#33hMu_SAeoOCt$=dwidQnCa@`q{cl9@ zsz{YevcP;($T{ibRdH#SzEuu|=S4ZcSP?JIStF%#b{W?3I@x1_YGGVlil+sf0InkU z#J_~e(`-iMUw(rdStBj_0d4bau#y=%CuXENh~9c-7*dlg@>!Qs<%fxKkZo)_#t31{ zfn7P$lNUh(TH1-^S^*;LWxN=>O6IdJS)Pv;T!zV`IJ|AY5T}p@ke@Eye}NR6<4+;+e9iw1a<73~_KL zB1Wy9g_*n>5_^{kR&Q;^=qwX-N?Z>(NrY>F)Godibd=oGOy-%D>p-b%oE~een}y#~ zK>siLML1K5X|mIV)5gkh#{ZvqpR`35K64W{UAi~ z=lbZ42G;j?TvgR1=t)6Kt5#a#{qd?8&)pdRn1c+UJ;nj!2GGRL;TikoC;k@XcdC

kM9h*Ie1)a4tw zEkm2l;ReFSPz2Yf_3S?cT=IOv8S%25M7HpHEG)#@ zn}Zxd9S2Nk=*0?KK)E2s>4Lz?!Y)?yOyU|r*Lv-}GtuLYfH+GKtxwJU_S_OCt&$jq z%g1XXh?XmLXhFR3JCJ13#eUfGTLH*0uf)VuxgFW`hADB9AYVyNJ@LJeqoIvxJ9xuw z{3+%-W2)SQ$y|!wDFt&dc^TgcI5F(^vrcQ+HVdd$+D&~iPmJTOqPO^qpud=~Z~=Q; zpNgTlyZq=<@0d$d-deJ^6^&5zCcsfdFX)s$1-z1t$ zbO@Dc*RkH}eoQnuAV(NKCsx;We<|XT#zo*~P;#n`mL8I{IsC(IZkpzwu zWx-G;strjKcv!T1K5r7US;E6>qhZPA(BgJgVbYU4br`T3&+b zYKtl{#HA$?yK3_V-I|(oheflaTg17KurWXNDc9_lg~a?@Pf~p-hG=IqL-|H-r;(`+ zo44PJa4u(b6#9FZlP|S9RGMtvr{1xQtE7i>k+7veO5zPc2g#&|5#i_Z|CJot?70X3 zyM)=uPSi^Q9@iXiA)*+k$;zOol4#r*~D9FD5RixYzpTh!0v znleKZ&Cv>X9*3WF{y;rS4hwD)=kJo|W=iph7!rd56<0~d8w~U@u+&WeIOV!Wq$OIn zC`7gJx;RTtheX9ImOA1lF(jLtgUK@R!SeSkACqP~W+GmOT0$Y-6tni}>CX(JyO4p@m6LLti3Ye(p0=<~D9sA0vy4-il{?f<)-Y@%W$@LByvR-2U zEIfLFZW_UHe$MOflb2E@HeX3PEA3C4O@N?ldp6Q#+V3S7cffIYW3s&^4ho z(SNQ#5CWl3X^K1KOnWL>Wr$-Bf^a4$atOfQ%JpKh&WZ}aWSwWC56=80_r952x>#S-oOVc}vwHkt*=HI+U(Y}7+%US z>Z&7SpMJ2z*HV*DxL7HU(2@ztxdIk-`GsQAc#U{x6ytu$#=>=?kZLm;rz;HLw!j-O ze6g~ilgv|pbfD2tW;$&&;At_I%Itv{I~(NiXBPaZ>Zmzcn3I`>j1i<26kB+=K{JNK z=0Z5H99op(ph0_JYEon$vm<^K;Z*bv%$r9^tUeEhtfCMyH r;565^6l2rFfKJa2 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≦`29}wc4xEBb_W}V~$=~7Wn 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 zhyNe`fB665|A+q{{(ty?pV0N}=l_TQAO3&%|Kb0K{~!K;`2XSmhyNe`fB665|A+q{ z{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSmhyNe`fB665|A+q{{(t!Y;s1yKAO3&%|Kb0K z{~!K;`2XSmhyNe`fB665|A+q{{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSmhyNe`fB665 z|A+q{{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSmhyNe`fB665|A+q{{(t!Y;s1yKAO3&% z|Kb0K{~!K;`2XSmhyNe`fB665|A+q{{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSmhyNe` zfB665|A+q{{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSmhyNe`fB665|A+q{{(t!Y;s1yK zAO3&%|Kb0K{~!K;`2XSmhyNe`fB665|A+q{{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSm zhyNe`fB665|A+q{{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSmhyNe`fB665|A+q{{(t!Y z;s1yKAO3&%|Kb0K{~!K;`2XSmhyNe`fB665|A+q{{(t!Y;s1yKAO3&%|Kb0K{~!K; z`2XSmhyNe`fB665|A+q{{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSmhyNe`fB665|A+q{ z{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSmhyNe`fB665|A+q{{(t!Y;s1yKAO3&%|Kb0K z{~!K;`2XSmhyNe`fB665|A+q{{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSmhyNe`fB665 z|A+q{{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSmhyNe`fB665|A+q{{(t!Y;s1yKAO3&% z|Kb0K{~!K;`2XSmhyNe`fB665|A+q{{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSmhyNe` zfB665|A+q{{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSmhyNe`fB665|A+q{{(t!Y;s1yK zAO3&%|Kb0K{~!K;`2XSmhyNe`fB665|A+q{{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSm zhyNe`fB665|A+q{{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSmhyNe`fB665|A+q{{(t!Y z;s1yKAO3&%|Kb0K{~!K;`2XSmhyNe`fB665|A+q{{(t!Y;s1yKAO3&%|Kb0K{~!K; z`2XSmhyNe`fB665|A+q{{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSmhyNe`fB665|A+q{ z{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSmhyNe`fB665|A+q{{(t!Y;s1yKAO3&%|Kb0K z{~!K;`2XSmhyNe`fB665|A+q{{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSmhyNe`fB665 z|A+q{{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSmhyNe`fB665|A+q{{(t!Y;s1yKAO3&% z|Kb0K{~!K;`2XSmhyNe`fB665|A+q{{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSmhyNe` zfB665|A+q{{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSmhyNe`fB665|A+q{{(t!Y;s1yK zAO3&%|Kb0K{~!K;`2XSmhyNe`fB665|A+q{{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSm zhyNe`fB665|A+q{{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSmhyNe`fB665|A+q{{(t!Y z;s1yKAO3&%|Kb0K{~!K;`2XSmhyNe`fB665|A+q{{(t!Y;s1yKAO3&%|Kb0K{~!K; z`2XSmhyNe`fB665|A+q{{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSmhyNe`fB665|A+q{ z{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSmhyNe`fB665|A+q{{(t!Y;s1yKAO3&%|Kb0K z{~!K;`2XSmhyNe`fB665|A+q{{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSmhyNe`fB665 z|A+q{{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSmhyNe`fB665|A+q{{(t!Y;s1yKAO3&% z|Kb0K{~!K;`2XSmhyNe`fB665|A+q{{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSmhyNe` zfB665|A+q{{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSmhyNe`fB665|A+q{{(t!Y;s1yK zAO3&%|Kb0K{~!K;`2XSmhyNe`fB665|A+q{{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSm zhyNe`fB665|A+q{{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSmhyNe`fB665|A+q{{(t!Y z;s1yKAO3&%|Kb0K{~!K;`2XSmhyNe`fB665|A+q{{(t!Y;s1yKAO3&%|Kb0K{~!K; z`2XSmhyNe`fB665|A+q{{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSmhyNe`fB665|A+q{ z{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSmhyNe`fB665|A+q{{(t!Y;s1yKAO3&%|Kb0K z{~!K;`2XSmhyNe`fB665|A+q{{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSmhyNe`fB665 z|A+q{{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSmhyNe`fB665|A+q{{(t!Y;s1yKAO3&% z|Kb0K{~!K;`2XSmhyNe`fB665|A+q{{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSmhyNe` zfB665|A+q{{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSmhyNe`fB665|A+q{{(t!Y;s1yK zAO3&%|Kb0K{~!K;`2XSmhyNe`fB665|A+q{{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSm zhyNe`fB665|A+q{{(t!Y;s1yKAO3&%|Kb0K{~!K;`2XSmhyRcNkN=PVkN=PVkN=PV zkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PV zkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PV zkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PV zkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PV zkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PV zkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PVkN=PV zkN=PVkN=PVkN@v~?C1aE|KtDT|KtDrAN%?L`2YC-`2YC-`2YC-`2YC-`2YC-`2YC- z`2YC-`2YC-`2YC-`2YC-`2YC-`2YC-{?~r~KmI@dKmI@dzyGzL|BwHV|BwHV|BwHV z|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV z|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV z|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV z|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV z|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV z|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV z|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV z|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV z|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV z|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV z|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV z|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV z|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV z|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV z|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV z|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV z|BwHV|BwHV|BwHV|BwHV|BwHV|L?&51N#r`Kd}G6{sa3D>_4#o!2SdK59~j%|G@qO z`w#3tu>ZjR1N#r`Kd}G6{sa3D>_4#o!2SdK59~j%|G@qO`w#3tu%G{r|BwHV|BwHV z|BwHV|L?&51N#r`Kd_(wkN@w${sa3D>_4#o!2SdK59~j%|G@qO`w#3tu>ZjR1N#r` zKd}G6{sa5@|M>s-|M>s-|M>s-|M>q7?LV~t(EdaF`TzL;4(;dvJGB4M{zLl@?LV~t z(EdaF5A8p+|Iq$J`w#6uwExilL;DZyKeYeQ{zLl@?LV~t(EdaF5A8p+|Iq$J`w#6u zwExilL;DZyKeYeQ{zLl@?LV~t(EdaF5A8p+|Iq$J`w#6uwExilL;DZyKeGSG{v-R3 z>_4*q$o?bykL*9PpZ|~lkN@w;{v-R3>_4)f|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV z|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV z|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV z|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwIg*#2YtkL^FU|JeRx`;YBEw*T1v zWBd94`2UXWKeqqa{$u<3|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s- z|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>s-|M>qN?0>MI|BwHV|BwHV|BwHV z|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwHV|BwIg(f&vK z`TzL;`2YC-`2YC-`2YC-`2YC-`2YC-`2YC-`2YC-`2YC-`2YC-`2YC-`2YC-`2YC- z`2YC-`2YC-`2YC-`2YC-`2YC-`2YC-`2YC-`2YC-`2YC-`2YC-`2YC-`2YC-_zuW(A|GWL~ z_P^WzZvVUe@Akjj|8D=g{U7#!*#BYwhy5S+f7t(F|A+k__J7#_VgHByANGIP|6%`! z{U7#!*#BYwhy5S+f7t(F|A+k__J7#_VgHByANGIP|6%`!{U7#!*#BYwhy5S+f7t(F z|A+k__J7zf1CR_rANGIP|6%`!{W1W_03-vD3_vmf$p9n+kPJXF0LcI(1CR_rG62Z{ zBmxnHGowEST%rE16VbHRRdTxfK>xnHGowEST%rE16VbHRRdTxfK>xnHGowEST%rE z16VbHRRdTxfK>xnHGowEST%rE16VbHRRdTxfK>xnHGowEST%rE16VbHRRdTxfK>xn zHGowEST%rE16VbHRRdTxfK>xnHGowEST%rE16VbHRRdTxfK>xnHGowEST%rE16VbH zRRdTxfK>xnHGowEST%rE16VbHRRdTxfK>xnHGowEST%rE16VbHRRdTxfK>xnHGowE zST%rE16VbHRRdTxfK>xnHGowEST%rE16VbHRRdTxfK>xnHGowEST%rE16VbHRRdTx zfK>xnHGowEST%rE16VbHRRdTxfK>xnHGowEST%rE16VbHRRdTxfK>xnHGowEST%rE z16VbHRRdTxfK>xnHGowEST%rE16VbHRRdTxfK>xnHGowEST%rE16VbHRRdTxfK>xn zHGowEST%rE16VbHRRdTxfK>xnHGowEST%rE16VbHRRdTxfK>xnHGowEST%rE1K9tu zUkzZ@09FlP)c{rvVATLt4Pey(Rt;d)09FlP)c{rvVATLt4Pey(Rt;d)09FlP)c{rv zVATLt4Pey(Rt;d)09FlP)c{rvVATLt4PgJ*el>tq16VbHRRdTxfK>xnHGowEST%rE z16VbHRRdTxfK>xnHGowEST%rE16VbHRRdTxfK>xnHGowEST%rE16VbHRRdTxfK>xn zHGowEST%rE16VbHRRdTxfK>xnHGowEST%rE16VbHRRdTxfK>xnHGowEST%rE16VbH zRRdTxfK>xnHGowEST%rE16VbHRRdTxfK>xnHGowEST%rE16VbHRRdTxfK>xnHGowE zST%rE16VbHRRdTxfK>xnHGowEST%rE16VbHRRdTxfK>xnHGowEST%rE16VbHRRdTx zfK>xnHGowEST%rE16VbHRRdTxfK>xnHGowEST%rE16VbHRRdTxfK>xnHGowEST%rE z16VbHRRdTxfK>xnHGowEST%rE16VbHRRdTxfK>xnHGowEST%rE16VbHRRdTxfK>xn zHGowEST%rE16VbHRRdTxfK>xnHGowEST%rE16VbHRRdTxfK>xnHGowEST%rE16VbH zRRdTxfK>xnHGowEST%rE16VbHRRdTxfK>xnHGowEST%rE16VbHRRdTxfK>xnHGowE zST%rE16VbHRRdTxfK>xnHGowEST%rE16VbHRRdTxfK>xnHGowEST%rE16VbHRRdTx zfK>xnHGowEST%rE16VbHRRdTxfK>xnHGowEST%rE16VbHRRdTxfK>xnHGowEST%rE z16VbHRRdTxfK>xnHGowEST%rE16VbHRRdTxfK>xnHGowEST%rE16VbHRRdTxfK>xn zHGowEST%rE16VbHRRdTxfK>xnHGowEST%rE16VbHRRdTxfK>xnHGowEST%rE16VbH zRRdTxfK>xnHGowEST%rE16VbHRRdTxfK>xnHGowEST%rE16VbHRRdTxfK>xnHGowE zST%rE16VbHRRdTxfK>xnHGowEST%rE16VbHRRdTxfK>xnHGowEST%rE16VbHRRdTx zfK>xnHGowEST%rE16VbHRRdTxfK>xnHGowEST%rE16VbHRRdTxfK>xnHGowEST%rE z16VbHRRdTxfK>xnHGowEST%rE16VbHRRdTxfK>xnHGowEST%rE16VbHRRdTxfK>xn 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 z(Ey?WL<5Kh5Dg$2Ks1180MP)V0Yn3c1`rJ(8bCCFXaLawq5(t$hz1Z1AR0h4fM@{G z0HOgz1BeC?4ImmoG=OLT(Ey?WL<5Kh5Dg$2Ks1180MP)V0Yn3c1`rJ(8bCCFXaLaw zq5(t$hz1Z1AR0h4fM@{G0HOgz1BeC?4ImmoG=OLT(Ey?WL<5Kh5Dg$2Ks1180MP)V z0Yn3c1`rJ(8bCCFXaLawq5(t$hz1Z1AR0h4fM@{G0HOgz1BeC?4ImmoG=OLT(Ey?W zL<5Kh5Dg$2Ks1180MP)V0Yn3c1`rJ(8bCCFXaLawq5(t$hz1Z1AR0h4fM@{G0HOgz z1BeC?4ImmoG=OLT(Ey?WL<5Kh5Dg$2Ks1180MP)V0Yn3c1`rJ(8bCCFXaLawq5(t$ zhz1Z1AR0h4fM@{G0HOgz1BeC?4ImmoG=OLT(Ey?WL<5Kh5Dg$2Ks1180MP)V0Yn3c z1`rJ(8bCCFXaLawq5(t$hz1Z1AR0h4fM@{G0HOgz1BeC?4ImmoG=OLT(Ey?WL<5Kh z5Dg$2Ks1180MP)V0Yn3c1`rJ(8bCCFXaLawq5(t$hz1Z1AR0h4fM@{G0HOgz1BeC? z4ImmoG=OLT(Ey?WL<5Kh5Dg$2Ks1180MP)V0Yn3c1`rJ(8bCCFXaLawq5(t$hz1Z1 zAR0h4fM@{G0HOgz1BeC?4ImmoG=OLT(Ey?WL<5Kh5Dg$2Ks1180MP)V0Yn3c1`rJ( z8bCCFXaLawq5(t$hz1Z1AR0h4fM@{G0HOgz1BeC?4ImmoG=OLT(Ey?WL<5Kh5Dg$2 zKs1180MP)V0Yn3c1`rJ(8bCCFXaLawq5(t$hz1Z1AR0h4fM@{G0HOgz1BeC?4Immo zG=OLT(Ey?WL<5Kh5Dg$2Ks1180MP)V0Yn3c1`rJ(8bCCFXaLawq5(t$hz1Z1AR0h4 zfM@{G0HOgz1BeC?4ImmoG=OLT(Ey?WL<5Kh5Dg$2Ks1180MP)V0Yn3c1`rJ(8bCCF zXaLawq5(t$hz1Z1AR0h4fM@{G0HOgz1BeC?4ImmoG=OLT(Ey?WL<5Kh5Dg$2Ks118 z0MP)V0Yn3c1`rJ(8bCCFXaLawq5(t$hz1Z1AR0h4fM@{G0HOgz1BeC?4ImmoG=OLT z(Ey?WL<5Kh5Dg$2Ks1180MP)V0Yn3c1`rJ(8bCCFXaLawq5(t$hz1Z1AR0h4fM@{G z0HOgz1BeC?4ImmoG=OLT(Ey?WL<5Kh5Dg$2Ks1180MP)V0Yn3c1`rJ(8bCCFXaLaw zq5(t$hz1Z1AR0h4fM@{G0HOgz1BeC?4ImmoG=OLT(Ey?WL<5Kh5Dg$2Ks1180MP)V z0Yn3c1`rJ(8bCCFXaLawq5(t$hz1Z1AR0h4fM@{G0HOgz1BeC?4ImmoG=OLT(Ey?W zL<5Kh5Dg$2Ks1180MP)V0Yn3c1`rJ(8bCCFXaLawq5(t$hz1Z1AR0h4fM@{G0HOgz z1BeC?4ImmoG=OLT(Ey?WL<5Kh5Dg$2Ks1180MP)V0Yn3c1`rJ(8bCCFXaLawq5(t$ zhz1Z1AR0h4fM@{G0HOgz1BeC?4ImmoG=OLT(Ey?WL<5Kh5Dg$2Ks1180MP)V0Yn3c z1`rJ(8bCCFXaLawq5(t$hz1Z1AR0h4fM@{G0HOgz1BeC?4ImmoG=OLT(Ey?WL<5Kh z5Dg$2Ks1180MP)V0Yn3c1`rJ(8bCCFXaLawq5(t$hz1Z1AR0h4fM@{G0HOgz1BeC? z4ImmoG=O=gP$;~)hPQ$`kMNHm`yxCQtmB3Mui>-c(k^)H&quHPY}bv~zirrYnD3AJ z?QlPL-v7Gu@2@)_>^%O@Q?G~owqfUbq#rxiBR&3f_mr<2cTc(7@sxw=)*LK-1;;vA zNY23(X%2?(=U_5;4(8kDU=U=EZUN@#yf;Vx^m8a*#$o=tPg>?$g= zD-X;rPd~dP>+G_6v%A%r-Mz%@7LT(tB?ND6f9H7n^{wqXv}e~&JG*|O*)@>NNd_soX /dev/null; then + python_command=python3 +else + python_command=python +fi + +pip install coverage +pip install colossalai==0.4.4 --no-deps +pip install pytest +pip install pytest-cov + +current_directory=$(dirname "$(readlink -f "$0")") +export PYTHONPATH=${current_directory}/../:$PYTHONPATH + +pytest -k "test_ and not _test" --cov=../opensoraplan --cov-branch --cov-report xml --cov-report html \ +--junit-xml=${current_directory}/final.xml \ +--continue-on-collection-errors \ No newline at end of file diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/tests/t2v_sora.txt b/MindIE/MultiModal/OpenSoraPlan-1.0/tests/t2v_sora.txt new file mode 100644 index 0000000000..6b73dea0fc --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/tests/t2v_sora.txt @@ -0,0 +1,48 @@ +A stylish woman walks down a Tokyo street filled with warm glowing neon and animated city signage. She wears a black leather jacket, a long red dress, and black boots, and carries a black purse. She wears sunglasses and red lipstick. She walks confidently and casually. The street is damp and reflective, creating a mirror effect of the colorful lights. Many pedestrians walk about. +Several giant wooly mammoths approach treading through a snowy meadow, their long wooly fur lightly blows in the wind as they walk, snow covered trees and dramatic snow capped mountains in the distance, mid afternoon light with wispy clouds and a sun high in the distance creates a warm glow, the low camera view is stunning capturing the large furry mammal with beautiful photography, depth of field. +A movie trailer featuring the adventures of the 30 year old space man wearing a red wool knitted motorcycle helmet, blue sky, salt desert, cinematic style, shot on 35mm film, vivid colors. +Drone view of waves crashing against the rugged cliffs along Big Sur’s garay point beach. The crashing blue waters create white-tipped waves, while the golden light of the setting sun illuminates the rocky shore. A small island with a lighthouse sits in the distance, and green shrubbery covers the cliff’s edge. The steep drop from the road down to the beach is a dramatic feat, with the cliff’s edges jutting out over the sea. This is a view that captures the raw beauty of the coast and the rugged landscape of the Pacific Coast Highway. +Animated scene features a close-up of a short fluffy monster kneeling beside a melting red candle. The art style is 3D and realistic, with a focus on lighting and texture. The mood of the painting is one of wonder and curiosity, as the monster gazes at the flame with wide eyes and open mouth. Its pose and expression convey a sense of innocence and playfulness, as if it is exploring the world around it for the first time. The use of warm colors and dramatic lighting further enhances the cozy atmosphere of the image. +A gorgeously rendered papercraft world of a coral reef, rife with colorful fish and sea creatures. +This close-up shot of a Victoria crowned pigeon showcases its striking blue plumage and red chest. Its crest is made of delicate, lacy feathers, while its eye is a striking red color. The bird’s head is tilted slightly to the side, giving the impression of it looking regal and majestic. The background is blurred, drawing attention to the bird’s striking appearance. +Photorealistic closeup video of two pirate ships battling each other as they sail inside a cup of coffee. +A young man at his 20s is sitting on a piece of cloud in the sky, reading a book. +Historical footage of California during the gold rush. +A close up view of a glass sphere that has a zen garden within it. There is a small dwarf in the sphere who is raking the zen garden and creating patterns in the sand. +Extreme close up of a 24 year old woman’s eye blinking, standing in Marrakech during magic hour, cinematic film shot in 70mm, depth of field, vivid colors, cinematic +A cartoon kangaroo disco dances. +A beautiful homemade video showing the people of Lagos, Nigeria in the year 2056. Shot with a mobile phone camera. +A petri dish with a bamboo forest growing within it that has tiny red pandas running around. +The camera rotates around a large stack of vintage televisions all showing different programs — 1950s sci-fi movies, horror movies, news, static, a 1970s sitcom, etc, set inside a large New York museum gallery. +3D animation of a small, round, fluffy creature with big, expressive eyes explores a vibrant, enchanted forest. The creature, a whimsical blend of a rabbit and a squirrel, has soft blue fur and a bushy, striped tail. It hops along a sparkling stream, its eyes wide with wonder. The forest is alive with magical elements: flowers that glow and change colors, trees with leaves in shades of purple and silver, and small floating lights that resemble fireflies. The creature stops to interact playfully with a group of tiny, fairy-like beings dancing around a mushroom ring. The creature looks up in awe at a large, glowing tree that seems to be the heart of the forest. +The camera follows behind a white vintage SUV with a black roof rack as it speeds up a steep dirt road surrounded by pine trees on a steep mountain slope, dust kicks up from it’s tires, the sunlight shines on the SUV as it speeds along the dirt road, casting a warm glow over the scene. The dirt road curves gently into the distance, with no other cars or vehicles in sight. The trees on either side of the road are redwoods, with patches of greenery scattered throughout. The car is seen from the rear following the curve with ease, making it seem as if it is on a rugged drive through the rugged terrain. The dirt road itself is surrounded by steep hills and mountains, with a clear blue sky above with wispy clouds. +Reflections in the window of a train traveling through the Tokyo suburbs. +A drone camera circles around a beautiful historic church built on a rocky outcropping along the Amalfi Coast, the view showcases historic and magnificent architectural details and tiered pathways and patios, waves are seen crashing against the rocks below as the view overlooks the horizon of the coastal waters and hilly landscapes of the Amalfi Coast Italy, several distant people are seen walking and enjoying vistas on patios of the dramatic ocean views, the warm glow of the afternoon sun creates a magical and romantic feeling to the scene, the view is stunning captured with beautiful photography. +A large orange octopus is seen resting on the bottom of the ocean floor, blending in with the sandy and rocky terrain. Its tentacles are spread out around its body, and its eyes are closed. The octopus is unaware of a king crab that is crawling towards it from behind a rock, its claws raised and ready to attack. The crab is brown and spiny, with long legs and antennae. The scene is captured from a wide angle, showing the vastness and depth of the ocean. The water is clear and blue, with rays of sunlight filtering through. The shot is sharp and crisp, with a high dynamic range. The octopus and the crab are in focus, while the background is slightly blurred, creating a depth of field effect. +A flock of paper airplanes flutters through a dense jungle, weaving around trees as if they were migrating birds. +A cat waking up its sleeping owner demanding breakfast. The owner tries to ignore the cat, but the cat tries new tactics and finally the owner pulls out a secret stash of treats from under the pillow to hold the cat off a little longer. +Borneo wildlife on the Kinabatangan River +A Chinese Lunar New Year celebration video with Chinese Dragon. +Tour of an art gallery with many beautiful works of art in different styles. +Beautiful, snowy Tokyo city is bustling. The camera moves through the bustling city street, following several people enjoying the beautiful snowy weather and shopping at nearby stalls. Gorgeous sakura petals are flying through the wind along with snowflakes. +A stop motion animation of a flower growing out of the windowsill of a suburban house. +The story of a robot’s life in a cyberpunk setting. +An extreme close-up of an gray-haired man with a beard in his 60s, he is deep in thought pondering the history of the universe as he sits at a cafe in Paris, his eyes focus on people offscreen as they walk as he sits mostly motionless, he is dressed in a wool coat suit coat with a button-down shirt , he wears a brown beret and glasses and has a very professorial appearance, and the end he offers a subtle closed-mouth smile as if he found the answer to the mystery of life, the lighting is very cinematic with the golden light and the Parisian streets and city in the background, depth of field, cinematic 35mm film. +A beautiful silhouette animation shows a wolf howling at the moon, feeling lonely, until it finds its pack. +New York City submerged like Atlantis. Fish, whales, sea turtles and sharks swim through the streets of New York. +A litter of golden retriever puppies playing in the snow. Their heads pop out of the snow, covered in. +Step-printing scene of a person running, cinematic film shot in 35mm. +Five gray wolf pups frolicking and chasing each other around a remote gravel road, surrounded by grass. The pups run and leap, chasing each other, and nipping at each other, playing. +Basketball through hoop then explodes. +Archeologists discover a generic plastic chair in the desert, excavating and dusting it with great care. +A grandmother with neatly combed grey hair stands behind a colorful birthday cake with numerous candles at a wood dining room table, expression is one of pure joy and happiness, with a happy glow in her eye. She leans forward and blows out the candles with a gentle puff, the cake has pink frosting and sprinkles and the candles cease to flicker, the grandmother wears a light blue blouse adorned with floral patterns, several happy friends and family sitting at the table can be seen celebrating, out of focus. The scene is beautifully captured, cinematic, showing a 3/4 view of the grandmother and the dining room. Warm color tones and soft lighting enhance the mood. +The camera directly faces colorful buildings in Burano Italy. An adorable dalmation looks through a window on a building on the ground floor. Many people are walking and cycling along the canal streets in front of the buildings. +An adorable happy otter confidently stands on a surfboard wearing a yellow lifejacket, riding along turquoise tropical waters near lush tropical islands, 3D digital render art style. +This close-up shot of a chameleon showcases its striking color changing capabilities. The background is blurred, drawing attention to the animal’s striking appearance. +A corgi vlogging itself in tropical Maui. +A white and orange tabby cat is seen happily darting through a dense garden, as if chasing something. Its eyes are wide and happy as it jogs forward, scanning the branches, flowers, and leaves as it walks. The path is narrow as it makes its way between all the plants. the scene is captured from a ground-level angle, following the cat closely, giving a low and intimate perspective. The image is cinematic with warm tones and a grainy texture. The scattered daylight between the leaves and plants above creates a warm contrast, accentuating the cat’s orange fur. The shot is clear and sharp, with a shallow depth of field. +Aerial view of Santorini during the blue hour, showcasing the stunning architecture of white Cycladic buildings with blue domes. The caldera views are breathtaking, and the lighting creates a beautiful, serene atmosphere. +Tiltshift of a construction site filled with workers, equipment, and heavy machinery. +A giant, towering cloud in the shape of a man looms over the earth. The cloud man shoots lighting bolts down to the earth. +A Samoyed and a Golden Retriever dog are playfully romping through a futuristic neon city at night. The neon lights emitted from the nearby buildings glistens off of their fur. +The Glenfinnan Viaduct is a historic railway bridge in Scotland, UK, that crosses over the west highland line between the towns of Mallaig and Fort William. It is a stunning sight as a steam train leaves the bridge, traveling over the arch-covered viaduct. The landscape is dotted with lush greenery and rocky mountains, creating a picturesque backdrop for the train journey. The sky is blue and the sun is shining, making for a beautiful day to explore this majestic spot. \ No newline at end of file diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/tests/test_config_utils.py b/MindIE/MultiModal/OpenSoraPlan-1.0/tests/test_config_utils.py new file mode 100644 index 0000000000..d4a5379825 --- /dev/null +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/tests/test_config_utils.py @@ -0,0 +1,91 @@ +#!/usr/bin/env python +# coding=utf-8 +# Copyright(C) 2024. Huawei Technologies Co.,Ltd. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License + +import unittest +import logging +import sys +import os +import json +sys.path.append('../') +from mindiesd.config_utils import ConfigMixin + +logger = logging.getLogger() +logger.setLevel(logging.INFO) + + +USED_KEY = "used_key" +NOUSED_KEY = "noused_key" +CONFIG_NAME = "./configs" + + +class ModelConfig(ConfigMixin): + config_name = "configmixin.json" + + def __init__(self, used_key): + self.used_key = used_key + + +class InvalidModelConfig(ConfigMixin): + config_name = "invalid.json" + + def __init__(self, used_key): + self.used_key = used_key + + +class TestConfigMixin(unittest.TestCase): + + def test_load_config(self): + init_dict, config_dict = ModelConfig.load_config(CONFIG_NAME) + # used_key will in init_dict + self.assertIn(USED_KEY, init_dict) + self.assertEqual(init_dict.get(USED_KEY), USED_KEY) + self.assertNotIn(USED_KEY, config_dict) + + # noused_key will in config_dict + self.assertIn(NOUSED_KEY, config_dict) + self.assertEqual(config_dict.get(NOUSED_KEY), NOUSED_KEY) + self.assertNotIn(NOUSED_KEY, init_dict) + + def test_config_path_invalid(self): + try: + init_dict, config_dict = ModelConfig.load_config("./no_used_path") + except Exception as e: + logger.error(e) + init_dict, config_dict = None, None + self.assertIsNone(init_dict) + self.assertIsNone(config_dict) + + def test_config_path_none(self): + try: + init_dict, config_dict = ConfigMixin.load_config(CONFIG_NAME) + except Exception as e: + logger.error(e) + init_dict, config_dict = None, None + self.assertIsNone(init_dict) + self.assertIsNone(config_dict) + + def test_config_json_invalid(self): + try: + init_dict, config_dict = InvalidModelConfig.load_config(CONFIG_NAME) + except Exception as e: + logger.error(e) + init_dict, config_dict = None, None + self.assertIsNone(init_dict) + self.assertIsNone(config_dict) + + +if __name__ == '__main__': + unittest.main() \ No newline at end of file -- Gitee From cf6186a0838aa55aea16a731b87d7273d32053da Mon Sep 17 00:00:00 2001 From: fangrongcan Date: Sat, 7 Jun 2025 02:09:16 +0000 Subject: [PATCH 2/5] =?UTF-8?q?OWNERS=E6=B7=BB=E5=8A=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: fangrongcan --- OWNERS | 176 +++++++++++++++++++++++++++++++++++---------------------- 1 file changed, 107 insertions(+), 69 deletions(-) diff --git a/OWNERS b/OWNERS index 601981ecf2..1012e0ab0e 100644 --- a/OWNERS +++ b/OWNERS @@ -1,82 +1,120 @@ -approvers: -- wangjiangben_hw -- zhangjunyi08 -- li_jing_hw -- qingfenxiaochong -- liuzhuheng -- gp513 -- block0219 -- dilililiwhy -- fengliangjun66 +branch_keeper: +- edmund_hu - wenbox -- Ronnie_zheng -- fighting_zhen -- ginray0215 -- kezhan1 +- chemsky +- yumiao-hw +- limuyuan3 + +approvers: +- msm_ascend +- lujunyi4 +- ZeroFadeAway +- edmund_hu +- wu_yushan +- hu-xiao-bo +- cxy-katrina - jyoung6652 -- Gongen -- coding-lz -- guowenna - maoxx241 -- ZeroFadeAway +- xiangsen2 +- he-jianping07 +- kezhan1 +- libliang + reviewers: -- ginray0215 -- matrixplayer -- wangjiangben_hw -- zhangjunyi08 -- li_jing_hw -- qingfenxiaochong -- zheng-wengang1 -- liuzhuheng -- gp513 -- block0219 -- dilililiwhy -- fengliangjun66 -- loomischen -- liu-qi-yuan -- onehaitao -- zhuobohang -- yiransun -- xiao-yamin -- mamba_chen +- lu2048 - wenbox +- kezhan1 +- Gongen +- block0219 +- filimonovegor +- garyll +- beolus +- li_junyu24 - zou-ying +- limuyuan3 +- lirui2017 +- redcyclone +- guohuanliang - hiyangbo -- garyll +- coding-lz +- wqh17101 +- timeash - Ronnie_zheng -- dl9864 +- loov +- ZeroFadeAway +- block0219 - sibylk -- sunyuqi3 -- fighting_zhen -- sunyi001 -- liu_zhi_xu +- dl9864 +- demo-v +- xulianhao +- yangyifei626 +- z2fan +- wenjiang2357 +- wuluotianqing126 +- xiong-liangcheng_admin +- gitee-code-template +- yaojia2021 +- chantcalf +- leizhenzhen +- liuyanghan +- lord_of_ironhill +- wu_mingjing +- cxy-katrina +- msm_ascend +- XHG +- you-zhiyuan-11 +- yuanwei66 +- taojiovo +- kpxing +- zhangxinyuanliuhengyu +- zhouyiiiiii +- wu_yushan +- hw-zhou-tianyang +- XhgAtHuawei +- xuyouyuywj +- git_ray +- ruixuandev +- jerryrual +- yj_1234 - han_yifeng - jyoung6652 - maoxx241 - chenchuw -- guowenna -- lanwangli -- mazhixin00 -- zhou-wenxue -- huanghao7 -- Gongen -- kezhan1 -- terrychen1982 -- fan2956 -- Yansifu -- yliuls -- shaopeng666 -- coding-lz -- JiayiZhou_1 -- zhengteju -- xinyanhe -- keilo-wang -- WeiChunyu-star -- liutongtong27 -- niushiya -- yeyifan1 -- guo-yucheng -- demo-v -- manyny -- bangbangchui66 -- ZeroFadeAway \ No newline at end of file +- xqchen007 +- guleo2 +- bigsir007 +- lujunyi4 +- hejingkui +- mayumeng0824 +- jiang-sihantj +- wbj1207 +- imwangyue +- brian-liu9973 +- shoufenghu +- lu2048 +- jiangyuan19 +- tonygaogsm +- cs3n21 +- liu-jiaolonghuawei +- mmjssg +- pjvord +- freyfwt +- Angazenn +- liuzepeng6 +- jsn-jia +- hu-xiao-bo +- shenxinjie +- sunyuqi3 +- chuyuelin +- yht1024 +- y30044005 +- zjks98 +- xiangsen2 +- he-jianping07 +- mueuler +- CLH126 +- littleyellowbicycle +- SoulMeister +- yangyx159654 +- han-sanyue +- xiangzhong007 \ No newline at end of file -- Gitee From 09cdc9ccebe8179ae9f7772680c9d07e85f067e8 Mon Sep 17 00:00:00 2001 From: fangrongcan Date: Thu, 12 Jun 2025 12:14:20 +0000 Subject: [PATCH 3/5] =?UTF-8?q?=E8=A7=A3=E9=99=A4=E4=BB=BF=E7=9C=9F?= =?UTF-8?q?=E9=80=82=E9=85=8Dbug?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: fangrongcan --- .../opensoraplan/layers/conv.py | 7 ++--- .../opensoraplan/layers/updownsample.py | 5 +-- .../models/latte/latte_modules.py | 31 +++++-------------- .../models/latte/modeling_latte.py | 3 +- .../opensoraplan/utils/utils.py | 2 -- 5 files changed, 12 insertions(+), 36 deletions(-) diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/layers/conv.py b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/layers/conv.py index 3bcd7c3201..546a8a4bce 100644 --- a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/layers/conv.py +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/layers/conv.py @@ -100,11 +100,8 @@ class CausalConv3d(nn.Module): output_shape = (n, out_channels, d_out, h_out, w_out) return torch.rand(output_shape, dtype=x.dtype, device=x.device) - if os.getenv("VASCEND", "0") == "1": # "1"仿真环境 - x = generate_random_conv3d_output(x.shape, self.embed_dim, self.patch_size, self.stride, self.padding) - return x - else: - return self.conv(x) + + return self.conv(x) def _init_weights(self, init_method): ks = torch.tensor(self.kernel_size) diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/layers/updownsample.py b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/layers/updownsample.py index 5c058a91e8..740020931e 100644 --- a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/layers/updownsample.py +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/layers/updownsample.py @@ -112,10 +112,7 @@ class SpatialUpsample2x(nn.Module): def forward(self, x): t = x.shape[2] x = rearrange(x, "b c t h w -> b (c t) h w") - if os.getenv("VASCEND", "0") == "1": # "1"仿真环境 - x = mock_interpolate(x, scale_factor=(2, 2), mode="nearest") - else: - x = F.interpolate(x, scale_factor=(2, 2), mode="nearest") + x = F.interpolate(x, scale_factor=(2, 2), mode="nearest") x = rearrange(x, "b (c t) h w -> b c t h w", t=t) x = self.conv(x) return x diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/latte/latte_modules.py b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/latte/latte_modules.py index 9ab3e9fb14..f7798a7954 100644 --- a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/latte/latte_modules.py +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/latte/latte_modules.py @@ -35,7 +35,7 @@ from diffusers.models.attention_processor import SpatialNorm, LORA_ATTENTION_PRO from diffusers.models.activations import GEGLU, GELU, ApproximateGELU from opensoraplan.layers.utils import get_2d_sincos_pos_embed -if os.getenv("VASCEND", "0") != "1" and is_xformers_available(): # "1"仿真环境 +if is_xformers_available(): # "1"仿真环境 import xformers import xformers.ops else: @@ -336,12 +336,9 @@ class AttnProcessor2: ) elif self.attention_mode == 'xformers': with torch.backends.cuda.sdp_kernel(enable_math=False, enable_flash=False, enable_mem_efficient=True): - if os.getenv("VASCEND", "0") == "1": # "1"仿真环境 - hidden_states = query - else: - hidden_states = F.scaled_dot_product_attention( - query, key, value, attn_mask=attention_mask, dropout_p=0.0, is_causal=False - ) + hidden_states = F.scaled_dot_product_attention( + query, key, value, attn_mask=attention_mask, dropout_p=0.0, is_causal=False + ) elif self.attention_mode == 'math': hidden_states = F.scaled_dot_product_attention( query, key, value, attn_mask=attention_mask, dropout_p=0.0, is_causal=False @@ -555,10 +552,7 @@ class BasicTransformerBlockTemporal(nn.Module): shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = ( self.scale_shift_table[None] + timestep.reshape(batch_size, 6, -1) ).chunk(6, dim=1) - if os.getenv("VASCEND", "0") == "1": # "1"仿真环境 - norm_hidden_states = hidden_states - else: - norm_hidden_states = self.norm1(hidden_states) + norm_hidden_states = self.norm1(hidden_states) norm_hidden_states = norm_hidden_states * (1 + scale_msa) + shift_msa norm_hidden_states = norm_hidden_states.squeeze(1) else: @@ -598,10 +592,7 @@ class BasicTransformerBlockTemporal(nn.Module): norm_hidden_states = norm_hidden_states * (1 + scale_mlp[:, None]) + shift_mlp[:, None] if self.use_ada_layer_norm_single: - if os.getenv("VASCEND", "0") == "1": # "1"仿真环境 - norm_hidden_states = hidden_states - else: - norm_hidden_states = self.norm3(hidden_states) + norm_hidden_states = self.norm3(hidden_states) norm_hidden_states = norm_hidden_states * (1 + scale_mlp) + shift_mlp if self._chunk_size is not None: @@ -777,10 +768,7 @@ class BasicTransformerBlock(nn.Module): shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = ( self.scale_shift_table[None] + timestep.reshape(batch_size, 6, -1) ).chunk(6, dim=1) - if os.getenv("VASCEND", "0") == "1": # "1"仿真环境 - norm_hidden_states = hidden_states - else: - norm_hidden_states = self.norm1(hidden_states) + norm_hidden_states = self.norm1(hidden_states) norm_hidden_states = norm_hidden_states * (1 + scale_msa) + shift_msa norm_hidden_states = norm_hidden_states.squeeze(1) else: @@ -839,10 +827,7 @@ class BasicTransformerBlock(nn.Module): # 4. Feed-forward if not self.use_ada_layer_norm_single: - if os.getenv("VASCEND", "0") == "1": # "1"仿真环境 - norm_hidden_states = hidden_states - else: - norm_hidden_states = self.norm3(hidden_states) + norm_hidden_states = self.norm3(hidden_states) if self.use_ada_layer_norm_zero: norm_hidden_states = norm_hidden_states * (1 + scale_mlp[:, None]) + shift_mlp[:, None] diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/latte/modeling_latte.py b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/latte/modeling_latte.py index 7307b4a5d3..139011a757 100644 --- a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/latte/modeling_latte.py +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/models/latte/modeling_latte.py @@ -502,8 +502,7 @@ class LatteT2V(ModelMixin, ConfigMixin): elif self.config.norm_type == ADA_NORM_SINGLE: embedded_timestep = repeat(embedded_timestep, 'b d -> (b f) d', f=frame + use_image_num).contiguous() shift, scale = (self.scale_shift_table[None] + embedded_timestep[:, None]).chunk(2, dim=1) - if os.getenv("VASCEND", "0") != "1": # "1"仿真环境 - hidden_states = self.norm_out(hidden_states) + hidden_states = self.norm_out(hidden_states) # Modulation hidden_states = hidden_states * (1 + scale) + shift hidden_states = self.proj_out(hidden_states) diff --git a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/utils/utils.py b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/utils/utils.py index 02c0196381..813c1c4190 100644 --- a/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/utils/utils.py +++ b/MindIE/MultiModal/OpenSoraPlan-1.0/opensoraplan/utils/utils.py @@ -94,8 +94,6 @@ TIMEOUT_T = 600 def is_npu_available(): "Checks if `torch_npu` is installed and potentially if a NPU is in the environment" - if os.getenv("VASCEND", "0") == "1": # "1"仿真环境 - return True if importlib.util.find_spec("torch") is None or importlib.util.find_spec("torch_npu") is None: return False -- Gitee From 46b5a4d720cab06d7b1b86741964893f5066c247 Mon Sep 17 00:00:00 2001 From: fangrongcan Date: Thu, 12 Jun 2025 12:17:39 +0000 Subject: [PATCH 4/5] =?UTF-8?q?bug=E4=BF=AE=E5=A4=8D?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: fangrongcan --- OWNERS | 190 +++++++++++++++++++++++++-------------------------------- 1 file changed, 83 insertions(+), 107 deletions(-) diff --git a/OWNERS b/OWNERS index 1012e0ab0e..96854f6e27 100644 --- a/OWNERS +++ b/OWNERS @@ -1,120 +1,96 @@ -branch_keeper: -- edmund_hu -- wenbox -- chemsky -- yumiao-hw -- limuyuan3 - approvers: -- msm_ascend -- lujunyi4 -- ZeroFadeAway -- edmund_hu -- wu_yushan -- hu-xiao-bo -- cxy-katrina -- jyoung6652 -- maoxx241 -- xiangsen2 -- he-jianping07 -- kezhan1 -- libliang - -reviewers: -- lu2048 +- wangjiangben_hw +- zhangjunyi08 +- li_jing_hw +- qingfenxiaochong +- liuzhuheng +- gp513 +- block0219 +- dilililiwhy +- fengliangjun66 - wenbox +- Ronnie_zheng +- fighting_zhen +- ginray0215 - kezhan1 +- jyoung6652 - Gongen +- coding-lz +- guowenna +- maoxx241 +- ZeroFadeAway +- onehaitao +- hhhzhuyizhi +reviewers: +- ginray0215 +- matrixplayer +- wangjiangben_hw +- zhangjunyi08 +- li_jing_hw +- qingfenxiaochong +- zheng-wengang1 +- liuzhuheng +- gp513 - block0219 -- filimonovegor -- garyll -- beolus -- li_junyu24 +- dilililiwhy +- fengliangjun66 +- loomischen +- liu-qi-yuan +- onehaitao +- zhuobohang +- yiransun +- xiao-yamin +- mamba_chen +- wenbox - zou-ying -- limuyuan3 -- lirui2017 -- redcyclone -- guohuanliang - hiyangbo -- coding-lz -- wqh17101 -- timeash +- garyll - Ronnie_zheng -- loov -- ZeroFadeAway -- block0219 -- sibylk - dl9864 -- demo-v -- xulianhao -- yangyifei626 -- z2fan -- wenjiang2357 -- wuluotianqing126 -- xiong-liangcheng_admin -- gitee-code-template -- yaojia2021 -- chantcalf -- leizhenzhen -- liuyanghan -- lord_of_ironhill -- wu_mingjing -- cxy-katrina -- msm_ascend -- XHG -- you-zhiyuan-11 -- yuanwei66 -- taojiovo -- kpxing -- zhangxinyuanliuhengyu -- zhouyiiiiii -- wu_yushan -- hw-zhou-tianyang -- XhgAtHuawei -- xuyouyuywj -- git_ray -- ruixuandev -- jerryrual -- yj_1234 +- sibylk +- sunyuqi3 +- fighting_zhen +- sunyi001 +- liu_zhi_xu - han_yifeng - jyoung6652 - maoxx241 - chenchuw -- xqchen007 -- guleo2 -- bigsir007 -- lujunyi4 -- hejingkui -- mayumeng0824 -- jiang-sihantj -- wbj1207 -- imwangyue -- brian-liu9973 -- shoufenghu -- lu2048 -- jiangyuan19 -- tonygaogsm -- cs3n21 -- liu-jiaolonghuawei -- mmjssg -- pjvord -- freyfwt -- Angazenn -- liuzepeng6 -- jsn-jia -- hu-xiao-bo -- shenxinjie -- sunyuqi3 -- chuyuelin -- yht1024 -- y30044005 -- zjks98 -- xiangsen2 -- he-jianping07 -- mueuler -- CLH126 -- littleyellowbicycle -- SoulMeister -- yangyx159654 -- han-sanyue -- xiangzhong007 \ No newline at end of file +- guowenna +- lanwangli +- mazhixin00 +- zhou-wenxue +- huanghao7 +- Gongen +- kezhan1 +- terrychen1982 +- fan2956 +- Yansifu +- yliuls +- shaopeng666 +- coding-lz +- JiayiZhou_1 +- zhengteju +- xinyanhe +- keilo-wang +- WeiChunyu-star +- liutongtong27 +- niushiya +- yeyifan1 +- guo-yucheng +- demo-v +- manyny +- bangbangchui66 +- ZeroFadeAway +- ascend-cxl +- hhhzhuyizhi +- bigdog1206 +- wangze_404 +- lin-mingzhe-hw +- zs-derrick +- leisuzz +- chenhaihui994 +- mr-lin314 +- lu-jinfu1999 +- liyx616 +- chenpeizhe \ No newline at end of file -- Gitee From 1205d18426a45f2f82266ed4aa57fee88e94173c Mon Sep 17 00:00:00 2001 From: fangrongcan Date: Thu, 12 Jun 2025 12:20:54 +0000 Subject: [PATCH 5/5] bug fix Signed-off-by: fangrongcan --- OWNERS | 16 +--------------- 1 file changed, 1 insertion(+), 15 deletions(-) diff --git a/OWNERS b/OWNERS index 96854f6e27..601981ecf2 100644 --- a/OWNERS +++ b/OWNERS @@ -19,8 +19,6 @@ approvers: - guowenna - maoxx241 - ZeroFadeAway -- onehaitao -- hhhzhuyizhi reviewers: - ginray0215 - matrixplayer @@ -81,16 +79,4 @@ reviewers: - demo-v - manyny - bangbangchui66 -- ZeroFadeAway -- ascend-cxl -- hhhzhuyizhi -- bigdog1206 -- wangze_404 -- lin-mingzhe-hw -- zs-derrick -- leisuzz -- chenhaihui994 -- mr-lin314 -- lu-jinfu1999 -- liyx616 -- chenpeizhe \ No newline at end of file +- ZeroFadeAway \ No newline at end of file -- Gitee