diff --git a/.gitattributes b/.gitattributes index 352893b6b6c3763536ca856d98ba1049b6d3c64a..bb8f626d848d5ea2a948b786034d14c7624f9cec 100644 --- a/.gitattributes +++ b/.gitattributes @@ -16,3 +16,4 @@ custom_nodes/ComfyUI-N-Nodes/libs/rifle/demo/I2_0.png filter=lfs diff=lfs merge= custom_nodes/ComfyUI-N-Nodes/libs/rifle/demo/I2_1.png filter=lfs diff=lfs merge=lfs -text custom_nodes/ComfyUI-N-Nodes/libs/rifle/demo/I2_slomo_clipped.gif filter=lfs diff=lfs merge=lfs -text custom_nodes/ComfyUI-N-Nodes/libs/rifle/train_log/flownet.pkl filter=lfs diff=lfs merge=lfs -text +custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/noise_warp_example_input_video.mp4 filter=lfs diff=lfs merge=lfs -text diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/.gitattributes b/custom_nodes/ComfyUI-CogVideoXWrapper/.gitattributes new file mode 100644 index 0000000000000000000000000000000000000000..f13e053bf0ebf99d69b8e28c0f02eb346dcfe15e --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/.gitattributes @@ -0,0 +1,2 @@ +# Auto detect text files and perform LF normalization +* text=auto diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/.github/FUNDING.yml b/custom_nodes/ComfyUI-CogVideoXWrapper/.github/FUNDING.yml new file mode 100644 index 0000000000000000000000000000000000000000..3f53dcd3b72ebc612b9f425af64f8158e48c3f02 --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/.github/FUNDING.yml @@ -0,0 +1,2 @@ +github: [kijai] +custom: ["https://www.paypal.me/kijaidesign"] diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/.github/workflows/publish.yml b/custom_nodes/ComfyUI-CogVideoXWrapper/.github/workflows/publish.yml new file mode 100644 index 0000000000000000000000000000000000000000..90c00b5c5c2a1da4918695ee93b0fa3b72e7836c --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/.github/workflows/publish.yml @@ -0,0 +1,24 @@ +name: Publish to Comfy registry +on: + workflow_dispatch: + push: + branches: + - main + - master + paths: + - "pyproject.toml" + +jobs: + publish-node: + name: Publish Custom Node to registry + runs-on: ubuntu-latest + # if this is a forked repository. Skipping the workflow. + if: github.event.repository.fork == false + steps: + - name: Check out code + uses: actions/checkout@v4 + - name: Publish Custom Node + uses: Comfy-Org/publish-node-action@main + with: + ## Add your own personal access token to your Github Repository secrets and reference it here. + personal_access_token: ${{ secrets.REGISTRY_ACCESS_TOKEN }} diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/.gitignore b/custom_nodes/ComfyUI-CogVideoXWrapper/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..13d8c5bf34e08d1d7dbfa2c53c6c2ba855f22152 --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/.gitignore @@ -0,0 +1,11 @@ +output/ +*__pycache__/ +samples*/ +runs/ +checkpoints/ +master_ip +logs/ +*.DS_Store +.idea +*.pt +tools/ \ No newline at end of file diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/LICENSE b/custom_nodes/ComfyUI-CogVideoXWrapper/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..29f81d812f3e768fa89638d1f72920dbfd1413a8 --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + 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/custom_nodes/ComfyUI-CogVideoXWrapper/__init__.py b/custom_nodes/ComfyUI-CogVideoXWrapper/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e78b873899d29a4b76cfb370938ed8439e410a44 --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/__init__.py @@ -0,0 +1,7 @@ +from .nodes import NODE_CLASS_MAPPINGS as NODES_CLASS, NODE_DISPLAY_NAME_MAPPINGS as NODES_DISPLAY +from .model_loading import NODE_CLASS_MAPPINGS as MODEL_CLASS, NODE_DISPLAY_NAME_MAPPINGS as MODEL_DISPLAY + +NODE_CLASS_MAPPINGS = {**NODES_CLASS, **MODEL_CLASS} +NODE_DISPLAY_NAME_MAPPINGS = {**NODES_DISPLAY, **MODEL_DISPLAY} + +__all__ = ["NODE_CLASS_MAPPINGS", "NODE_DISPLAY_NAME_MAPPINGS"] \ No newline at end of file diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/__init__.cpython-311.pyc b/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4253db0fabc9c227caf43839311c4faa9384d6f1 Binary files /dev/null and b/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/__init__.cpython-311.pyc differ diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/__init__.cpython-312.pyc b/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bf3dee4496dbe8358c91bdd513ea289d46d4d919 Binary files /dev/null and b/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/__init__.cpython-312.pyc differ diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/custom_cogvideox_transformer_3d.cpython-311.pyc b/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/custom_cogvideox_transformer_3d.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..915fa6261f917d4e66bbc06e4400fe219aa4a566 Binary files /dev/null and b/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/custom_cogvideox_transformer_3d.cpython-311.pyc differ diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/custom_cogvideox_transformer_3d.cpython-312.pyc b/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/custom_cogvideox_transformer_3d.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9deda0823f48c3a0b0d54e9ed01d4ea6eff80a56 Binary files /dev/null and b/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/custom_cogvideox_transformer_3d.cpython-312.pyc differ diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/embeddings.cpython-311.pyc b/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/embeddings.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6d360c14f35bf694d3c5115bce40350d52329afa Binary files /dev/null and b/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/embeddings.cpython-311.pyc differ diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/embeddings.cpython-312.pyc b/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/embeddings.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d7ffd47a51e83202a7fce460c2f05b0505ed4124 Binary files /dev/null and b/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/embeddings.cpython-312.pyc differ diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/model_loading.cpython-311.pyc b/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/model_loading.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2601655a652b3b921ee40cf221ce4b7684846e2e Binary files /dev/null and b/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/model_loading.cpython-311.pyc differ diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/model_loading.cpython-312.pyc b/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/model_loading.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..67f19f37a5d5063f8c4f678bf501cf8ed0eea7a5 Binary files /dev/null and b/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/model_loading.cpython-312.pyc differ diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/nodes.cpython-311.pyc b/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/nodes.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..04023a7f27f8565f81aefd2b802e349748d234cb Binary files /dev/null and b/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/nodes.cpython-311.pyc differ diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/nodes.cpython-312.pyc b/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/nodes.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c763ee46e9a17fbcceb5e4cf562e77a87898b5f6 Binary files /dev/null and b/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/nodes.cpython-312.pyc differ diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/pipeline_cogvideox.cpython-311.pyc b/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/pipeline_cogvideox.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d73229631b273c624841139c0453309839272e8c Binary files /dev/null and b/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/pipeline_cogvideox.cpython-311.pyc differ diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/pipeline_cogvideox.cpython-312.pyc b/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/pipeline_cogvideox.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a500c85e8903da0c96238f8c4798139f32f05eec Binary files /dev/null and b/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/pipeline_cogvideox.cpython-312.pyc differ diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/utils.cpython-311.pyc b/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/utils.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c0eb7ebb4f198dc26a6f6dde43574c5b497e6387 Binary files /dev/null and b/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/utils.cpython-311.pyc differ diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/utils.cpython-312.pyc b/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/utils.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..55ae038442631383f2afa02e29f68edfeb4011e0 Binary files /dev/null and b/custom_nodes/ComfyUI-CogVideoXWrapper/__pycache__/utils.cpython-312.pyc differ diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/cogvideo_controlnet.py b/custom_nodes/ComfyUI-CogVideoXWrapper/cogvideo_controlnet.py new file mode 100644 index 0000000000000000000000000000000000000000..9d236735a9c9dc0ebe35b7277648a4784e99873e --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/cogvideo_controlnet.py @@ -0,0 +1,220 @@ +# https://github.com/TheDenk/cogvideox-controlnet/blob/main/cogvideo_controlnet.py +from typing import Any, Dict, Optional, Tuple, Union + +import torch +from torch import nn +from einops import rearrange +import torch.nn.functional as F +from .custom_cogvideox_transformer_3d import Transformer2DModelOutput, CogVideoXBlock +from diffusers.utils import is_torch_version +from diffusers.loaders import PeftAdapterMixin +from diffusers.models.embeddings import CogVideoXPatchEmbed, TimestepEmbedding, Timesteps +from diffusers.models.modeling_utils import ModelMixin +from diffusers.configuration_utils import ConfigMixin, register_to_config + + +class CogVideoXControlnet(ModelMixin, ConfigMixin, PeftAdapterMixin): + _supports_gradient_checkpointing = True + + @register_to_config + def __init__( + self, + num_attention_heads: int = 30, + attention_head_dim: int = 64, + vae_channels: int = 16, + in_channels: int = 3, + downscale_coef: int = 8, + flip_sin_to_cos: bool = True, + freq_shift: int = 0, + time_embed_dim: int = 512, + num_layers: int = 8, + dropout: float = 0.0, + attention_bias: bool = True, + sample_width: int = 90, + sample_height: int = 60, + sample_frames: int = 49, + patch_size: int = 2, + temporal_compression_ratio: int = 4, + max_text_seq_length: int = 226, + activation_fn: str = "gelu-approximate", + timestep_activation_fn: str = "silu", + norm_elementwise_affine: bool = True, + norm_eps: float = 1e-5, + spatial_interpolation_scale: float = 1.875, + temporal_interpolation_scale: float = 1.0, + use_rotary_positional_embeddings: bool = False, + use_learned_positional_embeddings: bool = False, + out_proj_dim = None, + ): + super().__init__() + inner_dim = num_attention_heads * attention_head_dim + + if not use_rotary_positional_embeddings and use_learned_positional_embeddings: + raise ValueError( + "There are no CogVideoX checkpoints available with disable rotary embeddings and learned positional " + "embeddings. If you're using a custom model and/or believe this should be supported, please open an " + "issue at https://github.com/huggingface/diffusers/issues." + ) + + start_channels = in_channels * (downscale_coef ** 2) + input_channels = [start_channels, start_channels // 2, start_channels // 4] + self.unshuffle = nn.PixelUnshuffle(downscale_coef) + + self.controlnet_encode_first = nn.Sequential( + nn.Conv2d(input_channels[0], input_channels[1], kernel_size=1, stride=1, padding=0), + nn.GroupNorm(2, input_channels[1]), + nn.ReLU(), + ) + + self.controlnet_encode_second = nn.Sequential( + nn.Conv2d(input_channels[1], input_channels[2], kernel_size=1, stride=1, padding=0), + nn.GroupNorm(2, input_channels[2]), + nn.ReLU(), + ) + + # 1. Patch embedding + self.patch_embed = CogVideoXPatchEmbed( + patch_size=patch_size, + in_channels=vae_channels + input_channels[2], + embed_dim=inner_dim, + bias=True, + sample_width=sample_width, + sample_height=sample_height, + sample_frames=sample_frames, + temporal_compression_ratio=temporal_compression_ratio, + spatial_interpolation_scale=spatial_interpolation_scale, + temporal_interpolation_scale=temporal_interpolation_scale, + use_positional_embeddings=not use_rotary_positional_embeddings, + use_learned_positional_embeddings=use_learned_positional_embeddings, + ) + + self.embedding_dropout = nn.Dropout(dropout) + + # 2. Time embeddings + self.time_proj = Timesteps(inner_dim, flip_sin_to_cos, freq_shift) + self.time_embedding = TimestepEmbedding(inner_dim, time_embed_dim, timestep_activation_fn) + + # 3. Define spatio-temporal transformers blocks + self.transformer_blocks = nn.ModuleList( + [ + CogVideoXBlock( + dim=inner_dim, + num_attention_heads=num_attention_heads, + attention_head_dim=attention_head_dim, + time_embed_dim=time_embed_dim, + dropout=dropout, + activation_fn=activation_fn, + attention_bias=attention_bias, + norm_elementwise_affine=norm_elementwise_affine, + norm_eps=norm_eps, + ) + for _ in range(num_layers) + ] + ) + + self.out_projectors = None + if out_proj_dim is not None: + self.out_projectors = nn.ModuleList( + [nn.Linear(inner_dim, out_proj_dim) for _ in range(num_layers)] + ) + + self.gradient_checkpointing = False + + def _set_gradient_checkpointing(self, module, value=False): + self.gradient_checkpointing = value + + def compress_time(self, x, num_frames): + x = rearrange(x, '(b f) c h w -> b f c h w', f=num_frames) + batch_size, frames, channels, height, width = x.shape + x = rearrange(x, 'b f c h w -> (b h w) c f') + + if x.shape[-1] % 2 == 1: + x_first, x_rest = x[..., 0], x[..., 1:] + if x_rest.shape[-1] > 0: + x_rest = F.avg_pool1d(x_rest, kernel_size=2, stride=2) + + x = torch.cat([x_first[..., None], x_rest], dim=-1) + else: + x = F.avg_pool1d(x, kernel_size=2, stride=2) + x = rearrange(x, '(b h w) c f -> (b f) c h w', b=batch_size, h=height, w=width) + return x + + def forward( + self, + hidden_states: torch.Tensor, + encoder_hidden_states: torch.Tensor, + controlnet_states: torch.Tensor, + timestep: Union[int, float, torch.LongTensor], + image_rotary_emb: Optional[Tuple[torch.Tensor, torch.Tensor]] = None, + timestep_cond: Optional[torch.Tensor] = None, + return_dict: bool = True, + ): + batch_size, num_frames, channels, height, width = controlnet_states.shape + # 0. Controlnet encoder + controlnet_states = rearrange(controlnet_states, 'b f c h w -> (b f) c h w') + controlnet_states = self.unshuffle(controlnet_states) + controlnet_states = self.controlnet_encode_first(controlnet_states) + controlnet_states = self.compress_time(controlnet_states, num_frames=num_frames) + num_frames = controlnet_states.shape[0] // batch_size + + controlnet_states = self.controlnet_encode_second(controlnet_states) + controlnet_states = self.compress_time(controlnet_states, num_frames=num_frames) + controlnet_states = rearrange(controlnet_states, '(b f) c h w -> b f c h w', b=batch_size) + + hidden_states = torch.cat([hidden_states, controlnet_states], dim=2) + # controlnet_states = self.controlnext_encoder(controlnet_states, timestep=timestep) + # 1. Time embedding + timesteps = timestep + t_emb = self.time_proj(timesteps) + + # timesteps does not contain any weights and will always return f32 tensors + # but time_embedding might actually be running in fp16. so we need to cast here. + # there might be better ways to encapsulate this. + t_emb = t_emb.to(dtype=hidden_states.dtype) + emb = self.time_embedding(t_emb, timestep_cond) + + hidden_states = self.patch_embed(encoder_hidden_states, hidden_states) + hidden_states = self.embedding_dropout(hidden_states) + + + text_seq_length = encoder_hidden_states.shape[1] + encoder_hidden_states = hidden_states[:, :text_seq_length] + hidden_states = hidden_states[:, text_seq_length:] + + + controlnet_hidden_states = () + # 3. Transformer blocks + for i, block in enumerate(self.transformer_blocks): + if self.training and self.gradient_checkpointing: + + def create_custom_forward(module): + def custom_forward(*inputs): + return module(*inputs) + + return custom_forward + + ckpt_kwargs: Dict[str, Any] = {"use_reentrant": False} if is_torch_version(">=", "1.11.0") else {} + hidden_states, encoder_hidden_states = torch.utils.checkpoint.checkpoint( + create_custom_forward(block), + hidden_states, + encoder_hidden_states, + emb, + image_rotary_emb, + **ckpt_kwargs, + ) + else: + hidden_states, encoder_hidden_states = block( + hidden_states=hidden_states, + encoder_hidden_states=encoder_hidden_states, + temb=emb, + image_rotary_emb=image_rotary_emb, + ) + + if self.out_projectors is not None: + controlnet_hidden_states += (self.out_projectors[i](hidden_states),) + else: + controlnet_hidden_states += (hidden_states,) + + if not return_dict: + return (controlnet_hidden_states,) + return Transformer2DModelOutput(sample=controlnet_hidden_states) \ No newline at end of file diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/cogvideox_fun/utils.py b/custom_nodes/ComfyUI-CogVideoXWrapper/cogvideox_fun/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..09d934f3131652598c9bb4aa3f2f3b68a89af256 --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/cogvideox_fun/utils.py @@ -0,0 +1,43 @@ +import numpy as np +from PIL import Image + +ASPECT_RATIO_512 = { + '0.25': [256.0, 1024.0], '0.26': [256.0, 992.0], '0.27': [256.0, 960.0], '0.28': [256.0, 928.0], + '0.32': [288.0, 896.0], '0.33': [288.0, 864.0], '0.35': [288.0, 832.0], '0.4': [320.0, 800.0], + '0.42': [320.0, 768.0], '0.48': [352.0, 736.0], '0.5': [352.0, 704.0], '0.52': [352.0, 672.0], + '0.57': [384.0, 672.0], '0.6': [384.0, 640.0], '0.68': [416.0, 608.0], '0.72': [416.0, 576.0], + '0.78': [448.0, 576.0], '0.82': [448.0, 544.0], '0.88': [480.0, 544.0], '0.94': [480.0, 512.0], + '1.0': [512.0, 512.0], '1.07': [512.0, 480.0], '1.13': [544.0, 480.0], '1.21': [544.0, 448.0], + '1.29': [576.0, 448.0], '1.38': [576.0, 416.0], '1.46': [608.0, 416.0], '1.67': [640.0, 384.0], + '1.75': [672.0, 384.0], '2.0': [704.0, 352.0], '2.09': [736.0, 352.0], '2.4': [768.0, 320.0], + '2.5': [800.0, 320.0], '2.89': [832.0, 288.0], '3.0': [864.0, 288.0], '3.11': [896.0, 288.0], + '3.62': [928.0, 256.0], '3.75': [960.0, 256.0], '3.88': [992.0, 256.0], '4.0': [1024.0, 256.0] +} +ASPECT_RATIO_RANDOM_CROP_512 = { + '0.42': [320.0, 768.0], '0.5': [352.0, 704.0], + '0.57': [384.0, 672.0], '0.68': [416.0, 608.0], '0.78': [448.0, 576.0], '0.88': [480.0, 544.0], + '0.94': [480.0, 512.0], '1.0': [512.0, 512.0], '1.07': [512.0, 480.0], + '1.13': [544.0, 480.0], '1.29': [576.0, 448.0], '1.46': [608.0, 416.0], '1.75': [672.0, 384.0], + '2.0': [704.0, 352.0], '2.4': [768.0, 320.0] +} +ASPECT_RATIO_RANDOM_CROP_PROB = [ + 1, 2, + 4, 4, 4, 4, + 8, 8, 8, + 4, 4, 4, 4, + 2, 1 +] +ASPECT_RATIO_RANDOM_CROP_PROB = np.array(ASPECT_RATIO_RANDOM_CROP_PROB) / sum(ASPECT_RATIO_RANDOM_CROP_PROB) + +def get_closest_ratio(height: float, width: float, ratios: dict = ASPECT_RATIO_512): + aspect_ratio = height / width + closest_ratio = min(ratios.keys(), key=lambda ratio: abs(float(ratio) - aspect_ratio)) + return ratios[closest_ratio], float(closest_ratio) + +def get_width_and_height_from_image_and_base_resolution(image, base_resolution): + target_pixels = int(base_resolution) * int(base_resolution) + original_width, original_height = Image.open(image).size + ratio = (target_pixels / (original_width * original_height)) ** 0.5 + width_slider = round(original_width * ratio) + height_slider = round(original_height * ratio) + return height_slider, width_slider \ No newline at end of file diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/configs/scheduler_config_2b.json b/custom_nodes/ComfyUI-CogVideoXWrapper/configs/scheduler_config_2b.json new file mode 100644 index 0000000000000000000000000000000000000000..5ac9345663bea72e1e9771a598c7cc3d02743d0b --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/configs/scheduler_config_2b.json @@ -0,0 +1,18 @@ +{ + "_class_name": "CogVideoXDDIMScheduler", + "_diffusers_version": "0.30.0.dev0", + "beta_end": 0.012, + "beta_schedule": "scaled_linear", + "beta_start": 0.00085, + "clip_sample": false, + "clip_sample_range": 1.0, + "num_train_timesteps": 1000, + "prediction_type": "v_prediction", + "rescale_betas_zero_snr": true, + "sample_max_value": 1.0, + "set_alpha_to_one": true, + "snr_shift_scale": 3.0, + "steps_offset": 0, + "timestep_spacing": "trailing", + "trained_betas": null +} diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/configs/scheduler_config_5b.json b/custom_nodes/ComfyUI-CogVideoXWrapper/configs/scheduler_config_5b.json new file mode 100644 index 0000000000000000000000000000000000000000..e7517263d6bf421bf29e0b965bec69c912619809 --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/configs/scheduler_config_5b.json @@ -0,0 +1,18 @@ +{ + "_class_name": "CogVideoXDDIMScheduler", + "_diffusers_version": "0.31.0.dev0", + "beta_end": 0.012, + "beta_schedule": "scaled_linear", + "beta_start": 0.00085, + "clip_sample": false, + "clip_sample_range": 1.0, + "num_train_timesteps": 1000, + "prediction_type": "v_prediction", + "rescale_betas_zero_snr": true, + "sample_max_value": 1.0, + "set_alpha_to_one": true, + "snr_shift_scale": 1.0, + "steps_offset": 0, + "timestep_spacing": "trailing", + "trained_betas": null +} \ No newline at end of file diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/configs/transformer_config_2b.json b/custom_nodes/ComfyUI-CogVideoXWrapper/configs/transformer_config_2b.json new file mode 100644 index 0000000000000000000000000000000000000000..928ff1d0c2ddc381ee9e8b1d99d1753b8720aa53 --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/configs/transformer_config_2b.json @@ -0,0 +1,26 @@ +{ + "activation_fn": "gelu-approximate", + "attention_bias": true, + "attention_head_dim": 64, + "dropout": 0.0, + "flip_sin_to_cos": true, + "freq_shift": 0, + "in_channels": 16, + "max_text_seq_length": 226, + "norm_elementwise_affine": true, + "norm_eps": 1e-05, + "num_attention_heads": 30, + "num_layers": 30, + "out_channels": 16, + "patch_size": 2, + "sample_frames": 49, + "sample_height": 60, + "sample_width": 90, + "spatial_interpolation_scale": 1.875, + "temporal_compression_ratio": 4, + "temporal_interpolation_scale": 1.0, + "text_embed_dim": 4096, + "time_embed_dim": 512, + "timestep_activation_fn": "silu", + "use_rotary_positional_embeddings": false + } \ No newline at end of file diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/configs/transformer_config_5b.json b/custom_nodes/ComfyUI-CogVideoXWrapper/configs/transformer_config_5b.json new file mode 100644 index 0000000000000000000000000000000000000000..3b4d28dae9680c2bead184196febe27826e56f69 --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/configs/transformer_config_5b.json @@ -0,0 +1,26 @@ +{ + "activation_fn": "gelu-approximate", + "attention_bias": true, + "attention_head_dim": 64, + "dropout": 0.0, + "flip_sin_to_cos": true, + "freq_shift": 0, + "in_channels": 16, + "max_text_seq_length": 226, + "norm_elementwise_affine": true, + "norm_eps": 1e-05, + "num_attention_heads": 48, + "num_layers": 42, + "out_channels": 16, + "patch_size": 2, + "sample_frames": 49, + "sample_height": 60, + "sample_width": 90, + "spatial_interpolation_scale": 1.875, + "temporal_compression_ratio": 4, + "temporal_interpolation_scale": 1.0, + "text_embed_dim": 4096, + "time_embed_dim": 512, + "timestep_activation_fn": "silu", + "use_rotary_positional_embeddings": true + } \ No newline at end of file diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/configs/transformer_config_I2V_5b.json b/custom_nodes/ComfyUI-CogVideoXWrapper/configs/transformer_config_I2V_5b.json new file mode 100644 index 0000000000000000000000000000000000000000..3768d65ad8e300c1a47192392ad65cc3826e6ecb --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/configs/transformer_config_I2V_5b.json @@ -0,0 +1,27 @@ +{ + "activation_fn": "gelu-approximate", + "attention_bias": true, + "attention_head_dim": 64, + "dropout": 0.0, + "flip_sin_to_cos": true, + "freq_shift": 0, + "in_channels": 32, + "max_text_seq_length": 226, + "norm_elementwise_affine": true, + "norm_eps": 1e-05, + "num_attention_heads": 48, + "num_layers": 42, + "out_channels": 16, + "patch_size": 2, + "sample_frames": 49, + "sample_height": 60, + "sample_width": 90, + "spatial_interpolation_scale": 1.875, + "temporal_compression_ratio": 4, + "temporal_interpolation_scale": 1.0, + "text_embed_dim": 4096, + "time_embed_dim": 512, + "timestep_activation_fn": "silu", + "use_learned_positional_embeddings": true, + "use_rotary_positional_embeddings": true + } \ No newline at end of file diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/configs/vae_config.json b/custom_nodes/ComfyUI-CogVideoXWrapper/configs/vae_config.json new file mode 100644 index 0000000000000000000000000000000000000000..c2a2532b2bd5fd4a1ba72f2fcc7978727db2bb33 --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/configs/vae_config.json @@ -0,0 +1,39 @@ +{ + "_class_name": "AutoencoderKLCogVideoX", + "_diffusers_version": "0.31.0.dev0", + "act_fn": "silu", + "block_out_channels": [ + 128, + 256, + 256, + 512 + ], + "down_block_types": [ + "CogVideoXDownBlock3D", + "CogVideoXDownBlock3D", + "CogVideoXDownBlock3D", + "CogVideoXDownBlock3D" + ], + "force_upcast": true, + "in_channels": 3, + "latent_channels": 16, + "latents_mean": null, + "latents_std": null, + "layers_per_block": 3, + "norm_eps": 1e-06, + "norm_num_groups": 32, + "out_channels": 3, + "sample_height": 480, + "sample_width": 720, + "scaling_factor": 0.7, + "shift_factor": null, + "temporal_compression_ratio": 4, + "up_block_types": [ + "CogVideoXUpBlock3D", + "CogVideoXUpBlock3D", + "CogVideoXUpBlock3D", + "CogVideoXUpBlock3D" + ], + "use_post_quant_conv": false, + "use_quant_conv": false +} diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/context.py b/custom_nodes/ComfyUI-CogVideoXWrapper/context.py new file mode 100644 index 0000000000000000000000000000000000000000..e972554647ef0babe6af288726495a5b4b214085 --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/context.py @@ -0,0 +1,184 @@ +import numpy as np +from typing import Callable, Optional, List + + +def ordered_halving(val): + bin_str = f"{val:064b}" + bin_flip = bin_str[::-1] + as_int = int(bin_flip, 2) + + return as_int / (1 << 64) + +def does_window_roll_over(window: list[int], num_frames: int) -> tuple[bool, int]: + prev_val = -1 + for i, val in enumerate(window): + val = val % num_frames + if val < prev_val: + return True, i + prev_val = val + return False, -1 + +def shift_window_to_start(window: list[int], num_frames: int): + start_val = window[0] + for i in range(len(window)): + # 1) subtract each element by start_val to move vals relative to the start of all frames + # 2) add num_frames and take modulus to get adjusted vals + window[i] = ((window[i] - start_val) + num_frames) % num_frames + +def shift_window_to_end(window: list[int], num_frames: int): + # 1) shift window to start + shift_window_to_start(window, num_frames) + end_val = window[-1] + end_delta = num_frames - end_val - 1 + for i in range(len(window)): + # 2) add end_delta to each val to slide windows to end + window[i] = window[i] + end_delta + +def get_missing_indexes(windows: list[list[int]], num_frames: int) -> list[int]: + all_indexes = list(range(num_frames)) + for w in windows: + for val in w: + try: + all_indexes.remove(val) + except ValueError: + pass + return all_indexes + +def uniform_looped( + step: int = ..., + num_steps: Optional[int] = None, + num_frames: int = ..., + context_size: Optional[int] = None, + context_stride: int = 3, + context_overlap: int = 4, + closed_loop: bool = True, +): + if num_frames <= context_size: + yield list(range(num_frames)) + return + + context_stride = min(context_stride, int(np.ceil(np.log2(num_frames / context_size))) + 1) + + for context_step in 1 << np.arange(context_stride): + pad = int(round(num_frames * ordered_halving(step))) + for j in range( + int(ordered_halving(step) * context_step) + pad, + num_frames + pad + (0 if closed_loop else -context_overlap), + (context_size * context_step - context_overlap), + ): + yield [e % num_frames for e in range(j, j + context_size * context_step, context_step)] + +#from AnimateDiff-Evolved by Kosinkadink (https://github.com/Kosinkadink/ComfyUI-AnimateDiff-Evolved) +def uniform_standard( + step: int = ..., + num_steps: Optional[int] = None, + num_frames: int = ..., + context_size: Optional[int] = None, + context_stride: int = 3, + context_overlap: int = 4, + closed_loop: bool = True, +): + windows = [] + if num_frames <= context_size: + windows.append(list(range(num_frames))) + return windows + + context_stride = min(context_stride, int(np.ceil(np.log2(num_frames / context_size))) + 1) + + for context_step in 1 << np.arange(context_stride): + pad = int(round(num_frames * ordered_halving(step))) + for j in range( + int(ordered_halving(step) * context_step) + pad, + num_frames + pad + (0 if closed_loop else -context_overlap), + (context_size * context_step - context_overlap), + ): + windows.append([e % num_frames for e in range(j, j + context_size * context_step, context_step)]) + + # now that windows are created, shift any windows that loop, and delete duplicate windows + delete_idxs = [] + win_i = 0 + while win_i < len(windows): + # if window is rolls over itself, need to shift it + is_roll, roll_idx = does_window_roll_over(windows[win_i], num_frames) + if is_roll: + roll_val = windows[win_i][roll_idx] # roll_val might not be 0 for windows of higher strides + shift_window_to_end(windows[win_i], num_frames=num_frames) + # check if next window (cyclical) is missing roll_val + if roll_val not in windows[(win_i+1) % len(windows)]: + # need to insert new window here - just insert window starting at roll_val + windows.insert(win_i+1, list(range(roll_val, roll_val + context_size))) + # delete window if it's not unique + for pre_i in range(0, win_i): + if windows[win_i] == windows[pre_i]: + delete_idxs.append(win_i) + break + win_i += 1 + + # reverse delete_idxs so that they will be deleted in an order that doesn't break idx correlation + delete_idxs.reverse() + for i in delete_idxs: + windows.pop(i) + return windows + +def static_standard( + step: int = ..., + num_steps: Optional[int] = None, + num_frames: int = ..., + context_size: Optional[int] = None, + context_stride: int = 3, + context_overlap: int = 4, + closed_loop: bool = True, +): + windows = [] + if num_frames <= context_size: + windows.append(list(range(num_frames))) + return windows + # always return the same set of windows + delta = context_size - context_overlap + for start_idx in range(0, num_frames, delta): + # if past the end of frames, move start_idx back to allow same context_length + ending = start_idx + context_size + if ending >= num_frames: + final_delta = ending - num_frames + final_start_idx = start_idx - final_delta + windows.append(list(range(final_start_idx, final_start_idx + context_size))) + break + windows.append(list(range(start_idx, start_idx + context_size))) + return windows + +def get_context_scheduler(name: str) -> Callable: + if name == "uniform_looped": + return uniform_looped + elif name == "uniform_standard": + return uniform_standard + elif name == "static_standard": + return static_standard + else: + raise ValueError(f"Unknown context_overlap policy {name}") + + +def get_total_steps( + scheduler, + timesteps: List[int], + num_steps: Optional[int] = None, + num_frames: int = ..., + context_size: Optional[int] = None, + context_stride: int = 3, + context_overlap: int = 4, + closed_loop: bool = True, +): + return sum( + len( + list( + scheduler( + i, + num_steps, + num_frames, + context_size, + context_stride, + context_overlap, + ) + ) + ) + for i in range(len(timesteps)) + ) diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/custom_cogvideox_transformer_3d.py b/custom_nodes/ComfyUI-CogVideoXWrapper/custom_cogvideox_transformer_3d.py new file mode 100644 index 0000000000000000000000000000000000000000..5b08651d170cc13a97d78d3ffe9d63c9a6ba5eef --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/custom_cogvideox_transformer_3d.py @@ -0,0 +1,779 @@ +# Copyright 2024 The CogVideoX team, Tsinghua University & ZhipuAI and The HuggingFace Team. +# 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 typing import Any, Dict, Optional, Tuple, Union + +import torch +from torch import nn +import torch.nn.functional as F + +import numpy as np +from einops import rearrange + +from diffusers.configuration_utils import ConfigMixin, register_to_config +from diffusers.utils import logging +from diffusers.utils.torch_utils import maybe_allow_in_graph +from diffusers.models.attention import Attention, FeedForward +from diffusers.models.attention_processor import AttentionProcessor +from diffusers.models.embeddings import TimestepEmbedding, Timesteps +from diffusers.models.modeling_outputs import Transformer2DModelOutput +from diffusers.models.modeling_utils import ModelMixin +from diffusers.models.normalization import AdaLayerNorm, CogVideoXLayerNormZero +from diffusers.loaders import PeftAdapterMixin +from diffusers.models.embeddings import apply_rotary_emb +from .embeddings import CogVideoXPatchEmbed + +from .enhance_a_video.enhance import get_feta_scores +from .enhance_a_video.globals import is_enhance_enabled, set_num_frames + + +logger = logging.get_logger(__name__) # pylint: disable=invalid-name + +try: + from sageattention import sageattn + SAGEATTN_IS_AVAILABLE = True +except: + SAGEATTN_IS_AVAILABLE = False + +from comfy.ldm.modules.attention import optimized_attention + + +def set_attention_func(attention_mode, heads): + if attention_mode == "sdpa" or attention_mode == "fused_sdpa": + def func(q, k, v, is_causal=False, attn_mask=None): + return F.scaled_dot_product_attention(q, k, v, attn_mask=attn_mask, dropout_p=0.0, is_causal=is_causal) + return func + elif attention_mode == "comfy": + def func(q, k, v, is_causal=False, attn_mask=None): + return optimized_attention(q, k, v, mask=attn_mask, heads=heads, skip_reshape=True) + return func + + elif attention_mode == "sageattn" or attention_mode == "fused_sageattn": + @torch.compiler.disable() + def func(q, k, v, is_causal=False, attn_mask=None): + return sageattn(q.to(v), k.to(v), v, is_causal=is_causal, attn_mask=attn_mask) + return func + elif attention_mode == "sageattn_qk_int8_pv_fp16_cuda": + from sageattention import sageattn_qk_int8_pv_fp16_cuda + @torch.compiler.disable() + def func(q, k, v, is_causal=False, attn_mask=None): + return sageattn_qk_int8_pv_fp16_cuda(q.to(v), k.to(v), v, is_causal=is_causal, attn_mask=attn_mask, pv_accum_dtype="fp32") + return func + elif attention_mode == "sageattn_qk_int8_pv_fp16_triton": + from sageattention import sageattn_qk_int8_pv_fp16_triton + @torch.compiler.disable() + def func(q, k, v, is_causal=False, attn_mask=None): + return sageattn_qk_int8_pv_fp16_triton(q.to(v), k.to(v), v, is_causal=is_causal, attn_mask=attn_mask) + return func + elif attention_mode == "sageattn_qk_int8_pv_fp8_cuda": + from sageattention import sageattn_qk_int8_pv_fp8_cuda + @torch.compiler.disable() + def func(q, k, v, is_causal=False, attn_mask=None): + return sageattn_qk_int8_pv_fp8_cuda(q.to(v), k.to(v), v, is_causal=is_causal, attn_mask=attn_mask, pv_accum_dtype="fp32+fp32") + return func + +#for fastercache +def fft(tensor): + tensor_fft = torch.fft.fft2(tensor) + tensor_fft_shifted = torch.fft.fftshift(tensor_fft) + B, C, H, W = tensor.size() + radius = min(H, W) // 5 + + Y, X = torch.meshgrid(torch.arange(H), torch.arange(W)) + center_x, center_y = W // 2, H // 2 + mask = (X - center_x) ** 2 + (Y - center_y) ** 2 <= radius ** 2 + low_freq_mask = mask.unsqueeze(0).unsqueeze(0).to(tensor.device) + high_freq_mask = ~low_freq_mask + + low_freq_fft = tensor_fft_shifted * low_freq_mask + high_freq_fft = tensor_fft_shifted * high_freq_mask + + return low_freq_fft, high_freq_fft + +#for teacache +def poly1d(coefficients, x): + result = torch.zeros_like(x) + for i, coeff in enumerate(coefficients): + result += coeff * (x ** (len(coefficients) - 1 - i)) + return result.abs() + +#region Attention +class CogVideoXAttnProcessor2_0: + r""" + Processor for implementing scaled dot-product attention for the CogVideoX model. It applies a rotary embedding on + query and key vectors, but does not include spatial normalization. + """ + + def __init__(self, attn_func, attention_mode: Optional[str] = None): + if not hasattr(F, "scaled_dot_product_attention"): + raise ImportError("CogVideoXAttnProcessor requires PyTorch 2.0, to use it, please upgrade PyTorch to 2.0.") + self.attention_mode = attention_mode + self.attn_func = attn_func + def __call__( + self, + attn: Attention, + hidden_states: torch.Tensor, + encoder_hidden_states: torch.Tensor, + attention_mask: Optional[torch.Tensor] = None, + image_rotary_emb: Optional[torch.Tensor] = None, + ) -> torch.Tensor: + text_seq_length = encoder_hidden_states.size(1) + + hidden_states = torch.cat([encoder_hidden_states, hidden_states], dim=1) + + 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) + attention_mask = attention_mask.view(batch_size, attn.heads, -1, attention_mask.shape[-1]) + + if attn.to_q.weight.dtype == torch.float16 or attn.to_q.weight.dtype == torch.bfloat16: + hidden_states = hidden_states.to(attn.to_q.weight.dtype) + + if not "fused" in self.attention_mode: + query = attn.to_q(hidden_states) + key = attn.to_k(hidden_states) + value = attn.to_v(hidden_states) + else: + qkv = attn.to_qkv(hidden_states) + split_size = qkv.shape[-1] // 3 + query, key, value = torch.split(qkv, split_size, dim=-1) + + 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) + + if attn.norm_q is not None: + query = attn.norm_q(query) + if attn.norm_k is not None: + key = attn.norm_k(key) + + # Apply RoPE if needed + if image_rotary_emb is not None: + query[:, :, text_seq_length:] = apply_rotary_emb(query[:, :, text_seq_length:], image_rotary_emb) + if not attn.is_cross_attention: + key[:, :, text_seq_length:] = apply_rotary_emb(key[:, :, text_seq_length:], image_rotary_emb) + + #feta + if is_enhance_enabled(): + feta_scores = get_feta_scores(attn, query, key, head_dim, text_seq_length) + + hidden_states = self.attn_func(query, key, value, attn_mask=attention_mask, is_causal=False) + + if self.attention_mode != "comfy": + hidden_states = hidden_states.transpose(1, 2).reshape(batch_size, -1, attn.heads * head_dim) + + # linear proj + hidden_states = attn.to_out[0](hidden_states) + # dropout + hidden_states = attn.to_out[1](hidden_states) + + encoder_hidden_states, hidden_states = hidden_states.split( + [text_seq_length, hidden_states.size(1) - text_seq_length], dim=1 + ) + + if is_enhance_enabled(): + hidden_states *= feta_scores + + return hidden_states, encoder_hidden_states + +#region Blocks +@maybe_allow_in_graph +class CogVideoXBlock(nn.Module): + + r""" + Transformer block used in [CogVideoX](https://github.com/THUDM/CogVideo) model. + + Parameters: + dim (`int`): + The number of channels in the input and output. + num_attention_heads (`int`): + The number of heads to use for multi-head attention. + attention_head_dim (`int`): + The number of channels in each head. + time_embed_dim (`int`): + The number of channels in timestep embedding. + dropout (`float`, defaults to `0.0`): + The dropout probability to use. + activation_fn (`str`, defaults to `"gelu-approximate"`): + Activation function to be used in feed-forward. + attention_bias (`bool`, defaults to `False`): + Whether or not to use bias in attention projection layers. + qk_norm (`bool`, defaults to `True`): + Whether or not to use normalization after query and key projections in Attention. + norm_elementwise_affine (`bool`, defaults to `True`): + Whether to use learnable elementwise affine parameters for normalization. + norm_eps (`float`, defaults to `1e-5`): + Epsilon value for normalization layers. + final_dropout (`bool` defaults to `False`): + Whether to apply a final dropout after the last feed-forward layer. + ff_inner_dim (`int`, *optional*, defaults to `None`): + Custom hidden dimension of Feed-forward layer. If not provided, `4 * dim` is used. + ff_bias (`bool`, defaults to `True`): + Whether or not to use bias in Feed-forward layer. + attention_out_bias (`bool`, defaults to `True`): + Whether or not to use bias in Attention output projection layer. + """ + + def __init__( + self, + dim: int, + num_attention_heads: int, + attention_head_dim: int, + time_embed_dim: int, + dropout: float = 0.0, + activation_fn: str = "gelu-approximate", + attention_bias: bool = False, + qk_norm: bool = True, + norm_elementwise_affine: bool = True, + norm_eps: float = 1e-5, + final_dropout: bool = True, + ff_inner_dim: Optional[int] = None, + ff_bias: bool = True, + attention_out_bias: bool = True, + attention_mode: Optional[str] = "sdpa", + ): + super().__init__() + + # 1. Self Attention + self.norm1 = CogVideoXLayerNormZero(time_embed_dim, dim, norm_elementwise_affine, norm_eps, bias=True) + + attn_func = set_attention_func(attention_mode, num_attention_heads) + + self.attn1 = Attention( + query_dim=dim, + dim_head=attention_head_dim, + heads=num_attention_heads, + qk_norm="layer_norm" if qk_norm else None, + eps=1e-6, + bias=attention_bias, + out_bias=attention_out_bias, + processor=CogVideoXAttnProcessor2_0(attn_func, attention_mode=attention_mode), + ) + + # 2. Feed Forward + self.norm2 = CogVideoXLayerNormZero(time_embed_dim, dim, norm_elementwise_affine, norm_eps, bias=True) + + self.ff = FeedForward( + dim, + dropout=dropout, + activation_fn=activation_fn, + final_dropout=final_dropout, + inner_dim=ff_inner_dim, + bias=ff_bias, + ) + self.cached_hidden_states = [] + self.cached_encoder_hidden_states = [] + + def forward( + self, + hidden_states: torch.Tensor, + encoder_hidden_states: torch.Tensor, + temb: torch.Tensor, + image_rotary_emb: Optional[Tuple[torch.Tensor, torch.Tensor]] = None, + video_flow_feature: Optional[torch.Tensor] = None, + fuser=None, + block_use_fastercache=False, + fastercache_counter=0, + fastercache_start_step=15, + fastercache_device="cuda:0", + ) -> torch.Tensor: + #print("hidden_states in block: ", hidden_states.shape) #1.5: torch.Size([2, 3200, 3072]) 10.: torch.Size([2, 6400, 3072]) + text_seq_length = encoder_hidden_states.size(1) + + # norm & modulate + norm_hidden_states, norm_encoder_hidden_states, gate_msa, enc_gate_msa = self.norm1( + hidden_states, encoder_hidden_states, temb + ) + #print("norm_hidden_states in block: ", norm_hidden_states.shape) #torch.Size([2, 3200, 3072]) + + # Tora Motion-guidance Fuser + if video_flow_feature is not None: + H, W = video_flow_feature.shape[-2:] + T = norm_hidden_states.shape[1] // H // W + h = rearrange(norm_hidden_states, "B (T H W) C -> (B T) C H W", H=H, W=W) + h = fuser(h, video_flow_feature.to(h), T=T) + norm_hidden_states = rearrange(h, "(B T) C H W -> B (T H W) C", T=T) + del h, fuser + + #region fastercache + if block_use_fastercache: + B = norm_hidden_states.shape[0] + if fastercache_counter >= fastercache_start_step + 3 and fastercache_counter%3!=0 and self.cached_hidden_states[-1].shape[0] >= B: + attn_hidden_states = ( + self.cached_hidden_states[1][:B] + + (self.cached_hidden_states[1][:B] - self.cached_hidden_states[0][:B]) + * 0.3 + ).to(norm_hidden_states.device, non_blocking=True) + attn_encoder_hidden_states = ( + self.cached_encoder_hidden_states[1][:B] + + (self.cached_encoder_hidden_states[1][:B] - self.cached_encoder_hidden_states[0][:B]) + * 0.3 + ).to(norm_hidden_states.device, non_blocking=True) + else: + attn_hidden_states, attn_encoder_hidden_states = self.attn1( + hidden_states=norm_hidden_states, + encoder_hidden_states=norm_encoder_hidden_states, + image_rotary_emb=image_rotary_emb, + ) + if fastercache_counter == fastercache_start_step: + self.cached_hidden_states = [attn_hidden_states.to(fastercache_device), attn_hidden_states.to(fastercache_device)] + self.cached_encoder_hidden_states = [attn_encoder_hidden_states.to(fastercache_device), attn_encoder_hidden_states.to(fastercache_device)] + elif fastercache_counter > fastercache_start_step: + self.cached_hidden_states[-1].copy_(attn_hidden_states.to(fastercache_device)) + self.cached_encoder_hidden_states[-1].copy_(attn_encoder_hidden_states.to(fastercache_device)) + else: + attn_hidden_states, attn_encoder_hidden_states = self.attn1( + hidden_states=norm_hidden_states, + encoder_hidden_states=norm_encoder_hidden_states, + image_rotary_emb=image_rotary_emb + ) + + hidden_states = hidden_states + gate_msa * attn_hidden_states + encoder_hidden_states = encoder_hidden_states + enc_gate_msa * attn_encoder_hidden_states + + # norm & modulate + + norm_hidden_states, norm_encoder_hidden_states, gate_ff, enc_gate_ff = self.norm2( + hidden_states, encoder_hidden_states, temb + ) + + # feed-forward + norm_hidden_states = torch.cat([norm_encoder_hidden_states, norm_hidden_states], dim=1) + ff_output = self.ff(norm_hidden_states) + + hidden_states = hidden_states + gate_ff * ff_output[:, text_seq_length:] + encoder_hidden_states = encoder_hidden_states + enc_gate_ff * ff_output[:, :text_seq_length] + + return hidden_states, encoder_hidden_states + +#region Transformer +class CogVideoXTransformer3DModel(ModelMixin, ConfigMixin, PeftAdapterMixin): + """ + A Transformer model for video-like data in [CogVideoX](https://github.com/THUDM/CogVideo). + + Parameters: + num_attention_heads (`int`, defaults to `30`): + The number of heads to use for multi-head attention. + attention_head_dim (`int`, defaults to `64`): + The number of channels in each head. + in_channels (`int`, defaults to `16`): + The number of channels in the input. + out_channels (`int`, *optional*, defaults to `16`): + The number of channels in the output. + flip_sin_to_cos (`bool`, defaults to `True`): + Whether to flip the sin to cos in the time embedding. + time_embed_dim (`int`, defaults to `512`): + Output dimension of timestep embeddings. + text_embed_dim (`int`, defaults to `4096`): + Input dimension of text embeddings from the text encoder. + num_layers (`int`, defaults to `30`): + The number of layers of Transformer blocks to use. + dropout (`float`, defaults to `0.0`): + The dropout probability to use. + attention_bias (`bool`, defaults to `True`): + Whether or not to use bias in the attention projection layers. + sample_width (`int`, defaults to `90`): + The width of the input latents. + sample_height (`int`, defaults to `60`): + The height of the input latents. + sample_frames (`int`, defaults to `49`): + The number of frames in the input latents. Note that this parameter was incorrectly initialized to 49 + instead of 13 because CogVideoX processed 13 latent frames at once in its default and recommended settings, + but cannot be changed to the correct value to ensure backwards compatibility. To create a transformer with + K latent frames, the correct value to pass here would be: ((K - 1) * temporal_compression_ratio + 1). + patch_size (`int`, defaults to `2`): + The size of the patches to use in the patch embedding layer. + temporal_compression_ratio (`int`, defaults to `4`): + The compression ratio across the temporal dimension. See documentation for `sample_frames`. + max_text_seq_length (`int`, defaults to `226`): + The maximum sequence length of the input text embeddings. + activation_fn (`str`, defaults to `"gelu-approximate"`): + Activation function to use in feed-forward. + timestep_activation_fn (`str`, defaults to `"silu"`): + Activation function to use when generating the timestep embeddings. + norm_elementwise_affine (`bool`, defaults to `True`): + Whether or not to use elementwise affine in normalization layers. + norm_eps (`float`, defaults to `1e-5`): + The epsilon value to use in normalization layers. + spatial_interpolation_scale (`float`, defaults to `1.875`): + Scaling factor to apply in 3D positional embeddings across spatial dimensions. + temporal_interpolation_scale (`float`, defaults to `1.0`): + Scaling factor to apply in 3D positional embeddings across temporal dimensions. + """ + + _supports_gradient_checkpointing = True + + @register_to_config + def __init__( + self, + num_attention_heads: int = 30, + attention_head_dim: int = 64, + in_channels: int = 16, + out_channels: Optional[int] = 16, + flip_sin_to_cos: bool = True, + freq_shift: int = 0, + time_embed_dim: int = 512, + ofs_embed_dim: Optional[int] = None, + text_embed_dim: int = 4096, + num_layers: int = 30, + dropout: float = 0.0, + attention_bias: bool = True, + sample_width: int = 90, + sample_height: int = 60, + sample_frames: int = 49, + patch_size: int = 2, + patch_size_t: int = None, + temporal_compression_ratio: int = 4, + max_text_seq_length: int = 226, + activation_fn: str = "gelu-approximate", + timestep_activation_fn: str = "silu", + norm_elementwise_affine: bool = True, + norm_eps: float = 1e-5, + spatial_interpolation_scale: float = 1.875, + temporal_interpolation_scale: float = 1.0, + use_rotary_positional_embeddings: bool = False, + use_learned_positional_embeddings: bool = False, + patch_bias: bool = True, + attention_mode: Optional[str] = "sdpa", + ): + super().__init__() + inner_dim = num_attention_heads * attention_head_dim + + if not use_rotary_positional_embeddings and use_learned_positional_embeddings: + raise ValueError( + "There are no CogVideoX checkpoints available with disable rotary embeddings and learned positional " + "embeddings. If you're using a custom model and/or believe this should be supported, please open an " + "issue at https://github.com/huggingface/diffusers/issues." + ) + + # 1. Patch embedding + self.patch_embed = CogVideoXPatchEmbed( + patch_size=patch_size, + patch_size_t=patch_size_t, + in_channels=in_channels, + embed_dim=inner_dim, + text_embed_dim=text_embed_dim, + bias=patch_bias, + sample_width=sample_width, + sample_height=sample_height, + sample_frames=sample_frames, + temporal_compression_ratio=temporal_compression_ratio, + max_text_seq_length=max_text_seq_length, + spatial_interpolation_scale=spatial_interpolation_scale, + temporal_interpolation_scale=temporal_interpolation_scale, + use_positional_embeddings=not use_rotary_positional_embeddings, + use_learned_positional_embeddings=use_learned_positional_embeddings, + ) + self.embedding_dropout = nn.Dropout(dropout) + + # 2. Time embeddings + self.time_proj = Timesteps(inner_dim, flip_sin_to_cos, freq_shift) + self.time_embedding = TimestepEmbedding(inner_dim, time_embed_dim, timestep_activation_fn) + + self.ofs_proj = None + self.ofs_embedding = None + + if ofs_embed_dim: + self.ofs_proj = Timesteps(ofs_embed_dim, flip_sin_to_cos, freq_shift) + self.ofs_embedding = TimestepEmbedding(ofs_embed_dim, ofs_embed_dim, timestep_activation_fn) # same as time embeddings, for ofs + + # 3. Define spatio-temporal transformers blocks + self.transformer_blocks = nn.ModuleList( + [ + CogVideoXBlock( + dim=inner_dim, + num_attention_heads=num_attention_heads, + attention_head_dim=attention_head_dim, + time_embed_dim=time_embed_dim, + dropout=dropout, + activation_fn=activation_fn, + attention_bias=attention_bias, + attention_mode=attention_mode, + norm_elementwise_affine=norm_elementwise_affine, + norm_eps=norm_eps, + ) + for _ in range(num_layers) + ] + ) + self.norm_final = nn.LayerNorm(inner_dim, norm_eps, norm_elementwise_affine) + + # 4. Output blocks + self.norm_out = AdaLayerNorm( + embedding_dim=time_embed_dim, + output_dim=2 * inner_dim, + norm_elementwise_affine=norm_elementwise_affine, + norm_eps=norm_eps, + chunk_dim=1, + ) + if patch_size_t is None: + # For CogVideox 1.0 + output_dim = patch_size * patch_size * out_channels + else: + # For CogVideoX 1.5 + output_dim = patch_size * patch_size * patch_size_t * out_channels + + self.proj_out = nn.Linear(inner_dim, output_dim) + + self.gradient_checkpointing = False + + self.attention_mode = attention_mode + + #tora + self.fuser_list = None + + #fastercache + self.use_fastercache = False + self.fastercache_counter = 0 + self.fastercache_start_step = 15 + self.fastercache_lf_step = 40 + self.fastercache_hf_step = 30 + self.fastercache_device = "cuda" + self.fastercache_num_blocks_to_cache = len(self.transformer_blocks) + + #teacache + self.use_teacache = False + self.teacache_rel_l1_thresh = 0.0 + if not self.config.use_rotary_positional_embeddings: + #CogVideoX-2B + self.teacache_coefficients = [-3.10658903e+01, 2.54732368e+01, -5.92380459e+00, 1.75769064e+00, -3.61568434e-03] + else: + #CogVideoX-5B + self.teacache_coefficients = [-1.53880483e+03, 8.43202495e+02, -1.34363087e+02, 7.97131516e+00, -5.23162339e-02] + + + def _set_gradient_checkpointing(self, module, value=False): + self.gradient_checkpointing = value + #region forward + def forward( + self, + hidden_states: torch.Tensor, + encoder_hidden_states: torch.Tensor, + timestep: Union[int, float, torch.LongTensor], + timestep_cond: Optional[torch.Tensor] = None, + ofs: Optional[Union[int, float, torch.LongTensor]] = None, + image_rotary_emb: Optional[Tuple[torch.Tensor, torch.Tensor]] = None, + controlnet_states: torch.Tensor = None, + controlnet_weights: Optional[Union[float, int, list, np.ndarray, torch.FloatTensor]] = 1.0, + video_flow_features: Optional[torch.Tensor] = None, + return_dict: bool = True, + ): + batch_size, num_frames, channels, height, width = hidden_states.shape + + set_num_frames(num_frames) #enhance a video global + + # 1. Time embedding + timesteps = timestep + t_emb = self.time_proj(timesteps) + + # timesteps does not contain any weights and will always return f32 tensors + # but time_embedding might actually be running in fp16. so we need to cast here. + # there might be better ways to encapsulate this. + t_emb = t_emb.to(dtype=hidden_states.dtype) + + emb = self.time_embedding(t_emb, timestep_cond) + if self.ofs_embedding is not None: #1.5 I2V + ofs_emb = self.ofs_proj(ofs) + ofs_emb = ofs_emb.to(dtype=hidden_states.dtype) + ofs_emb = self.ofs_embedding(ofs_emb) + emb = emb + ofs_emb + + # 2. Patch embedding + p = self.config.patch_size + p_t = self.config.patch_size_t + + #print("hidden_states before patch_embedding", hidden_states.shape) #torch.Size([2, 4, 16, 60, 90]) + + hidden_states = self.patch_embed(encoder_hidden_states, hidden_states) + #print("hidden_states after patch_embedding", hidden_states.shape) #1.5: torch.Size([2, 2926, 3072]) #1.0: torch.Size([2, 5626, 3072]) + hidden_states = self.embedding_dropout(hidden_states) + + text_seq_length = encoder_hidden_states.shape[1] + encoder_hidden_states = hidden_states[:, :text_seq_length] + hidden_states = hidden_states[:, text_seq_length:] + #print("hidden_states after split", hidden_states.shape) #1.5: torch.Size([2, 2700, 3072]) #1.0: torch.Size([2, 5400, 3072]) + + if self.use_fastercache: + self.fastercache_counter+=1 + if self.fastercache_counter >= self.fastercache_start_step + 3 and self.fastercache_counter % 5 !=0: + # 3. Transformer blocks + for i, block in enumerate(self.transformer_blocks): + hidden_states, encoder_hidden_states = block( + hidden_states=hidden_states[:1], + encoder_hidden_states=encoder_hidden_states[:1], + temb=emb[:1], + image_rotary_emb=image_rotary_emb, + video_flow_feature=video_flow_features[i][:1] if video_flow_features is not None else None, + fuser = self.fuser_list[i] if self.fuser_list is not None else None, + block_use_fastercache = i <= self.fastercache_num_blocks_to_cache, + fastercache_counter = self.fastercache_counter, + fastercache_start_step = self.fastercache_start_step, + fastercache_device = self.fastercache_device + ) + + if (controlnet_states is not None) and (i < len(controlnet_states)): + controlnet_states_block = controlnet_states[i] + controlnet_block_weight = 1.0 + if isinstance(controlnet_weights, (list, np.ndarray)) or torch.is_tensor(controlnet_weights): + controlnet_block_weight = controlnet_weights[i] + elif isinstance(controlnet_weights, (float, int)): + controlnet_block_weight = controlnet_weights + + hidden_states = hidden_states + controlnet_states_block * controlnet_block_weight + + if not self.config.use_rotary_positional_embeddings: + # CogVideoX-2B + hidden_states = self.norm_final(hidden_states) + else: + # CogVideoX-5B + hidden_states = torch.cat([encoder_hidden_states, hidden_states], dim=1) + hidden_states = self.norm_final(hidden_states) + hidden_states = hidden_states[:, text_seq_length:] + + # 4. Final block + hidden_states = self.norm_out(hidden_states, temb=emb[:1]) + hidden_states = self.proj_out(hidden_states) + + # 5. Unpatchify + # Note: we use `-1` instead of `channels`: + # - It is okay to `channels` use for CogVideoX-2b and CogVideoX-5b (number of input channels is equal to output channels) + # - However, for CogVideoX-5b-I2V also takes concatenated input image latents (number of input channels is twice the output channels) + + if p_t is None: + output = hidden_states.reshape(1, num_frames, height // p, width // p, -1, p, p) + output = output.permute(0, 1, 4, 2, 5, 3, 6).flatten(5, 6).flatten(3, 4) + else: + output = hidden_states.reshape( + 1, (num_frames + p_t - 1) // p_t, height // p, width // p, -1, p_t, p, p + ) + output = output.permute(0, 1, 5, 4, 2, 6, 3, 7).flatten(6, 7).flatten(4, 5).flatten(1, 2) + + (bb, tt, cc, hh, ww) = output.shape + cond = rearrange(output, "B T C H W -> (B T) C H W", B=bb, C=cc, T=tt, H=hh, W=ww) + lf_c, hf_c = fft(cond.float()) + #lf_step = 40 + #hf_step = 30 + if self.fastercache_counter <= self.fastercache_lf_step: + self.delta_lf = self.delta_lf * 1.1 + if self.fastercache_counter >= self.fastercache_hf_step: + self.delta_hf = self.delta_hf * 1.1 + + new_hf_uc = self.delta_hf + hf_c + new_lf_uc = self.delta_lf + lf_c + + combine_uc = new_lf_uc + new_hf_uc + combined_fft = torch.fft.ifftshift(combine_uc) + recovered_uncond = torch.fft.ifft2(combined_fft).real + recovered_uncond = rearrange(recovered_uncond.to(output.dtype), "(B T) C H W -> B T C H W", B=bb, C=cc, T=tt, H=hh, W=ww) + output = torch.cat([output, recovered_uncond]) + else: + if self.use_teacache: + if not hasattr(self, 'accumulated_rel_l1_distance'): + should_calc = True + self.accumulated_rel_l1_distance = 0 + else: + self.accumulated_rel_l1_distance += poly1d(self.teacache_coefficients, ((emb-self.previous_modulated_input).abs().mean() / self.previous_modulated_input.abs().mean())) + if self.accumulated_rel_l1_distance < self.teacache_rel_l1_thresh: + should_calc = False + self.teacache_counter += 1 + else: + should_calc = True + self.accumulated_rel_l1_distance = 0 + #print("self.accumulated_rel_l1_distance ", self.accumulated_rel_l1_distance) + self.previous_modulated_input = emb + if not should_calc: + hidden_states += self.previous_residual + encoder_hidden_states += self.previous_residual_encoder + + if not self.use_teacache or (self.use_teacache and should_calc): + if self.use_teacache: + ori_hidden_states = hidden_states.clone() + ori_encoder_hidden_states = encoder_hidden_states.clone() + for i, block in enumerate(self.transformer_blocks): + hidden_states, encoder_hidden_states = block( + hidden_states=hidden_states, + encoder_hidden_states=encoder_hidden_states, + temb=emb, + image_rotary_emb=image_rotary_emb, + video_flow_feature=video_flow_features[i] if video_flow_features is not None else None, + fuser = self.fuser_list[i] if self.fuser_list is not None else None, + block_use_fastercache = i <= self.fastercache_num_blocks_to_cache, + fastercache_counter = self.fastercache_counter, + fastercache_start_step = self.fastercache_start_step, + fastercache_device = self.fastercache_device + ) + + #controlnet + if (controlnet_states is not None) and (i < len(controlnet_states)): + controlnet_states_block = controlnet_states[i] + controlnet_block_weight = 1.0 + if isinstance(controlnet_weights, (list, np.ndarray)) or torch.is_tensor(controlnet_weights): + controlnet_block_weight = controlnet_weights[i] + print(controlnet_block_weight) + elif isinstance(controlnet_weights, (float, int)): + controlnet_block_weight = controlnet_weights + hidden_states = hidden_states + controlnet_states_block * controlnet_block_weight + + if self.use_teacache: + self.previous_residual = hidden_states - ori_hidden_states + self.previous_residual_encoder = encoder_hidden_states - ori_encoder_hidden_states + + if not self.config.use_rotary_positional_embeddings: + # CogVideoX-2B + hidden_states = self.norm_final(hidden_states) + else: + # CogVideoX-5B + hidden_states = torch.cat([encoder_hidden_states, hidden_states], dim=1) + hidden_states = self.norm_final(hidden_states) + hidden_states = hidden_states[:, text_seq_length:] + + # 4. Final block + hidden_states = self.norm_out(hidden_states, temb=emb) + hidden_states = self.proj_out(hidden_states) + + # 5. Unpatchify + # Note: we use `-1` instead of `channels`: + # - It is okay to `channels` use for CogVideoX-2b and CogVideoX-5b (number of input channels is equal to output channels) + # - However, for CogVideoX-5b-I2V also takes concatenated input image latents (number of input channels is twice the output channels) + + if p_t is None: + output = hidden_states.reshape(batch_size, num_frames, height // p, width // p, -1, p, p) + output = output.permute(0, 1, 4, 2, 5, 3, 6).flatten(5, 6).flatten(3, 4) + else: + output = hidden_states.reshape( + batch_size, (num_frames + p_t - 1) // p_t, height // p, width // p, -1, p_t, p, p + ) + output = output.permute(0, 1, 5, 4, 2, 6, 3, 7).flatten(6, 7).flatten(4, 5).flatten(1, 2) + + if self.fastercache_counter >= self.fastercache_start_step + 1: + (bb, tt, cc, hh, ww) = output.shape + cond = rearrange(output[0:1].float(), "B T C H W -> (B T) C H W", B=bb//2, C=cc, T=tt, H=hh, W=ww) + uncond = rearrange(output[1:2].float(), "B T C H W -> (B T) C H W", B=bb//2, C=cc, T=tt, H=hh, W=ww) + + lf_c, hf_c = fft(cond) + lf_uc, hf_uc = fft(uncond) + + self.delta_lf = lf_uc - lf_c + self.delta_hf = hf_uc - hf_c + + if not return_dict: + return (output,) + return Transformer2DModelOutput(sample=output) + \ No newline at end of file diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/embeddings.py b/custom_nodes/ComfyUI-CogVideoXWrapper/embeddings.py new file mode 100644 index 0000000000000000000000000000000000000000..00733a3e7409b6a408902bdc5c71d9d0a1bdcfa8 --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/embeddings.py @@ -0,0 +1,226 @@ +import torch +import torch.nn as nn +import numpy as np +from typing import Tuple, Union, Optional +from diffusers.models.embeddings import get_3d_sincos_pos_embed, get_1d_rotary_pos_embed + + +class CogVideoXPatchEmbed(nn.Module): + def __init__( + self, + patch_size: int = 2, + patch_size_t: Optional[int] = None, + in_channels: int = 16, + embed_dim: int = 1920, + text_embed_dim: int = 4096, + bias: bool = True, + sample_width: int = 90, + sample_height: int = 60, + sample_frames: int = 49, + temporal_compression_ratio: int = 4, + max_text_seq_length: int = 226, + spatial_interpolation_scale: float = 1.875, + temporal_interpolation_scale: float = 1.0, + use_positional_embeddings: bool = True, + use_learned_positional_embeddings: bool = True, + ) -> None: + super().__init__() + + self.patch_size = patch_size + self.patch_size_t = patch_size_t + self.embed_dim = embed_dim + self.sample_height = sample_height + self.sample_width = sample_width + self.sample_frames = sample_frames + self.temporal_compression_ratio = temporal_compression_ratio + self.max_text_seq_length = max_text_seq_length + self.spatial_interpolation_scale = spatial_interpolation_scale + self.temporal_interpolation_scale = temporal_interpolation_scale + self.use_positional_embeddings = use_positional_embeddings + self.use_learned_positional_embeddings = use_learned_positional_embeddings + + if patch_size_t is None: + # CogVideoX 1.0 checkpoints + self.proj = nn.Conv2d( + in_channels, embed_dim, kernel_size=(patch_size, patch_size), stride=patch_size, bias=bias + ) + else: + # CogVideoX 1.5 checkpoints + self.proj = nn.Linear(in_channels * patch_size * patch_size * patch_size_t, embed_dim) + + self.text_proj = nn.Linear(text_embed_dim, embed_dim) + + if use_positional_embeddings or use_learned_positional_embeddings: + persistent = use_learned_positional_embeddings + pos_embedding = self._get_positional_embeddings(sample_height, sample_width, sample_frames) + self.register_buffer("pos_embedding", pos_embedding, persistent=persistent) + + def _get_positional_embeddings(self, sample_height: int, sample_width: int, sample_frames: int) -> torch.Tensor: + post_patch_height = sample_height // self.patch_size + post_patch_width = sample_width // self.patch_size + post_time_compression_frames = (sample_frames - 1) // self.temporal_compression_ratio + 1 + num_patches = post_patch_height * post_patch_width * post_time_compression_frames + + pos_embedding = get_3d_sincos_pos_embed( + self.embed_dim, + (post_patch_width, post_patch_height), + post_time_compression_frames, + self.spatial_interpolation_scale, + self.temporal_interpolation_scale, + ) + pos_embedding = torch.from_numpy(pos_embedding).flatten(0, 1) + joint_pos_embedding = torch.zeros( + 1, self.max_text_seq_length + num_patches, self.embed_dim, requires_grad=False + ) + joint_pos_embedding.data[:, self.max_text_seq_length :].copy_(pos_embedding) + + return joint_pos_embedding + + def forward(self, text_embeds: torch.Tensor, image_embeds: torch.Tensor): + r""" + Args: + text_embeds (`torch.Tensor`): + Input text embeddings. Expected shape: (batch_size, seq_length, embedding_dim). + image_embeds (`torch.Tensor`): + Input image embeddings. Expected shape: (batch_size, num_frames, channels, height, width). + """ + text_embeds = self.text_proj(text_embeds) + + batch_size, num_frames, channels, height, width = image_embeds.shape + + if self.patch_size_t is None: + image_embeds = image_embeds.reshape(-1, channels, height, width) + image_embeds = self.proj(image_embeds) + image_embeds = image_embeds.view(batch_size, num_frames, *image_embeds.shape[1:]) + image_embeds = image_embeds.flatten(3).transpose(2, 3) # [batch, num_frames, height x width, channels] + image_embeds = image_embeds.flatten(1, 2) # [batch, num_frames x height x width, channels] + else: + p = self.patch_size + p_t = self.patch_size_t + + image_embeds = image_embeds.permute(0, 1, 3, 4, 2) + image_embeds = image_embeds.reshape( + batch_size, num_frames // p_t, p_t, height // p, p, width // p, p, channels + ) + image_embeds = image_embeds.permute(0, 1, 3, 5, 7, 2, 4, 6).flatten(4, 7).flatten(1, 3) + image_embeds = self.proj(image_embeds) + + embeds = torch.cat( + [text_embeds, image_embeds], dim=1 + ).contiguous() # [batch, seq_length + num_frames x height x width, channels] + + if self.use_positional_embeddings or self.use_learned_positional_embeddings: + if self.use_learned_positional_embeddings and (self.sample_width != width or self.sample_height != height): + raise ValueError( + "It is currently not possible to generate videos at a different resolution that the defaults. This should only be the case with 'THUDM/CogVideoX-5b-I2V'." + "If you think this is incorrect, please open an issue at https://github.com/huggingface/diffusers/issues." + ) + + pre_time_compression_frames = (num_frames - 1) * self.temporal_compression_ratio + 1 + + if ( + self.sample_height != height + or self.sample_width != width + or self.sample_frames != pre_time_compression_frames + ): + pos_embedding = self._get_positional_embeddings(height, width, pre_time_compression_frames) + pos_embedding = pos_embedding.to(embeds.device, dtype=embeds.dtype) + else: + pos_embedding = self.pos_embedding + + embeds = embeds + pos_embedding + + return embeds + +def get_3d_rotary_pos_embed( + embed_dim, + crops_coords, + grid_size, + temporal_size, + theta: int = 10000, + use_real: bool = True, + grid_type: str = "linspace", + max_size: Optional[Tuple[int, int]] = None, +) -> Union[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]: + """ + RoPE for video tokens with 3D structure. + + Args: + embed_dim: (`int`): + The embedding dimension size, corresponding to hidden_size_head. + crops_coords (`Tuple[int]`): + The top-left and bottom-right coordinates of the crop. + grid_size (`Tuple[int]`): + The grid size of the spatial positional embedding (height, width). + temporal_size (`int`): + The size of the temporal dimension. + theta (`float`): + Scaling factor for frequency computation. + grid_type (`str`): + Whether to use "linspace" or "slice" to compute grids. + + Returns: + `torch.Tensor`: positional embedding with shape `(temporal_size * grid_size[0] * grid_size[1], embed_dim/2)`. + """ + if use_real is not True: + raise ValueError(" `use_real = False` is not currently supported for get_3d_rotary_pos_embed") + + if grid_type == "linspace": + start, stop = crops_coords + grid_size_h, grid_size_w = grid_size + grid_h = np.linspace(start[0], stop[0], grid_size_h, endpoint=False, dtype=np.float32) + grid_w = np.linspace(start[1], stop[1], grid_size_w, endpoint=False, dtype=np.float32) + grid_t = np.arange(temporal_size, dtype=np.float32) + grid_t = np.linspace(0, temporal_size, temporal_size, endpoint=False, dtype=np.float32) + elif grid_type == "slice": + max_h, max_w = max_size + grid_size_h, grid_size_w = grid_size + grid_h = np.arange(max_h, dtype=np.float32) + grid_w = np.arange(max_w, dtype=np.float32) + grid_t = np.arange(temporal_size, dtype=np.float32) + else: + raise ValueError("Invalid value passed for `grid_type`.") + + # Compute dimensions for each axis + dim_t = embed_dim // 4 + dim_h = embed_dim // 8 * 3 + dim_w = embed_dim // 8 * 3 + + # Temporal frequencies + freqs_t = get_1d_rotary_pos_embed(dim_t, grid_t, use_real=True) + # Spatial frequencies for height and width + freqs_h = get_1d_rotary_pos_embed(dim_h, grid_h, use_real=True) + freqs_w = get_1d_rotary_pos_embed(dim_w, grid_w, use_real=True) + + # BroadCast and concatenate temporal and spaial frequencie (height and width) into a 3d tensor + def combine_time_height_width(freqs_t, freqs_h, freqs_w): + freqs_t = freqs_t[:, None, None, :].expand( + -1, grid_size_h, grid_size_w, -1 + ) # temporal_size, grid_size_h, grid_size_w, dim_t + freqs_h = freqs_h[None, :, None, :].expand( + temporal_size, -1, grid_size_w, -1 + ) # temporal_size, grid_size_h, grid_size_2, dim_h + freqs_w = freqs_w[None, None, :, :].expand( + temporal_size, grid_size_h, -1, -1 + ) # temporal_size, grid_size_h, grid_size_2, dim_w + + freqs = torch.cat( + [freqs_t, freqs_h, freqs_w], dim=-1 + ) # temporal_size, grid_size_h, grid_size_w, (dim_t + dim_h + dim_w) + freqs = freqs.view( + temporal_size * grid_size_h * grid_size_w, -1 + ) # (temporal_size * grid_size_h * grid_size_w), (dim_t + dim_h + dim_w) + return freqs + + t_cos, t_sin = freqs_t # both t_cos and t_sin has shape: temporal_size, dim_t + h_cos, h_sin = freqs_h # both h_cos and h_sin has shape: grid_size_h, dim_h + w_cos, w_sin = freqs_w # both w_cos and w_sin has shape: grid_size_w, dim_w + + if grid_type == "slice": + t_cos, t_sin = t_cos[:temporal_size], t_sin[:temporal_size] + h_cos, h_sin = h_cos[:grid_size_h], h_sin[:grid_size_h] + w_cos, w_sin = w_cos[:grid_size_w], w_sin[:grid_size_w] + + cos = combine_time_height_width(t_cos, h_cos, w_cos) + sin = combine_time_height_width(t_sin, h_sin, w_sin) + return cos, sin \ No newline at end of file diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/enhance_a_video/__init__.py b/custom_nodes/ComfyUI-CogVideoXWrapper/enhance_a_video/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/enhance_a_video/__pycache__/__init__.cpython-311.pyc b/custom_nodes/ComfyUI-CogVideoXWrapper/enhance_a_video/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..565841881cf286e0ff54fe524968d643cf4aacb9 Binary files /dev/null and b/custom_nodes/ComfyUI-CogVideoXWrapper/enhance_a_video/__pycache__/__init__.cpython-311.pyc differ diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/enhance_a_video/__pycache__/__init__.cpython-312.pyc b/custom_nodes/ComfyUI-CogVideoXWrapper/enhance_a_video/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..770b53510b8dcc6445cd608a950bec05acf30f8e Binary files /dev/null and b/custom_nodes/ComfyUI-CogVideoXWrapper/enhance_a_video/__pycache__/__init__.cpython-312.pyc differ diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/enhance_a_video/__pycache__/enhance.cpython-311.pyc b/custom_nodes/ComfyUI-CogVideoXWrapper/enhance_a_video/__pycache__/enhance.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7970b49cb51103f81f066a7eed392645b9a95f21 Binary files /dev/null and b/custom_nodes/ComfyUI-CogVideoXWrapper/enhance_a_video/__pycache__/enhance.cpython-311.pyc differ diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/enhance_a_video/__pycache__/enhance.cpython-312.pyc b/custom_nodes/ComfyUI-CogVideoXWrapper/enhance_a_video/__pycache__/enhance.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..69cbf979bce98d03fa408424865e6042c98e649c Binary files /dev/null and b/custom_nodes/ComfyUI-CogVideoXWrapper/enhance_a_video/__pycache__/enhance.cpython-312.pyc differ diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/enhance_a_video/__pycache__/globals.cpython-311.pyc b/custom_nodes/ComfyUI-CogVideoXWrapper/enhance_a_video/__pycache__/globals.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ad23d447e03b71c1e35737ebdb9ff85b14766d3a Binary files /dev/null and b/custom_nodes/ComfyUI-CogVideoXWrapper/enhance_a_video/__pycache__/globals.cpython-311.pyc differ diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/enhance_a_video/__pycache__/globals.cpython-312.pyc b/custom_nodes/ComfyUI-CogVideoXWrapper/enhance_a_video/__pycache__/globals.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..103ae9fb1782c646a0a3d51962094d96b544f895 Binary files /dev/null and b/custom_nodes/ComfyUI-CogVideoXWrapper/enhance_a_video/__pycache__/globals.cpython-312.pyc differ diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/enhance_a_video/enhance.py b/custom_nodes/ComfyUI-CogVideoXWrapper/enhance_a_video/enhance.py new file mode 100644 index 0000000000000000000000000000000000000000..e6ee05057247faed44cf18bb11564341a6f8ba35 --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/enhance_a_video/enhance.py @@ -0,0 +1,82 @@ +import torch +from einops import rearrange +from diffusers.models.attention import Attention +from .globals import get_enhance_weight, get_num_frames + +# def get_feta_scores(query, key): +# img_q, img_k = query, key + +# num_frames = get_num_frames() + +# B, S, N, C = img_q.shape + +# # Calculate spatial dimension +# spatial_dim = S // num_frames + +# # Add time dimension between spatial and head dims +# query_image = img_q.reshape(B, spatial_dim, num_frames, N, C) +# key_image = img_k.reshape(B, spatial_dim, num_frames, N, C) + +# # Expand time dimension +# query_image = query_image.expand(-1, -1, num_frames, -1, -1) # [B, S, T, N, C] +# key_image = key_image.expand(-1, -1, num_frames, -1, -1) # [B, S, T, N, C] + +# # Reshape to match feta_score input format: [(B S) N T C] +# query_image = rearrange(query_image, "b s t n c -> (b s) n t c") #torch.Size([3200, 24, 5, 128]) +# key_image = rearrange(key_image, "b s t n c -> (b s) n t c") + +# return feta_score(query_image, key_image, C, num_frames) + +def get_feta_scores( + attn: Attention, + query: torch.Tensor, + key: torch.Tensor, + head_dim: int, + text_seq_length: int, + ) -> torch.Tensor: + num_frames = get_num_frames() + spatial_dim = int((query.shape[2] - text_seq_length) / num_frames) + + query_image = rearrange( + query[:, :, text_seq_length:], + "B N (T S) C -> (B S) N T C", + N=attn.heads, + T=num_frames, + S=spatial_dim, + C=head_dim, + ) + key_image = rearrange( + key[:, :, text_seq_length:], + "B N (T S) C -> (B S) N T C", + N=attn.heads, + T=num_frames, + S=spatial_dim, + C=head_dim, + ) + return feta_score(query_image, key_image, head_dim, num_frames) + +def feta_score(query_image, key_image, head_dim, num_frames): + scale = head_dim**-0.5 + query_image = query_image * scale + attn_temp = query_image @ key_image.transpose(-2, -1) # translate attn to float32 + attn_temp = attn_temp.to(torch.float32) + attn_temp = attn_temp.softmax(dim=-1) + + # Reshape to [batch_size * num_tokens, num_frames, num_frames] + attn_temp = attn_temp.reshape(-1, num_frames, num_frames) + + # Create a mask for diagonal elements + diag_mask = torch.eye(num_frames, device=attn_temp.device).bool() + diag_mask = diag_mask.unsqueeze(0).expand(attn_temp.shape[0], -1, -1) + + # Zero out diagonal elements + attn_wo_diag = attn_temp.masked_fill(diag_mask, 0) + + # Calculate mean for each token's attention matrix + # Number of off-diagonal elements per matrix is n*n - n + num_off_diag = num_frames * num_frames - num_frames + mean_scores = attn_wo_diag.sum(dim=(1, 2)) / num_off_diag + + enhance_scores = mean_scores.mean() * (num_frames + get_enhance_weight()) + enhance_scores = enhance_scores.clamp(min=1) + return enhance_scores diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/enhance_a_video/globals.py b/custom_nodes/ComfyUI-CogVideoXWrapper/enhance_a_video/globals.py new file mode 100644 index 0000000000000000000000000000000000000000..7254876b93b3d1b3124c8507c0528e63bc8cdeca --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/enhance_a_video/globals.py @@ -0,0 +1,31 @@ +NUM_FRAMES = None +FETA_WEIGHT = None +ENABLE_FETA = False + +def set_num_frames(num_frames: int): + global NUM_FRAMES + NUM_FRAMES = num_frames + + +def get_num_frames() -> int: + return NUM_FRAMES + + +def enable_enhance(): + global ENABLE_FETA + ENABLE_FETA = True + +def disable_enhance(): + global ENABLE_FETA + ENABLE_FETA = False + +def is_enhance_enabled() -> bool: + return ENABLE_FETA + +def set_enhance_weight(feta_weight: float): + global FETA_WEIGHT + FETA_WEIGHT = feta_weight + + +def get_enhance_weight() -> float: + return FETA_WEIGHT diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_1.0_5b_vid2vid_02.json b/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_1.0_5b_vid2vid_02.json new file mode 100644 index 0000000000000000000000000000000000000000..9714952135bafb0cc3e070828fea6617cf5dd8c5 --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_1.0_5b_vid2vid_02.json @@ -0,0 +1,1061 @@ +{ + "last_node_id": 78, + "last_link_id": 218, + "nodes": [ + { + "id": 20, + "type": "CLIPLoader", + "pos": { + "0": -29, + "1": 407 + }, + "size": { + "0": 451.30548095703125, + "1": 82 + }, + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "CLIP", + "type": "CLIP", + "links": [ + 54 + ], + "slot_index": 0, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "CLIPLoader" + }, + "widgets_values": [ + "t5\\google_t5-v1_1-xxl_encoderonly-fp8_e4m3fn.safetensors", + "sd3" + ] + }, + { + "id": 41, + "type": "ImageResizeKJ", + "pos": { + "0": 206, + "1": -69 + }, + "size": { + "0": 315, + "1": 242 + }, + "flags": {}, + "order": 7, + "mode": 0, + "inputs": [ + { + "name": "image", + "type": "IMAGE", + "link": 180 + }, + { + "name": "get_image_size", + "type": "IMAGE", + "link": null, + "shape": 7 + }, + { + "name": "width_input", + "type": "INT", + "link": null, + "widget": { + "name": "width_input" + } + }, + { + "name": "height_input", + "type": "INT", + "link": null, + "widget": { + "name": "height_input" + } + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 126 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "width", + "type": "INT", + "links": null, + "shape": 3 + }, + { + "name": "height", + "type": "INT", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "ImageResizeKJ" + }, + "widgets_values": [ + 720, + 480, + "lanczos", + false, + 2, + 0, + 0, + "disabled" + ] + }, + { + "id": 45, + "type": "VHS_LoadVideo", + "pos": { + "0": -93, + "1": -153 + }, + "size": [ + 247.455078125, + 365.7275390625 + ], + "flags": {}, + "order": 4, + "mode": 0, + "inputs": [ + { + "name": "meta_batch", + "type": "VHS_BatchManager", + "link": null, + "shape": 7 + }, + { + "name": "vae", + "type": "VAE", + "link": null, + "shape": 7 + }, + { + "name": "frame_load_cap", + "type": "INT", + "link": 177, + "widget": { + "name": "frame_load_cap" + } + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 179 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "frame_count", + "type": "INT", + "links": null, + "shape": 3 + }, + { + "name": "audio", + "type": "AUDIO", + "links": null, + "shape": 3 + }, + { + "name": "video_info", + "type": "VHS_VIDEOINFO", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "VHS_LoadVideo" + }, + "widgets_values": { + "video": "jeep.mp4", + "force_rate": 0, + "force_size": "Disabled", + "custom_width": 512, + "custom_height": 512, + "frame_load_cap": 20, + "skip_first_frames": 0, + "select_every_nth": 1, + "choose video to upload": "image", + "videopreview": { + "hidden": false, + "paused": false, + "params": { + "frame_load_cap": 20, + "skip_first_frames": 0, + "force_rate": 0, + "filename": "jeep.mp4", + "type": "input", + "format": "video/mp4", + "select_every_nth": 1 + } + } + } + }, + { + "id": 70, + "type": "GetImageSizeAndCount", + "pos": { + "0": 214, + "1": -234 + }, + "size": { + "0": 202.2143096923828, + "1": 99.23601531982422 + }, + "flags": {}, + "order": 6, + "mode": 0, + "inputs": [ + { + "name": "image", + "type": "IMAGE", + "link": 179, + "slot_index": 0 + } + ], + "outputs": [ + { + "name": "image", + "type": "IMAGE", + "links": [ + 180 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "512 width", + "type": "INT", + "links": [], + "slot_index": 1, + "shape": 3 + }, + { + "name": "256 height", + "type": "INT", + "links": [], + "slot_index": 2, + "shape": 3 + }, + { + "name": "33 count", + "type": "INT", + "links": [], + "slot_index": 3, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "GetImageSizeAndCount" + }, + "widgets_values": [] + }, + { + "id": 69, + "type": "INTConstant", + "pos": { + "0": -90, + "1": -305 + }, + "size": { + "0": 210, + "1": 58 + }, + "flags": {}, + "order": 1, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "value", + "type": "INT", + "links": [ + 177 + ], + "shape": 3 + } + ], + "title": "Frames to load", + "properties": { + "Node name for S&R": "INTConstant" + }, + "widgets_values": [ + 33 + ], + "color": "#1b4669", + "bgcolor": "#29699c" + }, + { + "id": 58, + "type": "ImageConcanate", + "pos": { + "0": 1594, + "1": 230 + }, + "size": { + "0": 315, + "1": 102 + }, + "flags": {}, + "order": 13, + "mode": 0, + "inputs": [ + { + "name": "image1", + "type": "IMAGE", + "link": 191 + }, + { + "name": "image2", + "type": "IMAGE", + "link": 170 + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 132 + ], + "slot_index": 0, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "ImageConcanate" + }, + "widgets_values": [ + "right", + false + ] + }, + { + "id": 55, + "type": "GetImageSizeAndCount", + "pos": { + "0": 1654, + "1": 77 + }, + "size": { + "0": 210, + "1": 86 + }, + "flags": {}, + "order": 12, + "mode": 0, + "inputs": [ + { + "name": "image", + "type": "IMAGE", + "link": 208, + "slot_index": 0 + } + ], + "outputs": [ + { + "name": "image", + "type": "IMAGE", + "links": [ + 170 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "720 width", + "type": "INT", + "links": null, + "shape": 3 + }, + { + "name": "480 height", + "type": "INT", + "links": null, + "shape": 3 + }, + { + "name": "33 count", + "type": "INT", + "links": [], + "slot_index": 3, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "GetImageSizeAndCount" + }, + "widgets_values": [] + }, + { + "id": 77, + "type": "CogVideoImageEncode", + "pos": { + "0": 952, + "1": -118 + }, + "size": { + "0": 315, + "1": 122 + }, + "flags": {}, + "order": 9, + "mode": 0, + "inputs": [ + { + "name": "vae", + "type": "VAE", + "link": 209 + }, + { + "name": "start_image", + "type": "IMAGE", + "link": 210 + }, + { + "name": "end_image", + "type": "IMAGE", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "samples", + "type": "LATENT", + "links": [ + 215 + ] + } + ], + "properties": { + "Node name for S&R": "CogVideoImageEncode" + }, + "widgets_values": [ + false, + 0 + ] + }, + { + "id": 76, + "type": "CogVideoDecode", + "pos": { + "0": 1335, + "1": -123 + }, + "size": { + "0": 315, + "1": 198 + }, + "flags": {}, + "order": 11, + "mode": 0, + "inputs": [ + { + "name": "vae", + "type": "VAE", + "link": 206 + }, + { + "name": "samples", + "type": "LATENT", + "link": 216 + } + ], + "outputs": [ + { + "name": "images", + "type": "IMAGE", + "links": [ + 208 + ] + } + ], + "properties": { + "Node name for S&R": "CogVideoDecode" + }, + "widgets_values": [ + true, + 240, + 360, + 0.2, + 0.2, + true + ] + }, + { + "id": 30, + "type": "CogVideoTextEncode", + "pos": { + "0": 491, + "1": 372 + }, + "size": [ + 478.6890949595422, + 215.66308749666905 + ], + "flags": {}, + "order": 3, + "mode": 0, + "inputs": [ + { + "name": "clip", + "type": "CLIP", + "link": 54 + } + ], + "outputs": [ + { + "name": "conditioning", + "type": "CONDITIONING", + "links": [ + 213 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "clip", + "type": "CLIP", + "links": [ + 217 + ], + "slot_index": 1 + } + ], + "properties": { + "Node name for S&R": "CogVideoTextEncode" + }, + "widgets_values": [ + "A high-definition nature video showcasing a brown bear as it gracefully runs down a crystal-clear stream, surrounded by the serene ambiance of a dense, verdant forest. The sunlight filters through the canopy of tall trees, casting dappled light on the forest floor, while the gentle sound of flowing water and rustling leaves creates a peaceful atmosphere. The brown bear's fur glistens in the sunlight, highlighting its striking red and white markings as it navigates the stream with agility and playfulness.", + 1, + false + ] + }, + { + "id": 31, + "type": "CogVideoTextEncode", + "pos": { + "0": 504, + "1": 651 + }, + "size": { + "0": 463.01251220703125, + "1": 144 + }, + "flags": {}, + "order": 5, + "mode": 0, + "inputs": [ + { + "name": "clip", + "type": "CLIP", + "link": 217 + } + ], + "outputs": [ + { + "name": "conditioning", + "type": "CONDITIONING", + "links": [ + 214 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "clip", + "type": "CLIP", + "links": null + } + ], + "properties": { + "Node name for S&R": "CogVideoTextEncode" + }, + "widgets_values": [ + "", + 1, + true + ] + }, + { + "id": 78, + "type": "CogVideoSampler", + "pos": { + "0": 1083, + "1": 255 + }, + "size": [ + 330, + 574 + ], + "flags": {}, + "order": 10, + "mode": 0, + "inputs": [ + { + "name": "model", + "type": "COGVIDEOMODEL", + "link": 212 + }, + { + "name": "positive", + "type": "CONDITIONING", + "link": 213 + }, + { + "name": "negative", + "type": "CONDITIONING", + "link": 214 + }, + { + "name": "samples", + "type": "LATENT", + "link": 215, + "shape": 7 + }, + { + "name": "image_cond_latents", + "type": "LATENT", + "link": null, + "shape": 7 + }, + { + "name": "context_options", + "type": "COGCONTEXT", + "link": null, + "shape": 7 + }, + { + "name": "controlnet", + "type": "COGVIDECONTROLNET", + "link": null, + "shape": 7 + }, + { + "name": "tora_trajectory", + "type": "TORAFEATURES", + "link": null, + "shape": 7 + }, + { + "name": "fastercache", + "type": "FASTERCACHEARGS", + "link": null, + "shape": 7 + }, + { + "name": "num_frames", + "type": "INT", + "link": 218, + "widget": { + "name": "num_frames" + } + } + ], + "outputs": [ + { + "name": "samples", + "type": "LATENT", + "links": [ + 216 + ] + } + ], + "properties": { + "Node name for S&R": "CogVideoSampler" + }, + "widgets_values": [ + 49, + 25, + 6, + 0, + "fixed", + "CogVideoXDDIM", + 0.8 + ] + }, + { + "id": 57, + "type": "GetImageSizeAndCount", + "pos": { + "0": 595, + "1": -79 + }, + "size": { + "0": 202.2143096923828, + "1": 99.23601531982422 + }, + "flags": {}, + "order": 8, + "mode": 0, + "inputs": [ + { + "name": "image", + "type": "IMAGE", + "link": 126, + "slot_index": 0 + } + ], + "outputs": [ + { + "name": "image", + "type": "IMAGE", + "links": [ + 191, + 210 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "720 width", + "type": "INT", + "links": [], + "slot_index": 1, + "shape": 3 + }, + { + "name": "480 height", + "type": "INT", + "links": [], + "slot_index": 2, + "shape": 3 + }, + { + "name": "33 count", + "type": "INT", + "links": [ + 218 + ], + "slot_index": 3, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "GetImageSizeAndCount" + }, + "widgets_values": [] + }, + { + "id": 75, + "type": "DownloadAndLoadCogVideoModel", + "pos": { + "0": 606, + "1": 85 + }, + "size": { + "0": 315, + "1": 218 + }, + "flags": {}, + "order": 2, + "mode": 0, + "inputs": [ + { + "name": "block_edit", + "type": "TRANSFORMERBLOCKS", + "link": null, + "shape": 7 + }, + { + "name": "lora", + "type": "COGLORA", + "link": null, + "shape": 7 + }, + { + "name": "compile_args", + "type": "COMPILEARGS", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "model", + "type": "COGVIDEOMODEL", + "links": [ + 212 + ] + }, + { + "name": "vae", + "type": "VAE", + "links": [ + 206, + 209 + ] + } + ], + "properties": { + "Node name for S&R": "DownloadAndLoadCogVideoModel" + }, + "widgets_values": [ + "THUDM/CogVideoX-5b", + "bf16", + "disabled", + false, + "sdpa", + "main_device" + ] + }, + { + "id": 47, + "type": "VHS_VideoCombine", + "pos": { + "0": 1946, + "1": -172 + }, + "size": [ + 1110, + 687.3333333333333 + ], + "flags": {}, + "order": 14, + "mode": 0, + "inputs": [ + { + "name": "images", + "type": "IMAGE", + "link": 132 + }, + { + "name": "audio", + "type": "AUDIO", + "link": null, + "shape": 7 + }, + { + "name": "meta_batch", + "type": "VHS_BatchManager", + "link": null, + "shape": 7 + }, + { + "name": "vae", + "type": "VAE", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "Filenames", + "type": "VHS_FILENAMES", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "VHS_VideoCombine" + }, + "widgets_values": { + "frame_rate": 8, + "loop_count": 0, + "filename_prefix": "CogVideoX_vid2vid", + "format": "video/h264-mp4", + "pix_fmt": "yuv420p", + "crf": 19, + "save_metadata": true, + "pingpong": false, + "save_output": true, + "videopreview": { + "hidden": false, + "paused": false, + "params": { + "filename": "CogVideoX_vid2vid_00003.mp4", + "subfolder": "", + "type": "temp", + "format": "video/h264-mp4", + "frame_rate": 8 + } + } + } + } + ], + "links": [ + [ + 54, + 20, + 0, + 30, + 0, + "CLIP" + ], + [ + 126, + 41, + 0, + 57, + 0, + "IMAGE" + ], + [ + 132, + 58, + 0, + 47, + 0, + "IMAGE" + ], + [ + 170, + 55, + 0, + 58, + 1, + "IMAGE" + ], + [ + 177, + 69, + 0, + 45, + 2, + "INT" + ], + [ + 179, + 45, + 0, + 70, + 0, + "IMAGE" + ], + [ + 180, + 70, + 0, + 41, + 0, + "IMAGE" + ], + [ + 191, + 57, + 0, + 58, + 0, + "IMAGE" + ], + [ + 206, + 75, + 1, + 76, + 0, + "VAE" + ], + [ + 208, + 76, + 0, + 55, + 0, + "IMAGE" + ], + [ + 209, + 75, + 1, + 77, + 0, + "VAE" + ], + [ + 210, + 57, + 0, + 77, + 1, + "IMAGE" + ], + [ + 212, + 75, + 0, + 78, + 0, + "COGVIDEOMODEL" + ], + [ + 213, + 30, + 0, + 78, + 1, + "CONDITIONING" + ], + [ + 214, + 31, + 0, + 78, + 2, + "CONDITIONING" + ], + [ + 215, + 77, + 0, + 78, + 3, + "LATENT" + ], + [ + 216, + 78, + 0, + 76, + 1, + "LATENT" + ], + [ + 217, + 30, + 1, + 31, + 0, + "CLIP" + ], + [ + 218, + 57, + 3, + 78, + 9, + "INT" + ] + ], + "groups": [], + "config": {}, + "extra": { + "ds": { + "scale": 0.8390545288825798, + "offset": [ + -318.82552550589344, + 331.70430573737934 + ] + } + }, + "version": 0.4 +} \ No newline at end of file diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_1_0_2b_controlnet_02.json b/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_1_0_2b_controlnet_02.json new file mode 100644 index 0000000000000000000000000000000000000000..30326672d14080308536d174a925078874b2e173 --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_1_0_2b_controlnet_02.json @@ -0,0 +1,1003 @@ +{ + "last_node_id": 48, + "last_link_id": 90, + "nodes": [ + { + "id": 41, + "type": "HEDPreprocessor", + "pos": { + "0": -570, + "1": -76 + }, + "size": { + "0": 315, + "1": 82 + }, + "flags": {}, + "order": 4, + "mode": 0, + "inputs": [ + { + "name": "image", + "type": "IMAGE", + "link": 73 + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 74 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "HEDPreprocessor" + }, + "widgets_values": [ + "enable", + 768 + ] + }, + { + "id": 38, + "type": "VHS_LoadVideo", + "pos": { + "0": -847, + "1": -78 + }, + "size": [ + 247.455078125, + 427.63671875 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "meta_batch", + "type": "VHS_BatchManager", + "link": null, + "shape": 7 + }, + { + "name": "vae", + "type": "VAE", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 73 + ], + "slot_index": 0 + }, + { + "name": "frame_count", + "type": "INT", + "links": null + }, + { + "name": "audio", + "type": "AUDIO", + "links": null + }, + { + "name": "video_info", + "type": "VHS_VIDEOINFO", + "links": null + } + ], + "properties": { + "Node name for S&R": "VHS_LoadVideo" + }, + "widgets_values": { + "video": "car.mp4", + "force_rate": 0, + "force_size": "Disabled", + "custom_width": 512, + "custom_height": 512, + "frame_load_cap": 49, + "skip_first_frames": 0, + "select_every_nth": 1, + "choose video to upload": "image", + "videopreview": { + "hidden": false, + "paused": false, + "params": { + "frame_load_cap": 49, + "skip_first_frames": 0, + "force_rate": 0, + "filename": "car.mp4", + "type": "input", + "format": "video/mp4", + "select_every_nth": 1 + }, + "muted": false + } + } + }, + { + "id": 39, + "type": "ImageResizeKJ", + "pos": { + "0": -563, + "1": 63 + }, + "size": { + "0": 315, + "1": 266 + }, + "flags": {}, + "order": 6, + "mode": 0, + "inputs": [ + { + "name": "image", + "type": "IMAGE", + "link": 74 + }, + { + "name": "get_image_size", + "type": "IMAGE", + "link": null, + "shape": 7 + }, + { + "name": "width_input", + "type": "INT", + "link": null, + "widget": { + "name": "width_input" + }, + "shape": 7 + }, + { + "name": "height_input", + "type": "INT", + "link": null, + "widget": { + "name": "height_input" + }, + "shape": 7 + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 71 + ], + "slot_index": 0 + }, + { + "name": "width", + "type": "INT", + "links": null + }, + { + "name": "height", + "type": "INT", + "links": null + } + ], + "properties": { + "Node name for S&R": "ImageResizeKJ" + }, + "widgets_values": [ + 720, + 480, + "lanczos", + false, + 2, + 0, + 0, + "disabled" + ] + }, + { + "id": 30, + "type": "CogVideoTextEncode", + "pos": { + "0": 130, + "1": 350 + }, + "size": { + "0": 475.7875061035156, + "1": 231.29896545410156 + }, + "flags": {}, + "order": 5, + "mode": 0, + "inputs": [ + { + "name": "clip", + "type": "CLIP", + "link": 54 + } + ], + "outputs": [ + { + "name": "conditioning", + "type": "CONDITIONING", + "links": [ + 84 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "clip", + "type": "CLIP", + "links": [ + 78 + ], + "slot_index": 1 + } + ], + "properties": { + "Node name for S&R": "CogVideoTextEncode" + }, + "widgets_values": [ + "car is moving among mountains", + 1, + false + ] + }, + { + "id": 31, + "type": "CogVideoTextEncode", + "pos": { + "0": 139, + "1": 643 + }, + "size": { + "0": 463.01251220703125, + "1": 144 + }, + "flags": {}, + "order": 7, + "mode": 0, + "inputs": [ + { + "name": "clip", + "type": "CLIP", + "link": 78 + } + ], + "outputs": [ + { + "name": "conditioning", + "type": "CONDITIONING", + "links": [ + 85 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "clip", + "type": "CLIP", + "links": null + } + ], + "properties": { + "Node name for S&R": "CogVideoTextEncode" + }, + "widgets_values": [ + "", + 1, + true + ] + }, + { + "id": 44, + "type": "DownloadAndLoadCogVideoModel", + "pos": { + "0": 326, + "1": -319 + }, + "size": { + "0": 315, + "1": 218 + }, + "flags": {}, + "order": 1, + "mode": 0, + "inputs": [ + { + "name": "block_edit", + "type": "TRANSFORMERBLOCKS", + "link": null, + "shape": 7 + }, + { + "name": "lora", + "type": "COGLORA", + "link": null, + "shape": 7 + }, + { + "name": "compile_args", + "type": "COMPILEARGS", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "model", + "type": "COGVIDEOMODEL", + "links": [ + 83 + ] + }, + { + "name": "vae", + "type": "VAE", + "links": [ + 82 + ], + "slot_index": 1 + } + ], + "properties": { + "Node name for S&R": "DownloadAndLoadCogVideoModel" + }, + "widgets_values": [ + "THUDM/CogVideoX-2b", + "bf16", + "disabled", + false, + "sdpa", + "main_device" + ] + }, + { + "id": 20, + "type": "CLIPLoader", + "pos": { + "0": -175, + "1": -317 + }, + "size": { + "0": 452.912353515625, + "1": 82 + }, + "flags": {}, + "order": 2, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "CLIP", + "type": "CLIP", + "links": [ + 54 + ], + "slot_index": 0, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "CLIPLoader" + }, + "widgets_values": [ + "t5\\google_t5-v1_1-xxl_encoderonly-fp8_e4m3fn.safetensors", + "sd3" + ] + }, + { + "id": 35, + "type": "DownloadAndLoadCogVideoControlNet", + "pos": { + "0": -105, + "1": -182 + }, + "size": { + "0": 378, + "1": 58 + }, + "flags": {}, + "order": 3, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "cogvideo_controlnet", + "type": "COGVIDECONTROLNETMODEL", + "links": [ + 67 + ] + } + ], + "properties": { + "Node name for S&R": "DownloadAndLoadCogVideoControlNet" + }, + "widgets_values": [ + "TheDenk/cogvideox-2b-controlnet-hed-v1" + ] + }, + { + "id": 37, + "type": "CogVideoControlNet", + "pos": { + "0": 220, + "1": 155 + }, + "size": { + "0": 367.79998779296875, + "1": 126 + }, + "flags": {}, + "order": 9, + "mode": 0, + "inputs": [ + { + "name": "controlnet", + "type": "COGVIDECONTROLNETMODEL", + "link": 67 + }, + { + "name": "images", + "type": "IMAGE", + "link": 72 + } + ], + "outputs": [ + { + "name": "cogvideo_controlnet", + "type": "COGVIDECONTROLNET", + "links": [ + 86 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "CogVideoControlNet" + }, + "widgets_values": [ + 1, + 0, + 1 + ] + }, + { + "id": 40, + "type": "GetImageSizeAndCount", + "pos": { + "0": -123, + "1": -34 + }, + "size": { + "0": 277.20001220703125, + "1": 86 + }, + "flags": {}, + "order": 8, + "mode": 0, + "inputs": [ + { + "name": "image", + "type": "IMAGE", + "link": 71 + } + ], + "outputs": [ + { + "name": "image", + "type": "IMAGE", + "links": [ + 72, + 75 + ], + "slot_index": 0 + }, + { + "name": "720 width", + "type": "INT", + "links": [ + 89 + ] + }, + { + "name": "480 height", + "type": "INT", + "links": [ + 90 + ], + "slot_index": 2 + }, + { + "name": "49 count", + "type": "INT", + "links": null + } + ], + "properties": { + "Node name for S&R": "GetImageSizeAndCount" + }, + "widgets_values": [] + }, + { + "id": 47, + "type": "EmptyLatentImage", + "pos": { + "0": 409, + "1": 77 + }, + "size": { + "0": 315, + "1": 106 + }, + "flags": { + "collapsed": true + }, + "order": 10, + "mode": 0, + "inputs": [ + { + "name": "width", + "type": "INT", + "link": 89, + "widget": { + "name": "width" + } + }, + { + "name": "height", + "type": "INT", + "link": 90, + "widget": { + "name": "height" + } + } + ], + "outputs": [ + { + "name": "LATENT", + "type": "LATENT", + "links": [ + 88 + ] + } + ], + "properties": { + "Node name for S&R": "EmptyLatentImage" + }, + "widgets_values": [ + 720, + 480, + 1 + ] + }, + { + "id": 46, + "type": "CogVideoSampler", + "pos": { + "0": 743, + "1": 49 + }, + "size": { + "0": 330, + "1": 574 + }, + "flags": {}, + "order": 11, + "mode": 0, + "inputs": [ + { + "name": "model", + "type": "COGVIDEOMODEL", + "link": 83 + }, + { + "name": "positive", + "type": "CONDITIONING", + "link": 84 + }, + { + "name": "negative", + "type": "CONDITIONING", + "link": 85 + }, + { + "name": "samples", + "type": "LATENT", + "link": 88, + "shape": 7 + }, + { + "name": "image_cond_latents", + "type": "LATENT", + "link": null, + "shape": 7 + }, + { + "name": "context_options", + "type": "COGCONTEXT", + "link": null, + "shape": 7 + }, + { + "name": "controlnet", + "type": "COGVIDECONTROLNET", + "link": 86, + "shape": 7 + }, + { + "name": "tora_trajectory", + "type": "TORAFEATURES", + "link": null, + "shape": 7 + }, + { + "name": "fastercache", + "type": "FASTERCACHEARGS", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "samples", + "type": "LATENT", + "links": [ + 87 + ] + } + ], + "properties": { + "Node name for S&R": "CogVideoSampler" + }, + "widgets_values": [ + 49, + 40, + 6, + 0, + "fixed", + "CogVideoXDDIM", + 1 + ] + }, + { + "id": 45, + "type": "CogVideoDecode", + "pos": { + "0": 758, + "1": 685 + }, + "size": { + "0": 315, + "1": 198 + }, + "flags": {}, + "order": 12, + "mode": 0, + "inputs": [ + { + "name": "vae", + "type": "VAE", + "link": 82 + }, + { + "name": "samples", + "type": "LATENT", + "link": 87 + } + ], + "outputs": [ + { + "name": "images", + "type": "IMAGE", + "links": [ + 81 + ] + } + ], + "properties": { + "Node name for S&R": "CogVideoDecode" + }, + "widgets_values": [ + true, + 240, + 360, + 0.2, + 0.2, + true + ] + }, + { + "id": 42, + "type": "ImageConcatMulti", + "pos": { + "0": 1145, + "1": -24 + }, + "size": { + "0": 210, + "1": 150 + }, + "flags": {}, + "order": 13, + "mode": 0, + "inputs": [ + { + "name": "image_1", + "type": "IMAGE", + "link": 75 + }, + { + "name": "image_2", + "type": "IMAGE", + "link": 81 + } + ], + "outputs": [ + { + "name": "images", + "type": "IMAGE", + "links": [ + 77 + ], + "slot_index": 0 + } + ], + "properties": {}, + "widgets_values": [ + 2, + "right", + false, + null + ] + }, + { + "id": 43, + "type": "VHS_VideoCombine", + "pos": { + "0": 1154, + "1": 202 + }, + "size": [ + 778.7022705078125, + 576.9007568359375 + ], + "flags": {}, + "order": 14, + "mode": 0, + "inputs": [ + { + "name": "images", + "type": "IMAGE", + "link": 77 + }, + { + "name": "audio", + "type": "AUDIO", + "link": null, + "shape": 7 + }, + { + "name": "meta_batch", + "type": "VHS_BatchManager", + "link": null, + "shape": 7 + }, + { + "name": "vae", + "type": "VAE", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "Filenames", + "type": "VHS_FILENAMES", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "VHS_VideoCombine" + }, + "widgets_values": { + "frame_rate": 8, + "loop_count": 0, + "filename_prefix": "CogVideoX_2b_controlnet", + "format": "video/h264-mp4", + "pix_fmt": "yuv420p", + "crf": 19, + "save_metadata": true, + "pingpong": false, + "save_output": true, + "videopreview": { + "hidden": false, + "paused": false, + "params": { + "filename": "CogVideoX2B_controlnet_00003.mp4", + "subfolder": "", + "type": "temp", + "format": "video/h264-mp4", + "frame_rate": 8 + }, + "muted": false + } + } + } + ], + "links": [ + [ + 54, + 20, + 0, + 30, + 0, + "CLIP" + ], + [ + 67, + 35, + 0, + 37, + 0, + "COGVIDECONTROLNETMODEL" + ], + [ + 71, + 39, + 0, + 40, + 0, + "IMAGE" + ], + [ + 72, + 40, + 0, + 37, + 1, + "IMAGE" + ], + [ + 73, + 38, + 0, + 41, + 0, + "IMAGE" + ], + [ + 74, + 41, + 0, + 39, + 0, + "IMAGE" + ], + [ + 75, + 40, + 0, + 42, + 0, + "IMAGE" + ], + [ + 77, + 42, + 0, + 43, + 0, + "IMAGE" + ], + [ + 78, + 30, + 1, + 31, + 0, + "CLIP" + ], + [ + 81, + 45, + 0, + 42, + 1, + "IMAGE" + ], + [ + 82, + 44, + 1, + 45, + 0, + "VAE" + ], + [ + 83, + 44, + 0, + 46, + 0, + "COGVIDEOMODEL" + ], + [ + 84, + 30, + 0, + 46, + 1, + "CONDITIONING" + ], + [ + 85, + 31, + 0, + 46, + 2, + "CONDITIONING" + ], + [ + 86, + 37, + 0, + 46, + 6, + "COGVIDECONTROLNET" + ], + [ + 87, + 46, + 0, + 45, + 1, + "LATENT" + ], + [ + 88, + 47, + 0, + 46, + 3, + "LATENT" + ], + [ + 89, + 40, + 1, + 47, + 0, + "INT" + ], + [ + 90, + 40, + 2, + 47, + 1, + "INT" + ] + ], + "groups": [], + "config": {}, + "extra": { + "ds": { + "scale": 0.7627768444387069, + "offset": [ + 1075.4957551311677, + 398.4420252790512 + ] + } + }, + "version": 0.4 +} \ No newline at end of file diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_1_0_5b_I2V_02.json b/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_1_0_5b_I2V_02.json new file mode 100644 index 0000000000000000000000000000000000000000..ac7816ac9ad5ab15926c110f8c73b3d80c7e05a7 --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_1_0_5b_I2V_02.json @@ -0,0 +1,688 @@ +{ + "last_node_id": 63, + "last_link_id": 149, + "nodes": [ + { + "id": 31, + "type": "CogVideoTextEncode", + "pos": { + "0": 497, + "1": 520 + }, + "size": { + "0": 463.01251220703125, + "1": 144 + }, + "flags": {}, + "order": 6, + "mode": 0, + "inputs": [ + { + "name": "clip", + "type": "CLIP", + "link": 149 + } + ], + "outputs": [ + { + "name": "conditioning", + "type": "CONDITIONING", + "links": [ + 146 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "clip", + "type": "CLIP", + "links": null + } + ], + "properties": { + "Node name for S&R": "CogVideoTextEncode" + }, + "widgets_values": [ + "The video is not of a high quality, it has a low resolution. Watermark present in each frame. Strange motion trajectory. ", + 1, + true + ] + }, + { + "id": 63, + "type": "CogVideoSampler", + "pos": { + "0": 1142, + "1": 74 + }, + "size": [ + 330, + 574 + ], + "flags": {}, + "order": 7, + "mode": 0, + "inputs": [ + { + "name": "model", + "type": "COGVIDEOMODEL", + "link": 144 + }, + { + "name": "positive", + "type": "CONDITIONING", + "link": 145 + }, + { + "name": "negative", + "type": "CONDITIONING", + "link": 146 + }, + { + "name": "samples", + "type": "LATENT", + "link": null, + "shape": 7 + }, + { + "name": "image_cond_latents", + "type": "LATENT", + "link": 147, + "shape": 7 + }, + { + "name": "context_options", + "type": "COGCONTEXT", + "link": null, + "shape": 7 + }, + { + "name": "controlnet", + "type": "COGVIDECONTROLNET", + "link": null, + "shape": 7 + }, + { + "name": "tora_trajectory", + "type": "TORAFEATURES", + "link": null, + "shape": 7 + }, + { + "name": "fastercache", + "type": "FASTERCACHEARGS", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "samples", + "type": "LATENT", + "links": [ + 148 + ] + } + ], + "properties": { + "Node name for S&R": "CogVideoSampler" + }, + "widgets_values": [ + 49, + 25, + 6, + 0, + "fixed", + "CogVideoXDDIM", + 1 + ] + }, + { + "id": 62, + "type": "CogVideoImageEncode", + "pos": { + "0": 1149, + "1": 711 + }, + "size": { + "0": 315, + "1": 122 + }, + "flags": {}, + "order": 5, + "mode": 0, + "inputs": [ + { + "name": "vae", + "type": "VAE", + "link": 141 + }, + { + "name": "start_image", + "type": "IMAGE", + "link": 142 + }, + { + "name": "end_image", + "type": "IMAGE", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "samples", + "type": "LATENT", + "links": [ + 147 + ] + } + ], + "properties": { + "Node name for S&R": "CogVideoImageEncode" + }, + "widgets_values": [ + false, + 0 + ] + }, + { + "id": 59, + "type": "DownloadAndLoadCogVideoModel", + "pos": { + "0": 622, + "1": -25 + }, + "size": { + "0": 315, + "1": 218 + }, + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "block_edit", + "type": "TRANSFORMERBLOCKS", + "link": null, + "shape": 7 + }, + { + "name": "lora", + "type": "COGLORA", + "link": null, + "shape": 7 + }, + { + "name": "compile_args", + "type": "COMPILEARGS", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "model", + "type": "COGVIDEOMODEL", + "links": [ + 144 + ] + }, + { + "name": "vae", + "type": "VAE", + "links": [ + 132, + 141 + ], + "slot_index": 1 + } + ], + "properties": { + "Node name for S&R": "DownloadAndLoadCogVideoModel" + }, + "widgets_values": [ + "THUDM/CogVideoX-5b-I2V", + "bf16", + "disabled", + false, + "sdpa", + "main_device" + ] + }, + { + "id": 30, + "type": "CogVideoTextEncode", + "pos": { + "0": 493, + "1": 303 + }, + "size": { + "0": 471.90142822265625, + "1": 168.08047485351562 + }, + "flags": {}, + "order": 4, + "mode": 0, + "inputs": [ + { + "name": "clip", + "type": "CLIP", + "link": 54 + } + ], + "outputs": [ + { + "name": "conditioning", + "type": "CONDITIONING", + "links": [ + 145 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "clip", + "type": "CLIP", + "links": [ + 149 + ], + "slot_index": 1 + } + ], + "properties": { + "Node name for S&R": "CogVideoTextEncode" + }, + "widgets_values": [ + "a majestic stag is grazing in an enhanced forest, basking in the setting sun filtered by the trees", + 1, + false + ] + }, + { + "id": 37, + "type": "ImageResizeKJ", + "pos": { + "0": 784, + "1": 731 + }, + "size": { + "0": 315, + "1": 266 + }, + "flags": {}, + "order": 3, + "mode": 0, + "inputs": [ + { + "name": "image", + "type": "IMAGE", + "link": 71 + }, + { + "name": "get_image_size", + "type": "IMAGE", + "link": null, + "shape": 7 + }, + { + "name": "width_input", + "type": "INT", + "link": null, + "widget": { + "name": "width_input" + } + }, + { + "name": "height_input", + "type": "INT", + "link": null, + "widget": { + "name": "height_input" + } + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 142 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "width", + "type": "INT", + "links": null, + "shape": 3 + }, + { + "name": "height", + "type": "INT", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "ImageResizeKJ" + }, + "widgets_values": [ + 720, + 480, + "lanczos", + false, + 16, + 0, + 0, + "disabled" + ] + }, + { + "id": 36, + "type": "LoadImage", + "pos": { + "0": 335, + "1": 731 + }, + "size": { + "0": 402.06353759765625, + "1": 396.6225891113281 + }, + "flags": {}, + "order": 1, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 71 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "MASK", + "type": "MASK", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "LoadImage" + }, + "widgets_values": [ + "sd3stag.png", + "image" + ] + }, + { + "id": 20, + "type": "CLIPLoader", + "pos": { + "0": -2, + "1": 304 + }, + "size": { + "0": 451.30548095703125, + "1": 82 + }, + "flags": {}, + "order": 2, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "CLIP", + "type": "CLIP", + "links": [ + 54 + ], + "slot_index": 0, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "CLIPLoader" + }, + "widgets_values": [ + "t5\\google_t5-v1_1-xxl_encoderonly-fp8_e4m3fn.safetensors", + "sd3" + ] + }, + { + "id": 60, + "type": "CogVideoDecode", + "pos": { + "0": 1523, + "1": -6 + }, + "size": { + "0": 315, + "1": 198 + }, + "flags": {}, + "order": 8, + "mode": 0, + "inputs": [ + { + "name": "vae", + "type": "VAE", + "link": 132 + }, + { + "name": "samples", + "type": "LATENT", + "link": 148 + } + ], + "outputs": [ + { + "name": "images", + "type": "IMAGE", + "links": [ + 134 + ] + } + ], + "properties": { + "Node name for S&R": "CogVideoDecode" + }, + "widgets_values": [ + true, + 240, + 360, + 0.2, + 0.2, + true + ] + }, + { + "id": 44, + "type": "VHS_VideoCombine", + "pos": { + "0": 1884, + "1": -6 + }, + "size": [ + 605.3909912109375, + 714.2606608072917 + ], + "flags": {}, + "order": 9, + "mode": 0, + "inputs": [ + { + "name": "images", + "type": "IMAGE", + "link": 134 + }, + { + "name": "audio", + "type": "AUDIO", + "link": null, + "shape": 7 + }, + { + "name": "meta_batch", + "type": "VHS_BatchManager", + "link": null, + "shape": 7 + }, + { + "name": "vae", + "type": "VAE", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "Filenames", + "type": "VHS_FILENAMES", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "VHS_VideoCombine" + }, + "widgets_values": { + "frame_rate": 8, + "loop_count": 0, + "filename_prefix": "CogVideoX-I2V", + "format": "video/h264-mp4", + "pix_fmt": "yuv420p", + "crf": 19, + "save_metadata": true, + "pingpong": false, + "save_output": true, + "videopreview": { + "hidden": false, + "paused": false, + "params": { + "filename": "CogVideoX-I2V_00001.mp4", + "subfolder": "", + "type": "temp", + "format": "video/h264-mp4", + "frame_rate": 8 + }, + "muted": false + } + } + } + ], + "links": [ + [ + 54, + 20, + 0, + 30, + 0, + "CLIP" + ], + [ + 71, + 36, + 0, + 37, + 0, + "IMAGE" + ], + [ + 132, + 59, + 1, + 60, + 0, + "VAE" + ], + [ + 134, + 60, + 0, + 44, + 0, + "IMAGE" + ], + [ + 141, + 59, + 1, + 62, + 0, + "VAE" + ], + [ + 142, + 37, + 0, + 62, + 1, + "IMAGE" + ], + [ + 144, + 59, + 0, + 63, + 0, + "COGVIDEOMODEL" + ], + [ + 145, + 30, + 0, + 63, + 1, + "CONDITIONING" + ], + [ + 146, + 31, + 0, + 63, + 2, + "CONDITIONING" + ], + [ + 147, + 62, + 0, + 63, + 4, + "LATENT" + ], + [ + 148, + 63, + 0, + 60, + 1, + "LATENT" + ], + [ + 149, + 30, + 1, + 31, + 0, + "CLIP" + ] + ], + "groups": [], + "config": {}, + "extra": { + "ds": { + "scale": 0.7627768444387059, + "offset": [ + 648.7113591814891, + 185.9907078691075 + ] + } + }, + "version": 0.4 +} \ No newline at end of file diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_1_0_5b_I2V_Tora_02.json b/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_1_0_5b_I2V_Tora_02.json new file mode 100644 index 0000000000000000000000000000000000000000..ea43f2915e3d69f831514d28b3647928a5059f8b --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_1_0_5b_I2V_Tora_02.json @@ -0,0 +1,1710 @@ +{ + "last_node_id": 92, + "last_link_id": 223, + "nodes": [ + { + "id": 31, + "type": "CogVideoTextEncode", + "pos": { + "0": 497, + "1": 520 + }, + "size": { + "0": 463.01251220703125, + "1": 144 + }, + "flags": {}, + "order": 13, + "mode": 0, + "inputs": [ + { + "name": "clip", + "type": "CLIP", + "link": 209 + } + ], + "outputs": [ + { + "name": "conditioning", + "type": "CONDITIONING", + "links": [ + 198 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "clip", + "type": "CLIP", + "links": null + } + ], + "properties": { + "Node name for S&R": "CogVideoTextEncode" + }, + "widgets_values": [ + "The video is not of a high quality, it has a low resolution. Watermark present in each frame. Strange motion trajectory. ", + 1, + true + ] + }, + { + "id": 78, + "type": "ToraEncodeTrajectory", + "pos": { + "0": 1053, + "1": 640 + }, + "size": [ + 355.20001220703125, + 246 + ], + "flags": {}, + "order": 18, + "mode": 0, + "inputs": [ + { + "name": "tora_model", + "type": "TORAMODEL", + "link": 193 + }, + { + "name": "vae", + "type": "VAE", + "link": 205 + }, + { + "name": "coordinates", + "type": "STRING", + "link": 220, + "widget": { + "name": "coordinates" + } + }, + { + "name": "num_frames", + "type": "INT", + "link": 189, + "widget": { + "name": "num_frames" + } + }, + { + "name": "width", + "type": "INT", + "link": 190, + "widget": { + "name": "width" + } + }, + { + "name": "height", + "type": "INT", + "link": 191, + "widget": { + "name": "height" + } + } + ], + "outputs": [ + { + "name": "tora_trajectory", + "type": "TORAFEATURES", + "links": [ + 200 + ] + }, + { + "name": "video_flow_images", + "type": "IMAGE", + "links": [ + 203 + ], + "slot_index": 1 + } + ], + "properties": { + "Node name for S&R": "ToraEncodeTrajectory" + }, + "widgets_values": [ + "", + 720, + 480, + 49, + 1, + 0, + 1, + true + ] + }, + { + "id": 73, + "type": "ImageResizeKJ", + "pos": { + "0": -436, + "1": 527 + }, + "size": { + "0": 315, + "1": 266 + }, + "flags": {}, + "order": 7, + "mode": 0, + "inputs": [ + { + "name": "image", + "type": "IMAGE", + "link": 166 + }, + { + "name": "get_image_size", + "type": "IMAGE", + "link": null, + "shape": 7 + }, + { + "name": "width_input", + "type": "INT", + "link": null, + "widget": { + "name": "width_input" + }, + "shape": 7 + }, + { + "name": "height_input", + "type": "INT", + "link": null, + "widget": { + "name": "height_input" + }, + "shape": 7 + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 167, + 187, + 210, + 216 + ], + "slot_index": 0 + }, + { + "name": "width", + "type": "INT", + "links": null + }, + { + "name": "height", + "type": "INT", + "links": null + } + ], + "properties": { + "Node name for S&R": "ImageResizeKJ" + }, + "widgets_values": [ + 720, + 480, + "nearest-exact", + false, + 2, + 0, + 0, + "center" + ] + }, + { + "id": 72, + "type": "LoadImage", + "pos": { + "0": -820, + "1": 531 + }, + "size": { + "0": 315, + "1": 314 + }, + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 166 + ], + "slot_index": 0 + }, + { + "name": "MASK", + "type": "MASK", + "links": null + } + ], + "properties": { + "Node name for S&R": "LoadImage" + }, + "widgets_values": [ + "pasted/image (473).png", + "image" + ] + }, + { + "id": 20, + "type": "CLIPLoader", + "pos": { + "0": -21, + "1": 288 + }, + "size": { + "0": 451.30548095703125, + "1": 82 + }, + "flags": {}, + "order": 1, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "CLIP", + "type": "CLIP", + "links": [ + 54 + ], + "slot_index": 0, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "CLIPLoader" + }, + "widgets_values": [ + "t5\\google_t5-v1_1-xxl_encoderonly-fp8_e4m3fn.safetensors", + "sd3" + ] + }, + { + "id": 71, + "type": "CogVideoImageEncode", + "pos": { + "0": 651, + "1": 96 + }, + "size": { + "0": 315, + "1": 122 + }, + "flags": {}, + "order": 9, + "mode": 0, + "inputs": [ + { + "name": "vae", + "type": "VAE", + "link": 208 + }, + { + "name": "start_image", + "type": "IMAGE", + "link": 167 + }, + { + "name": "end_image", + "type": "IMAGE", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "samples", + "type": "LATENT", + "links": [ + 199 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "CogVideoImageEncode" + }, + "widgets_values": [ + 16, + false + ] + }, + { + "id": 67, + "type": "GetMaskSizeAndCount", + "pos": { + "0": 750, + "1": 775 + }, + "size": { + "0": 264.5999755859375, + "1": 86 + }, + "flags": { + "collapsed": true + }, + "order": 14, + "mode": 0, + "inputs": [ + { + "name": "mask", + "type": "MASK", + "link": 146 + } + ], + "outputs": [ + { + "name": "mask", + "type": "MASK", + "links": null + }, + { + "name": "720 width", + "type": "INT", + "links": [ + 149, + 190 + ], + "slot_index": 1 + }, + { + "name": "480 height", + "type": "INT", + "links": [ + 150, + 191 + ], + "slot_index": 2 + }, + { + "name": "49 count", + "type": "INT", + "links": [ + 189, + 201 + ], + "slot_index": 3 + } + ], + "properties": { + "Node name for S&R": "GetMaskSizeAndCount" + }, + "widgets_values": [] + }, + { + "id": 56, + "type": "CogVideoDecode", + "pos": { + "0": 1582, + "1": -66 + }, + "size": { + "0": 300.396484375, + "1": 198 + }, + "flags": {}, + "order": 21, + "mode": 0, + "inputs": [ + { + "name": "vae", + "type": "VAE", + "link": 206 + }, + { + "name": "samples", + "type": "LATENT", + "link": 202 + } + ], + "outputs": [ + { + "name": "images", + "type": "IMAGE", + "links": [ + 155 + ], + "slot_index": 0, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "CogVideoDecode" + }, + "widgets_values": [ + true, + 240, + 360, + 0.2, + 0.2, + true + ] + }, + { + "id": 30, + "type": "CogVideoTextEncode", + "pos": { + "0": 498, + "1": 293 + }, + "size": { + "0": 471.90142822265625, + "1": 168.08047485351562 + }, + "flags": {}, + "order": 8, + "mode": 0, + "inputs": [ + { + "name": "clip", + "type": "CLIP", + "link": 54 + } + ], + "outputs": [ + { + "name": "conditioning", + "type": "CONDITIONING", + "links": [ + 197 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "clip", + "type": "CLIP", + "links": [ + 209 + ], + "slot_index": 1 + } + ], + "properties": { + "Node name for S&R": "CogVideoTextEncode" + }, + "widgets_values": [ + "flying car lifts off in the air in front of a house", + 1, + false + ] + }, + { + "id": 44, + "type": "VHS_VideoCombine", + "pos": { + "0": 2229, + "1": -113 + }, + "size": [ + 1388.8330963815574, + 1236.555397587705 + ], + "flags": {}, + "order": 23, + "mode": 0, + "inputs": [ + { + "name": "images", + "type": "IMAGE", + "link": 156 + }, + { + "name": "audio", + "type": "AUDIO", + "link": null, + "shape": 7 + }, + { + "name": "meta_batch", + "type": "VHS_BatchManager", + "link": null, + "shape": 7 + }, + { + "name": "vae", + "type": "VAE", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "Filenames", + "type": "VHS_FILENAMES", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "VHS_VideoCombine" + }, + "widgets_values": { + "frame_rate": 16, + "loop_count": 0, + "filename_prefix": "CogVideoX-Tora", + "format": "video/h264-mp4", + "pix_fmt": "yuv420p", + "crf": 19, + "save_metadata": true, + "pingpong": false, + "save_output": false, + "videopreview": { + "hidden": false, + "paused": false, + "params": { + "filename": "CogVideoX-Tora_00009.mp4", + "subfolder": "", + "type": "temp", + "format": "video/h264-mp4", + "frame_rate": 16 + }, + "muted": false + } + } + }, + { + "id": 60, + "type": "SplineEditor", + "pos": { + "0": -1367, + "1": 1222 + }, + "size": [ + 765, + 910 + ], + "flags": {}, + "order": 10, + "mode": 0, + "inputs": [ + { + "name": "bg_image", + "type": "IMAGE", + "link": 187, + "shape": 7 + } + ], + "outputs": [ + { + "name": "mask", + "type": "MASK", + "links": [ + 146 + ], + "slot_index": 0 + }, + { + "name": "coord_str", + "type": "STRING", + "links": [ + 212 + ], + "slot_index": 1 + }, + { + "name": "float", + "type": "FLOAT", + "links": null + }, + { + "name": "count", + "type": "INT", + "links": null + }, + { + "name": "normalized_str", + "type": "STRING", + "links": null + } + ], + "properties": { + "Node name for S&R": "SplineEditor", + "points": "SplineEditor", + "imgData": { + "name": "bg_image", + "base64": [ + "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" + ] + } + }, + "widgets_values": [ + "[{\"x\":568.1871482594877,\"y\":385.0405294042721},{\"x\":566.745048898423,\"y\":216.3149041597034}]", + "[{\"x\":568.1871337890625,\"y\":385.04052734375},{\"x\":568.1571044921875,\"y\":381.525390625},{\"x\":568.1270141601562,\"y\":378.01031494140625},{\"x\":568.0969848632812,\"y\":374.49517822265625},{\"x\":568.0669555664062,\"y\":370.9800720214844},{\"x\":568.0369262695312,\"y\":367.4649353027344},{\"x\":568.0068969726562,\"y\":363.9498291015625},{\"x\":567.976806640625,\"y\":360.4346923828125},{\"x\":567.94677734375,\"y\":356.9195861816406},{\"x\":567.916748046875,\"y\":353.40447998046875},{\"x\":567.88671875,\"y\":349.88934326171875},{\"x\":567.8566284179688,\"y\":346.374267578125},{\"x\":567.8265991210938,\"y\":342.859130859375},{\"x\":567.7965698242188,\"y\":339.343994140625},{\"x\":567.7665405273438,\"y\":335.8288879394531},{\"x\":567.7364501953125,\"y\":332.31378173828125},{\"x\":567.7064208984375,\"y\":328.79864501953125},{\"x\":567.6763916015625,\"y\":325.2835388183594},{\"x\":567.6463623046875,\"y\":321.7684326171875},{\"x\":567.6163330078125,\"y\":318.2532958984375},{\"x\":567.5862426757812,\"y\":314.7381896972656},{\"x\":567.5562133789062,\"y\":311.22308349609375},{\"x\":567.5261840820312,\"y\":307.70794677734375},{\"x\":567.4961547851562,\"y\":304.1928405761719},{\"x\":567.466064453125,\"y\":300.677734375},{\"x\":567.43603515625,\"y\":297.16259765625},{\"x\":567.406005859375,\"y\":293.6474914550781},{\"x\":567.3759765625,\"y\":290.1323547363281},{\"x\":567.345947265625,\"y\":286.61724853515625},{\"x\":567.3158569335938,\"y\":283.1021423339844},{\"x\":567.2858276367188,\"y\":279.5870056152344},{\"x\":567.2557983398438,\"y\":276.0718994140625},{\"x\":567.2257690429688,\"y\":272.5567932128906},{\"x\":567.1956787109375,\"y\":269.0416564941406},{\"x\":567.1656494140625,\"y\":265.52655029296875},{\"x\":567.1356201171875,\"y\":262.01141357421875},{\"x\":567.1055908203125,\"y\":258.4963073730469},{\"x\":567.0755004882812,\"y\":254.981201171875},{\"x\":567.0454711914062,\"y\":251.46607971191406},{\"x\":567.0154418945312,\"y\":247.95095825195312},{\"x\":566.9854125976562,\"y\":244.43585205078125},{\"x\":566.9553833007812,\"y\":240.9207305908203},{\"x\":566.92529296875,\"y\":237.40560913085938},{\"x\":566.895263671875,\"y\":233.8905029296875},{\"x\":566.865234375,\"y\":230.3753662109375},{\"x\":566.835205078125,\"y\":226.86026000976562},{\"x\":566.8051147460938,\"y\":223.3451385498047},{\"x\":566.7750854492188,\"y\":219.8300323486328},{\"x\":566.7450561523438,\"y\":216.31491088867188}]", + 720, + 480, + 49, + "path", + "basis", + 0.5, + 1, + "list", + 0, + 1, + null, + null, + null + ] + }, + { + "id": 82, + "type": "SplineEditor", + "pos": { + "0": -564, + "1": 1226 + }, + "size": [ + 765, + 910 + ], + "flags": {}, + "order": 11, + "mode": 0, + "inputs": [ + { + "name": "bg_image", + "type": "IMAGE", + "link": 210, + "shape": 7 + } + ], + "outputs": [ + { + "name": "mask", + "type": "MASK", + "links": [], + "slot_index": 0 + }, + { + "name": "coord_str", + "type": "STRING", + "links": [ + 211 + ], + "slot_index": 1 + }, + { + "name": "float", + "type": "FLOAT", + "links": null + }, + { + "name": "count", + "type": "INT", + "links": null + }, + { + "name": "normalized_str", + "type": "STRING", + "links": null + } + ], + "properties": { + "Node name for S&R": "SplineEditor", + "points": "SplineEditor", + "imgData": { + "name": "bg_image", + "base64": [ + "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" + ] + } + }, + "widgets_values": [ + "[{\"x\":174.49402268882744,\"y\":383.8868499154203},{\"x\":173.05192332776272,\"y\":200.4518111879918}]", + "[{\"x\":174.4940185546875,\"y\":383.8868408203125},{\"x\":174.46397399902344,\"y\":380.0652770996094},{\"x\":174.43392944335938,\"y\":376.24371337890625},{\"x\":174.4038848876953,\"y\":372.4221496582031},{\"x\":174.37384033203125,\"y\":368.6005859375},{\"x\":174.3437957763672,\"y\":364.77899169921875},{\"x\":174.31375122070312,\"y\":360.95745849609375},{\"x\":174.28370666503906,\"y\":357.1358947753906},{\"x\":174.253662109375,\"y\":353.3143310546875},{\"x\":174.22361755371094,\"y\":349.4927673339844},{\"x\":174.19357299804688,\"y\":345.67120361328125},{\"x\":174.16354370117188,\"y\":341.8496398925781},{\"x\":174.1334991455078,\"y\":338.028076171875},{\"x\":174.10345458984375,\"y\":334.2065124511719},{\"x\":174.0734100341797,\"y\":330.38494873046875},{\"x\":174.04336547851562,\"y\":326.56341552734375},{\"x\":174.01332092285156,\"y\":322.7418212890625},{\"x\":173.9832763671875,\"y\":318.9202880859375},{\"x\":173.95323181152344,\"y\":315.09869384765625},{\"x\":173.92318725585938,\"y\":311.2771301269531},{\"x\":173.8931427001953,\"y\":307.45556640625},{\"x\":173.86309814453125,\"y\":303.6340026855469},{\"x\":173.8330535888672,\"y\":299.81243896484375},{\"x\":173.80300903320312,\"y\":295.9908752441406},{\"x\":173.77296447753906,\"y\":292.1693115234375},{\"x\":173.742919921875,\"y\":288.3477783203125},{\"x\":173.712890625,\"y\":284.52618408203125},{\"x\":173.68284606933594,\"y\":280.70465087890625},{\"x\":173.65280151367188,\"y\":276.8830871582031},{\"x\":173.6227569580078,\"y\":273.0615234375},{\"x\":173.59271240234375,\"y\":269.2399597167969},{\"x\":173.5626678466797,\"y\":265.41839599609375},{\"x\":173.53262329101562,\"y\":261.5968322753906},{\"x\":173.50257873535156,\"y\":257.7752685546875},{\"x\":173.4725341796875,\"y\":253.95370483398438},{\"x\":173.44248962402344,\"y\":250.13214111328125},{\"x\":173.41244506835938,\"y\":246.31056213378906},{\"x\":173.3824005126953,\"y\":242.489013671875},{\"x\":173.35235595703125,\"y\":238.66744995117188},{\"x\":173.3223114013672,\"y\":234.84588623046875},{\"x\":173.29226684570312,\"y\":231.02430725097656},{\"x\":173.26223754882812,\"y\":227.2027587890625},{\"x\":173.23219299316406,\"y\":223.38119506835938},{\"x\":173.2021484375,\"y\":219.5596160888672},{\"x\":173.17210388183594,\"y\":215.73806762695312},{\"x\":173.14205932617188,\"y\":211.91650390625},{\"x\":173.1120147705078,\"y\":208.09494018554688},{\"x\":173.08197021484375,\"y\":204.27337646484375},{\"x\":173.0519256591797,\"y\":200.45181274414062}]", + 720, + 480, + 49, + "path", + "basis", + 0.5, + 1, + "list", + 0, + 1, + null, + null, + null + ] + }, + { + "id": 83, + "type": "AppendStringsToList", + "pos": { + "0": 334, + "1": 915 + }, + "size": [ + 315, + 82 + ], + "flags": { + "collapsed": false + }, + "order": 15, + "mode": 0, + "inputs": [ + { + "name": "string1", + "type": "STRING", + "link": 212, + "widget": { + "name": "string1" + } + }, + { + "name": "string2", + "type": "STRING", + "link": 211, + "widget": { + "name": "string2" + } + } + ], + "outputs": [ + { + "name": "STRING", + "type": "STRING", + "links": [ + 217 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "AppendStringsToList" + }, + "widgets_values": [ + "", + "" + ] + }, + { + "id": 86, + "type": "AppendStringsToList", + "pos": { + "0": 683, + "1": 916 + }, + "size": [ + 315, + 82 + ], + "flags": { + "collapsed": false + }, + "order": 16, + "mode": 0, + "inputs": [ + { + "name": "string1", + "type": "STRING", + "link": 217, + "widget": { + "name": "string1" + } + }, + { + "name": "string2", + "type": "STRING", + "link": 218, + "widget": { + "name": "string2" + } + } + ], + "outputs": [ + { + "name": "STRING", + "type": "STRING", + "links": [ + 219, + 220 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "AppendStringsToList" + }, + "widgets_values": [ + "", + "" + ] + }, + { + "id": 65, + "type": "CreateShapeImageOnPath", + "pos": { + "0": 1189.82080078125, + "1": 1284.833251953125 + }, + "size": { + "0": 313.4619445800781, + "1": 286 + }, + "flags": {}, + "order": 17, + "mode": 0, + "inputs": [ + { + "name": "coordinates", + "type": "STRING", + "link": 219, + "widget": { + "name": "coordinates" + } + }, + { + "name": "size_multiplier", + "type": "FLOAT", + "link": null, + "widget": { + "name": "size_multiplier" + }, + "shape": 7 + }, + { + "name": "frame_width", + "type": "INT", + "link": 149, + "widget": { + "name": "frame_width" + } + }, + { + "name": "frame_height", + "type": "INT", + "link": 150, + "widget": { + "name": "frame_height" + } + } + ], + "outputs": [ + { + "name": "image", + "type": "IMAGE", + "links": [ + 153 + ], + "slot_index": 0 + }, + { + "name": "mask", + "type": "MASK", + "links": [ + 154 + ], + "slot_index": 1 + } + ], + "properties": { + "Node name for S&R": "CreateShapeImageOnPath" + }, + "widgets_values": [ + "circle", + "", + 512, + 512, + 12, + 12, + "red", + "black", + 0, + 1, + [ + 1 + ], + 1.3 + ] + }, + { + "id": 68, + "type": "ImageCompositeMasked", + "pos": { + "0": 1528.82080078125, + "1": 1280.833251953125 + }, + "size": { + "0": 315, + "1": 146 + }, + "flags": {}, + "order": 22, + "mode": 0, + "inputs": [ + { + "name": "destination", + "type": "IMAGE", + "link": 155 + }, + { + "name": "source", + "type": "IMAGE", + "link": 153 + }, + { + "name": "mask", + "type": "MASK", + "link": 154, + "shape": 7 + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 156 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "ImageCompositeMasked" + }, + "widgets_values": [ + 0, + 0, + false + ] + }, + { + "id": 91, + "type": "Note", + "pos": { + "0": 1565.82080078125, + "1": 1475.833251953125 + }, + "size": [ + 251.63747656176258, + 73.90463053872986 + ], + "flags": {}, + "order": 2, + "mode": 0, + "inputs": [], + "outputs": [], + "properties": {}, + "widgets_values": [ + "This is only for visualization" + ], + "color": "#432", + "bgcolor": "#653" + }, + { + "id": 85, + "type": "SplineEditor", + "pos": { + "0": 232, + "1": 1226 + }, + "size": [ + 765, + 910 + ], + "flags": {}, + "order": 12, + "mode": 0, + "inputs": [ + { + "name": "bg_image", + "type": "IMAGE", + "link": 216, + "shape": 7 + } + ], + "outputs": [ + { + "name": "mask", + "type": "MASK", + "links": [], + "slot_index": 0 + }, + { + "name": "coord_str", + "type": "STRING", + "links": [ + 218 + ], + "slot_index": 1 + }, + { + "name": "float", + "type": "FLOAT", + "links": null + }, + { + "name": "count", + "type": "INT", + "links": null + }, + { + "name": "normalized_str", + "type": "STRING", + "links": null + } + ], + "properties": { + "Node name for S&R": "SplineEditor", + "points": "SplineEditor", + "imgData": { + "name": "bg_image", + "base64": [ + "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" + ] + } + }, + "widgets_values": [ + "[{\"x\":374.36899413239337,\"y\":315.67555013706055},{\"x\":377.5416127267357,\"y\":142.76783674540425,\"fix\":null}]", + "[{\"x\":374.3689880371094,\"y\":315.675537109375},{\"x\":374.4350891113281,\"y\":312.07330322265625},{\"x\":374.5011901855469,\"y\":308.4710388183594},{\"x\":374.5672912597656,\"y\":304.8688049316406},{\"x\":374.6333923339844,\"y\":301.26654052734375},{\"x\":374.6994934082031,\"y\":297.664306640625},{\"x\":374.76556396484375,\"y\":294.06207275390625},{\"x\":374.8316650390625,\"y\":290.4598083496094},{\"x\":374.89776611328125,\"y\":286.8575744628906},{\"x\":374.9638671875,\"y\":283.25531005859375},{\"x\":375.02996826171875,\"y\":279.653076171875},{\"x\":375.0960693359375,\"y\":276.05084228515625},{\"x\":375.1621398925781,\"y\":272.4486083984375},{\"x\":375.2282409667969,\"y\":268.84637451171875},{\"x\":375.2943420410156,\"y\":265.2441101074219},{\"x\":375.3604431152344,\"y\":261.6418762207031},{\"x\":375.4265441894531,\"y\":258.03961181640625},{\"x\":375.4926452636719,\"y\":254.4373779296875},{\"x\":375.5587463378906,\"y\":250.83514404296875},{\"x\":375.62481689453125,\"y\":247.23291015625},{\"x\":375.69091796875,\"y\":243.63064575195312},{\"x\":375.75701904296875,\"y\":240.02841186523438},{\"x\":375.8231201171875,\"y\":236.42617797851562},{\"x\":375.88922119140625,\"y\":232.8239288330078},{\"x\":375.955322265625,\"y\":229.2216796875},{\"x\":376.02142333984375,\"y\":225.61944580078125},{\"x\":376.0874938964844,\"y\":222.01718139648438},{\"x\":376.1535949707031,\"y\":218.41494750976562},{\"x\":376.2196960449219,\"y\":214.81271362304688},{\"x\":376.2857971191406,\"y\":211.21046447753906},{\"x\":376.3518981933594,\"y\":207.60821533203125},{\"x\":376.4179992675781,\"y\":204.0059814453125},{\"x\":376.48406982421875,\"y\":200.4037322998047},{\"x\":376.5501708984375,\"y\":196.80148315429688},{\"x\":376.61627197265625,\"y\":193.19924926757812},{\"x\":376.682373046875,\"y\":189.5970001220703},{\"x\":376.74847412109375,\"y\":185.9947509765625},{\"x\":376.8145751953125,\"y\":182.39251708984375},{\"x\":376.88067626953125,\"y\":178.790283203125},{\"x\":376.9467468261719,\"y\":175.18801879882812},{\"x\":377.0128479003906,\"y\":171.58578491210938},{\"x\":377.0789489746094,\"y\":167.98355102539062},{\"x\":377.1450500488281,\"y\":164.38128662109375},{\"x\":377.2111511230469,\"y\":160.779052734375},{\"x\":377.2772521972656,\"y\":157.17681884765625},{\"x\":377.34332275390625,\"y\":153.57456970214844},{\"x\":377.409423828125,\"y\":149.97232055664062},{\"x\":377.47552490234375,\"y\":146.3700714111328},{\"x\":377.5416259765625,\"y\":142.76783752441406}]", + 720, + 480, + 49, + "path", + "basis", + 0.5, + 1, + "list", + 0, + 1, + null, + null, + null + ] + }, + { + "id": 75, + "type": "DownloadAndLoadToraModel", + "pos": { + "0": 1074, + "1": 937 + }, + "size": { + "0": 315, + "1": 58 + }, + "flags": {}, + "order": 3, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "tora_model", + "type": "TORAMODEL", + "links": [ + 193 + ] + } + ], + "properties": { + "Node name for S&R": "DownloadAndLoadToraModel" + }, + "widgets_values": [ + "kijai/CogVideoX-5b-Tora" + ] + }, + { + "id": 66, + "type": "VHS_VideoCombine", + "pos": { + "0": 1485, + "1": 436 + }, + "size": [ + 605.3909912109375, + 714.2606608072917 + ], + "flags": {}, + "order": 20, + "mode": 0, + "inputs": [ + { + "name": "images", + "type": "IMAGE", + "link": 203 + }, + { + "name": "audio", + "type": "AUDIO", + "link": null, + "shape": 7 + }, + { + "name": "meta_batch", + "type": "VHS_BatchManager", + "link": null, + "shape": 7 + }, + { + "name": "vae", + "type": "VAE", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "Filenames", + "type": "VHS_FILENAMES", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "VHS_VideoCombine" + }, + "widgets_values": { + "frame_rate": 8, + "loop_count": 0, + "filename_prefix": "CogVideoX-Tora-trajectory", + "format": "video/h264-mp4", + "pix_fmt": "yuv420p", + "crf": 19, + "save_metadata": true, + "pingpong": false, + "save_output": false, + "videopreview": { + "hidden": false, + "paused": false, + "params": { + "filename": "CogVideoX-Tora-trajectory_00010.mp4", + "subfolder": "", + "type": "temp", + "format": "video/h264-mp4", + "frame_rate": 8 + }, + "muted": false + } + } + }, + { + "id": 90, + "type": "Note", + "pos": { + "0": 339, + "1": 1066 + }, + "size": [ + 251.63747656176258, + 73.90463053872986 + ], + "flags": {}, + "order": 4, + "mode": 0, + "inputs": [], + "outputs": [], + "properties": {}, + "widgets_values": [ + "Three sets of coordinates are created here and appened to a list" + ], + "color": "#432", + "bgcolor": "#653" + }, + { + "id": 92, + "type": "Note", + "pos": { + "0": 1200, + "1": 1045 + }, + "size": [ + 251.63747656176258, + 73.90463053872986 + ], + "flags": {}, + "order": 5, + "mode": 0, + "inputs": [], + "outputs": [], + "properties": {}, + "widgets_values": [ + "Coordinates are used to create optical flow video, which is then encoded for Tora" + ], + "color": "#432", + "bgcolor": "#653" + }, + { + "id": 80, + "type": "DownloadAndLoadCogVideoModel", + "pos": { + "0": 106, + "1": -85 + }, + "size": { + "0": 315, + "1": 218 + }, + "flags": {}, + "order": 6, + "mode": 0, + "inputs": [ + { + "name": "block_edit", + "type": "TRANSFORMERBLOCKS", + "link": null, + "shape": 7 + }, + { + "name": "lora", + "type": "COGLORA", + "link": null, + "shape": 7 + }, + { + "name": "compile_args", + "type": "COMPILEARGS", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "model", + "type": "COGVIDEOMODEL", + "links": [ + 204 + ] + }, + { + "name": "vae", + "type": "VAE", + "links": [ + 205, + 206, + 208 + ] + } + ], + "properties": { + "Node name for S&R": "DownloadAndLoadCogVideoModel" + }, + "widgets_values": [ + "THUDM/CogVideoX-5b-I2V", + "bf16", + "disabled", + false, + "sdpa", + "main_device" + ] + }, + { + "id": 79, + "type": "CogVideoSampler", + "pos": { + "0": 1089, + "1": 17 + }, + "size": [ + 330, + 570 + ], + "flags": {}, + "order": 19, + "mode": 0, + "inputs": [ + { + "name": "model", + "type": "COGVIDEOMODEL", + "link": 204 + }, + { + "name": "positive", + "type": "CONDITIONING", + "link": 197 + }, + { + "name": "negative", + "type": "CONDITIONING", + "link": 198 + }, + { + "name": "samples", + "type": "LATENT", + "link": null, + "shape": 7 + }, + { + "name": "image_cond_latents", + "type": "LATENT", + "link": 199, + "shape": 7 + }, + { + "name": "context_options", + "type": "COGCONTEXT", + "link": null, + "shape": 7 + }, + { + "name": "controlnet", + "type": "COGVIDECONTROLNET", + "link": null, + "shape": 7 + }, + { + "name": "tora_trajectory", + "type": "TORAFEATURES", + "link": 200, + "shape": 7 + }, + { + "name": "fastercache", + "type": "FASTERCACHEARGS", + "link": null, + "shape": 7 + }, + { + "name": "num_frames", + "type": "INT", + "link": 201, + "widget": { + "name": "num_frames" + } + } + ], + "outputs": [ + { + "name": "samples", + "type": "LATENT", + "links": [ + 202 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "CogVideoSampler" + }, + "widgets_values": [ + 49, + 40, + 6, + 3, + "fixed", + "CogVideoXDDIM", + 1 + ] + } + ], + "links": [ + [ + 54, + 20, + 0, + 30, + 0, + "CLIP" + ], + [ + 146, + 60, + 0, + 67, + 0, + "MASK" + ], + [ + 149, + 67, + 1, + 65, + 2, + "INT" + ], + [ + 150, + 67, + 2, + 65, + 3, + "INT" + ], + [ + 153, + 65, + 0, + 68, + 1, + "IMAGE" + ], + [ + 154, + 65, + 1, + 68, + 2, + "MASK" + ], + [ + 155, + 56, + 0, + 68, + 0, + "IMAGE" + ], + [ + 156, + 68, + 0, + 44, + 0, + "IMAGE" + ], + [ + 166, + 72, + 0, + 73, + 0, + "IMAGE" + ], + [ + 167, + 73, + 0, + 71, + 1, + "IMAGE" + ], + [ + 187, + 73, + 0, + 60, + 0, + "IMAGE" + ], + [ + 189, + 67, + 3, + 78, + 3, + "INT" + ], + [ + 190, + 67, + 1, + 78, + 4, + "INT" + ], + [ + 191, + 67, + 2, + 78, + 5, + "INT" + ], + [ + 193, + 75, + 0, + 78, + 0, + "TORAMODEL" + ], + [ + 197, + 30, + 0, + 79, + 1, + "CONDITIONING" + ], + [ + 198, + 31, + 0, + 79, + 2, + "CONDITIONING" + ], + [ + 199, + 71, + 0, + 79, + 4, + "LATENT" + ], + [ + 200, + 78, + 0, + 79, + 7, + "TORAFEATURES" + ], + [ + 201, + 67, + 3, + 79, + 9, + "INT" + ], + [ + 202, + 79, + 0, + 56, + 1, + "LATENT" + ], + [ + 203, + 78, + 1, + 66, + 0, + "IMAGE" + ], + [ + 204, + 80, + 0, + 79, + 0, + "COGVIDEOMODEL" + ], + [ + 205, + 80, + 1, + 78, + 1, + "VAE" + ], + [ + 206, + 80, + 1, + 56, + 0, + "VAE" + ], + [ + 208, + 80, + 1, + 71, + 0, + "VAE" + ], + [ + 209, + 30, + 1, + 31, + 0, + "CLIP" + ], + [ + 210, + 73, + 0, + 82, + 0, + "IMAGE" + ], + [ + 211, + 82, + 1, + 83, + 1, + "STRING" + ], + [ + 212, + 60, + 1, + 83, + 0, + "STRING" + ], + [ + 216, + 73, + 0, + 85, + 0, + "IMAGE" + ], + [ + 217, + 83, + 0, + 86, + 0, + "STRING" + ], + [ + 218, + 85, + 1, + 86, + 1, + "STRING" + ], + [ + 219, + 86, + 0, + 65, + 0, + "STRING" + ], + [ + 220, + 86, + 0, + 78, + 2, + "STRING" + ] + ], + "groups": [ + { + "title": "VisualizeTrajectories", + "bounding": [ + 1124, + 1198, + 832, + 413 + ], + "color": "#3f789e", + "font_size": 24, + "flags": {} + } + ], + "config": {}, + "extra": { + "ds": { + "scale": 0.39142513012212404, + "offset": [ + 2198.0900495441047, + 429.7964748076673 + ] + } + }, + "version": 0.4 +} \ No newline at end of file diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_1_0_5b_I2V_noise_warp_01.json b/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_1_0_5b_I2V_noise_warp_01.json new file mode 100644 index 0000000000000000000000000000000000000000..b6f3eb896bba3232f20bed40c020a611504780e5 --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_1_0_5b_I2V_noise_warp_01.json @@ -0,0 +1,1291 @@ +{ + "last_node_id": 84, + "last_link_id": 190, + "nodes": [ + { + "id": 31, + "type": "CogVideoTextEncode", + "pos": [ + 497, + 520 + ], + "size": [ + 463.01251220703125, + 144 + ], + "flags": {}, + "order": 10, + "mode": 0, + "inputs": [ + { + "name": "clip", + "type": "CLIP", + "link": 149 + } + ], + "outputs": [ + { + "name": "conditioning", + "type": "CONDITIONING", + "links": [ + 146 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "clip", + "type": "CLIP", + "links": null + } + ], + "properties": { + "Node name for S&R": "CogVideoTextEncode" + }, + "widgets_values": [ + "The video is not of a high quality, it has a low resolution. Watermark present in each frame. Strange motion trajectory. ", + 1, + true + ] + }, + { + "id": 20, + "type": "CLIPLoader", + "pos": [ + -2, + 304 + ], + "size": [ + 451.30548095703125, + 82 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "CLIP", + "type": "CLIP", + "links": [ + 54 + ], + "slot_index": 0, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "CLIPLoader" + }, + "widgets_values": [ + "t5\\google_t5-v1_1-xxl_encoderonly-fp8_e4m3fn.safetensors", + "sd3", + "default" + ] + }, + { + "id": 74, + "type": "ImageConcatMulti", + "pos": [ + 1787.351318359375, + 513.0852661132812 + ], + "size": [ + 210, + 150 + ], + "flags": {}, + "order": 19, + "mode": 0, + "inputs": [ + { + "name": "image_1", + "type": "IMAGE", + "link": 171 + }, + { + "name": "image_2", + "type": "IMAGE", + "link": 184 + } + ], + "outputs": [ + { + "name": "images", + "type": "IMAGE", + "links": [ + 170 + ], + "slot_index": 0 + } + ], + "properties": {}, + "widgets_values": [ + 2, + "right", + false, + null + ] + }, + { + "id": 60, + "type": "CogVideoDecode", + "pos": [ + 1518.4959716796875, + -16.81044578552246 + ], + "size": [ + 315, + 198 + ], + "flags": {}, + "order": 18, + "mode": 0, + "inputs": [ + { + "name": "vae", + "type": "VAE", + "link": 132 + }, + { + "name": "samples", + "type": "LATENT", + "link": 148 + } + ], + "outputs": [ + { + "name": "images", + "type": "IMAGE", + "links": [ + 184 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "CogVideoDecode" + }, + "widgets_values": [ + true, + 240, + 360, + 0.2, + 0.2, + true + ] + }, + { + "id": 72, + "type": "CogVideoLoraSelect", + "pos": [ + 149.58236694335938, + -19.5003604888916 + ], + "size": [ + 429.9602355957031, + 108.1800765991211 + ], + "flags": {}, + "order": 1, + "mode": 0, + "inputs": [ + { + "name": "prev_lora", + "type": "COGLORA", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "lora", + "type": "COGLORA", + "links": [ + 174 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "CogVideoLoraSelect" + }, + "widgets_values": [ + "I2V5B_final_i30000_lora_weights.safetensors", + 1, + false + ] + }, + { + "id": 59, + "type": "DownloadAndLoadCogVideoModel", + "pos": [ + 620.1983032226562, + -39.41391372680664 + ], + "size": [ + 315, + 218 + ], + "flags": {}, + "order": 8, + "mode": 0, + "inputs": [ + { + "name": "block_edit", + "type": "TRANSFORMERBLOCKS", + "link": null, + "shape": 7 + }, + { + "name": "lora", + "type": "COGLORA", + "link": 174, + "shape": 7 + }, + { + "name": "compile_args", + "type": "COMPILEARGS", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "model", + "type": "COGVIDEOMODEL", + "links": [ + 144 + ] + }, + { + "name": "vae", + "type": "VAE", + "links": [ + 132, + 141, + 165 + ], + "slot_index": 1 + } + ], + "properties": { + "Node name for S&R": "DownloadAndLoadCogVideoModel" + }, + "widgets_values": [ + "THUDM/CogVideoX-5b-I2V", + "bf16", + "disabled", + false, + "sageattn", + "main_device" + ] + }, + { + "id": 30, + "type": "CogVideoTextEncode", + "pos": [ + 493, + 303 + ], + "size": [ + 471.90142822265625, + 168.08047485351562 + ], + "flags": {}, + "order": 7, + "mode": 0, + "inputs": [ + { + "name": "clip", + "type": "CLIP", + "link": 54 + } + ], + "outputs": [ + { + "name": "conditioning", + "type": "CONDITIONING", + "links": [ + 145 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "clip", + "type": "CLIP", + "links": [ + 149 + ], + "slot_index": 1 + } + ], + "properties": { + "Node name for S&R": "CogVideoTextEncode" + }, + "widgets_values": [ + "mouse knight walking in a forest", + 1, + false + ] + }, + { + "id": 63, + "type": "CogVideoSampler", + "pos": [ + 1144.7025146484375, + 55.98257064819336 + ], + "size": [ + 330, + 594 + ], + "flags": {}, + "order": 17, + "mode": 0, + "inputs": [ + { + "name": "model", + "type": "COGVIDEOMODEL", + "link": 144 + }, + { + "name": "positive", + "type": "CONDITIONING", + "link": 145 + }, + { + "name": "negative", + "type": "CONDITIONING", + "link": 146 + }, + { + "name": "samples", + "type": "LATENT", + "link": 164, + "shape": 7 + }, + { + "name": "image_cond_latents", + "type": "LATENT", + "link": 147, + "shape": 7 + }, + { + "name": "context_options", + "type": "COGCONTEXT", + "link": null, + "shape": 7 + }, + { + "name": "controlnet", + "type": "COGVIDECONTROLNET", + "link": null, + "shape": 7 + }, + { + "name": "tora_trajectory", + "type": "TORAFEATURES", + "link": null, + "shape": 7 + }, + { + "name": "fastercache", + "type": "FASTERCACHEARGS", + "link": null, + "shape": 7 + }, + { + "name": "feta_args", + "type": "FETAARGS", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "samples", + "type": "LATENT", + "links": [ + 148 + ] + } + ], + "properties": { + "Node name for S&R": "CogVideoSampler" + }, + "widgets_values": [ + 49, + 25, + 6, + 0, + "fixed", + "CogVideoXDDIM", + 1 + ] + }, + { + "id": 79, + "type": "Note", + "pos": [ + 141.44003295898438, + -129.33815002441406 + ], + "size": [ + 436.1673889160156, + 58 + ], + "flags": {}, + "order": 2, + "mode": 0, + "inputs": [], + "outputs": [], + "properties": {}, + "widgets_values": [ + "https://huggingface.co/VGenAI-Netflix-Eyeline-Research/Go-with-the-Flow/blob/main/I2V5B_final_i38800_nearest_lora_weights.safetensors" + ], + "color": "#432", + "bgcolor": "#653" + }, + { + "id": 76, + "type": "VHS_VideoCombine", + "pos": [ + 1955.22119140625, + 841.7718505859375 + ], + "size": [ + 1141.2095947265625, + 1095.4730224609375 + ], + "flags": {}, + "order": 16, + "mode": 2, + "inputs": [ + { + "name": "images", + "type": "IMAGE", + "link": 185 + }, + { + "name": "audio", + "type": "AUDIO", + "link": null, + "shape": 7 + }, + { + "name": "meta_batch", + "type": "VHS_BatchManager", + "link": null, + "shape": 7 + }, + { + "name": "vae", + "type": "VAE", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "Filenames", + "type": "VHS_FILENAMES", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "VHS_VideoCombine" + }, + "widgets_values": { + "frame_rate": 8, + "loop_count": 0, + "filename_prefix": "CogVideoX-I2V", + "format": "video/h264-mp4", + "pix_fmt": "yuv420p", + "crf": 19, + "save_metadata": true, + "trim_to_audio": false, + "pingpong": false, + "save_output": false, + "videopreview": { + "hidden": false, + "paused": false, + "params": { + "filename": "CogVideoX-I2V_00001.mp4", + "subfolder": "", + "type": "temp", + "format": "video/h264-mp4", + "frame_rate": 8, + "workflow": "CogVideoX-I2V_00001.png", + "fullpath": "N:\\AI\\ComfyUI\\temp\\CogVideoX-I2V_00001.mp4" + }, + "muted": false + } + } + }, + { + "id": 80, + "type": "Note", + "pos": [ + 1648.847900390625, + 1100.5545654296875 + ], + "size": [ + 249.00543212890625, + 58 + ], + "flags": {}, + "order": 3, + "mode": 0, + "inputs": [], + "outputs": [], + "properties": {}, + "widgets_values": [ + "This is just for testing the noise" + ], + "color": "#432", + "bgcolor": "#653" + }, + { + "id": 73, + "type": "CogVideoDecode", + "pos": [ + 1567.16064453125, + 842.2813110351562 + ], + "size": [ + 315, + 198 + ], + "flags": {}, + "order": 14, + "mode": 2, + "inputs": [ + { + "name": "vae", + "type": "VAE", + "link": 165 + }, + { + "name": "samples", + "type": "LATENT", + "link": 167 + } + ], + "outputs": [ + { + "name": "images", + "type": "IMAGE", + "links": [ + 185 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "CogVideoDecode" + }, + "widgets_values": [ + true, + 240, + 360, + 0.2, + 0.2, + true + ] + }, + { + "id": 68, + "type": "GetImageSizeAndCount", + "pos": [ + -195.5599822998047, + 1273.8702392578125 + ], + "size": [ + 277.20001220703125, + 86 + ], + "flags": {}, + "order": 9, + "mode": 0, + "inputs": [ + { + "name": "image", + "type": "IMAGE", + "link": 181 + } + ], + "outputs": [ + { + "name": "image", + "type": "IMAGE", + "links": [ + 178 + ], + "slot_index": 0 + }, + { + "name": "1024 width", + "type": "INT", + "links": null + }, + { + "name": "768 height", + "type": "INT", + "links": null + }, + { + "name": "49 count", + "type": "INT", + "links": null + } + ], + "properties": { + "Node name for S&R": "GetImageSizeAndCount" + } + }, + { + "id": 62, + "type": "CogVideoImageEncode", + "pos": [ + 612.8922729492188, + 751.6295776367188 + ], + "size": [ + 315, + 194 + ], + "flags": {}, + "order": 15, + "mode": 0, + "inputs": [ + { + "name": "vae", + "type": "VAE", + "link": 141 + }, + { + "name": "start_image", + "type": "IMAGE", + "link": 190 + }, + { + "name": "end_image", + "type": "IMAGE", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "samples", + "type": "LATENT", + "links": [ + 147 + ] + } + ], + "properties": { + "Node name for S&R": "CogVideoImageEncode" + }, + "widgets_values": [ + false, + 0, + 1, + 0, + 1 + ] + }, + { + "id": 82, + "type": "Note", + "pos": [ + -533.0764770507812, + 1158.188232421875 + ], + "size": [ + 364.71002197265625, + 58 + ], + "flags": {}, + "order": 4, + "mode": 0, + "inputs": [], + "outputs": [], + "properties": {}, + "widgets_values": [ + "Input video that's used to create the noise" + ], + "color": "#432", + "bgcolor": "#653" + }, + { + "id": 64, + "type": "GetWarpedNoiseFromVideo", + "pos": [ + 674.1111450195312, + 1289.6090087890625 + ], + "size": [ + 315, + 222 + ], + "flags": {}, + "order": 12, + "mode": 0, + "inputs": [ + { + "name": "images", + "type": "IMAGE", + "link": 161 + } + ], + "outputs": [ + { + "name": "noise", + "type": "LATENT", + "links": [ + 164, + 167 + ], + "slot_index": 0 + }, + { + "name": "visualization", + "type": "IMAGE", + "links": null + } + ], + "properties": { + "Node name for S&R": "GetWarpedNoiseFromVideo" + }, + "widgets_values": [ + 16, + "nearest", + 13, + 0.5, + "BCTHW", + 99026504067718, + "fixed" + ] + }, + { + "id": 83, + "type": "Note", + "pos": [ + 679.4560546875, + 1179.797607421875 + ], + "size": [ + 293.1480407714844, + 58 + ], + "flags": {}, + "order": 5, + "mode": 0, + "inputs": [], + "outputs": [], + "properties": {}, + "widgets_values": [ + "https://github.com/kijai/ComfyUI-VideoNoiseWarp" + ], + "color": "#432", + "bgcolor": "#653" + }, + { + "id": 69, + "type": "VHS_LoadVideo", + "pos": [ + -536.2808837890625, + 1265.4254150390625 + ], + "size": [ + 247.455078125, + 446.3408203125 + ], + "flags": {}, + "order": 6, + "mode": 0, + "inputs": [ + { + "name": "meta_batch", + "type": "VHS_BatchManager", + "link": null, + "shape": 7 + }, + { + "name": "vae", + "type": "VAE", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 181 + ], + "slot_index": 0 + }, + { + "name": "frame_count", + "type": "INT", + "links": null + }, + { + "name": "audio", + "type": "AUDIO", + "links": null + }, + { + "name": "video_info", + "type": "VHS_VIDEOINFO", + "links": null + } + ], + "properties": { + "Node name for S&R": "VHS_LoadVideo" + }, + "widgets_values": { + "video": "AnimateDiff_00023 (16).mp4", + "force_rate": 0, + "force_size": "Disabled", + "custom_width": 512, + "custom_height": 512, + "frame_load_cap": 0, + "skip_first_frames": 0, + "select_every_nth": 1, + "choose video to upload": "image", + "videopreview": { + "hidden": false, + "paused": false, + "params": { + "force_rate": 0, + "frame_load_cap": 0, + "skip_first_frames": 0, + "select_every_nth": 1, + "filename": "AnimateDiff_00023 (16).mp4", + "type": "input", + "format": "video/mp4" + }, + "muted": false + } + } + }, + { + "id": 44, + "type": "VHS_VideoCombine", + "pos": [ + 2071.7626953125, + -69.11408233642578 + ], + "size": [ + 1141.2095947265625, + 721.7365112304688 + ], + "flags": {}, + "order": 20, + "mode": 0, + "inputs": [ + { + "name": "images", + "type": "IMAGE", + "link": 170 + }, + { + "name": "audio", + "type": "AUDIO", + "link": null, + "shape": 7 + }, + { + "name": "meta_batch", + "type": "VHS_BatchManager", + "link": null, + "shape": 7 + }, + { + "name": "vae", + "type": "VAE", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "Filenames", + "type": "VHS_FILENAMES", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "VHS_VideoCombine" + }, + "widgets_values": { + "frame_rate": 8, + "loop_count": 0, + "filename_prefix": "CogVideoX_I2V_NoiseWarp", + "format": "video/h264-mp4", + "pix_fmt": "yuv420p", + "crf": 19, + "save_metadata": true, + "trim_to_audio": false, + "pingpong": false, + "save_output": false, + "videopreview": { + "hidden": false, + "paused": false, + "params": { + "filename": "CogVideoX-I2V_00002.mp4", + "subfolder": "", + "type": "temp", + "format": "video/h264-mp4", + "frame_rate": 8, + "workflow": "CogVideoX-I2V_00002.png", + "fullpath": "N:\\AI\\ComfyUI\\temp\\CogVideoX-I2V_00002.mp4" + }, + "muted": false + } + } + }, + { + "id": 71, + "type": "ImageResizeKJ", + "pos": [ + 204.58009338378906, + 1289.261474609375 + ], + "size": [ + 315, + 266 + ], + "flags": {}, + "order": 11, + "mode": 0, + "inputs": [ + { + "name": "image", + "type": "IMAGE", + "link": 178 + }, + { + "name": "get_image_size", + "type": "IMAGE", + "link": null, + "shape": 7 + }, + { + "name": "width_input", + "type": "INT", + "link": null, + "widget": { + "name": "width_input" + }, + "shape": 7 + }, + { + "name": "height_input", + "type": "INT", + "link": null, + "widget": { + "name": "height_input" + }, + "shape": 7 + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 161, + 171, + 189 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "width", + "type": "INT", + "links": null, + "shape": 3 + }, + { + "name": "height", + "type": "INT", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "ImageResizeKJ" + }, + "widgets_values": [ + 720, + 480, + "lanczos", + false, + 16, + 0, + 0, + "disabled" + ] + }, + { + "id": 84, + "type": "GetImageRangeFromBatch", + "pos": [ + 197.0398712158203, + 1077.9952392578125 + ], + "size": [ + 340.2047424316406, + 102 + ], + "flags": {}, + "order": 13, + "mode": 0, + "inputs": [ + { + "name": "images", + "type": "IMAGE", + "link": 189, + "shape": 7 + }, + { + "name": "masks", + "type": "MASK", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 190 + ], + "slot_index": 0 + }, + { + "name": "MASK", + "type": "MASK", + "links": null + } + ], + "properties": { + "Node name for S&R": "GetImageRangeFromBatch" + }, + "widgets_values": [ + 0, + 1 + ] + } + ], + "links": [ + [ + 54, + 20, + 0, + 30, + 0, + "CLIP" + ], + [ + 132, + 59, + 1, + 60, + 0, + "VAE" + ], + [ + 141, + 59, + 1, + 62, + 0, + "VAE" + ], + [ + 144, + 59, + 0, + 63, + 0, + "COGVIDEOMODEL" + ], + [ + 145, + 30, + 0, + 63, + 1, + "CONDITIONING" + ], + [ + 146, + 31, + 0, + 63, + 2, + "CONDITIONING" + ], + [ + 147, + 62, + 0, + 63, + 4, + "LATENT" + ], + [ + 148, + 63, + 0, + 60, + 1, + "LATENT" + ], + [ + 149, + 30, + 1, + 31, + 0, + "CLIP" + ], + [ + 161, + 71, + 0, + 64, + 0, + "IMAGE" + ], + [ + 164, + 64, + 0, + 63, + 3, + "LATENT" + ], + [ + 165, + 59, + 1, + 73, + 0, + "VAE" + ], + [ + 167, + 64, + 0, + 73, + 1, + "LATENT" + ], + [ + 170, + 74, + 0, + 44, + 0, + "IMAGE" + ], + [ + 171, + 71, + 0, + 74, + 0, + "IMAGE" + ], + [ + 174, + 72, + 0, + 59, + 1, + "COGLORA" + ], + [ + 178, + 68, + 0, + 71, + 0, + "IMAGE" + ], + [ + 181, + 69, + 0, + 68, + 0, + "IMAGE" + ], + [ + 184, + 60, + 0, + 74, + 1, + "IMAGE" + ], + [ + 185, + 73, + 0, + 76, + 0, + "IMAGE" + ], + [ + 189, + 71, + 0, + 84, + 0, + "IMAGE" + ], + [ + 190, + 84, + 0, + 62, + 1, + "IMAGE" + ] + ], + "groups": [], + "config": {}, + "extra": { + "ds": { + "scale": 0.6115909044841579, + "offset": [ + 1276.2661497783536, + -1.7440717555266154 + ] + }, + "node_versions": { + "ComfyUI-CogVideoXWrapper": "8c5e4f812d869653a6c201af0dcd6249c18b3231", + "comfy-core": "0.3.12", + "ComfyUI-KJNodes": "c9c8dcd5e7ed2f7669f130a5ced1e3005264a2de", + "ComfyUI-VideoHelperSuite": "c47b10ca1798b4925ff5a5f07d80c51ca80a837d", + "ComfyUI-NoiseWarp": "8c5e4f812d869653a6c201af0dcd6249c18b3231" + }, + "VHS_latentpreview": true, + "VHS_latentpreviewrate": 0 + }, + "version": 0.4 +} \ No newline at end of file diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_1_0_5b_T2V_02.json b/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_1_0_5b_T2V_02.json new file mode 100644 index 0000000000000000000000000000000000000000..a257abc8bcd20f6c2e608e9bad66a6fff06033cb --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_1_0_5b_T2V_02.json @@ -0,0 +1,529 @@ +{ + "last_node_id": 37, + "last_link_id": 72, + "nodes": [ + { + "id": 30, + "type": "CogVideoTextEncode", + "pos": { + "0": 500, + "1": 308 + }, + "size": [ + 470.99399664051055, + 237.5088638951354 + ], + "flags": {}, + "order": 3, + "mode": 0, + "inputs": [ + { + "name": "clip", + "type": "CLIP", + "link": 54 + } + ], + "outputs": [ + { + "name": "conditioning", + "type": "CONDITIONING", + "links": [ + 67 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "clip", + "type": "CLIP", + "links": [ + 65 + ], + "slot_index": 1 + } + ], + "properties": { + "Node name for S&R": "CogVideoTextEncode" + }, + "widgets_values": [ + "A golden retriever, sporting sleek black sunglasses, with its lengthy fur flowing in the breeze, sprints playfully across a rooftop terrace, recently refreshed by a light rain. The scene unfolds from a distance, the dog's energetic bounds growing larger as it approaches the camera, its tail wagging with unrestrained joy, while droplets of water glisten on the concrete behind it. The overcast sky provides a dramatic backdrop, emphasizing the vibrant golden coat of the canine as it dashes towards the viewer.\n\n", + 1, + false + ] + }, + { + "id": 31, + "type": "CogVideoTextEncode", + "pos": { + "0": 503, + "1": 602 + }, + "size": [ + 464.4980515341475, + 169.87479027400514 + ], + "flags": {}, + "order": 4, + "mode": 0, + "inputs": [ + { + "name": "clip", + "type": "CLIP", + "link": 65 + } + ], + "outputs": [ + { + "name": "conditioning", + "type": "CONDITIONING", + "links": [ + 68 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "clip", + "type": "CLIP", + "links": null + } + ], + "properties": { + "Node name for S&R": "CogVideoTextEncode" + }, + "widgets_values": [ + "", + 1, + true + ] + }, + { + "id": 11, + "type": "CogVideoDecode", + "pos": { + "0": 1416, + "1": 40 + }, + "size": { + "0": 300.396484375, + "1": 198 + }, + "flags": {}, + "order": 6, + "mode": 0, + "inputs": [ + { + "name": "vae", + "type": "VAE", + "link": 71 + }, + { + "name": "samples", + "type": "LATENT", + "link": 69 + } + ], + "outputs": [ + { + "name": "images", + "type": "IMAGE", + "links": [ + 59 + ], + "slot_index": 0, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "CogVideoDecode" + }, + "widgets_values": [ + false, + 240, + 360, + 0.2, + 0.2, + true + ] + }, + { + "id": 36, + "type": "DownloadAndLoadCogVideoModel", + "pos": { + "0": 645, + "1": 17 + }, + "size": { + "0": 315, + "1": 218 + }, + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "block_edit", + "type": "TRANSFORMERBLOCKS", + "link": null, + "shape": 7 + }, + { + "name": "lora", + "type": "COGLORA", + "link": null, + "shape": 7 + }, + { + "name": "compile_args", + "type": "COMPILEARGS", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "model", + "type": "COGVIDEOMODEL", + "links": [ + 70 + ] + }, + { + "name": "vae", + "type": "VAE", + "links": [ + 71 + ], + "slot_index": 1 + } + ], + "properties": { + "Node name for S&R": "DownloadAndLoadCogVideoModel" + }, + "widgets_values": [ + "THUDM/CogVideoX-5b", + "bf16", + "disabled", + false, + "sdpa", + "main_device" + ] + }, + { + "id": 20, + "type": "CLIPLoader", + "pos": { + "0": 5, + "1": 308 + }, + "size": { + "0": 451.30548095703125, + "1": 82 + }, + "flags": {}, + "order": 1, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "CLIP", + "type": "CLIP", + "links": [ + 54 + ], + "slot_index": 0, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "CLIPLoader" + }, + "widgets_values": [ + "t5\\google_t5-v1_1-xxl_encoderonly-fp8_e4m3fn.safetensors", + "sd3" + ] + }, + { + "id": 37, + "type": "EmptyLatentImage", + "pos": { + "0": 643, + "1": 827 + }, + "size": { + "0": 315, + "1": 106 + }, + "flags": {}, + "order": 2, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "LATENT", + "type": "LATENT", + "links": [ + 72 + ] + } + ], + "properties": { + "Node name for S&R": "EmptyLatentImage" + }, + "widgets_values": [ + 720, + 480, + 1 + ] + }, + { + "id": 35, + "type": "CogVideoSampler", + "pos": { + "0": 1042, + "1": 291 + }, + "size": [ + 330, + 574 + ], + "flags": {}, + "order": 5, + "mode": 0, + "inputs": [ + { + "name": "model", + "type": "COGVIDEOMODEL", + "link": 70 + }, + { + "name": "positive", + "type": "CONDITIONING", + "link": 67 + }, + { + "name": "negative", + "type": "CONDITIONING", + "link": 68 + }, + { + "name": "samples", + "type": "LATENT", + "link": 72, + "shape": 7 + }, + { + "name": "image_cond_latents", + "type": "LATENT", + "link": null, + "shape": 7 + }, + { + "name": "context_options", + "type": "COGCONTEXT", + "link": null, + "shape": 7 + }, + { + "name": "controlnet", + "type": "COGVIDECONTROLNET", + "link": null, + "shape": 7 + }, + { + "name": "tora_trajectory", + "type": "TORAFEATURES", + "link": null, + "shape": 7 + }, + { + "name": "fastercache", + "type": "FASTERCACHEARGS", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "samples", + "type": "LATENT", + "links": [ + 69 + ] + } + ], + "properties": { + "Node name for S&R": "CogVideoSampler" + }, + "widgets_values": [ + 49, + 50, + 6, + 0, + "fixed", + "CogVideoXDDIM", + 1 + ] + }, + { + "id": 33, + "type": "VHS_VideoCombine", + "pos": { + "0": 1767, + "1": 39 + }, + "size": [ + 778.7022705078125, + 829.801513671875 + ], + "flags": {}, + "order": 7, + "mode": 0, + "inputs": [ + { + "name": "images", + "type": "IMAGE", + "link": 59 + }, + { + "name": "audio", + "type": "AUDIO", + "link": null, + "shape": 7 + }, + { + "name": "meta_batch", + "type": "VHS_BatchManager", + "link": null, + "shape": 7 + }, + { + "name": "vae", + "type": "VAE", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "Filenames", + "type": "VHS_FILENAMES", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "VHS_VideoCombine" + }, + "widgets_values": { + "frame_rate": 8, + "loop_count": 0, + "filename_prefix": "CogVideoX5B-T2V", + "format": "video/h264-mp4", + "pix_fmt": "yuv420p", + "crf": 19, + "save_metadata": true, + "pingpong": false, + "save_output": false, + "videopreview": { + "hidden": false, + "paused": false, + "params": { + "filename": "CogVideoX5B_00001.mp4", + "subfolder": "", + "type": "temp", + "format": "video/h264-mp4", + "frame_rate": 8 + }, + "muted": false + } + } + } + ], + "links": [ + [ + 54, + 20, + 0, + 30, + 0, + "CLIP" + ], + [ + 59, + 11, + 0, + 33, + 0, + "IMAGE" + ], + [ + 65, + 30, + 1, + 31, + 0, + "CLIP" + ], + [ + 67, + 30, + 0, + 35, + 1, + "CONDITIONING" + ], + [ + 68, + 31, + 0, + 35, + 2, + "CONDITIONING" + ], + [ + 69, + 35, + 0, + 11, + 1, + "LATENT" + ], + [ + 70, + 36, + 0, + 35, + 0, + "COGVIDEOMODEL" + ], + [ + 71, + 36, + 1, + 11, + 0, + "VAE" + ], + [ + 72, + 37, + 0, + 35, + 3, + "LATENT" + ] + ], + "groups": [], + "config": {}, + "extra": { + "ds": { + "scale": 0.7627768444387061, + "offset": [ + 734.1791945221892, + 237.29437844909364 + ] + } + }, + "version": 0.4 +} \ No newline at end of file diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_1_0_5b_interpolation_02.json b/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_1_0_5b_interpolation_02.json new file mode 100644 index 0000000000000000000000000000000000000000..3c8a1d33864c6cf6433252387e79ce0a91157ea6 --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_1_0_5b_interpolation_02.json @@ -0,0 +1,864 @@ +{ + "last_node_id": 68, + "last_link_id": 155, + "nodes": [ + { + "id": 31, + "type": "CogVideoTextEncode", + "pos": { + "0": 497, + "1": 520 + }, + "size": { + "0": 463.01251220703125, + "1": 144 + }, + "flags": {}, + "order": 6, + "mode": 0, + "inputs": [ + { + "name": "clip", + "type": "CLIP", + "link": 149 + } + ], + "outputs": [ + { + "name": "conditioning", + "type": "CONDITIONING", + "links": [ + 146 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "clip", + "type": "CLIP", + "links": null + } + ], + "properties": { + "Node name for S&R": "CogVideoTextEncode" + }, + "widgets_values": [ + "The video is not of a high quality, it has a low resolution. Watermark present in each frame. Strange motion trajectory. ", + 1, + true + ] + }, + { + "id": 63, + "type": "CogVideoSampler", + "pos": { + "0": 1142, + "1": 74 + }, + "size": [ + 330, + 574 + ], + "flags": {}, + "order": 9, + "mode": 0, + "inputs": [ + { + "name": "model", + "type": "COGVIDEOMODEL", + "link": 144 + }, + { + "name": "positive", + "type": "CONDITIONING", + "link": 145 + }, + { + "name": "negative", + "type": "CONDITIONING", + "link": 146 + }, + { + "name": "samples", + "type": "LATENT", + "link": null, + "shape": 7 + }, + { + "name": "image_cond_latents", + "type": "LATENT", + "link": 147, + "shape": 7 + }, + { + "name": "context_options", + "type": "COGCONTEXT", + "link": null, + "shape": 7 + }, + { + "name": "controlnet", + "type": "COGVIDECONTROLNET", + "link": null, + "shape": 7 + }, + { + "name": "tora_trajectory", + "type": "TORAFEATURES", + "link": null, + "shape": 7 + }, + { + "name": "fastercache", + "type": "FASTERCACHEARGS", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "samples", + "type": "LATENT", + "links": [ + 148 + ] + } + ], + "properties": { + "Node name for S&R": "CogVideoSampler" + }, + "widgets_values": [ + 49, + 25, + 6, + 0, + "fixed", + "CogVideoXDDIM", + 1 + ] + }, + { + "id": 30, + "type": "CogVideoTextEncode", + "pos": { + "0": 493, + "1": 303 + }, + "size": { + "0": 471.90142822265625, + "1": 168.08047485351562 + }, + "flags": {}, + "order": 4, + "mode": 0, + "inputs": [ + { + "name": "clip", + "type": "CLIP", + "link": 54 + } + ], + "outputs": [ + { + "name": "conditioning", + "type": "CONDITIONING", + "links": [ + 145 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "clip", + "type": "CLIP", + "links": [ + 149 + ], + "slot_index": 1 + } + ], + "properties": { + "Node name for S&R": "CogVideoTextEncode" + }, + "widgets_values": [ + "a majestic stag is grazing in an enhanced forest, basking in the setting sun filtered by the trees", + 1, + false + ] + }, + { + "id": 20, + "type": "CLIPLoader", + "pos": { + "0": -2, + "1": 304 + }, + "size": { + "0": 451.30548095703125, + "1": 82 + }, + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "CLIP", + "type": "CLIP", + "links": [ + 54 + ], + "slot_index": 0, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "CLIPLoader" + }, + "widgets_values": [ + "t5\\google_t5-v1_1-xxl_encoderonly-fp8_e4m3fn.safetensors", + "sd3" + ] + }, + { + "id": 36, + "type": "LoadImage", + "pos": { + "0": 105, + "1": 732 + }, + "size": { + "0": 402.06353759765625, + "1": 396.6225891113281 + }, + "flags": {}, + "order": 1, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 71 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "MASK", + "type": "MASK", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "LoadImage" + }, + "widgets_values": [ + "sd3stag.png", + "image" + ] + }, + { + "id": 64, + "type": "LoadImage", + "pos": { + "0": 105, + "1": 1189 + }, + "size": { + "0": 402.06353759765625, + "1": 396.6225891113281 + }, + "flags": {}, + "order": 2, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 151 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "MASK", + "type": "MASK", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "LoadImage" + }, + "widgets_values": [ + "sd3stag.png", + "image" + ] + }, + { + "id": 65, + "type": "ImageResizeKJ", + "pos": { + "0": 607, + "1": 1188 + }, + "size": [ + 315, + 266 + ], + "flags": {}, + "order": 7, + "mode": 0, + "inputs": [ + { + "name": "image", + "type": "IMAGE", + "link": 151 + }, + { + "name": "get_image_size", + "type": "IMAGE", + "link": null, + "shape": 7 + }, + { + "name": "width_input", + "type": "INT", + "link": null, + "widget": { + "name": "width_input" + }, + "shape": 7 + }, + { + "name": "height_input", + "type": "INT", + "link": null, + "widget": { + "name": "height_input" + }, + "shape": 7 + }, + { + "name": "width", + "type": "INT", + "link": 152, + "widget": { + "name": "width" + } + }, + { + "name": "height", + "type": "INT", + "link": 153, + "widget": { + "name": "height" + } + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 155 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "width", + "type": "INT", + "links": null, + "shape": 3 + }, + { + "name": "height", + "type": "INT", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "ImageResizeKJ" + }, + "widgets_values": [ + 720, + 480, + "lanczos", + false, + 16, + 0, + 0, + "disabled" + ] + }, + { + "id": 37, + "type": "ImageResizeKJ", + "pos": { + "0": 593, + "1": 731 + }, + "size": { + "0": 315, + "1": 266 + }, + "flags": {}, + "order": 5, + "mode": 0, + "inputs": [ + { + "name": "image", + "type": "IMAGE", + "link": 71 + }, + { + "name": "get_image_size", + "type": "IMAGE", + "link": null, + "shape": 7 + }, + { + "name": "width_input", + "type": "INT", + "link": null, + "widget": { + "name": "width_input" + } + }, + { + "name": "height_input", + "type": "INT", + "link": null, + "widget": { + "name": "height_input" + } + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 142 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "width", + "type": "INT", + "links": [ + 152 + ], + "shape": 3, + "slot_index": 1 + }, + { + "name": "height", + "type": "INT", + "links": [ + 153 + ], + "shape": 3, + "slot_index": 2 + } + ], + "properties": { + "Node name for S&R": "ImageResizeKJ" + }, + "widgets_values": [ + 720, + 480, + "lanczos", + false, + 16, + 0, + 0, + "disabled" + ] + }, + { + "id": 60, + "type": "CogVideoDecode", + "pos": { + "0": 1526, + "1": -4 + }, + "size": { + "0": 315, + "1": 198 + }, + "flags": {}, + "order": 10, + "mode": 0, + "inputs": [ + { + "name": "vae", + "type": "VAE", + "link": 132 + }, + { + "name": "samples", + "type": "LATENT", + "link": 148 + } + ], + "outputs": [ + { + "name": "images", + "type": "IMAGE", + "links": [ + 134 + ] + } + ], + "properties": { + "Node name for S&R": "CogVideoDecode" + }, + "widgets_values": [ + true, + 240, + 360, + 0.2, + 0.2, + true + ] + }, + { + "id": 62, + "type": "CogVideoImageEncode", + "pos": { + "0": 1152, + "1": 706 + }, + "size": { + "0": 315, + "1": 122 + }, + "flags": {}, + "order": 8, + "mode": 0, + "inputs": [ + { + "name": "vae", + "type": "VAE", + "link": 141 + }, + { + "name": "start_image", + "type": "IMAGE", + "link": 142 + }, + { + "name": "end_image", + "type": "IMAGE", + "link": 155, + "shape": 7 + } + ], + "outputs": [ + { + "name": "samples", + "type": "LATENT", + "links": [ + 147 + ] + } + ], + "properties": { + "Node name for S&R": "CogVideoImageEncode" + }, + "widgets_values": [ + false, + 0 + ] + }, + { + "id": 44, + "type": "VHS_VideoCombine", + "pos": { + "0": 1884, + "1": -3 + }, + "size": [ + 605.3909912109375, + 714.2606608072917 + ], + "flags": {}, + "order": 11, + "mode": 0, + "inputs": [ + { + "name": "images", + "type": "IMAGE", + "link": 134 + }, + { + "name": "audio", + "type": "AUDIO", + "link": null, + "shape": 7 + }, + { + "name": "meta_batch", + "type": "VHS_BatchManager", + "link": null, + "shape": 7 + }, + { + "name": "vae", + "type": "VAE", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "Filenames", + "type": "VHS_FILENAMES", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "VHS_VideoCombine" + }, + "widgets_values": { + "frame_rate": 8, + "loop_count": 0, + "filename_prefix": "CogVideoX-Interpolation", + "format": "video/h264-mp4", + "pix_fmt": "yuv420p", + "crf": 19, + "save_metadata": true, + "pingpong": false, + "save_output": true, + "videopreview": { + "hidden": false, + "paused": false, + "params": { + "filename": "CogVideoX-I2V_00003.mp4", + "subfolder": "", + "type": "temp", + "format": "video/h264-mp4", + "frame_rate": 8 + }, + "muted": false + } + } + }, + { + "id": 59, + "type": "DownloadAndLoadCogVideoModel", + "pos": { + "0": 622, + "1": -25 + }, + "size": [ + 347.24594407027485, + 218 + ], + "flags": {}, + "order": 3, + "mode": 0, + "inputs": [ + { + "name": "block_edit", + "type": "TRANSFORMERBLOCKS", + "link": null, + "shape": 7 + }, + { + "name": "lora", + "type": "COGLORA", + "link": null, + "shape": 7 + }, + { + "name": "compile_args", + "type": "COMPILEARGS", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "model", + "type": "COGVIDEOMODEL", + "links": [ + 144 + ] + }, + { + "name": "vae", + "type": "VAE", + "links": [ + 132, + 141 + ], + "slot_index": 1 + } + ], + "properties": { + "Node name for S&R": "DownloadAndLoadCogVideoModel" + }, + "widgets_values": [ + "feizhengcong/CogvideoX-Interpolation", + "bf16", + "disabled", + false, + "sdpa", + "main_device" + ] + } + ], + "links": [ + [ + 54, + 20, + 0, + 30, + 0, + "CLIP" + ], + [ + 71, + 36, + 0, + 37, + 0, + "IMAGE" + ], + [ + 132, + 59, + 1, + 60, + 0, + "VAE" + ], + [ + 134, + 60, + 0, + 44, + 0, + "IMAGE" + ], + [ + 141, + 59, + 1, + 62, + 0, + "VAE" + ], + [ + 142, + 37, + 0, + 62, + 1, + "IMAGE" + ], + [ + 144, + 59, + 0, + 63, + 0, + "COGVIDEOMODEL" + ], + [ + 145, + 30, + 0, + 63, + 1, + "CONDITIONING" + ], + [ + 146, + 31, + 0, + 63, + 2, + "CONDITIONING" + ], + [ + 147, + 62, + 0, + 63, + 4, + "LATENT" + ], + [ + 148, + 63, + 0, + 60, + 1, + "LATENT" + ], + [ + 149, + 30, + 1, + 31, + 0, + "CLIP" + ], + [ + 151, + 64, + 0, + 65, + 0, + "IMAGE" + ], + [ + 152, + 37, + 1, + 65, + 4, + "INT" + ], + [ + 153, + 37, + 2, + 65, + 5, + "INT" + ], + [ + 155, + 65, + 0, + 62, + 2, + "IMAGE" + ] + ], + "groups": [], + "config": {}, + "extra": { + "ds": { + "scale": 0.7627768444387061, + "offset": [ + 630.1733472923837, + 148.14641794691272 + ] + } + }, + "version": 0.4 +} \ No newline at end of file diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_1_0_5b_vid2vid_02.json b/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_1_0_5b_vid2vid_02.json new file mode 100644 index 0000000000000000000000000000000000000000..9714952135bafb0cc3e070828fea6617cf5dd8c5 --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_1_0_5b_vid2vid_02.json @@ -0,0 +1,1061 @@ +{ + "last_node_id": 78, + "last_link_id": 218, + "nodes": [ + { + "id": 20, + "type": "CLIPLoader", + "pos": { + "0": -29, + "1": 407 + }, + "size": { + "0": 451.30548095703125, + "1": 82 + }, + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "CLIP", + "type": "CLIP", + "links": [ + 54 + ], + "slot_index": 0, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "CLIPLoader" + }, + "widgets_values": [ + "t5\\google_t5-v1_1-xxl_encoderonly-fp8_e4m3fn.safetensors", + "sd3" + ] + }, + { + "id": 41, + "type": "ImageResizeKJ", + "pos": { + "0": 206, + "1": -69 + }, + "size": { + "0": 315, + "1": 242 + }, + "flags": {}, + "order": 7, + "mode": 0, + "inputs": [ + { + "name": "image", + "type": "IMAGE", + "link": 180 + }, + { + "name": "get_image_size", + "type": "IMAGE", + "link": null, + "shape": 7 + }, + { + "name": "width_input", + "type": "INT", + "link": null, + "widget": { + "name": "width_input" + } + }, + { + "name": "height_input", + "type": "INT", + "link": null, + "widget": { + "name": "height_input" + } + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 126 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "width", + "type": "INT", + "links": null, + "shape": 3 + }, + { + "name": "height", + "type": "INT", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "ImageResizeKJ" + }, + "widgets_values": [ + 720, + 480, + "lanczos", + false, + 2, + 0, + 0, + "disabled" + ] + }, + { + "id": 45, + "type": "VHS_LoadVideo", + "pos": { + "0": -93, + "1": -153 + }, + "size": [ + 247.455078125, + 365.7275390625 + ], + "flags": {}, + "order": 4, + "mode": 0, + "inputs": [ + { + "name": "meta_batch", + "type": "VHS_BatchManager", + "link": null, + "shape": 7 + }, + { + "name": "vae", + "type": "VAE", + "link": null, + "shape": 7 + }, + { + "name": "frame_load_cap", + "type": "INT", + "link": 177, + "widget": { + "name": "frame_load_cap" + } + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 179 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "frame_count", + "type": "INT", + "links": null, + "shape": 3 + }, + { + "name": "audio", + "type": "AUDIO", + "links": null, + "shape": 3 + }, + { + "name": "video_info", + "type": "VHS_VIDEOINFO", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "VHS_LoadVideo" + }, + "widgets_values": { + "video": "jeep.mp4", + "force_rate": 0, + "force_size": "Disabled", + "custom_width": 512, + "custom_height": 512, + "frame_load_cap": 20, + "skip_first_frames": 0, + "select_every_nth": 1, + "choose video to upload": "image", + "videopreview": { + "hidden": false, + "paused": false, + "params": { + "frame_load_cap": 20, + "skip_first_frames": 0, + "force_rate": 0, + "filename": "jeep.mp4", + "type": "input", + "format": "video/mp4", + "select_every_nth": 1 + } + } + } + }, + { + "id": 70, + "type": "GetImageSizeAndCount", + "pos": { + "0": 214, + "1": -234 + }, + "size": { + "0": 202.2143096923828, + "1": 99.23601531982422 + }, + "flags": {}, + "order": 6, + "mode": 0, + "inputs": [ + { + "name": "image", + "type": "IMAGE", + "link": 179, + "slot_index": 0 + } + ], + "outputs": [ + { + "name": "image", + "type": "IMAGE", + "links": [ + 180 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "512 width", + "type": "INT", + "links": [], + "slot_index": 1, + "shape": 3 + }, + { + "name": "256 height", + "type": "INT", + "links": [], + "slot_index": 2, + "shape": 3 + }, + { + "name": "33 count", + "type": "INT", + "links": [], + "slot_index": 3, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "GetImageSizeAndCount" + }, + "widgets_values": [] + }, + { + "id": 69, + "type": "INTConstant", + "pos": { + "0": -90, + "1": -305 + }, + "size": { + "0": 210, + "1": 58 + }, + "flags": {}, + "order": 1, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "value", + "type": "INT", + "links": [ + 177 + ], + "shape": 3 + } + ], + "title": "Frames to load", + "properties": { + "Node name for S&R": "INTConstant" + }, + "widgets_values": [ + 33 + ], + "color": "#1b4669", + "bgcolor": "#29699c" + }, + { + "id": 58, + "type": "ImageConcanate", + "pos": { + "0": 1594, + "1": 230 + }, + "size": { + "0": 315, + "1": 102 + }, + "flags": {}, + "order": 13, + "mode": 0, + "inputs": [ + { + "name": "image1", + "type": "IMAGE", + "link": 191 + }, + { + "name": "image2", + "type": "IMAGE", + "link": 170 + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 132 + ], + "slot_index": 0, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "ImageConcanate" + }, + "widgets_values": [ + "right", + false + ] + }, + { + "id": 55, + "type": "GetImageSizeAndCount", + "pos": { + "0": 1654, + "1": 77 + }, + "size": { + "0": 210, + "1": 86 + }, + "flags": {}, + "order": 12, + "mode": 0, + "inputs": [ + { + "name": "image", + "type": "IMAGE", + "link": 208, + "slot_index": 0 + } + ], + "outputs": [ + { + "name": "image", + "type": "IMAGE", + "links": [ + 170 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "720 width", + "type": "INT", + "links": null, + "shape": 3 + }, + { + "name": "480 height", + "type": "INT", + "links": null, + "shape": 3 + }, + { + "name": "33 count", + "type": "INT", + "links": [], + "slot_index": 3, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "GetImageSizeAndCount" + }, + "widgets_values": [] + }, + { + "id": 77, + "type": "CogVideoImageEncode", + "pos": { + "0": 952, + "1": -118 + }, + "size": { + "0": 315, + "1": 122 + }, + "flags": {}, + "order": 9, + "mode": 0, + "inputs": [ + { + "name": "vae", + "type": "VAE", + "link": 209 + }, + { + "name": "start_image", + "type": "IMAGE", + "link": 210 + }, + { + "name": "end_image", + "type": "IMAGE", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "samples", + "type": "LATENT", + "links": [ + 215 + ] + } + ], + "properties": { + "Node name for S&R": "CogVideoImageEncode" + }, + "widgets_values": [ + false, + 0 + ] + }, + { + "id": 76, + "type": "CogVideoDecode", + "pos": { + "0": 1335, + "1": -123 + }, + "size": { + "0": 315, + "1": 198 + }, + "flags": {}, + "order": 11, + "mode": 0, + "inputs": [ + { + "name": "vae", + "type": "VAE", + "link": 206 + }, + { + "name": "samples", + "type": "LATENT", + "link": 216 + } + ], + "outputs": [ + { + "name": "images", + "type": "IMAGE", + "links": [ + 208 + ] + } + ], + "properties": { + "Node name for S&R": "CogVideoDecode" + }, + "widgets_values": [ + true, + 240, + 360, + 0.2, + 0.2, + true + ] + }, + { + "id": 30, + "type": "CogVideoTextEncode", + "pos": { + "0": 491, + "1": 372 + }, + "size": [ + 478.6890949595422, + 215.66308749666905 + ], + "flags": {}, + "order": 3, + "mode": 0, + "inputs": [ + { + "name": "clip", + "type": "CLIP", + "link": 54 + } + ], + "outputs": [ + { + "name": "conditioning", + "type": "CONDITIONING", + "links": [ + 213 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "clip", + "type": "CLIP", + "links": [ + 217 + ], + "slot_index": 1 + } + ], + "properties": { + "Node name for S&R": "CogVideoTextEncode" + }, + "widgets_values": [ + "A high-definition nature video showcasing a brown bear as it gracefully runs down a crystal-clear stream, surrounded by the serene ambiance of a dense, verdant forest. The sunlight filters through the canopy of tall trees, casting dappled light on the forest floor, while the gentle sound of flowing water and rustling leaves creates a peaceful atmosphere. The brown bear's fur glistens in the sunlight, highlighting its striking red and white markings as it navigates the stream with agility and playfulness.", + 1, + false + ] + }, + { + "id": 31, + "type": "CogVideoTextEncode", + "pos": { + "0": 504, + "1": 651 + }, + "size": { + "0": 463.01251220703125, + "1": 144 + }, + "flags": {}, + "order": 5, + "mode": 0, + "inputs": [ + { + "name": "clip", + "type": "CLIP", + "link": 217 + } + ], + "outputs": [ + { + "name": "conditioning", + "type": "CONDITIONING", + "links": [ + 214 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "clip", + "type": "CLIP", + "links": null + } + ], + "properties": { + "Node name for S&R": "CogVideoTextEncode" + }, + "widgets_values": [ + "", + 1, + true + ] + }, + { + "id": 78, + "type": "CogVideoSampler", + "pos": { + "0": 1083, + "1": 255 + }, + "size": [ + 330, + 574 + ], + "flags": {}, + "order": 10, + "mode": 0, + "inputs": [ + { + "name": "model", + "type": "COGVIDEOMODEL", + "link": 212 + }, + { + "name": "positive", + "type": "CONDITIONING", + "link": 213 + }, + { + "name": "negative", + "type": "CONDITIONING", + "link": 214 + }, + { + "name": "samples", + "type": "LATENT", + "link": 215, + "shape": 7 + }, + { + "name": "image_cond_latents", + "type": "LATENT", + "link": null, + "shape": 7 + }, + { + "name": "context_options", + "type": "COGCONTEXT", + "link": null, + "shape": 7 + }, + { + "name": "controlnet", + "type": "COGVIDECONTROLNET", + "link": null, + "shape": 7 + }, + { + "name": "tora_trajectory", + "type": "TORAFEATURES", + "link": null, + "shape": 7 + }, + { + "name": "fastercache", + "type": "FASTERCACHEARGS", + "link": null, + "shape": 7 + }, + { + "name": "num_frames", + "type": "INT", + "link": 218, + "widget": { + "name": "num_frames" + } + } + ], + "outputs": [ + { + "name": "samples", + "type": "LATENT", + "links": [ + 216 + ] + } + ], + "properties": { + "Node name for S&R": "CogVideoSampler" + }, + "widgets_values": [ + 49, + 25, + 6, + 0, + "fixed", + "CogVideoXDDIM", + 0.8 + ] + }, + { + "id": 57, + "type": "GetImageSizeAndCount", + "pos": { + "0": 595, + "1": -79 + }, + "size": { + "0": 202.2143096923828, + "1": 99.23601531982422 + }, + "flags": {}, + "order": 8, + "mode": 0, + "inputs": [ + { + "name": "image", + "type": "IMAGE", + "link": 126, + "slot_index": 0 + } + ], + "outputs": [ + { + "name": "image", + "type": "IMAGE", + "links": [ + 191, + 210 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "720 width", + "type": "INT", + "links": [], + "slot_index": 1, + "shape": 3 + }, + { + "name": "480 height", + "type": "INT", + "links": [], + "slot_index": 2, + "shape": 3 + }, + { + "name": "33 count", + "type": "INT", + "links": [ + 218 + ], + "slot_index": 3, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "GetImageSizeAndCount" + }, + "widgets_values": [] + }, + { + "id": 75, + "type": "DownloadAndLoadCogVideoModel", + "pos": { + "0": 606, + "1": 85 + }, + "size": { + "0": 315, + "1": 218 + }, + "flags": {}, + "order": 2, + "mode": 0, + "inputs": [ + { + "name": "block_edit", + "type": "TRANSFORMERBLOCKS", + "link": null, + "shape": 7 + }, + { + "name": "lora", + "type": "COGLORA", + "link": null, + "shape": 7 + }, + { + "name": "compile_args", + "type": "COMPILEARGS", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "model", + "type": "COGVIDEOMODEL", + "links": [ + 212 + ] + }, + { + "name": "vae", + "type": "VAE", + "links": [ + 206, + 209 + ] + } + ], + "properties": { + "Node name for S&R": "DownloadAndLoadCogVideoModel" + }, + "widgets_values": [ + "THUDM/CogVideoX-5b", + "bf16", + "disabled", + false, + "sdpa", + "main_device" + ] + }, + { + "id": 47, + "type": "VHS_VideoCombine", + "pos": { + "0": 1946, + "1": -172 + }, + "size": [ + 1110, + 687.3333333333333 + ], + "flags": {}, + "order": 14, + "mode": 0, + "inputs": [ + { + "name": "images", + "type": "IMAGE", + "link": 132 + }, + { + "name": "audio", + "type": "AUDIO", + "link": null, + "shape": 7 + }, + { + "name": "meta_batch", + "type": "VHS_BatchManager", + "link": null, + "shape": 7 + }, + { + "name": "vae", + "type": "VAE", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "Filenames", + "type": "VHS_FILENAMES", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "VHS_VideoCombine" + }, + "widgets_values": { + "frame_rate": 8, + "loop_count": 0, + "filename_prefix": "CogVideoX_vid2vid", + "format": "video/h264-mp4", + "pix_fmt": "yuv420p", + "crf": 19, + "save_metadata": true, + "pingpong": false, + "save_output": true, + "videopreview": { + "hidden": false, + "paused": false, + "params": { + "filename": "CogVideoX_vid2vid_00003.mp4", + "subfolder": "", + "type": "temp", + "format": "video/h264-mp4", + "frame_rate": 8 + } + } + } + } + ], + "links": [ + [ + 54, + 20, + 0, + 30, + 0, + "CLIP" + ], + [ + 126, + 41, + 0, + 57, + 0, + "IMAGE" + ], + [ + 132, + 58, + 0, + 47, + 0, + "IMAGE" + ], + [ + 170, + 55, + 0, + 58, + 1, + "IMAGE" + ], + [ + 177, + 69, + 0, + 45, + 2, + "INT" + ], + [ + 179, + 45, + 0, + 70, + 0, + "IMAGE" + ], + [ + 180, + 70, + 0, + 41, + 0, + "IMAGE" + ], + [ + 191, + 57, + 0, + 58, + 0, + "IMAGE" + ], + [ + 206, + 75, + 1, + 76, + 0, + "VAE" + ], + [ + 208, + 76, + 0, + 55, + 0, + "IMAGE" + ], + [ + 209, + 75, + 1, + 77, + 0, + "VAE" + ], + [ + 210, + 57, + 0, + 77, + 1, + "IMAGE" + ], + [ + 212, + 75, + 0, + 78, + 0, + "COGVIDEOMODEL" + ], + [ + 213, + 30, + 0, + 78, + 1, + "CONDITIONING" + ], + [ + 214, + 31, + 0, + 78, + 2, + "CONDITIONING" + ], + [ + 215, + 77, + 0, + 78, + 3, + "LATENT" + ], + [ + 216, + 78, + 0, + 76, + 1, + "LATENT" + ], + [ + 217, + 30, + 1, + 31, + 0, + "CLIP" + ], + [ + 218, + 57, + 3, + 78, + 9, + "INT" + ] + ], + "groups": [], + "config": {}, + "extra": { + "ds": { + "scale": 0.8390545288825798, + "offset": [ + -318.82552550589344, + 331.70430573737934 + ] + } + }, + "version": 0.4 +} \ No newline at end of file diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_1_5_5b_I2V_01.json b/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_1_5_5b_I2V_01.json new file mode 100644 index 0000000000000000000000000000000000000000..42d200cc8dd4b73626bbd7d1818a84ce3d7159a3 --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_1_5_5b_I2V_01.json @@ -0,0 +1,688 @@ +{ + "last_node_id": 64, + "last_link_id": 149, + "nodes": [ + { + "id": 63, + "type": "CogVideoSampler", + "pos": { + "0": 1142, + "1": 74 + }, + "size": { + "0": 330, + "1": 574 + }, + "flags": {}, + "order": 7, + "mode": 0, + "inputs": [ + { + "name": "model", + "type": "COGVIDEOMODEL", + "link": 144 + }, + { + "name": "positive", + "type": "CONDITIONING", + "link": 145 + }, + { + "name": "negative", + "type": "CONDITIONING", + "link": 146 + }, + { + "name": "samples", + "type": "LATENT", + "link": null, + "shape": 7 + }, + { + "name": "image_cond_latents", + "type": "LATENT", + "link": 147, + "shape": 7 + }, + { + "name": "context_options", + "type": "COGCONTEXT", + "link": null, + "shape": 7 + }, + { + "name": "controlnet", + "type": "COGVIDECONTROLNET", + "link": null, + "shape": 7 + }, + { + "name": "tora_trajectory", + "type": "TORAFEATURES", + "link": null, + "shape": 7 + }, + { + "name": "fastercache", + "type": "FASTERCACHEARGS", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "samples", + "type": "LATENT", + "links": [ + 148 + ] + } + ], + "properties": { + "Node name for S&R": "CogVideoSampler" + }, + "widgets_values": [ + 49, + 25, + 6, + 0, + "fixed", + "CogVideoXDDIM", + 1 + ] + }, + { + "id": 62, + "type": "CogVideoImageEncode", + "pos": { + "0": 1149, + "1": 711 + }, + "size": { + "0": 315, + "1": 122 + }, + "flags": {}, + "order": 5, + "mode": 0, + "inputs": [ + { + "name": "vae", + "type": "VAE", + "link": 141 + }, + { + "name": "start_image", + "type": "IMAGE", + "link": 142 + }, + { + "name": "end_image", + "type": "IMAGE", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "samples", + "type": "LATENT", + "links": [ + 147 + ] + } + ], + "properties": { + "Node name for S&R": "CogVideoImageEncode" + }, + "widgets_values": [ + false, + 0 + ] + }, + { + "id": 30, + "type": "CogVideoTextEncode", + "pos": { + "0": 493, + "1": 303 + }, + "size": { + "0": 471.90142822265625, + "1": 168.08047485351562 + }, + "flags": {}, + "order": 4, + "mode": 0, + "inputs": [ + { + "name": "clip", + "type": "CLIP", + "link": 54 + } + ], + "outputs": [ + { + "name": "conditioning", + "type": "CONDITIONING", + "links": [ + 145 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "clip", + "type": "CLIP", + "links": [ + 149 + ], + "slot_index": 1 + } + ], + "properties": { + "Node name for S&R": "CogVideoTextEncode" + }, + "widgets_values": [ + "a majestic stag is grazing in an enhanced forest, basking in the setting sun filtered by the trees", + 1, + false + ] + }, + { + "id": 36, + "type": "LoadImage", + "pos": { + "0": 335, + "1": 731 + }, + "size": { + "0": 402.06353759765625, + "1": 396.6225891113281 + }, + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 71 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "MASK", + "type": "MASK", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "LoadImage" + }, + "widgets_values": [ + "sd3stag.png", + "image" + ] + }, + { + "id": 20, + "type": "CLIPLoader", + "pos": { + "0": -2, + "1": 304 + }, + "size": { + "0": 451.30548095703125, + "1": 82 + }, + "flags": {}, + "order": 1, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "CLIP", + "type": "CLIP", + "links": [ + 54 + ], + "slot_index": 0, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "CLIPLoader" + }, + "widgets_values": [ + "t5\\google_t5-v1_1-xxl_encoderonly-fp8_e4m3fn.safetensors", + "sd3" + ] + }, + { + "id": 60, + "type": "CogVideoDecode", + "pos": { + "0": 1523, + "1": -6 + }, + "size": { + "0": 315, + "1": 198 + }, + "flags": {}, + "order": 8, + "mode": 0, + "inputs": [ + { + "name": "vae", + "type": "VAE", + "link": 132 + }, + { + "name": "samples", + "type": "LATENT", + "link": 148 + } + ], + "outputs": [ + { + "name": "images", + "type": "IMAGE", + "links": [ + 134 + ] + } + ], + "properties": { + "Node name for S&R": "CogVideoDecode" + }, + "widgets_values": [ + true, + 240, + 360, + 0.2, + 0.2, + true + ] + }, + { + "id": 37, + "type": "ImageResizeKJ", + "pos": { + "0": 784, + "1": 731 + }, + "size": { + "0": 315, + "1": 266 + }, + "flags": {}, + "order": 3, + "mode": 0, + "inputs": [ + { + "name": "image", + "type": "IMAGE", + "link": 71 + }, + { + "name": "get_image_size", + "type": "IMAGE", + "link": null, + "shape": 7 + }, + { + "name": "width_input", + "type": "INT", + "link": null, + "widget": { + "name": "width_input" + } + }, + { + "name": "height_input", + "type": "INT", + "link": null, + "widget": { + "name": "height_input" + } + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 142 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "width", + "type": "INT", + "links": null, + "shape": 3 + }, + { + "name": "height", + "type": "INT", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "ImageResizeKJ" + }, + "widgets_values": [ + 1360, + 768, + "lanczos", + false, + 16, + 0, + 0, + "disabled" + ] + }, + { + "id": 31, + "type": "CogVideoTextEncode", + "pos": { + "0": 497, + "1": 520 + }, + "size": { + "0": 463.01251220703125, + "1": 144 + }, + "flags": {}, + "order": 6, + "mode": 0, + "inputs": [ + { + "name": "clip", + "type": "CLIP", + "link": 149 + } + ], + "outputs": [ + { + "name": "conditioning", + "type": "CONDITIONING", + "links": [ + 146 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "clip", + "type": "CLIP", + "links": null + } + ], + "properties": { + "Node name for S&R": "CogVideoTextEncode" + }, + "widgets_values": [ + "", + 1, + true + ] + }, + { + "id": 59, + "type": "DownloadAndLoadCogVideoModel", + "pos": { + "0": 622, + "1": -25 + }, + "size": { + "0": 315, + "1": 218 + }, + "flags": {}, + "order": 2, + "mode": 0, + "inputs": [ + { + "name": "block_edit", + "type": "TRANSFORMERBLOCKS", + "link": null, + "shape": 7 + }, + { + "name": "lora", + "type": "COGLORA", + "link": null, + "shape": 7 + }, + { + "name": "compile_args", + "type": "COMPILEARGS", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "model", + "type": "COGVIDEOMODEL", + "links": [ + 144 + ] + }, + { + "name": "vae", + "type": "VAE", + "links": [ + 132, + 141 + ], + "slot_index": 1 + } + ], + "properties": { + "Node name for S&R": "DownloadAndLoadCogVideoModel" + }, + "widgets_values": [ + "kijai/CogVideoX-5b-1.5-I2V", + "bf16", + "disabled", + false, + "sdpa", + "main_device" + ] + }, + { + "id": 44, + "type": "VHS_VideoCombine", + "pos": { + "0": 1884, + "1": -6 + }, + "size": [ + 605.3909912109375, + 310 + ], + "flags": {}, + "order": 9, + "mode": 0, + "inputs": [ + { + "name": "images", + "type": "IMAGE", + "link": 134 + }, + { + "name": "audio", + "type": "AUDIO", + "link": null, + "shape": 7 + }, + { + "name": "meta_batch", + "type": "VHS_BatchManager", + "link": null, + "shape": 7 + }, + { + "name": "vae", + "type": "VAE", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "Filenames", + "type": "VHS_FILENAMES", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "VHS_VideoCombine" + }, + "widgets_values": { + "frame_rate": 16, + "loop_count": 0, + "filename_prefix": "CogVideoX_1_5_I2V", + "format": "video/h264-mp4", + "pix_fmt": "yuv420p", + "crf": 19, + "save_metadata": true, + "pingpong": false, + "save_output": true, + "videopreview": { + "hidden": false, + "paused": false, + "params": { + "filename": "CogVideoX-I2V_00004.mp4", + "subfolder": "", + "type": "temp", + "format": "video/h264-mp4", + "frame_rate": 8 + }, + "muted": false + } + } + } + ], + "links": [ + [ + 54, + 20, + 0, + 30, + 0, + "CLIP" + ], + [ + 71, + 36, + 0, + 37, + 0, + "IMAGE" + ], + [ + 132, + 59, + 1, + 60, + 0, + "VAE" + ], + [ + 134, + 60, + 0, + 44, + 0, + "IMAGE" + ], + [ + 141, + 59, + 1, + 62, + 0, + "VAE" + ], + [ + 142, + 37, + 0, + 62, + 1, + "IMAGE" + ], + [ + 144, + 59, + 0, + 63, + 0, + "COGVIDEOMODEL" + ], + [ + 145, + 30, + 0, + 63, + 1, + "CONDITIONING" + ], + [ + 146, + 31, + 0, + 63, + 2, + "CONDITIONING" + ], + [ + 147, + 62, + 0, + 63, + 4, + "LATENT" + ], + [ + 148, + 63, + 0, + 60, + 1, + "LATENT" + ], + [ + 149, + 30, + 1, + 31, + 0, + "CLIP" + ] + ], + "groups": [], + "config": {}, + "extra": { + "ds": { + "scale": 0.7627768444387097, + "offset": [ + 716.7143770104391, + 291.75859557289965 + ] + } + }, + "version": 0.4 +} \ No newline at end of file diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_Fun_180_orbit_02.json b/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_Fun_180_orbit_02.json new file mode 100644 index 0000000000000000000000000000000000000000..afbe588461c2d331fb144fc4232b34047a7ac8e4 --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_Fun_180_orbit_02.json @@ -0,0 +1,2360 @@ +{ + "last_node_id": 83, + "last_link_id": 179, + "nodes": [ + { + "id": 59, + "type": "GIMMVFI_interpolate", + "pos": [ + 3172.496826171875, + 217.28204345703125 + ], + "size": [ + 330, + 150 + ], + "flags": {}, + "order": 36, + "mode": 0, + "inputs": [ + { + "name": "gimmvfi_model", + "type": "GIMMVIF_MODEL", + "link": 134 + }, + { + "name": "images", + "type": "IMAGE", + "link": 165 + } + ], + "outputs": [ + { + "name": "images", + "type": "IMAGE", + "links": [ + 164 + ], + "slot_index": 0 + }, + { + "name": "flow_tensors", + "type": "IMAGE", + "links": null + } + ], + "properties": { + "Node name for S&R": "GIMMVFI_interpolate" + }, + "widgets_values": [ + 1, + 2, + 223874235763998, + "fixed" + ] + }, + { + "id": 58, + "type": "DownloadAndLoadGIMMVFIModel", + "pos": [ + 2802.496826171875, + 207.2820281982422 + ], + "size": [ + 315, + 58 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "gimmvfi_model", + "type": "GIMMVIF_MODEL", + "links": [ + 134 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "DownloadAndLoadGIMMVFIModel" + }, + "widgets_values": [ + "gimmvfi_r_arb_lpips_fp32.safetensors" + ] + }, + { + "id": 44, + "type": "VHS_VideoCombine", + "pos": [ + 1731.9658203125, + -809.0521850585938 + ], + "size": [ + 592.7720947265625, + 1087.6961669921875 + ], + "flags": {}, + "order": 33, + "mode": 0, + "inputs": [ + { + "name": "images", + "type": "IMAGE", + "link": 131 + }, + { + "name": "audio", + "type": "AUDIO", + "link": null, + "shape": 7 + }, + { + "name": "meta_batch", + "type": "VHS_BatchManager", + "link": null, + "shape": 7 + }, + { + "name": "vae", + "type": "VAE", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "Filenames", + "type": "VHS_FILENAMES", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "VHS_VideoCombine" + }, + "widgets_values": { + "frame_rate": 8, + "loop_count": 0, + "filename_prefix": "CogVideoX_Fun", + "format": "video/h264-mp4", + "pix_fmt": "yuv420p", + "crf": 19, + "save_metadata": true, + "pingpong": false, + "save_output": false, + "videopreview": { + "hidden": false, + "paused": false, + "params": { + "filename": "CogVideoX_Fun_00001.mp4", + "subfolder": "", + "type": "temp", + "format": "video/h264-mp4", + "frame_rate": 8 + }, + "muted": false + } + } + }, + { + "id": 69, + "type": "DownloadAndLoadFlorence2Model", + "pos": [ + -1255.9063720703125, + 695.8967895507812 + ], + "size": [ + 442.37554931640625, + 106 + ], + "flags": {}, + "order": 1, + "mode": 0, + "inputs": [ + { + "name": "lora", + "type": "PEFTLORA", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "florence2_model", + "type": "FL2MODEL", + "links": [ + 158 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "DownloadAndLoadFlorence2Model" + }, + "widgets_values": [ + "MiaoshouAI/Florence-2-base-PromptGen-v2.0", + "fp16", + "sdpa" + ] + }, + { + "id": 70, + "type": "Florence2Run", + "pos": [ + -1245.906494140625, + 861.896728515625 + ], + "size": [ + 400, + 352 + ], + "flags": {}, + "order": 21, + "mode": 0, + "inputs": [ + { + "name": "image", + "type": "IMAGE", + "link": 159 + }, + { + "name": "florence2_model", + "type": "FL2MODEL", + "link": 158 + } + ], + "outputs": [ + { + "name": "image", + "type": "IMAGE", + "links": null, + "slot_index": 0 + }, + { + "name": "mask", + "type": "MASK", + "links": null + }, + { + "name": "caption", + "type": "STRING", + "links": [ + 161, + 162 + ], + "slot_index": 2 + }, + { + "name": "data", + "type": "JSON", + "links": null + } + ], + "properties": { + "Node name for S&R": "Florence2Run" + }, + "widgets_values": [ + "", + "more_detailed_caption", + true, + false, + 226, + 3, + true, + "", + 586007018516875, + "fixed" + ] + }, + { + "id": 71, + "type": "StringConstantMultiline", + "pos": [ + -792.9064331054688, + 428.8970947265625 + ], + "size": [ + 400, + 200 + ], + "flags": {}, + "order": 2, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "STRING", + "type": "STRING", + "links": [ + 160 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "StringConstantMultiline" + }, + "widgets_values": [ + "camera orbit", + false + ] + }, + { + "id": 72, + "type": "JoinStrings", + "pos": [ + -705.906494140625, + 754.896728515625 + ], + "size": [ + 315, + 106 + ], + "flags": {}, + "order": 24, + "mode": 0, + "inputs": [ + { + "name": "string1", + "type": "STRING", + "link": 160, + "widget": { + "name": "string1" + } + }, + { + "name": "string2", + "type": "STRING", + "link": 162, + "widget": { + "name": "string2" + } + } + ], + "outputs": [ + { + "name": "STRING", + "type": "STRING", + "links": [ + 163 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "JoinStrings" + }, + "widgets_values": [ + "", + "", + ", " + ] + }, + { + "id": 73, + "type": "ShowText|pysssss", + "pos": [ + -799.9064331054688, + 950.8969116210938 + ], + "size": [ + 502.3168640136719, + 180.55015563964844 + ], + "flags": {}, + "order": 23, + "mode": 0, + "inputs": [ + { + "name": "text", + "type": "STRING", + "link": 161, + "widget": { + "name": "text" + } + } + ], + "outputs": [ + { + "name": "STRING", + "type": "STRING", + "links": null, + "shape": 6 + } + ], + "properties": { + "Node name for S&R": "ShowText|pysssss" + }, + "widgets_values": [ + "", + "A digital illustration shoot from a frontal camera angle about a dark knight in shining armor stands in a dimly lit forest, with a glowing fire in the background. the image also shows a mysterious and intense atmosphere. on the middle of the image, a male knight appears to be standing, facing the viewer, with his full body visible. he is wearing a full plate armor with a red cloth draped over his shoulders. the armor is shiny and detailed, with intricate designs and a chain attached to it. he has two curved horns on his head, and his eyes are glowing yellow. the background is dark and smoky, with tall trees and a warm, glowing fire." + ] + }, + { + "id": 74, + "type": "SetNode", + "pos": [ + -208.98883056640625, + -1011.4821166992188 + ], + "size": [ + 210, + 58 + ], + "flags": { + "collapsed": true + }, + "order": 18, + "mode": 0, + "inputs": [ + { + "name": "VAE", + "type": "VAE", + "link": 166 + } + ], + "outputs": [ + { + "name": "*", + "type": "*", + "links": null + } + ], + "title": "Set_VAE", + "properties": { + "previousName": "VAE" + }, + "widgets_values": [ + "VAE" + ], + "color": "#322", + "bgcolor": "#533" + }, + { + "id": 51, + "type": "CogVideoDecode", + "pos": [ + 1301.9658203125, + -479.0520324707031 + ], + "size": [ + 315, + 198 + ], + "flags": {}, + "order": 29, + "mode": 0, + "inputs": [ + { + "name": "vae", + "type": "VAE", + "link": 167 + }, + { + "name": "samples", + "type": "LATENT", + "link": 123 + } + ], + "outputs": [ + { + "name": "images", + "type": "IMAGE", + "links": [ + 130 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "CogVideoDecode" + }, + "widgets_values": [ + true, + 240, + 360, + 0.2, + 0.2, + true + ] + }, + { + "id": 64, + "type": "CogVideoDecode", + "pos": [ + 1266.369384765625, + 889 + ], + "size": [ + 315, + 198 + ], + "flags": {}, + "order": 30, + "mode": 0, + "inputs": [ + { + "name": "vae", + "type": "VAE", + "link": 170 + }, + { + "name": "samples", + "type": "LATENT", + "link": 148 + } + ], + "outputs": [ + { + "name": "images", + "type": "IMAGE", + "links": [ + 150, + 153 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "CogVideoDecode" + }, + "widgets_values": [ + true, + 240, + 360, + 0.2, + 0.2, + true + ] + }, + { + "id": 68, + "type": "PrimitiveNode", + "pos": [ + 1081.9658203125, + -649.0521850585938 + ], + "size": [ + 295.9042053222656, + 82 + ], + "flags": {}, + "order": 3, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "INT", + "type": "INT", + "links": [ + 156, + 157 + ], + "slot_index": 0, + "widget": { + "name": "seed" + } + } + ], + "title": "seed", + "properties": { + "Run widget replace on values": false + }, + "widgets_values": [ + 458091243358278, + "fixed" + ] + }, + { + "id": 54, + "type": "ImageFlip+", + "pos": [ + 931.9658813476562, + 300.9479675292969 + ], + "size": [ + 315, + 58 + ], + "flags": {}, + "order": 19, + "mode": 0, + "inputs": [ + { + "name": "image", + "type": "IMAGE", + "link": 128 + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 129 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "ImageFlip+" + }, + "widgets_values": [ + "x" + ] + }, + { + "id": 63, + "type": "CogVideoImageEncodeFunInP", + "pos": [ + 944.7587280273438, + 1048.5242919921875 + ], + "size": [ + 253.60000610351562, + 146 + ], + "flags": {}, + "order": 20, + "mode": 0, + "inputs": [ + { + "name": "vae", + "type": "VAE", + "link": 169 + }, + { + "name": "start_image", + "type": "IMAGE", + "link": 146 + }, + { + "name": "end_image", + "type": "IMAGE", + "link": null, + "shape": 7 + }, + { + "name": "num_frames", + "type": "INT", + "link": 175, + "widget": { + "name": "num_frames" + } + } + ], + "outputs": [ + { + "name": "image_cond_latents", + "type": "LATENT", + "links": [ + 147 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "CogVideoImageEncodeFunInP" + }, + "widgets_values": [ + 33, + true, + 0.03 + ] + }, + { + "id": 48, + "type": "CogVideoSampler", + "pos": [ + 1281.9658203125, + -219.0520782470703 + ], + "size": [ + 330, + 574 + ], + "flags": {}, + "order": 27, + "mode": 0, + "inputs": [ + { + "name": "model", + "type": "COGVIDEOMODEL", + "link": 178 + }, + { + "name": "positive", + "type": "CONDITIONING", + "link": 116 + }, + { + "name": "negative", + "type": "CONDITIONING", + "link": 117 + }, + { + "name": "samples", + "type": "LATENT", + "link": null, + "shape": 7 + }, + { + "name": "image_cond_latents", + "type": "LATENT", + "link": 120, + "shape": 7 + }, + { + "name": "context_options", + "type": "COGCONTEXT", + "link": null, + "shape": 7 + }, + { + "name": "controlnet", + "type": "COGVIDECONTROLNET", + "link": null, + "shape": 7 + }, + { + "name": "tora_trajectory", + "type": "TORAFEATURES", + "link": null, + "shape": 7 + }, + { + "name": "fastercache", + "type": "FASTERCACHEARGS", + "link": null, + "shape": 7 + }, + { + "name": "num_frames", + "type": "INT", + "link": 172, + "widget": { + "name": "num_frames" + } + }, + { + "name": "seed", + "type": "INT", + "link": 156, + "widget": { + "name": "seed" + } + } + ], + "outputs": [ + { + "name": "samples", + "type": "LATENT", + "links": [ + 123 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "CogVideoSampler" + }, + "widgets_values": [ + 33, + 40, + 6, + 458091243358278, + "fixed", + "CogVideoXDDIM", + 1 + ] + }, + { + "id": 79, + "type": "GetNode", + "pos": [ + 971.9658813476562, + -8.052048683166504 + ], + "size": [ + 210, + 58 + ], + "flags": { + "collapsed": true + }, + "order": 4, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "INT", + "type": "INT", + "links": [ + 172, + 173 + ], + "slot_index": 0 + } + ], + "title": "Get_Frames", + "properties": {}, + "widgets_values": [ + "Frames" + ], + "color": "#1b4669", + "bgcolor": "#29699c" + }, + { + "id": 65, + "type": "VHS_VideoCombine", + "pos": [ + 1748.369384765625, + 682 + ], + "size": [ + 620.0130615234375, + 1124.0174560546875 + ], + "flags": {}, + "order": 32, + "mode": 0, + "inputs": [ + { + "name": "images", + "type": "IMAGE", + "link": 150 + }, + { + "name": "audio", + "type": "AUDIO", + "link": null, + "shape": 7 + }, + { + "name": "meta_batch", + "type": "VHS_BatchManager", + "link": null, + "shape": 7 + }, + { + "name": "vae", + "type": "VAE", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "Filenames", + "type": "VHS_FILENAMES", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "VHS_VideoCombine" + }, + "widgets_values": { + "frame_rate": 8, + "loop_count": 0, + "filename_prefix": "CogVideoX_Fun", + "format": "video/h264-mp4", + "pix_fmt": "yuv420p", + "crf": 19, + "save_metadata": true, + "pingpong": false, + "save_output": false, + "videopreview": { + "hidden": false, + "paused": false, + "params": { + "filename": "CogVideoX_Fun_00002.mp4", + "subfolder": "", + "type": "temp", + "format": "video/h264-mp4", + "frame_rate": 8 + }, + "muted": false + } + } + }, + { + "id": 80, + "type": "GetNode", + "pos": [ + 927.369384765625, + 1387 + ], + "size": [ + 210, + 58 + ], + "flags": { + "collapsed": true + }, + "order": 5, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "INT", + "type": "INT", + "links": [ + 174, + 175 + ], + "slot_index": 0 + } + ], + "title": "Get_Frames", + "properties": {}, + "widgets_values": [ + "Frames" + ], + "color": "#1b4669", + "bgcolor": "#29699c" + }, + { + "id": 76, + "type": "GetNode", + "pos": [ + 907.369384765625, + 919 + ], + "size": [ + 210, + 58 + ], + "flags": { + "collapsed": true + }, + "order": 6, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "VAE", + "type": "VAE", + "links": [ + 169, + 170 + ] + } + ], + "title": "Get_VAE", + "properties": {}, + "widgets_values": [ + "VAE" + ], + "color": "#322", + "bgcolor": "#533" + }, + { + "id": 50, + "type": "CogVideoImageEncodeFunInP", + "pos": [ + 991.9658813476562, + 90.94794464111328 + ], + "size": [ + 253.60000610351562, + 146 + ], + "flags": {}, + "order": 22, + "mode": 0, + "inputs": [ + { + "name": "vae", + "type": "VAE", + "link": 176 + }, + { + "name": "start_image", + "type": "IMAGE", + "link": 129 + }, + { + "name": "end_image", + "type": "IMAGE", + "link": null, + "shape": 7 + }, + { + "name": "num_frames", + "type": "INT", + "link": 173, + "widget": { + "name": "num_frames" + } + } + ], + "outputs": [ + { + "name": "image_cond_latents", + "type": "LATENT", + "links": [ + 120 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "CogVideoImageEncodeFunInP" + }, + "widgets_values": [ + 33, + true, + 0.03 + ] + }, + { + "id": 55, + "type": "ImageFlip+", + "pos": [ + 1746, + 333 + ], + "size": [ + 315, + 58 + ], + "flags": {}, + "order": 31, + "mode": 0, + "inputs": [ + { + "name": "image", + "type": "IMAGE", + "link": 130 + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 131, + 151 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "ImageFlip+" + }, + "widgets_values": [ + "x" + ] + }, + { + "id": 66, + "type": "ReverseImageBatch", + "pos": [ + 2123, + 338 + ], + "size": [ + 239.40000915527344, + 26 + ], + "flags": {}, + "order": 34, + "mode": 0, + "inputs": [ + { + "name": "images", + "type": "IMAGE", + "link": 151 + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 152 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "ReverseImageBatch" + }, + "widgets_values": [] + }, + { + "id": 67, + "type": "ImageBatchMulti", + "pos": [ + 2812.2978515625, + 337.11962890625 + ], + "size": [ + 210, + 102 + ], + "flags": {}, + "order": 35, + "mode": 0, + "inputs": [ + { + "name": "image_1", + "type": "IMAGE", + "link": 152 + }, + { + "name": "image_2", + "type": "IMAGE", + "link": 153 + } + ], + "outputs": [ + { + "name": "images", + "type": "IMAGE", + "links": [ + 165 + ], + "slot_index": 0 + } + ], + "properties": {}, + "widgets_values": [ + 2, + null + ] + }, + { + "id": 60, + "type": "VHS_VideoCombine", + "pos": [ + 2909.2978515625, + 564.1198120117188 + ], + "size": [ + 552.211181640625, + 1033.6148681640625 + ], + "flags": {}, + "order": 37, + "mode": 0, + "inputs": [ + { + "name": "images", + "type": "IMAGE", + "link": 164 + }, + { + "name": "audio", + "type": "AUDIO", + "link": null, + "shape": 7 + }, + { + "name": "meta_batch", + "type": "VHS_BatchManager", + "link": null, + "shape": 7 + }, + { + "name": "vae", + "type": "VAE", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "Filenames", + "type": "VHS_FILENAMES", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "VHS_VideoCombine" + }, + "widgets_values": { + "frame_rate": 16, + "loop_count": 0, + "filename_prefix": "CogVideoX_Fun_orbits", + "format": "video/h264-mp4", + "pix_fmt": "yuv420p", + "crf": 19, + "save_metadata": true, + "pingpong": false, + "save_output": true, + "videopreview": { + "hidden": false, + "paused": false, + "params": { + "filename": "CogVideoX_Fun_orbits_00001.mp4", + "subfolder": "", + "type": "output", + "format": "video/h264-mp4", + "frame_rate": 16 + }, + "muted": false + } + } + }, + { + "id": 30, + "type": "CogVideoTextEncode", + "pos": [ + 134, + 151 + ], + "size": [ + 458.8887634277344, + 119.00272369384766 + ], + "flags": {}, + "order": 25, + "mode": 0, + "inputs": [ + { + "name": "clip", + "type": "CLIP", + "link": 54 + }, + { + "name": "prompt", + "type": "STRING", + "link": 163, + "widget": { + "name": "prompt" + } + } + ], + "outputs": [ + { + "name": "conditioning", + "type": "CONDITIONING", + "links": [ + 116, + 140 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "clip", + "type": "CLIP", + "links": [ + 110 + ], + "slot_index": 1 + } + ], + "properties": { + "Node name for S&R": "CogVideoTextEncode" + }, + "widgets_values": [ + "camera orbit around a mouse knight standing in a fantasy forest", + 1, + false + ], + "color": "#232", + "bgcolor": "#353" + }, + { + "id": 81, + "type": "SetNode", + "pos": [ + -234, + -1069 + ], + "size": [ + 210, + 58 + ], + "flags": { + "collapsed": true + }, + "order": 17, + "mode": 0, + "inputs": [ + { + "name": "COGVIDEOMODEL", + "type": "COGVIDEOMODEL", + "link": 177 + } + ], + "outputs": [ + { + "name": "*", + "type": "*", + "links": null + } + ], + "title": "Set_CogVideoXModel", + "properties": { + "previousName": "CogVideoXModel" + }, + "widgets_values": [ + "CogVideoXModel" + ], + "color": "#223", + "bgcolor": "#335" + }, + { + "id": 49, + "type": "DownloadAndLoadCogVideoModel", + "pos": [ + -710, + -1109 + ], + "size": [ + 362.1656799316406, + 218 + ], + "flags": {}, + "order": 14, + "mode": 0, + "inputs": [ + { + "name": "block_edit", + "type": "TRANSFORMERBLOCKS", + "link": null, + "shape": 7 + }, + { + "name": "lora", + "type": "COGLORA", + "link": 124, + "shape": 7 + }, + { + "name": "compile_args", + "type": "COMPILEARGS", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "model", + "type": "COGVIDEOMODEL", + "links": [ + 177 + ], + "slot_index": 0 + }, + { + "name": "vae", + "type": "VAE", + "links": [ + 166 + ], + "slot_index": 1 + } + ], + "properties": { + "Node name for S&R": "DownloadAndLoadCogVideoModel" + }, + "widgets_values": [ + "alibaba-pai/CogVideoX-Fun-V1.1-5b-InP", + "bf16", + "disabled", + false, + "sdpa", + "main_device" + ], + "color": "#223", + "bgcolor": "#335" + }, + { + "id": 52, + "type": "CogVideoLoraSelect", + "pos": [ + -1232, + -1096 + ], + "size": [ + 438.4476318359375, + 106 + ], + "flags": {}, + "order": 7, + "mode": 0, + "inputs": [ + { + "name": "prev_lora", + "type": "COGLORA", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "lora", + "type": "COGLORA", + "links": [ + 124 + ] + } + ], + "properties": { + "Node name for S&R": "CogVideoLoraSelect" + }, + "widgets_values": [ + "DimensionX_orbit_left_lora_rank256_bf16.safetensors", + 1, + true + ], + "color": "#223", + "bgcolor": "#335" + }, + { + "id": 75, + "type": "GetNode", + "pos": [ + 1037, + -446 + ], + "size": [ + 210, + 58 + ], + "flags": { + "collapsed": true + }, + "order": 8, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "VAE", + "type": "VAE", + "links": [ + 167, + 176 + ] + } + ], + "title": "Get_VAE", + "properties": {}, + "widgets_values": [ + "VAE" + ], + "color": "#322", + "bgcolor": "#533" + }, + { + "id": 82, + "type": "GetNode", + "pos": [ + 1043, + -330 + ], + "size": [ + 210, + 58 + ], + "flags": { + "collapsed": true + }, + "order": 9, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "COGVIDEOMODEL", + "type": "COGVIDEOMODEL", + "links": [ + 178 + ], + "slot_index": 0 + } + ], + "title": "Get_CogVideoXModel", + "properties": {}, + "widgets_values": [ + "CogVideoXModel" + ], + "color": "#223", + "bgcolor": "#335" + }, + { + "id": 62, + "type": "CogVideoSampler", + "pos": [ + 1266.369384765625, + 1151 + ], + "size": [ + 330, + 574 + ], + "flags": {}, + "order": 28, + "mode": 0, + "inputs": [ + { + "name": "model", + "type": "COGVIDEOMODEL", + "link": 179 + }, + { + "name": "positive", + "type": "CONDITIONING", + "link": 140 + }, + { + "name": "negative", + "type": "CONDITIONING", + "link": 141 + }, + { + "name": "samples", + "type": "LATENT", + "link": null, + "shape": 7 + }, + { + "name": "image_cond_latents", + "type": "LATENT", + "link": 147, + "shape": 7 + }, + { + "name": "context_options", + "type": "COGCONTEXT", + "link": null, + "shape": 7 + }, + { + "name": "controlnet", + "type": "COGVIDECONTROLNET", + "link": null, + "shape": 7 + }, + { + "name": "tora_trajectory", + "type": "TORAFEATURES", + "link": null, + "shape": 7 + }, + { + "name": "fastercache", + "type": "FASTERCACHEARGS", + "link": null, + "shape": 7 + }, + { + "name": "num_frames", + "type": "INT", + "link": 174, + "widget": { + "name": "num_frames" + } + }, + { + "name": "seed", + "type": "INT", + "link": 157, + "widget": { + "name": "seed" + } + } + ], + "outputs": [ + { + "name": "samples", + "type": "LATENT", + "links": [ + 148 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "CogVideoSampler" + }, + "widgets_values": [ + 33, + 40, + 6, + 458091243358278, + "fixed", + "CogVideoXDDIM", + 1 + ] + }, + { + "id": 83, + "type": "GetNode", + "pos": [ + 1044, + 1245 + ], + "size": [ + 210, + 58 + ], + "flags": { + "collapsed": true + }, + "order": 10, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "COGVIDEOMODEL", + "type": "COGVIDEOMODEL", + "links": [ + 179 + ], + "slot_index": 0 + } + ], + "title": "Get_CogVideoXModel", + "properties": {}, + "widgets_values": [ + "CogVideoXModel" + ], + "color": "#223", + "bgcolor": "#335" + }, + { + "id": 31, + "type": "CogVideoTextEncode", + "pos": [ + 134, + 337 + ], + "size": [ + 463.01251220703125, + 144 + ], + "flags": {}, + "order": 26, + "mode": 0, + "inputs": [ + { + "name": "clip", + "type": "CLIP", + "link": 110 + } + ], + "outputs": [ + { + "name": "conditioning", + "type": "CONDITIONING", + "links": [ + 117, + 141 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "clip", + "type": "CLIP", + "links": null + } + ], + "properties": { + "Node name for S&R": "CogVideoTextEncode" + }, + "widgets_values": [ + "The video is not of a high quality, it has a low resolution. Watermark present in each frame. Strange motion trajectory. ", + 1, + true + ], + "color": "#322", + "bgcolor": "#533" + }, + { + "id": 20, + "type": "CLIPLoader", + "pos": [ + -705, + -833 + ], + "size": [ + 451.30548095703125, + 82 + ], + "flags": {}, + "order": 11, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "CLIP", + "type": "CLIP", + "links": [ + 54 + ], + "slot_index": 0, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "CLIPLoader" + }, + "widgets_values": [ + "t5\\google_t5-v1_1-xxl_encoderonly-fp8_e4m3fn.safetensors", + "sd3" + ], + "color": "#432", + "bgcolor": "#653" + }, + { + "id": 36, + "type": "LoadImage", + "pos": [ + -1250, + -382 + ], + "size": [ + 441.7763671875, + 587.7473754882812 + ], + "flags": {}, + "order": 12, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 71 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "MASK", + "type": "MASK", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "LoadImage" + }, + "widgets_values": [ + "ComfyUI_temp_lhgah_00059_.png", + "image" + ] + }, + { + "id": 37, + "type": "ImageResizeKJ", + "pos": [ + -723, + -384 + ], + "size": [ + 315, + 266 + ], + "flags": {}, + "order": 15, + "mode": 0, + "inputs": [ + { + "name": "image", + "type": "IMAGE", + "link": 71 + }, + { + "name": "get_image_size", + "type": "IMAGE", + "link": null, + "shape": 7 + }, + { + "name": "width_input", + "type": "INT", + "link": null, + "widget": { + "name": "width_input" + } + }, + { + "name": "height_input", + "type": "INT", + "link": null, + "widget": { + "name": "height_input" + } + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 128, + 146, + 159 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "width", + "type": "INT", + "links": null, + "shape": 3 + }, + { + "name": "height", + "type": "INT", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "ImageResizeKJ" + }, + "widgets_values": [ + 768, + 768, + "lanczos", + true, + 16, + 0, + 0, + "disabled" + ] + }, + { + "id": 77, + "type": "INTConstant", + "pos": [ + 106, + -459 + ], + "size": [ + 200, + 58 + ], + "flags": {}, + "order": 13, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "value", + "type": "INT", + "links": [ + 171 + ], + "slot_index": 0 + } + ], + "title": "Frames", + "properties": { + "Node name for S&R": "INTConstant" + }, + "widgets_values": [ + 33 + ], + "color": "#1b4669", + "bgcolor": "#29699c" + }, + { + "id": 78, + "type": "SetNode", + "pos": [ + 348, + -428 + ], + "size": [ + 210, + 58 + ], + "flags": { + "collapsed": true + }, + "order": 16, + "mode": 0, + "inputs": [ + { + "name": "INT", + "type": "INT", + "link": 171 + } + ], + "outputs": [ + { + "name": "*", + "type": "*", + "links": null + } + ], + "title": "Set_Frames", + "properties": { + "previousName": "Frames" + }, + "widgets_values": [ + "Frames" + ], + "color": "#1b4669", + "bgcolor": "#29699c" + } + ], + "links": [ + [ + 54, + 20, + 0, + 30, + 0, + "CLIP" + ], + [ + 71, + 36, + 0, + 37, + 0, + "IMAGE" + ], + [ + 110, + 30, + 1, + 31, + 0, + "CLIP" + ], + [ + 116, + 30, + 0, + 48, + 1, + "CONDITIONING" + ], + [ + 117, + 31, + 0, + 48, + 2, + "CONDITIONING" + ], + [ + 120, + 50, + 0, + 48, + 4, + "LATENT" + ], + [ + 123, + 48, + 0, + 51, + 1, + "LATENT" + ], + [ + 124, + 52, + 0, + 49, + 1, + "COGLORA" + ], + [ + 128, + 37, + 0, + 54, + 0, + "IMAGE" + ], + [ + 129, + 54, + 0, + 50, + 1, + "IMAGE" + ], + [ + 130, + 51, + 0, + 55, + 0, + "IMAGE" + ], + [ + 131, + 55, + 0, + 44, + 0, + "IMAGE" + ], + [ + 134, + 58, + 0, + 59, + 0, + "GIMMVIF_MODEL" + ], + [ + 140, + 30, + 0, + 62, + 1, + "CONDITIONING" + ], + [ + 141, + 31, + 0, + 62, + 2, + "CONDITIONING" + ], + [ + 146, + 37, + 0, + 63, + 1, + "IMAGE" + ], + [ + 147, + 63, + 0, + 62, + 4, + "LATENT" + ], + [ + 148, + 62, + 0, + 64, + 1, + "LATENT" + ], + [ + 150, + 64, + 0, + 65, + 0, + "IMAGE" + ], + [ + 151, + 55, + 0, + 66, + 0, + "IMAGE" + ], + [ + 152, + 66, + 0, + 67, + 0, + "IMAGE" + ], + [ + 153, + 64, + 0, + 67, + 1, + "IMAGE" + ], + [ + 156, + 68, + 0, + 48, + 10, + "INT" + ], + [ + 157, + 68, + 0, + 62, + 10, + "INT" + ], + [ + 158, + 69, + 0, + 70, + 1, + "FL2MODEL" + ], + [ + 159, + 37, + 0, + 70, + 0, + "IMAGE" + ], + [ + 160, + 71, + 0, + 72, + 0, + "STRING" + ], + [ + 161, + 70, + 2, + 73, + 0, + "STRING" + ], + [ + 162, + 70, + 2, + 72, + 1, + "STRING" + ], + [ + 163, + 72, + 0, + 30, + 1, + "STRING" + ], + [ + 164, + 59, + 0, + 60, + 0, + "IMAGE" + ], + [ + 165, + 67, + 0, + 59, + 1, + "IMAGE" + ], + [ + 166, + 49, + 1, + 74, + 0, + "*" + ], + [ + 167, + 75, + 0, + 51, + 0, + "VAE" + ], + [ + 169, + 76, + 0, + 63, + 0, + "VAE" + ], + [ + 170, + 76, + 0, + 64, + 0, + "VAE" + ], + [ + 171, + 77, + 0, + 78, + 0, + "*" + ], + [ + 172, + 79, + 0, + 48, + 9, + "INT" + ], + [ + 173, + 79, + 0, + 50, + 3, + "INT" + ], + [ + 174, + 80, + 0, + 62, + 9, + "INT" + ], + [ + 175, + 80, + 0, + 63, + 3, + "INT" + ], + [ + 176, + 75, + 0, + 50, + 0, + "VAE" + ], + [ + 177, + 49, + 0, + 81, + 0, + "*" + ], + [ + 178, + 82, + 0, + 48, + 0, + "COGVIDEOMODEL" + ], + [ + 179, + 83, + 0, + 62, + 0, + "COGVIDEOMODEL" + ] + ], + "groups": [ + { + "id": 1, + "title": "Autoprompt", + "bounding": [ + -1333.6951904296875, + 307.17431640625, + 1163.29296875, + 942.3335571289062 + ], + "color": "#3f789e", + "font_size": 24, + "flags": {} + }, + { + "id": 2, + "title": "OrbitRight", + "bounding": [ + 811.9992065429688, + -916.5665283203125, + 1616.8448486328125, + 1372.9599609375 + ], + "color": "#3f789e", + "font_size": 24, + "flags": {} + }, + { + "id": 3, + "title": "Join and interpolate", + "bounding": [ + 2641.15380859375, + 36.47324752807617, + 1039.7998046875, + 1633.928955078125 + ], + "color": "#3f789e", + "font_size": 24, + "flags": {} + }, + { + "id": 4, + "title": "OrbitLeft", + "bounding": [ + 823.7742919921875, + 504.1250915527344, + 1597.70068359375, + 1384.0621337890625 + ], + "color": "#3f789e", + "font_size": 24, + "flags": {} + }, + { + "id": 5, + "title": "InputImage", + "bounding": [ + -1323.1298828125, + -495.65478515625, + 1164.93603515625, + 770.36083984375 + ], + "color": "#3f789e", + "font_size": 24, + "flags": {} + }, + { + "id": 6, + "title": "Models", + "bounding": [ + -1306.8953857421875, + -1216.529052734375, + 1272.3226318359375, + 494.4677429199219 + ], + "color": "#a1309b", + "font_size": 24, + "flags": {} + } + ], + "config": {}, + "extra": { + "ds": { + "scale": 0.38554328942953225, + "offset": [ + 3283.3233389403267, + 1116.9679324983256 + ] + } + }, + "version": 0.4 +} \ No newline at end of file diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_Fun_I2V_02.json b/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_Fun_I2V_02.json new file mode 100644 index 0000000000000000000000000000000000000000..6315ce0d96baffe8433798788747b03ff000185f --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_Fun_I2V_02.json @@ -0,0 +1,691 @@ +{ + "last_node_id": 51, + "last_link_id": 123, + "nodes": [ + { + "id": 48, + "type": "CogVideoSampler", + "pos": { + "0": 1200, + "1": 124 + }, + "size": [ + 330, + 574 + ], + "flags": {}, + "order": 7, + "mode": 0, + "inputs": [ + { + "name": "model", + "type": "COGVIDEOMODEL", + "link": 114 + }, + { + "name": "positive", + "type": "CONDITIONING", + "link": 116 + }, + { + "name": "negative", + "type": "CONDITIONING", + "link": 117 + }, + { + "name": "samples", + "type": "LATENT", + "link": null, + "shape": 7 + }, + { + "name": "image_cond_latents", + "type": "LATENT", + "link": 120, + "shape": 7 + }, + { + "name": "context_options", + "type": "COGCONTEXT", + "link": null, + "shape": 7 + }, + { + "name": "controlnet", + "type": "COGVIDECONTROLNET", + "link": null, + "shape": 7 + }, + { + "name": "tora_trajectory", + "type": "TORAFEATURES", + "link": null, + "shape": 7 + }, + { + "name": "fastercache", + "type": "FASTERCACHEARGS", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "samples", + "type": "LATENT", + "links": [ + 123 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "CogVideoSampler" + }, + "widgets_values": [ + 49, + 25, + 6, + 458091243358272, + "randomize", + "CogVideoXDDIM", + 1 + ] + }, + { + "id": 30, + "type": "CogVideoTextEncode", + "pos": { + "0": 490, + "1": 146 + }, + "size": { + "0": 471.90142822265625, + "1": 168.08047485351562 + }, + "flags": {}, + "order": 3, + "mode": 0, + "inputs": [ + { + "name": "clip", + "type": "CLIP", + "link": 54 + } + ], + "outputs": [ + { + "name": "conditioning", + "type": "CONDITIONING", + "links": [ + 116 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "clip", + "type": "CLIP", + "links": [ + 110 + ], + "slot_index": 1 + } + ], + "properties": { + "Node name for S&R": "CogVideoTextEncode" + }, + "widgets_values": [ + "fireworks display over night city. The video is of high quality, and the view is very clear. High quality, masterpiece, best quality, highres, ultra-detailed, fantastic.", + 1, + false + ] + }, + { + "id": 31, + "type": "CogVideoTextEncode", + "pos": { + "0": 497, + "1": 365 + }, + "size": { + "0": 463.01251220703125, + "1": 144 + }, + "flags": {}, + "order": 5, + "mode": 0, + "inputs": [ + { + "name": "clip", + "type": "CLIP", + "link": 110 + } + ], + "outputs": [ + { + "name": "conditioning", + "type": "CONDITIONING", + "links": [ + 117 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "clip", + "type": "CLIP", + "links": null + } + ], + "properties": { + "Node name for S&R": "CogVideoTextEncode" + }, + "widgets_values": [ + "The video is not of a high quality, it has a low resolution. Watermark present in each frame. Strange motion trajectory. ", + 1, + true + ] + }, + { + "id": 20, + "type": "CLIPLoader", + "pos": { + "0": -7, + "1": -37 + }, + "size": { + "0": 451.30548095703125, + "1": 82 + }, + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "CLIP", + "type": "CLIP", + "links": [ + 54 + ], + "slot_index": 0, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "CLIPLoader" + }, + "widgets_values": [ + "t5\\google_t5-v1_1-xxl_encoderonly-fp8_e4m3fn.safetensors", + "sd3" + ] + }, + { + "id": 50, + "type": "CogVideoImageEncodeFunInP", + "pos": { + "0": 865, + "1": 567 + }, + "size": [ + 253.60000610351562, + 146 + ], + "flags": {}, + "order": 6, + "mode": 0, + "inputs": [ + { + "name": "vae", + "type": "VAE", + "link": 119 + }, + { + "name": "start_image", + "type": "IMAGE", + "link": 118 + }, + { + "name": "end_image", + "type": "IMAGE", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "image_cond_latents", + "type": "LATENT", + "links": [ + 120 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "CogVideoImageEncodeFunInP" + }, + "widgets_values": [ + 49, + true, + 0 + ] + }, + { + "id": 37, + "type": "ImageResizeKJ", + "pos": { + "0": 499, + "1": 587 + }, + "size": { + "0": 315, + "1": 266 + }, + "flags": {}, + "order": 4, + "mode": 0, + "inputs": [ + { + "name": "image", + "type": "IMAGE", + "link": 71 + }, + { + "name": "get_image_size", + "type": "IMAGE", + "link": null, + "shape": 7 + }, + { + "name": "width_input", + "type": "INT", + "link": null, + "widget": { + "name": "width_input" + } + }, + { + "name": "height_input", + "type": "INT", + "link": null, + "widget": { + "name": "height_input" + } + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 118 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "width", + "type": "INT", + "links": null, + "shape": 3 + }, + { + "name": "height", + "type": "INT", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "ImageResizeKJ" + }, + "widgets_values": [ + 720, + 480, + "lanczos", + false, + 2, + 0, + 0, + "disabled" + ] + }, + { + "id": 36, + "type": "LoadImage", + "pos": { + "0": 43, + "1": 587 + }, + "size": [ + 405.2986131072541, + 477.48971409949377 + ], + "flags": {}, + "order": 1, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 71 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "MASK", + "type": "MASK", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "LoadImage" + }, + "widgets_values": [ + "6e1a7befce6daa63fc01cb66c1a22ed0.jpg", + "image" + ] + }, + { + "id": 51, + "type": "CogVideoDecode", + "pos": { + "0": 1219, + "1": -134 + }, + "size": { + "0": 315, + "1": 198 + }, + "flags": {}, + "order": 8, + "mode": 0, + "inputs": [ + { + "name": "vae", + "type": "VAE", + "link": 122 + }, + { + "name": "samples", + "type": "LATENT", + "link": 123 + } + ], + "outputs": [ + { + "name": "images", + "type": "IMAGE", + "links": [ + 121 + ] + } + ], + "properties": { + "Node name for S&R": "CogVideoDecode" + }, + "widgets_values": [ + true, + 240, + 360, + 0.2, + 0.2, + true + ] + }, + { + "id": 44, + "type": "VHS_VideoCombine", + "pos": { + "0": 1602, + "1": -131 + }, + "size": [ + 767.7372279260157, + 822.491455078125 + ], + "flags": {}, + "order": 9, + "mode": 0, + "inputs": [ + { + "name": "images", + "type": "IMAGE", + "link": 121 + }, + { + "name": "audio", + "type": "AUDIO", + "link": null, + "shape": 7 + }, + { + "name": "meta_batch", + "type": "VHS_BatchManager", + "link": null, + "shape": 7 + }, + { + "name": "vae", + "type": "VAE", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "Filenames", + "type": "VHS_FILENAMES", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "VHS_VideoCombine" + }, + "widgets_values": { + "frame_rate": 8, + "loop_count": 0, + "filename_prefix": "CogVideoX_Fun", + "format": "video/h264-mp4", + "pix_fmt": "yuv420p", + "crf": 19, + "save_metadata": true, + "pingpong": false, + "save_output": true, + "videopreview": { + "hidden": false, + "paused": false, + "params": { + "filename": "CogVideoX_Fun_00002.mp4", + "subfolder": "", + "type": "temp", + "format": "video/h264-mp4", + "frame_rate": 8 + }, + "muted": false + } + } + }, + { + "id": 49, + "type": "DownloadAndLoadCogVideoModel", + "pos": { + "0": 491, + "1": -167 + }, + "size": { + "0": 362.1656799316406, + "1": 218 + }, + "flags": {}, + "order": 2, + "mode": 0, + "inputs": [ + { + "name": "block_edit", + "type": "TRANSFORMERBLOCKS", + "link": null, + "shape": 7 + }, + { + "name": "lora", + "type": "COGLORA", + "link": null, + "shape": 7 + }, + { + "name": "compile_args", + "type": "COMPILEARGS", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "model", + "type": "COGVIDEOMODEL", + "links": [ + 114 + ] + }, + { + "name": "vae", + "type": "VAE", + "links": [ + 119, + 122 + ], + "slot_index": 1 + } + ], + "properties": { + "Node name for S&R": "DownloadAndLoadCogVideoModel" + }, + "widgets_values": [ + "alibaba-pai/CogVideoX-Fun-V1.1-5b-InP", + "bf16", + "disabled", + false, + "sdpa", + "main_device" + ] + } + ], + "links": [ + [ + 54, + 20, + 0, + 30, + 0, + "CLIP" + ], + [ + 71, + 36, + 0, + 37, + 0, + "IMAGE" + ], + [ + 110, + 30, + 1, + 31, + 0, + "CLIP" + ], + [ + 114, + 49, + 0, + 48, + 0, + "COGVIDEOMODEL" + ], + [ + 116, + 30, + 0, + 48, + 1, + "CONDITIONING" + ], + [ + 117, + 31, + 0, + 48, + 2, + "CONDITIONING" + ], + [ + 118, + 37, + 0, + 50, + 1, + "IMAGE" + ], + [ + 119, + 49, + 1, + 50, + 0, + "VAE" + ], + [ + 120, + 50, + 0, + 48, + 4, + "LATENT" + ], + [ + 121, + 51, + 0, + 44, + 0, + "IMAGE" + ], + [ + 122, + 49, + 1, + 51, + 0, + "VAE" + ], + [ + 123, + 48, + 0, + 51, + 1, + "LATENT" + ] + ], + "groups": [], + "config": {}, + "extra": { + "ds": { + "scale": 0.693433494944278, + "offset": [ + 416.0091223165226, + 378.00843746369645 + ] + } + }, + "version": 0.4 +} \ No newline at end of file diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_Fun_I2V_Tora.json b/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_Fun_I2V_Tora.json new file mode 100644 index 0000000000000000000000000000000000000000..104d2d684505fe27f930f2a062b089720116b5ed --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_Fun_I2V_Tora.json @@ -0,0 +1,1711 @@ +{ + "last_node_id": 93, + "last_link_id": 226, + "nodes": [ + { + "id": 31, + "type": "CogVideoTextEncode", + "pos": { + "0": 497, + "1": 520 + }, + "size": { + "0": 463.01251220703125, + "1": 144 + }, + "flags": {}, + "order": 13, + "mode": 0, + "inputs": [ + { + "name": "clip", + "type": "CLIP", + "link": 209 + } + ], + "outputs": [ + { + "name": "conditioning", + "type": "CONDITIONING", + "links": [ + 198 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "clip", + "type": "CLIP", + "links": null + } + ], + "properties": { + "Node name for S&R": "CogVideoTextEncode" + }, + "widgets_values": [ + "The video is not of a high quality, it has a low resolution. Watermark present in each frame. Strange motion trajectory. ", + 1, + true + ] + }, + { + "id": 78, + "type": "ToraEncodeTrajectory", + "pos": { + "0": 1053, + "1": 640 + }, + "size": [ + 355.20001220703125, + 246 + ], + "flags": {}, + "order": 18, + "mode": 0, + "inputs": [ + { + "name": "tora_model", + "type": "TORAMODEL", + "link": 193 + }, + { + "name": "vae", + "type": "VAE", + "link": 205 + }, + { + "name": "coordinates", + "type": "STRING", + "link": 220, + "widget": { + "name": "coordinates" + } + }, + { + "name": "num_frames", + "type": "INT", + "link": 189, + "widget": { + "name": "num_frames" + } + }, + { + "name": "width", + "type": "INT", + "link": 190, + "widget": { + "name": "width" + } + }, + { + "name": "height", + "type": "INT", + "link": 191, + "widget": { + "name": "height" + } + } + ], + "outputs": [ + { + "name": "tora_trajectory", + "type": "TORAFEATURES", + "links": [ + 200 + ] + }, + { + "name": "video_flow_images", + "type": "IMAGE", + "links": [ + 203 + ], + "slot_index": 1 + } + ], + "properties": { + "Node name for S&R": "ToraEncodeTrajectory" + }, + "widgets_values": [ + "", + 720, + 480, + 49, + 1, + 0, + 1, + true + ] + }, + { + "id": 73, + "type": "ImageResizeKJ", + "pos": { + "0": -436, + "1": 527 + }, + "size": { + "0": 315, + "1": 266 + }, + "flags": {}, + "order": 7, + "mode": 0, + "inputs": [ + { + "name": "image", + "type": "IMAGE", + "link": 166 + }, + { + "name": "get_image_size", + "type": "IMAGE", + "link": null, + "shape": 7 + }, + { + "name": "width_input", + "type": "INT", + "link": null, + "widget": { + "name": "width_input" + }, + "shape": 7 + }, + { + "name": "height_input", + "type": "INT", + "link": null, + "widget": { + "name": "height_input" + }, + "shape": 7 + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 187, + 210, + 216, + 225 + ], + "slot_index": 0 + }, + { + "name": "width", + "type": "INT", + "links": null + }, + { + "name": "height", + "type": "INT", + "links": null + } + ], + "properties": { + "Node name for S&R": "ImageResizeKJ" + }, + "widgets_values": [ + 720, + 480, + "nearest-exact", + false, + 2, + 0, + 0, + "center" + ] + }, + { + "id": 72, + "type": "LoadImage", + "pos": { + "0": -820, + "1": 531 + }, + "size": { + "0": 315, + "1": 314 + }, + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 166 + ], + "slot_index": 0 + }, + { + "name": "MASK", + "type": "MASK", + "links": null + } + ], + "properties": { + "Node name for S&R": "LoadImage" + }, + "widgets_values": [ + "pasted/image (473).png", + "image" + ] + }, + { + "id": 20, + "type": "CLIPLoader", + "pos": { + "0": -21, + "1": 288 + }, + "size": { + "0": 451.30548095703125, + "1": 82 + }, + "flags": {}, + "order": 1, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "CLIP", + "type": "CLIP", + "links": [ + 54 + ], + "slot_index": 0, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "CLIPLoader" + }, + "widgets_values": [ + "t5\\google_t5-v1_1-xxl_encoderonly-fp8_e4m3fn.safetensors", + "sd3" + ] + }, + { + "id": 67, + "type": "GetMaskSizeAndCount", + "pos": { + "0": 750, + "1": 775 + }, + "size": { + "0": 264.5999755859375, + "1": 86 + }, + "flags": { + "collapsed": true + }, + "order": 14, + "mode": 0, + "inputs": [ + { + "name": "mask", + "type": "MASK", + "link": 146 + } + ], + "outputs": [ + { + "name": "mask", + "type": "MASK", + "links": null + }, + { + "name": "720 width", + "type": "INT", + "links": [ + 149, + 190 + ], + "slot_index": 1 + }, + { + "name": "480 height", + "type": "INT", + "links": [ + 150, + 191 + ], + "slot_index": 2 + }, + { + "name": "49 count", + "type": "INT", + "links": [ + 189, + 201 + ], + "slot_index": 3 + } + ], + "properties": { + "Node name for S&R": "GetMaskSizeAndCount" + }, + "widgets_values": [] + }, + { + "id": 56, + "type": "CogVideoDecode", + "pos": { + "0": 1582, + "1": -66 + }, + "size": { + "0": 300.396484375, + "1": 198 + }, + "flags": {}, + "order": 21, + "mode": 0, + "inputs": [ + { + "name": "vae", + "type": "VAE", + "link": 206 + }, + { + "name": "samples", + "type": "LATENT", + "link": 202 + } + ], + "outputs": [ + { + "name": "images", + "type": "IMAGE", + "links": [ + 155 + ], + "slot_index": 0, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "CogVideoDecode" + }, + "widgets_values": [ + true, + 240, + 360, + 0.2, + 0.2, + true + ] + }, + { + "id": 30, + "type": "CogVideoTextEncode", + "pos": { + "0": 498, + "1": 293 + }, + "size": { + "0": 471.90142822265625, + "1": 168.08047485351562 + }, + "flags": {}, + "order": 8, + "mode": 0, + "inputs": [ + { + "name": "clip", + "type": "CLIP", + "link": 54 + } + ], + "outputs": [ + { + "name": "conditioning", + "type": "CONDITIONING", + "links": [ + 197 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "clip", + "type": "CLIP", + "links": [ + 209 + ], + "slot_index": 1 + } + ], + "properties": { + "Node name for S&R": "CogVideoTextEncode" + }, + "widgets_values": [ + "flying car lifts off in the air in front of a house", + 1, + false + ] + }, + { + "id": 44, + "type": "VHS_VideoCombine", + "pos": { + "0": 2229, + "1": -113 + }, + "size": [ + 1388.8330963815574, + 1236.555397587705 + ], + "flags": {}, + "order": 23, + "mode": 0, + "inputs": [ + { + "name": "images", + "type": "IMAGE", + "link": 156 + }, + { + "name": "audio", + "type": "AUDIO", + "link": null, + "shape": 7 + }, + { + "name": "meta_batch", + "type": "VHS_BatchManager", + "link": null, + "shape": 7 + }, + { + "name": "vae", + "type": "VAE", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "Filenames", + "type": "VHS_FILENAMES", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "VHS_VideoCombine" + }, + "widgets_values": { + "frame_rate": 16, + "loop_count": 0, + "filename_prefix": "CogVideoX-Tora", + "format": "video/h264-mp4", + "pix_fmt": "yuv420p", + "crf": 19, + "save_metadata": true, + "pingpong": false, + "save_output": true, + "videopreview": { + "hidden": false, + "paused": false, + "params": { + "filename": "CogVideoX-Tora_00011.mp4", + "subfolder": "", + "type": "temp", + "format": "video/h264-mp4", + "frame_rate": 16 + }, + "muted": false + } + } + }, + { + "id": 60, + "type": "SplineEditor", + "pos": { + "0": -1367, + "1": 1222 + }, + "size": [ + 765, + 910 + ], + "flags": {}, + "order": 9, + "mode": 0, + "inputs": [ + { + "name": "bg_image", + "type": "IMAGE", + "link": 187, + "shape": 7 + } + ], + "outputs": [ + { + "name": "mask", + "type": "MASK", + "links": [ + 146 + ], + "slot_index": 0 + }, + { + "name": "coord_str", + "type": "STRING", + "links": [ + 212 + ], + "slot_index": 1 + }, + { + "name": "float", + "type": "FLOAT", + "links": null + }, + { + "name": "count", + "type": "INT", + "links": null + }, + { + "name": "normalized_str", + "type": "STRING", + "links": null + } + ], + "properties": { + "Node name for S&R": "SplineEditor", + "points": "SplineEditor", + "imgData": { + "name": "bg_image", + "base64": [ + "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" + ] + } + }, + "widgets_values": [ + "[{\"x\":568.1871482594877,\"y\":385.0405294042721},{\"x\":566.745048898423,\"y\":216.3149041597034}]", + "[{\"x\":568.1871337890625,\"y\":385.04052734375},{\"x\":568.1571044921875,\"y\":381.525390625},{\"x\":568.1270141601562,\"y\":378.01031494140625},{\"x\":568.0969848632812,\"y\":374.49517822265625},{\"x\":568.0669555664062,\"y\":370.9800720214844},{\"x\":568.0369262695312,\"y\":367.4649353027344},{\"x\":568.0068969726562,\"y\":363.9498291015625},{\"x\":567.976806640625,\"y\":360.4346923828125},{\"x\":567.94677734375,\"y\":356.9195861816406},{\"x\":567.916748046875,\"y\":353.40447998046875},{\"x\":567.88671875,\"y\":349.88934326171875},{\"x\":567.8566284179688,\"y\":346.374267578125},{\"x\":567.8265991210938,\"y\":342.859130859375},{\"x\":567.7965698242188,\"y\":339.343994140625},{\"x\":567.7665405273438,\"y\":335.8288879394531},{\"x\":567.7364501953125,\"y\":332.31378173828125},{\"x\":567.7064208984375,\"y\":328.79864501953125},{\"x\":567.6763916015625,\"y\":325.2835388183594},{\"x\":567.6463623046875,\"y\":321.7684326171875},{\"x\":567.6163330078125,\"y\":318.2532958984375},{\"x\":567.5862426757812,\"y\":314.7381896972656},{\"x\":567.5562133789062,\"y\":311.22308349609375},{\"x\":567.5261840820312,\"y\":307.70794677734375},{\"x\":567.4961547851562,\"y\":304.1928405761719},{\"x\":567.466064453125,\"y\":300.677734375},{\"x\":567.43603515625,\"y\":297.16259765625},{\"x\":567.406005859375,\"y\":293.6474914550781},{\"x\":567.3759765625,\"y\":290.1323547363281},{\"x\":567.345947265625,\"y\":286.61724853515625},{\"x\":567.3158569335938,\"y\":283.1021423339844},{\"x\":567.2858276367188,\"y\":279.5870056152344},{\"x\":567.2557983398438,\"y\":276.0718994140625},{\"x\":567.2257690429688,\"y\":272.5567932128906},{\"x\":567.1956787109375,\"y\":269.0416564941406},{\"x\":567.1656494140625,\"y\":265.52655029296875},{\"x\":567.1356201171875,\"y\":262.01141357421875},{\"x\":567.1055908203125,\"y\":258.4963073730469},{\"x\":567.0755004882812,\"y\":254.981201171875},{\"x\":567.0454711914062,\"y\":251.46607971191406},{\"x\":567.0154418945312,\"y\":247.95095825195312},{\"x\":566.9854125976562,\"y\":244.43585205078125},{\"x\":566.9553833007812,\"y\":240.9207305908203},{\"x\":566.92529296875,\"y\":237.40560913085938},{\"x\":566.895263671875,\"y\":233.8905029296875},{\"x\":566.865234375,\"y\":230.3753662109375},{\"x\":566.835205078125,\"y\":226.86026000976562},{\"x\":566.8051147460938,\"y\":223.3451385498047},{\"x\":566.7750854492188,\"y\":219.8300323486328},{\"x\":566.7450561523438,\"y\":216.31491088867188}]", + 720, + 480, + 49, + "path", + "basis", + 0.5, + 1, + "list", + 0, + 1, + null, + null, + null + ] + }, + { + "id": 82, + "type": "SplineEditor", + "pos": { + "0": -564, + "1": 1226 + }, + "size": [ + 765, + 910 + ], + "flags": {}, + "order": 10, + "mode": 0, + "inputs": [ + { + "name": "bg_image", + "type": "IMAGE", + "link": 210, + "shape": 7 + } + ], + "outputs": [ + { + "name": "mask", + "type": "MASK", + "links": [], + "slot_index": 0 + }, + { + "name": "coord_str", + "type": "STRING", + "links": [ + 211 + ], + "slot_index": 1 + }, + { + "name": "float", + "type": "FLOAT", + "links": null + }, + { + "name": "count", + "type": "INT", + "links": null + }, + { + "name": "normalized_str", + "type": "STRING", + "links": null + } + ], + "properties": { + "Node name for S&R": "SplineEditor", + "points": "SplineEditor", + "imgData": { + "name": "bg_image", + "base64": [ + "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" + ] + } + }, + "widgets_values": [ + "[{\"x\":174.49402268882744,\"y\":383.8868499154203},{\"x\":173.05192332776272,\"y\":200.4518111879918}]", + "[{\"x\":174.4940185546875,\"y\":383.8868408203125},{\"x\":174.46397399902344,\"y\":380.0652770996094},{\"x\":174.43392944335938,\"y\":376.24371337890625},{\"x\":174.4038848876953,\"y\":372.4221496582031},{\"x\":174.37384033203125,\"y\":368.6005859375},{\"x\":174.3437957763672,\"y\":364.77899169921875},{\"x\":174.31375122070312,\"y\":360.95745849609375},{\"x\":174.28370666503906,\"y\":357.1358947753906},{\"x\":174.253662109375,\"y\":353.3143310546875},{\"x\":174.22361755371094,\"y\":349.4927673339844},{\"x\":174.19357299804688,\"y\":345.67120361328125},{\"x\":174.16354370117188,\"y\":341.8496398925781},{\"x\":174.1334991455078,\"y\":338.028076171875},{\"x\":174.10345458984375,\"y\":334.2065124511719},{\"x\":174.0734100341797,\"y\":330.38494873046875},{\"x\":174.04336547851562,\"y\":326.56341552734375},{\"x\":174.01332092285156,\"y\":322.7418212890625},{\"x\":173.9832763671875,\"y\":318.9202880859375},{\"x\":173.95323181152344,\"y\":315.09869384765625},{\"x\":173.92318725585938,\"y\":311.2771301269531},{\"x\":173.8931427001953,\"y\":307.45556640625},{\"x\":173.86309814453125,\"y\":303.6340026855469},{\"x\":173.8330535888672,\"y\":299.81243896484375},{\"x\":173.80300903320312,\"y\":295.9908752441406},{\"x\":173.77296447753906,\"y\":292.1693115234375},{\"x\":173.742919921875,\"y\":288.3477783203125},{\"x\":173.712890625,\"y\":284.52618408203125},{\"x\":173.68284606933594,\"y\":280.70465087890625},{\"x\":173.65280151367188,\"y\":276.8830871582031},{\"x\":173.6227569580078,\"y\":273.0615234375},{\"x\":173.59271240234375,\"y\":269.2399597167969},{\"x\":173.5626678466797,\"y\":265.41839599609375},{\"x\":173.53262329101562,\"y\":261.5968322753906},{\"x\":173.50257873535156,\"y\":257.7752685546875},{\"x\":173.4725341796875,\"y\":253.95370483398438},{\"x\":173.44248962402344,\"y\":250.13214111328125},{\"x\":173.41244506835938,\"y\":246.31056213378906},{\"x\":173.3824005126953,\"y\":242.489013671875},{\"x\":173.35235595703125,\"y\":238.66744995117188},{\"x\":173.3223114013672,\"y\":234.84588623046875},{\"x\":173.29226684570312,\"y\":231.02430725097656},{\"x\":173.26223754882812,\"y\":227.2027587890625},{\"x\":173.23219299316406,\"y\":223.38119506835938},{\"x\":173.2021484375,\"y\":219.5596160888672},{\"x\":173.17210388183594,\"y\":215.73806762695312},{\"x\":173.14205932617188,\"y\":211.91650390625},{\"x\":173.1120147705078,\"y\":208.09494018554688},{\"x\":173.08197021484375,\"y\":204.27337646484375},{\"x\":173.0519256591797,\"y\":200.45181274414062}]", + 720, + 480, + 49, + "path", + "basis", + 0.5, + 1, + "list", + 0, + 1, + null, + null, + null + ] + }, + { + "id": 83, + "type": "AppendStringsToList", + "pos": { + "0": 334, + "1": 915 + }, + "size": [ + 315, + 82 + ], + "flags": { + "collapsed": false + }, + "order": 15, + "mode": 0, + "inputs": [ + { + "name": "string1", + "type": "STRING", + "link": 212, + "widget": { + "name": "string1" + } + }, + { + "name": "string2", + "type": "STRING", + "link": 211, + "widget": { + "name": "string2" + } + } + ], + "outputs": [ + { + "name": "STRING", + "type": "STRING", + "links": [ + 217 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "AppendStringsToList" + }, + "widgets_values": [ + "", + "" + ] + }, + { + "id": 86, + "type": "AppendStringsToList", + "pos": { + "0": 683, + "1": 916 + }, + "size": [ + 315, + 82 + ], + "flags": { + "collapsed": false + }, + "order": 16, + "mode": 0, + "inputs": [ + { + "name": "string1", + "type": "STRING", + "link": 217, + "widget": { + "name": "string1" + } + }, + { + "name": "string2", + "type": "STRING", + "link": 218, + "widget": { + "name": "string2" + } + } + ], + "outputs": [ + { + "name": "STRING", + "type": "STRING", + "links": [ + 219, + 220 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "AppendStringsToList" + }, + "widgets_values": [ + "", + "" + ] + }, + { + "id": 65, + "type": "CreateShapeImageOnPath", + "pos": { + "0": 1189.82080078125, + "1": 1284.833251953125 + }, + "size": { + "0": 313.4619445800781, + "1": 286 + }, + "flags": {}, + "order": 17, + "mode": 0, + "inputs": [ + { + "name": "coordinates", + "type": "STRING", + "link": 219, + "widget": { + "name": "coordinates" + } + }, + { + "name": "size_multiplier", + "type": "FLOAT", + "link": null, + "widget": { + "name": "size_multiplier" + }, + "shape": 7 + }, + { + "name": "frame_width", + "type": "INT", + "link": 149, + "widget": { + "name": "frame_width" + } + }, + { + "name": "frame_height", + "type": "INT", + "link": 150, + "widget": { + "name": "frame_height" + } + } + ], + "outputs": [ + { + "name": "image", + "type": "IMAGE", + "links": [ + 153 + ], + "slot_index": 0 + }, + { + "name": "mask", + "type": "MASK", + "links": [ + 154 + ], + "slot_index": 1 + } + ], + "properties": { + "Node name for S&R": "CreateShapeImageOnPath" + }, + "widgets_values": [ + "circle", + "", + 512, + 512, + 12, + 12, + "red", + "black", + 0, + 1, + [ + 1 + ], + 1.3 + ] + }, + { + "id": 68, + "type": "ImageCompositeMasked", + "pos": { + "0": 1528.82080078125, + "1": 1280.833251953125 + }, + "size": { + "0": 315, + "1": 146 + }, + "flags": {}, + "order": 22, + "mode": 0, + "inputs": [ + { + "name": "destination", + "type": "IMAGE", + "link": 155 + }, + { + "name": "source", + "type": "IMAGE", + "link": 153 + }, + { + "name": "mask", + "type": "MASK", + "link": 154, + "shape": 7 + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 156 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "ImageCompositeMasked" + }, + "widgets_values": [ + 0, + 0, + false + ] + }, + { + "id": 91, + "type": "Note", + "pos": { + "0": 1565.82080078125, + "1": 1475.833251953125 + }, + "size": [ + 251.63747656176258, + 73.90463053872986 + ], + "flags": {}, + "order": 2, + "mode": 0, + "inputs": [], + "outputs": [], + "properties": {}, + "widgets_values": [ + "This is only for visualization" + ], + "color": "#432", + "bgcolor": "#653" + }, + { + "id": 85, + "type": "SplineEditor", + "pos": { + "0": 232, + "1": 1226 + }, + "size": [ + 765, + 910 + ], + "flags": {}, + "order": 11, + "mode": 0, + "inputs": [ + { + "name": "bg_image", + "type": "IMAGE", + "link": 216, + "shape": 7 + } + ], + "outputs": [ + { + "name": "mask", + "type": "MASK", + "links": [], + "slot_index": 0 + }, + { + "name": "coord_str", + "type": "STRING", + "links": [ + 218 + ], + "slot_index": 1 + }, + { + "name": "float", + "type": "FLOAT", + "links": null + }, + { + "name": "count", + "type": "INT", + "links": null + }, + { + "name": "normalized_str", + "type": "STRING", + "links": null + } + ], + "properties": { + "Node name for S&R": "SplineEditor", + "points": "SplineEditor", + "imgData": { + "name": "bg_image", + "base64": [ + "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAHgAtADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwDWAoFLigfSu0+YExRinYoxQAgFAFKBSgUAJilxxS4oxQAmKMUtGKBiYNFLiigBMUGloxQhhijFLilAoEAFFOxRigBMUAUuKWgBuKMe1OxRigBuKUClxRigBMUtGKKADFJTsUYoAbTgKMc0YoAMUmKXFLigBtFOIpMUgDFFLijFACYoxTsUYoAbiinYpMUwEoxS0tACYpMU7FIRSATFLikxTsUCExRilxRigBKMUuKKYxtGKdigCkIbilpcUEUAJSYpcUuKAG4oxS0UAJiilpCKYDTRilxxRikISjFLRigBMUY46UuKMUANxRilIoxQAmKKUijFADaMc07FGKAGYoIxT8UhFMQ3FJTsUY5pCG4oApcUY9qYDSKTFPx7UmDQAzFGKeR7UYoEMxS4p22kxQAmKDS4ooAZR+FOIpCKAG4paXFJigB4FGKdiig0EpMU6jFADcUtLRigBKWjFL2oASlx7UAUuKBjaMU/HNJtouAmPaj8KdRSGNFOAopaYgo70tLigBKKXFGKQCUtGKWmAlJTqMcUgG0U4UYoASjFOxRjNADcUU7HtRj2oATFFLQKAEoxTsUUANoxTsUAUXASjFLiloAbijilooAbilxS8UtADaPwp1JigBPwpcUfhS0ANxRTqSkIKTFOxQBQAlJTiKMUAJSYp2KCKAG4oxTsUUwG0YpcUtADaTFOIpMUCGkH0ox7U7bRigBuKMe1OxRQIbgelJjmnYoxQMbiilxRigBtFOxSEc0AJ+FFLilxQA3FGKU0UCYmKbg0+kxQIbiinYoxTENxRinYpMUAJikxTse1H4UANx7UmKdj2oxSAYRRinEUYoAbikxTsUYpgNoxzTiKQ9TQIdRilApcUGo3FGKdijFACbaMU4CigBMUYpaXFFwsIBS4opaQxuKMU6jFIY3FGKXFLRcBMUuKXFLigLCYpcUtFFxWExRinYoouOw3FGKdij8qBWExRjil70YouOw3FLg0uKXFFxWG4pcUuPalxRcY3FGKdijFADSKBTsUmKQhMUYp2KUCmFhuKMe1OxRigLDcUYp2KKAG4pMU+kxQAzFOxS4oxQAmKMU7HtRigBmKdijFLQAm2kAp9JjmlcBMUYpxFJQAmKMUtFO4hMUY9qWjFFwEA9qMUuKKAGkZoxTqMUANIpMU/FJigQ3FJin4oxQAzFHenYowfQUANxRTse1GKAG4pNvtTsUEc0ANxQRS0YoEJijFLijFADSKTFPoxTAbikwKcR9KTFIQ2ilopgJijFLRQA3FGKdikxQIQUYpcc0YoAaRRinYpMUCG4pcD0paMUAMIoxTiKTFMY7FID6V3K6Fpq/8uwP1Ymnro+nIci0iz7jNcDx0OzPV/s6fdHC9aK7/APs6xHSzg/79ipY7eCP7kES/RAKl49di/wCzn1kedgE9Bn6VKltO/wB2GRvopNehYX0FKMVP159i1ly6yOBGn3hGRaT/APfs/wCFKNOvT/y6Tf8AfBrvajj+5/wI/wAzS+uy7Ff2dDucSuj6g3S0k/EYp39i6j/z6v8AmK7jnGM0c+tL67Psh/2fT7s4kaHqJ/5dj+LCn/2BqP8AzwH/AH2K7Ln1o59aX12p5D+oU/M43/hH9R/54L/32P8AGl/4R7Uf+eK/99iuxpfxpfXKnkP6hS8zjx4d1A9UQfV6evhy+PeIfVv/AK1dbRS+uVPIf1Cl5nKf8I1ff34f++j/AIUf8I1e/wB+D/vo/wCFdWOtL+NH1uoP6jS8zk/+Ebvf+ekH/fR/wpf+Ebvf+ekH/fR/wrq8UYo+t1A+o0vM5T/hG73/AJ6Qf99H/Ck/4Ru+/vw/99H/AArq6X8aPrlQPqNLzOS/4Ry+B6w/99f/AFqT/hHr8D7sZ/4HXXfjR+NH1yoH1Gl5nI/8I/qH/PND9HFH9g6h/wA8V/77FdaG+dlzyAD/ADpc+9H1yp5C+oUvM5A6DqAH+pH/AH2KYdGvwf8Aj2J+hFdn+NB+tP65PyE8BT8zi/7Hv/8An2b8xTG0y+Xrayfgua7bNLn3p/XZ9kL+z6fdnDGwvB1tZ/8Av2aja2nT70Mi/VTXe8+tHXrT+uy7C/s+Pc8+II4IOaXBrvtinqq/lUbWlq/37aFv95AapY1dUQ8u7M4TFLiu2bTLFutrEPouP5VE2jae3/LAD6MatY2HVGby6fRo47FGK61tBsD0R1+jmoW8OWpA2zSg++DVLGU2S8vq+RzFGK6FvDQx8tzn6p/9eom8OTgfLNE31BFUsTT7mbwVZdDC70uK1G0G9X+BD9GFRNpN8nW2c/TBrRVoPZmTw1VfZZRxSYxVl7S4iHzwyL/vKRUJUjqKtSTIdOS3QzFGKdiincnlG44o606ii4rCEUU6jFAWGEc0mKkxRimIZijFP20hFADaMU4CjHtSAbRilxS4p3EMxRTsUUXAaRSYp+KTFAhtLS0Y5oAaaMU4ikpgNNJj2p+KMUAMxS4paWgBmKXFLiloAZijFPxzSYoAZj6UYp2KTFAhhFGKfijFAhmKMU/ApMCgBmKMU/H0oxQAzHNFOIoxQAwiinYoxTENxSYp+KSgBp/CinYpMCi4M9Hooor54+sDFFFApAFGKWkp2HcWo0+4fqf5mpKaowp+p/nQFxaKXFGKAEpKUijFACd6XvSgc0uOaQxMUYp2PpRigY3/ABopaMUwCijFGKAAjikFOxSYpAIKWl2k0bTTAiX/AI+JP91f60+gIRMx9VH8zS4NABSU7FAFAhtLS4oI9KBiUUYpMcUALRSYpaQB9aM0hpQKYBmk/KlxSfiKQBRRiloATNLmkOc0UDFz7UxVVl+ZVPzN1HuafTI/un/eb/0I0xNET2Vq/wB63iPvsFQNotgw/wBRj3DH/Gr1FUpyWzIdOD3Rjv4dtjnZLKv1wagbw4c/JcD8VrfFLVrEVF1MnhKL6HLyeH7xASpjf0Abn9arvpV8nW3Y/Tn+VdfS5rRYya3MngKT20OGkgli/wBbG6f7y4pgFd4cHggH61A9rbSD54ImPqVFarG90Yyy7tI4vFIRXWvo9i//ACy2/wC6xqtL4ft2/wBXK6n35FaxxlN7mMsvqLbU5vFGK2n8PTc+XMh9Mgiqr6NfR/8ALHd/usDWqr031MJYWrHeJn4oxU0ttNCf3kTr9RURFaKSexg4SW4hFNxT6Sncmw3FJin4oxTuKwzFGKfikxQIbilxS4pcUANIpMU7FBFADMUYp+KQimA3FGKUClxSuIZijFPxRincCOjGafikxzRcQzFGKdijFAhuKMU7FGKAG4pCKcRRQIaBRinUmKAGYpcU6jFMBm2jFPxSEUDGYo20+jBoFc6WTxr4bibDatEf9xHf+QqrP8QvDcIJS7lmPpHAw/8AQsV4wKO9fPn2vsonrZ+J+hDpb35P/XNP/iqhPxS00H5LC7I9yo/rXleBTgKVx+yient8U7LHyaZcE+8ij+lQt8U1/h0cn63P/wBjXm+KXoaLsfs49j0J/ilKfuaQi/705P8A7KKrt8TdSIwllaKffcf6iuGzS8EYpXY/Zw7HaH4maz2ttPH/AGzf/wCLpr/EjXGGBHZL/uxH+rGuNGBT6LsOSPY6d/iB4gY/LcxJ9IV/qKZ/wnfiMn/kIAfSCP8A+Jrm80oNK7Hyx7HQt428Rtx/aTD6Qxj/ANlqM+Ldfbrqk/4YH9KxM0uaV2Oy7GwfE+uN11W7/CQikPiPWj/zFr3/AL/t/jWTmlzRdlWRp/2/rJ/5i19/3/b/ABpp13V++q3v/f8Ab/Gs/NLmi7CyL41vVf8AoKXv/f8Ab/Gl/trVD11K7P8A22b/ABrPBpQaV2FkX/7a1Uf8xK7/AO/zf40o1zVh01O8H/bZv8aoUZFF2OyNH+3tYHTVb0f9t2/xpw8Qa1/0Fb3/AL/t/jWbRnFF2Fkay+I9aHI1S7/GUmnr4p1xTldTn/E5/nWOGpQaV2PlXY3l8ZeIFGBqLH6xIf5rUi+N/ECnm9VvrCn+Fc7S5ouxcsex1KeP9aXhvsz/AO9F/gRUw+Ier97exP8A2zf/AOKrkKcKOZi5IdjsY/iJqAP72ytWH+xuX+pq2vxHOBv0oe+Lj/7GuEyKOKOZh7OHY9BX4jWxHz6bMD/syg/0qVPiHpzH57S6Ue20/wBRXnPFHFHOxexh2PTo/H2iucFbtPdox/QmraeMdAfH+n7T6NC4/pXlFHFPnYvYQPYE8R6K4yup230LY/nVmPVtOkxt1C1Oen75f8a8WwKMUe0YvYR6M9zRlkGY2Dj1U5p2Mda8MjkkiOUdlP8AsnFWY9Tv4T+6vblP92Vh/Wn7QX1fzPacUYryODxRrlvnZqU5z/z0w/8A6EDVyPxzrsagGeGT3eEZ/TFNTQnQken4pF4H4n+ZrzyP4gamMeZbWjDvhWB/nV6H4iLwJ9N+rRzf0I/rT5kS6Mztu9HauWh8e6VIwEkVzD7lQR+hrQj8XaDL0vwp/wBuNx/SjmRDpyXQ2aPxqjFrmkzECPUrUk9jKAT+dX1xIgZGDKe6nNMlpoaaKdijFAhDSU40lACfjRzS0YoABRRRQAhqJ7eCT78MbfVRUtHSmm1sJpPcz5NGs5eiMhPdT/jVOXw8Cf3VwQPRlzW4KK0VepHZmMsNSlvE5iXQ7tPuBZB7HH86qSWVzF9+CQD/AHTXYntRW0cZNbnPPAU3s7HD4oxXZvbQSA+ZCjH3UGqkmi2b52qyH2b/ABraOMi9zmll0ujOXorcl8PnrFOD7Mv9aoyaVeR5/clh6qc1vGvCWzOaeEqx3RQxmlxUjxPEcOjKfQjFNFbJpnO4tDce1GKdRii4rDMUmKfjFGKAsMIoxTiKTFNEjcUU6kIpgNwKTFPpMUhDaMU7FLTEMIpKeaTFADcUU7FFADTSYp9JikMbikp+KQincQwilpaMUEs8woFIKXvXgH3Y7NKDTKcKQhwpaQUtIAoopR0oGKD60ozTRS0gHd6Wmc+tLmgB4NLmmfjS596VgHg07NR5pc0WHcfmjNNDe9KGpWC48GnCq88siQO0Sh5AOFJxms9dYi8tR9tg88H5o2XA/PPFUoN7DubGaM1FHKJEDDHTnBp26psA/NLmo93vS7qLBcfml3e9R7qXd70rDH7qXNR7qN1FguSZo3YqPd707cKLASBqM1Hu96XdRYLkmaX8ai3e9LupWGS5pQai3UBqLAS5pc1Hupd1Fh3H5ozTN1G6iw7kmaKYGpc+9ILj88UAim596QdOvc/zoAk4oxTPxpQT60rDHUqSSQtuikaNvVDg03dRmgRfh1zVoMeXqN0MeshP860bfxrrsDAtcpMB/DLGP5jB/WufzRVJsTjF7o7CH4h3yt+/sbd19ELJ/PNaEPxDtHH76wmjP+w4cf0rz/8AGlwKOeRLpQfQ9Pg8b6JKcPNLCf8AppEf6ZrTh1vSrjAi1G2Ynt5gB/I145jmlxT5yXQie4IySLuRldfVTkUteK295d2mfs1zNDnr5blf5Vfg8Ta5btlNSnPtIQ4/8ezVc6M3h30Z6170YrzqLx9qiACWG3l99pU/oa07b4hW7H/StPlT3ikDfocU+ZEOjNHZUGsW38XaJcYH2zymIziVCuPxxj9a0oL6zuuILuCUnskgNO6IcWt0TelFKVxxRimSJRmlpOfWgVgoowaOaAsNZVcFWUEehFVpdMtJRzCFPqvFWjmiqjNx2JlCMt0Y82gDrFOR7OM/qKpTaPdxDIUOP9g5rpqK2jiqi3OaWCpS2VjjJIZYj86Mv1GKZXaOiyKVdQynqCM1Vl0uzlHMQX3TiuiOMX2kcs8uf2WcrikxW9LoKnJimIPowzVGXSbyL/lnvHqhzW8cRCWzOSeDqx3Rn4oxUrxvGcOrKfQjFR1smc7g0NI4pMU7FGKdyXETFJin4oxTuTYZijFOxRii4WGYoxTse9G3mmFhmKXFKR70EUh2G0YpcUY96YhhBopxoxQKx5UDTs1CGHrS78d68Cx9yTDFOFQCUU7zR60rBYmHWlFQ+co7003kS9XGfY0WY7Fmioo51k6BqmJAUk8YHepCzEpcgUxmGOtM8z3phYmzSZqHzfc0eZmiwE+73o3e9Qb+epxS7x60WCxNuGKUPVfcT3pd9FgJ99LuqDdRvosFifd70yFRbRXcULNHHdqVnRTgSA8EEVHupd1VqthDoI47aIRxKQg4AyTUu+oN9HmUrDLAajfVYuTShjipsBY30u+q+6l3Uxk+/Bo3iod3FAb60WAn30u+oNx96Nx96LAWNwo3VBuNKGJpWGTBqcHqvk0uTRYCffS76g3GgPilYZY3Uu6oN/1o8z60coXJw1LuFQeZ9aPM+tKwFjeKXcKreZ9aXzKLAWS+Kgubs28G9V3HJzk4AHqabvpj7Jo2R1DIwwQehppdxjRqbrbCWQx7T0YKwQ+mG6fzq9HLvjViMEgEj0NZzWweyjsnmna0iYMkDTMUUjpgE1aVsCnNLoJXLO6nBqrb6cHqLDuT5pc1BvpQ1KwE2aUGog1AeiwE2aM1Hv8AelDUrBckzS5pgajNFgH5pabmjdQFx1NKgnkA0uaKQXLtvrGp2iqsF9cIo6L5hIH4dK17Lxtq1s3+kNHdJ6OgUj8RiucJparmYnFPc7q2+IMTuBc6e6LjlopA3P0IH861rfxhok7BTdNEx7SoQPzGRXl4ApQKamzN0ons8N1bXQBguYZQenlyBv5VNivE0Z4pA8bsjjkMpwRWlB4j1q3xs1Kc+0hDj/x7NVzmbodmeskUmK4C38f36DFxa282B1XKE/zH6VsWfjzTZyFuoZ7Zj3wHX8xz+lPmRm6UkdPRVS31jS7v/U39uxPRS4DfkeavbeM9jVENNDKDT8UmKBDKWlIpMUDGMiOu11DKexGapT6TaTAgIY27FeP0q/SE1UZyjszOVOMviRhS6FIOYpQ3+8MVSl0+4gHzxNj1HIrqcUoHFdEcVNb6nNPBU5baHGlfrSY+tdbJaW8xJkhQk98c1Rl0OJuYpGU+h5FdEcXF76HHPL5r4dTBIpMVfm0q5iPCeYPVKqNGyHDKQfQjFdMakZbM5J0ZR0kiKjFPxRiruZcozFJipMUhFAWGYoxT8Um2mKwzFIRUm2grQFjxbcaaXI71gP4lH8Fsfxf/AOtUD+I7hvuQRKP9rJrx1Skfb88TozIfU0hd/WuXbXL9j8rIvsEz/PNNGrak3SU/hGP8KpUWT7SJ0z727mo4YXE4JbIx0rmpLzUZOTLL+HH8qvaE10+qJ57yMu08MxNEqbSbuNTV9jtLSPgVPeKEtJWZgFCHJJwBS2qfKKTXF/4kt2B3iIri+0VzHNjVbaDj7XGR6Bs07+3rHk/aV/I1y32L1f8ASlFiP7/6V3+yiZuUux03/CQ6eOsz/ghpp8S6eP4pW+if/XrnRYp3Y04WcQ65/On7OAryN4+KLEdEnP8AwEf40xvFMAPyW8h+pArG+yw/3T+dL9nhCn5P1NHs4CvI1f8AhK17Wjf9/P8A61J/wlef+XM/9/f/AK1c0DU9qqvcoGGR6fhVeyh2FzM3v+ErYf8ALmP+/v8A9aj/AISuTtZp+LmqYji/55L+QpQkY6Iv5VPLDsVqTv4ouz923iH5n+tRHxJqR6eWv0SlG0dAB+FLuHpRaPYdn3Iz4h1Q/wAaf9+xR/bmrHpJ+UY/wqTcPSkzTSj2Cz7jDq2rn/lq4+iD/Ck/tbV/+e0v/fA/wqTPtRmnZdhW8xn9p6uf+W83/fP/ANak+36v/wA/E/51KGoBpadgt5kP27Vv+fmf/vql+36sP+Xqf/vqps0Zo07BbzIf7Q1b/n6n/wC+qP7Q1b/n6n/76qXNGaenYLFc6vqqPt+2TbvTNSDVtaHS4m/FR/hVWbH2z8RV8UNJdBLUjGsa0P8AlvKf+AD/AAp39t6yOsz/AIxj/CpM0bjS93sOw0eINYX/AJag/WIf4U4eI9VHJaP/AL9CjNGaLR7BZ9yVPFl8vDwwv+BH9amHi6X+KxXPtIf8KplUP8IP4UnlR/8APNP++RScYdh69y+PFx/isfyl/wDrU8eL4+9m4+kmf6VlmCE9Y1/Dimm1g/ufqaXs4dg1NxPFtiR88Nwp9lU/1qVfFOnE8+cv1T/A1z32SD+4f++jSGyhP94fQ0vZUx3kdQPE2lngTMPrGami1rTZMAXsI4/iO3+dcAyhZio7EimsOlDw8Re0Z6ZHcwTDMU8Tj/ZcGpQx+tebx2LPGrhhyKlVL63/ANTPKo/2JCKh0F0ZXO+x6JvpQ9cEmqaxCu0XEpH+0ob9SKeviLVoz8zq/s0YH8sUvYS6MXOd2GpweuMi8XXaj97aRN7qSv8AjVuPxhD/AMtLORfUq4P9BUOhPsPnR1Qel31gweKNMmOGeSH/AK6J/hmr0eq2Ev8Aq7yA+mXAP5Gs3Tkt0PmTNAPTw9VVkD/dIb6HNODGpsMtB6XfVcNijd70rBcsB6dvqtu96cHosBZD5pwb3qsr08NSsBPu96A2Rmod2aUNilYLk4NLuqIPShsmiwEoNBPNMBpc0gHUcd6SlHWmAYFWrPUb7Tyfsl3NCCckI5AP4dKrGlFAM6Sy8capbv8A6T5d0nowCn8wK3bTx7Yy5F1azQHsUIcf0P6V59S1Sk0ZunF9D1q017Sr4gQX0O48BHO1vyNaGM9ORXiu2r1lrOpadxa3kqL/AHSdy/keKfOQ6PZnrZWmkV5/aeOtTgwtxFDcr3JGxv04/St2x8babdOEuY5LUn+JvmX8x/hVKSZm6ckdHiiobe+s7xd1tdQyj/YcGp9pqiLCUlOpvekApqN4Y5VKugYHsafRTTsJq+5nTaRBJyhMZ9uRVGbSJ48lMOPbrW9iito4ipHqc88LTn0OUkheI4dGU+4pmK6x40kG10DD0IqnJpVs4JQFD7GuqGLT+JHHPANfCzn8UYrSm0maMZQiQe3Bqi8TxnDqyn3GK6I1Yy2ZyzoTh8SI8UhFPINJitLmLifMCxRj+EU8Kg6KPyqMNkUu73rh1PsNCXj0oyKi3UbqQyQmtHRBu1Jf901lbq1/DmG1UD0Q1M/hYrnd2cfyiovECbdFuT/sVoWcXyD6VV8TDboN1/1zNcNveQKR5nmlyfSoCxBpRIDXfYLk26kLVCT3o3U7Bcl3Uhb5T9Ki3UFuD9KdiSitWLU4ul/H+VRIKliG24X6/wBKt7ELc0N9G6ot1JurOxoTbqUNUG6l3UWAm30b/eod1G+iwE2+l31Buo3UWC5Nv96XfUG40bqLBcn8yl31X3H1p2/iiwE2+gPUO+jdRYCGU/6WD7ir26qL8zZ9xVjdTaJTJ91G6qrfMQdxGPSlAKHdubB9ehpWKuWd1LuqDfRuosFybdzTt1QB+aN3vSsMn3Ck3Cot3vRuosBLuFLuqHdShqLAUJObhv8AeNNYdPrUm3dM3+8aJEwB9a0MzRt+IE+lP3VDCcQp9Kdmsmaku7igtUefejNIBxVG+8in8KY1vA38A/Cl3UuaYiJrGEj5dw/WojYej/0q2WpU+dgq9ScCndhZFT+zbuOISoSFJ4IfFTRX+sWv3bifHoTuH65rSvZAm22ThYwAfc1U3VKk3ugcUOi8ValCw81Y5FHUFcE/iK0Y/GNu2PNtZU/3WDf4VlkBxhgCPeo2tYG6p+RxScYPdCszpofE2mSgZmaMns6n+nFaFve21z/qLiKT2RwTXCPYRH7pYfXmoWsZByrAn64qXRg9mNNnpQbmnh/rXnMGoatZ/cnmCjjDfMP1zV6DxZfxECZIpV78bT+n+FZvDy6D5kdzvpfMrlIvGNu2BLayoe+xg3+Fa1rrVhdKvl3KKx/gc7SPzrN05R3Q00zXD04Pk1WByM9qerVFgLO+nBhVfdTg9JoCwDUFxqEdsVBUsSeTkAD6k0oeqs+mWd1dR3M0StNGMKTyPxB4P4iiKV9RNltdRhknWNFLq3R1IK1aBFZllp1rYSSPbxhXlOWPQfgBwPwFXg9ErX0AmpajDZpwNSA+lpuaXNABiijIpc0AIMg5HBFatn4j1ayAWO8dkH8Mp3j9elZYpe9MnRna2fjtPLVb2zbeOC8J4P4Hp+dbdr4l0e7IC3axsf4ZRs/U8V5gKXFVzMhwiz2NSrqGUhlPQg5BpcV5NZ6lfaeQbS5kiGc7QflP4Hit2z8b30LYu4Y7hMclfkbP8v0qudEOmzuxRWJYeLdMviVd2tnA6TYAP0PStpGSVA8bBlPQqcimjNprcMUYpSKQimISkZFcEMoI9CKcKKAKE+lW8mSgMbe3T8qoy6TOnK7XHt1rcpe9bQxE49TCphqc+h8U7qN1R5o3e9dVj0OYl3Ubqi3e9KGosFyXNb3hIb9ax/0zP8xXO7q6TwUN2tn/AK5H+YqJL3WKT0PULSL92KzPFa7dAvD/ANM/6ity1XEYrH8Xj/inbz/rn/UVx21RFOWp5CzZpm6kY88Uw13pGrJA9O3ZqDNKGosK5Juo3cGo80ZpiJIkzmnAbZ/8+lPt1+99aHGJj9f6U+hK3HE0maQ0VBoLmlzTcDNLigLhmlzRtpQhJwBmgLiZoqUW8zfdic/RSaeLK6PS2m/74NFmLmRXpasjTr09LWb/AL4NO/sq/P8Ay5z/APfBp2YuZdypRV0aRqBP/HpL+IxT10TUGP8Ax7MPqRRZhzx7lDNGa0x4f1AjPkqPq4pf+Ee1DH+rX/vsU+Vi9pHuZbKcZ9x/WjmrRtJRP9mIHm71TGe/NXB4evj/AAIP+BinysXPFbsyc4o71rf8I5ff3Y/++xR/wjt9/wBMv++6XKx+0j3MrNLnNah8O3+OPK/77ph0C/X/AJZo30cUuVh7SPczgSDS7jVw6Rfqf+PVz9OaadMvh/y6Tf8AfJo5WNTj3KuTS5NTmwvF62sw/wCAGm/ZLn/n3l/74NKzDmXci3UobkUphkXrGw+opoU5osVcZEuZj9TT7lNsa/Wlt1zKfxqS8H7tOP4v6VdjO42M/u1+lO3UxBhF+lFZtGtx+6jdTDRnilYCTNG6osmjNFguTbqvaaFBkuJPuRL+tZgPNXpj5FlHD0Z/3j/0qJLoUiKSQu7Mx5JyaQNxUW6jcc1SQmyYGlzUW7mnbqTQEmacKh3ZpwakMlzUM4VoXyASAacGzTZf9S/+6aEDMpaU8EUkYp7CtjJbFmE3tuA8LyJkZBRv8K07XxVfwECdUmUdcjDH8RTYP+PaL/cH8qHhSX76A1jKz3Roo9jct/Fmny4EvmQHvkbh+Y/wrWt7+1u8/Z7iOQjqFbn8q4V9PibOMiq7afKnMZzjpg4NZulB7B7x6ZmlVq8+t/EGrWXytJ5i4wFmXP69a1bTxmpAF5alT/eiOR+R/wAazdCS2C6OvDU7dWZaarZXqgw3KEn+AnDflV7cRWTi1uBOGpwaq4fmnhqmwyffTg1V91ODUWEWAacDUAenB6LAT5paiDU8NxSJHilFN3Zp1AC0UlLQFxRUsM01u2+CaSJvVGKn9KizTs+1AHQ2PjLULZgt0FuowMc/K35gfzFdDaeL9KuRiSR7dsdJF4/MV5517Uu3IpqTJcUz1yCeG5jEkEqSoejIwIp5FeS21xPZy+bbSvE+MFlOM1v2vjPUIdqzxwzqOpIKsfxHH6VSkQ6fY7rFFY1h4p029bY7NbvjpLgA/j0raUrIoZGDKehByKozaaPiGjNGB60nA716ZqLRSbhRvAHA5oFckHSup8CjdrrD/pif5iuULkEjA/A5rq/h9l/EEntbsf8Ax5aiWwpS0PXLZMRjisXxiMeG73/c/qK37df3Y+lYPjQ48MX3+5/UVy21RnTep4ue/IphZR3FNfrUZ6HPWuw2cidFLhmUZCjJIHSpUgLmIKykydMducc1UeVmjSPChUGOB15zk1dsruXR74yCNWlUbSG7Z/rVIhyfQZdwy2c7xSoQy9+gNOtpbU8To2cNyGwM4+X9abfalcX0sjyNhXP3R0A7Cqi/eH1o0C7e5q24HzDHerulWUd/rCW8udrbicHHRc/0qvbJzJ/vVo+H+PEcJH/TT/0E00hSdk2bv/CO6an3rct9Xb/GpU0nTk6WcX/Ahn+dbHyzDbjDenrVdk2Ng1aSOR1Jdyn/AGbY/wDPnb/9+x/hTlsLNelpAP8AtmP8KsUVVkRzy7jUjjThI1X2UYqeOUr8rZMZ6rn9R71FmjNFkHMxZVaPBDb0PRvX/Cmj5hxTkk2gqy7kPVc/r9aZInlEMp3I3Q/0PvSKbuL0pc01TmlxTJA0lKaSmAZpaTvS4pDOUcf8VD/29p/M11QzXMOMeIB/19p/M11JpI0qdBh5pMU40lVczExQBS/hQTkk4HXtQAdOlFFApAFA5opRQAoJ7Gn5zjPP1qMU8dRRYdziLhQNZuwOglf+ZplyPlj/AN7+lTXHOtXZHTzX/maZdrhY/wDf/pWR2LY6y1hilsLbfFG2Yk+8oPYUNYWZP/HrD/3wKfZf8g+2/wCuKfyFSmtLI5XJplF9JsZOtso/3SR/Kqz6BZNnb5i/Rv8AGtY00jNLlTGqkl1MJ/DJO4w3YPorp/XP9KrN4cvV6PC30Y/1Feg+HJ9HtZ531bawKhY0e3Min1PDDB/xro21LwaYyRb2ZbHANnKM/wDjxrGbUXblZtGpJ63PG4NCvVnUvCDGp3MQwPA56ZzVa7trx7h5Ht5BuPA2ngV27gBHmCbBMSETP3Vzn/634GoPeqVJPUHiZLQ4Mgg4I5o6V3UsUc67ZY1cf7QzVOXRrCUH9zsPqjEUOl2KWJXVHJZpc10L+G4SfkuJF/3gD/hVSXw9cKf3UqOPf5al02aKvB9TJDUuanm067gYh4HwP4lXI/MVXKlTyMVm423NVJPYfmhzmJx/smmUN/q2HtRYdynCuafKuAKdbrz+FSTrgL9a0sQti7EcQRj/AGB/Kn5qGNsRJz/CKcDWDWpqSdQRntSr8oxkn6nNMDU8GlYYpAYYYAj0NQyWcL/w7fpU2aKLtCM2TTnXPlsCPTOKmh1XVrEjFxKVH8LncP1q5SEZ7Zp819xcvY0bLxhGQEvYWRu7pyPyrftNWsL3/UXSM3908H8jXDyWkTj7u0+oqpLZGNSyMCBzjpUOnB+Qao9QyaVWrzix8R6jZbVWXzIl/gkGRj69a37PxlbyHbdW7RH+8h3D/H+dZyoSQrpnVBqcGqpb3dvdxh7eZJFP908/iO1TZxWLVgLAb3qRXqtupwaiwiyGp4aqwfmnh6VgLAYU7IqANUgakIkpRTFNSCkAuBS0etOxQAgpcUUUgCp7e8urQk21xLFk5OxyM/WocUtMD56kieJtsiMpwDgjseRTM4BFOkleQAMeFzgemajr2DAKUCkpwoAUV2Pw4GfEU3/Xs3/oS1xwrtPhqM+Ibj/r1b/0JamWwS2PYIF/d1zvjcf8Uxff7g/mK6WEfu/wrmvHRK+Fb3H90f8AoQrne6MqT1PEnB64NRnpWlaaiLOG6TyEkaeIx7yeUBHOKoRRPPIsUYy7cAetdRuyOinyKF2jBDY+bPr/AJxTKYgpyfeH1ptOT74+tAG3bj5pPrWhoA/4qGL6Sf8AoJqlbj5pP96tHw+P+KiX/df+Rqo7kVPhZ17DNSBw42yDns3+NIRzTCK1aucN7Ehtz25pv2dj6imYpMVNmO6Jfs596T7M2e9R7RRgUWY7of8AZzTljKcEZU9VPQ1FSYoswuiTyhEQ33o+57j61Lsi/vR/mKgjcxk8BlYYZT0IqQRxh1kKs0JIDAHBHtn+tS7opNMGSMDO5SO+0jNRvFsPYg8gg9a6VbTwe0QLX+oq2MkeUpwfyrCmFtFdyQQytLbZ+SVk2n64qVK5TViuqKfT86eI19qf5Ef/AD2j/wC+qBbx5/1kf/fQqrhY4+TjxAB6XafzNdPXMuufEarkY+2rznj7xrsGtk/57Rf99ihOxU1exUIpMVb+zp/z2i/77FI9vGIyRNGSOQAw5p8xnylTFFKRSYqiQoFO3EIU4wSD0+v+NNoGFKKKKBB3p46iminDqKYzi251W6/66v8A+hGm3f3I/wDf/pT8f8TO5/66P/M0l4MJH/v/ANDWR2o62y/5B9t/1xT+QqTFMsh/xLrX/rin8hUhFaHHLcb+FFLijFAjUg1LT0hSOfRLaYqoBfzZFJ9+GqhIEubs/Z4VhR2wkYYkL+J5qPFWYcQwyTYBYjYmexPU/gP51Fraoq5DdsGnZVbdGnyIfUDgGoKcRSYq1oiW9QxRS4ooEJS0UCgAzTJIYphiWNH/AN5QakpKNx3sUZdFspuREYz6ocfpWbdeH3WN2hmVgAThxiuiFNm/1En+6f5VLhFmsas11OBthnt/DT7gfKn1othz/wABqS6H7tfr/SszrT0Bf9Wv0FLXR2+gWt1pltKGeOR4UYkcgkgHpVW48OXMXMLrMuP90/l/9es3TY414PS5jg04OQaJIZIXKSRsjDswxTKixtcmDg04NVfNKGNS0BZoqJZegqVSDUlCFajmX9zJ/umrGKjmH7iT/dP8qAMnT0V51DAEYPB+lXZrCNxlPkNVdOH+kD6GtbFaSbTIiroyPJubVw6FlKnIZD0rTsvFF/auBNJ56dxJ1/Pr/OnkVDLaxS8suD6ipbT+JD5Ox01n4o0+6AEjmBz2ccfmOK2I5UdA6OGU9CpyDXmkmmuuTGwb2PFNtr690yYtC7Rk8EY4P4dKh0U/hYtVuenh/eniT3rjLTxgSFW6twT/ABOhx+h/xrdttUt7tN0Mgb26EfhWMqclug3NkS8df1qRZR61jm6x3pPthHSs+ULG6sq+oqZZk7sPzrl5NS2nHU+1RG8nm4B2j260OI+U7JHVjgMCR2BqcDNYHh+Hif1+XJ/Ot0bl75HvWT0YrIo3+pR2eVVd8vYE7R+Z/pTbPUGuCvyxyA43GJidh7g5Azj1FaOULZaMbh0OM1IuwDCAAe1CkhWG7aXbT6Xbmi4rHzveQeTINuNrDIHpVatXUlPlRnJwGPH1/wD1VnKwR1YDOOcNzmvYhLmjcmtDkm0N2kYyCPSipZ5vPZTyMDAUnIUeg9qjAqjMceeQAAewrtfhqP8Aiop/+vRv/Q0rjGTY23IJHociu1+Ga58QXB9LVv8A0NKmWwp/Cz2CIfIPpXMeOxnwte/Qf+hCupiH7v8ACuW8eHHhW89wB/48Kwe6MaW54pIgVVbepLDOB2+tRhmXocfSnkZ54HNXLqw+wWqPO0LvOm6NY5QWj5HJA9Rmuk6CpcTRyiIJEI9qAHnO4+tQ9sYoABzlguBnnvUyBp0IATESFuTgkZ/XrTERMhU4OOPQ5oj++v1FSAIBl13ZyMA4xU1vatJGJVwx3Y2Lywxjkj0xmhBc1rcff+taPhznX8+ivVC2+6+fWtHw2M642OyP/OqW5FT4Wdg1MNSGmkVqcAzFGKfiqct9DFqMNif9bKCQew4P+FK40m9iwRSYqTFG2mIZjijFP20EUAMxT4yUbI/HI60KKo6veS2FmbiMD5CCcng+xqWXFNuw/UtQgsJLfP3ZXIIPGz8fyp0U8V0vmRSK6eoNchrus2+qx2zRKyOgYOrdBnHQ1L4WvCl81ux+WReB7j/JqFLWxu6XuX6nXbaUCn7aAK0MDlH/AOQ8P+vlf5muoxXLt/yH1/6+l/ma6k9aEaVOgzFGKcaMUGY3FJinYoxQAwikxUmKQigBtHpS4B5FLigBMU9aKUDFAHF4zqdz/wBdH/maS8+5H/v/ANDT1/5CFwf9t/8A0KmXmcRf7/8AQ1kdvQ66z/5B9t/1yT+QqQjmmWgxp9t/1yT+QqQ1qcb3GnrSUp5oANAkKBk4AyTU91iNlgGP3QwxHdj1/wAPwotfkdpj/wAshuH16D9SKgOaXUb2GmjFLijbTJEoxTiKMUANxRinAfzpdtAxoFNYqhXcwG44GT1NNN3BHceTI+184G7gHjPWsfVb5WleDeuwMCpHVTgZqJTSRrCk5M0b28FttKEPtyZEGMgY606O7iubNnDKpKnKlhmua81pNrONwGRu5z+dIsmwmRGVcrwuOvrWXtnc3+rqxTthz+FPuVyi/U0lqvT/AHf61LcjCqe2T/KqNDs9OkRdIsyzqP3CdT/sirakPGHUjaRmuat5QLaFD2jA/Sri3hWExADB79wKXtTF0OpYv7mPhGCSL0YMoIrGawt53ZR+6PY54/KrM6qT95XGB839KjVwGBPJ9azcrs2hHlWhQn0a7iXcieanUMnP6daoMjKcMCD6EYrrG1HMZCpg8fhUcj299KIp4lIA69CD7Gm1HoNTmviRy1KGI6Gti90WNMvbTgrnAVv8aypYJIX2uu0/zqGrGsZJ7CrcEdelPeVHgkAPJU8H6VX2ijZwaXKXch01czA+qmtcrWZpg/er9DWrSnuENhmKQgU8kCo2kVRyQKgoMVHIqMuHCke9RSXYHCjntnvURZ25JJqkmIhns4W/1Z2n9Kpss1udwJGOjA1o4qG6GIGq03sQ0SWWtXomiidxIjMF+ccjn1reWV3+834CuRtP+PyD/rov8666JazqxSY4PQmiT2q5ElQxLVyNawsU2dD4cjBW44/u/wBa2jF7VmeGUyLn/gP9a3zHWU46mDlqZ5iphjrQaKmGKs3EamUsOO9KJCOoP4VZMWaY0WKmw+ZM8Gv1zanpgMKy5ImjfY6kNwcfUZravJ3sRDLER5ivkZAPT2NZMkzzMrSNkgY6ds5r16PwmuK/iBcW4gKASxyErk7Odvtmoe9dP9nsx4TllRP9ICpuYrjOX4xn6Gsi7t4YbCweMHzZY2eQ5/22A/QVs1Y5FK5FcQxJDbvEwYsn7z5s4bJ4x24xXZfDFc61dH/p3I/8eWuGr0D4at5ut3jhFT/RwMKMDqP8KiWwqnws9WT7n4Vy3j3aPDFzvzt3LnHXG4V1SfdrkviB/wAird/Vf/QhWL3RhS3PFXxuOOnamHnmpCON3HXHWmVujrsNxxSqSpyKcQoXBB359eMYppA4wfrxTJZotd/2nqKz6hIsasu0ukQ4444FdDD4Tktbh5jcRS2qRlg8bfe+U9vTNYFhol9fxl7eHcoI5JA69/pXXaNok2mWF5LcMdzRuoUHjAzzj14q4q5jOVtmYUAwG+uK0fDA/wCJ3IfRH/mKzoM4f61qeFhnW5v+ub/+hChbjn8LOuI5pMU8jmkx3rQ4TO1W+FjaFtwDN8qk+tcPc3091f8A2iR8OTjI4wMVt+ItQjun+zIcNGcgk9DyCCK5jdiQeuawlK7PQo07R1PTYJkmVQrqW2gsoPTIqXFcjoGqR2STecSSVL8+2AB+OTWzoF5LeWsjSkHEhC/z/rWqlc5Z0nG7NWsnX3u4bAyWrABfvYB3fhitikYAqQwBBGCPWmyIuzucfo3id1nWG/fdEf8AloRyv19RV7xJMsMDNBqTbZBgxYDgAj8xXL6wunx3LLYrOhVirpIBgH2Oaqw3kkUckWFaKT76kdfx7Vk30O1U03zIgPHTpViyupLS5SaIgOvIzVZsbjjOO2aAccUkzW11Y9G1fUxp+nK24GZgBgH25/nU2lXYnsLVpZB5siZAJ5bnGcV55c3kl04aRs4AAHYYAH9KW2u5Le4imQgtGcru5AqufUwdBctjo2H/ABPkPrdD+ZrqiK5GzZptQsXc5Z5lY/XrXYd6tGFXdDMUlPIopmZGRRinkUgoATFGKd+FH4UAMPWlxTutFFwGjrTsc0YFLimgOKT/AI/Z/wDeb+dNvekX+/8A0pYebuY+pb+dF6OIv9/+lZnb0OutB/oFt/1yT+QqUim2o/0OAf8ATNf5VIQau5xvcfa3EtnOs8JUSLkAsgYc8dCCKlvdQnvlQTLANp48uBIz+O0DNV8cdaTbzU6XuCJXIjtkjxhn+Zj7dh/M/jVfFP20baaYMbigCn4o207isNxRinbaMUrjsNxWZq7wmII1wYpF5GMjP4itbHrWfqV3awlFnjLZBIZRnHalJqxdNPmOXeWTILN5h7YbJxS+Yybnl5GenekdjI5eEBFJwq4xjHemIXkcfNwx6LwQK5GegkSFiVHl4OB1PGPwpWw0WT5ZI6ELjimsy+X06nHy0ZbYVzuKgjp0FJDZDa/wf7v9amn+4v1P8qjtR8qH/ZP86mnHCfU/yrp6GQ+G6IAVgGCpwR1wKuQzxyABHBOM47iqLiKNVTGJGUZ5yDQxGG3FMlcHP8Nc7eptY0iT2bPtTS2OSBWc128GU8xWKjOCP60sepqVBkUrz25oQWLxc888YpA5HfnFQrPFNzG4z6U/nnnNMLEwlwOv1qQSJJGUfDc9DVTdjPP6UqvkdOKBWJBp9vKX+dYmLYUDmq0mnSxMQAJB6pzVjdgD0qaOUqvynnt7UXDVHP2ZEZB6cYq0bgAE5PX0pmnwrPchH3bST93rVufRZsZjkRv9npVOF9RKajoyhJckn5cVXd2IJJzT5reWBtsiFTUZHyN9KOWxV7j4eUzgZzUwXFMtVzCfrVkJWctzREW2obsf6M5q5sqter/okn0/rQnqDWhnWYze2/8A10X+ddjEtcnZL/plt/10X+ddzBZStyQFHqxxRWZnDYWNDgVZjXmpIreGP/WSZPooq5Fc20GSijPqeTXM5DaNnw0BGlwXIUNtxu4z1reMkX/PRP8AvoVxh1QetJ/ag9ah3Zm6d3c7LfH/AM9E/wC+hRmP++v51xn9qL60f2mvrSsxezOyIQ9x+dNKL6j864t9aRJFTZIxY9VXgfU1J/aq+v6UuVlch5Jqk4mutqHKR8D3PeqI4p2KbXqRXKrBOTlJyZMbmVofKMr+WP4cnFR7icAkkDpTe1KKZJIBXoPwuTOo3xHXylGPxrgApGM9xmvaP2f7JJtV1i6cZMEUSqD6sW5/8dqJuyJmrxZ2Rs7mOHzHglVMfeKECuL8fc+Fbv6r/wChCvd7nBiIPIxXiPxOiWDRL6NBhdyED0+YVgndmVONpHh7DFDRBYVfIyRnAOfz9KV+tMNdSOhkkkUflGWORcFsCMnLAep4xUcSgyLubaM8nGcVNJHHFBFJHOryODvUA/L7c+1N83MKxBEGDuL45P1pkbnpeiXVrLp8TRzRnIAxwpHsR61oah/yDbn/AK5N/KuP8H2CNNJPMjb48bQy8YPeui127MGmuAwDP8mD3zWqehxOHv2RyEH8f1/pWn4VH/E6l943/wDQhWZCRl+v3v6VCLp7SXzIyQ24j9ai51OPMmj0l9qKWYgKBkk9qp6jdRQ6XJNvG10+Qg9cjjFRSTQ6toBJl27xt3dAGH/1645tTmFodOmI2xudpHbrxn0pylZGFOjd+hmyszylt2SSST60xSBKCxxj2pCcMQfSkJyQSOeuaxO+xIzk4Y9TwK6Pwom68LGYfKpxGBn6nPauTMnzcH860rDVZtPiYW5IeQEEn+lVHRmdSN42R6WOtQ3ySG0cxT+Q6jcHbG3j14PFcff+JpXtYUgcpKo/eB1wc+tZ6+JdRTyNsv8Aqk2EHkOM9xWjmcsaEr3KWoo7TNMTA5PLPA2QeeuO1UM+tTyvHICwUq2eg6VBxWZ2RjZC0UCjvQULSg0hpB1oE0dVpv8Ax/ab670/lXaMmCSPyrjNPwL/AE3P/PSP+VdszpIDhgcHGRz+Fao4ay1IjSYp4p4XNFzEgNAGaseWfw+tKI29P1ouFivikq15bf3ahkXDZ9aLjI6XtRjNGKYhBwafjNM5z0p4oQHDwDE7++f50Xn/ACx/3/6GlhH75j9f50XIz5Xs39Kk7Tsrcf6LD/uL/KpMVJZW0k8UUca5OwfyrXi8OXhVXcKinoTnBrGviqVFXqSsZUsPUqv3FcxcUYrp4vDUZxvlYn2q5F4XtiM7JH/GvNeeYb7N38jtWV1vtWXzOMxk0u2u6Xw3bIM/ZXP1U1J/Y9sn/Lqv/fNZvO49Kci1ld95o4LbRt9q7v8As21H/Luv/fNKNMtz0tV/74qf7c/6dP8Ar5Ff2Uv+fi/r5nBbaiuY5zARbsqv6tXoZ02FRzaLj/rnR/ZluRk2KEf9c6Tz1dab/r5FLKrP41/XzPE5ri8MjKZ8sDyQeDVYmVnGJACT36GvbW0fSSTusEz9SP61Xl8M6DP9/Tl/Bm/xrP8AtinfWLR0LANLRniwcybVLAdQOMZpSHOSGXA444IxXr7+CfDjf8uci/SU1Wl8A6C5ypuoz/suD/MVazag+4fUZnkcshMmxhlccYHeiNPLQqWyx644/CvUW+GuksSyahco56EoCBVab4ZyFT9m1SCQnHEkZX+RNbwzHDy+0ZSwlRdDzm3HyRj/AGf61LLyF+p/lXYf8Kz1uLaIpLSUKMfLLjPPuKq3XgPxFHgiwDYz92VP8a7o4ujJaSRg8PNdDk5CpTAbBAGT1qt9oclk3Ag8ZxWpe6Nq9lE6z2FxGc8tsJGPqKyljKybmUhh0B4oUovVMpwkt0WHZVQgYywyT1FVHRW+593+IelWiCilsncVxkDiq2wo6nI9TxTTRNhEt5POzn5fXOOKuG6aFMo/AOPn5prxuwLueNvY0ySFVT5WII5ye34UXuFi3HfRuo3kpnjmpw2eUYY9RWSQphIJGWbAzxinRxhFKLvZieccYoEaoLf3gf1pSzEEEqB64qi8nloIwxJP3sn+tRq0GCGL7+2KAJ9LkEVwrtnHPQZroTOhXIP4YrlbYlVGCR9K1EuY1iGS39a3TMJRvqaDyxsMFciqM1lbTpIyoUIGTg9eRT9wK7h0NOjYbJf93+orRx0M1o9CrDp5SM7XBGeh4pTA6dUNXInAQ5OOaUzr7muacdTqjPQo+Wx/hb8qqX6FbSXIxgf1rV85mIAGB+dUdRGba4/z3qLWaL5roxrZzHJDIOqsCPzrqpruWK1Fwb22cEj92kylxkenWuTUfulPpVY3DVc4czIjJROp/tiQ9G/Oj+1XP8Vcr9pNL9pNT7JD50dR/arf3qT+1G/vVy/2k0faTR7JBzo6j+1H/vUv9pt/erlvtJ9aX7UfWj2SFzo6f+0z/eNH9qN/eNcv9qPrS/aGo9kh86IB2x1pCpBIIII7GrAtZAc5XP1pzW0juWO3JOeK3MisFz065pQOas/ZX9B+dAtZM9BSAjQV7v8AAKR5rnxFLIQWZbckgAd5OwrxJLVx1H617f8AAJCj6/nutv8AzkrKpsOWx7Fc/wCrP0rxX4pn/iWXg/3P/QhXtVyfkP0rxT4n4eyu1/3P/QhWC3RjHc8RkHJqIirr2r5OAMfWojaSe3511o3KtOQ7WB61P9kk/wBn86kFm+3tn61RJt+HtSvmnEKSbkJGd7dB7UuuX73OqNEsrNCjjCnscYNV9Elk06Z3Yrg4O3aDk/XtVfyZXuN7YJLZJz1p3IUVzXLUX8f+9/SqN30/4Ef51fUBck8bm4/KqN5xt+p/nQ2Ulqa9nqBXw5cWqsRJG+4496wJJC7ZZuR7dauW06qs0ZPEqY6dD2qhIhD471F7lxjZsPMOzJPOfSgrhd2eewpqAE4Y80+U5xjPTpmkWVuuOTU8jtM4baFG0AKowAAKYiqWO7OMdvWrMMBYktnYgy59P89KolkE00lxJvldmYADJOSahNXr2XzHBW2WKMDCgD+vc1ToBCUmeaO9KAKADNLijFLSGGKTFSIMuo9TU0y8jFFwaNgxvILOOM7XZkVTnGD0612CyWel20cDyqnHAIOWPc1x12r/AGa3KjnIx9cVatdNVLoPqlzsAG/aDuLY7Z7VdzmnDmOyjIkjV1PysAQfapUz0P4Vjw+JLCWWdVykMSKUJXr1z/SoT4rtfsssgRvND7UQ/wAXoSaLnP7KXY6LB9KMf7IqnZ3UlxaxyFslhnp/9YVP5j+v6U7Gb0JlI/u0y4xheKarNnkn16USuWC5NCAhopcUYNMQmPelA5oqvcX0NuvXc3YChsaTexydpC0kpCgk4qzLFGMAqZJFOQA2F/PvWlb6dc3p2wxCG3/vngf4k12Wh+DYoVSe6LZPIyBvb8P4R+tc1bEU6MeabsjuhCU5csVdnK6Z4e1HX5le4j8uFByxU4A9BuyR+FegWljo/hPSJXM/kWmAzyTNjew7Knc/QE1D4j8Wad4WgMO0S3uP3doh4XPdj2+nU15XrOqah4ovzeagOnEdvFnZGvoB/Pua4lGtjVyzXLB9Or9eyOn3KDutZfgjoNW+JOqX7yW+gQiztweJyP3pHuTwv0HPvXO3Oo+JL4lrjXrls/wtdSEflUASdVCrbuAOwQ0uy5P/ACwk/wC+DXoUsNClHlgrIxlV5neTuVWsrx23PeKWPfk05bK5Uf8AH6R9Mj+tWPLuv+eMn/fJpDHcj/ljL/3ya05GLnRH5F4P+YhIPxP+NN8i9z/yEGP1ZqeVuM/6iX/vg0hEo6xsPqpo5GPnQJ/akZymouv+7Iwqymo6/GP3et3a/S6kFUy7DrSeaaPZD5zUTxD4qTga7d497lj/ADp//CU+LgQf7Vkkx/fKN/6EKyDMfSmmc0nRi90NTZ0MXj/xXAwErJOB2NvGR+aqKtn4p60G/eaVp+B2Ecq/+z1yfnmk88+prKWBoy3ivuLVecdmd1Y/FWMsRqOmke8Eo4/Bv8a14viP4fmxuN1Dn+/GDj/vkmvLTNkYPIPY0wrA/wB6JPwGP5VyzybCy+zY1jjqq6nttl4l0W/GbfVLZj/dd9h/JsVqrMwAKSHB6YPFeH+H9Ej1PVFgSUxKiSTMxOQAiliPxxj8a9xcgW9sgABWFQQBjHf+teDmuX08JBTpyZ34TFyrT5JIX7TKP4s/UVWubaxvR/pen2kxPUtEM/nT6SvFhiqsdpHounF7oybjwl4dueVsmtnxjdA5GPwPH6VhX/w1tZIiNO1FgxPK3IGPzArsjTa66ea14dbmcsLTl0PMNR8C+IrYF4rdblFGAbZwxP8AwHr+lctcQywO8VwHWUcEOMEfhXvKyMhBViCPSuU16ytv7Rme7QNHMd0bmMMAO49sGvfy7H/Wrxa1R5mMoKglLozypI2VwVcsPpUzzBIwuTgEDArrJPDVrcljZzlfYHI/I4NYl14b1GJm2wiUKM4Q4P5HBr1L9zhUk9jGkHnOVUtnOST3qQtGqHO7IOMU8WzBz5gcY6hh0/CmyhHLYJViemOtUgsNjYJGpOce1SJLhhk4BOcdQajU4iHAPtQ0bNjavOegP9K1urk20NCO4Mqk7h+FBZvU1FbqRCMjB6HNS4roi7o55KzJYf8AVn61KBTYB+6P1qZRxWMtzWOwgXLD61W1FP8ARrj6GroHzD61DqKj7LcfQ1jLdGkdjmgP3C1mmtYD9wPrWSa1IY2iiimSIelJQelJQIWkNGaKYgqUGoqkFJlRPdR4d0n/AKB1t/36FOHhvR886dbf9+xWmKcK4uZnPzMzP+Eb0f8A6B1v/wB8Cl/4RrR/+gdb/wDfArVFKKnnY7syv+Eb0cD/AJB8H/fArtPh3ptnYSakbW3SIuI920Yzjdj+dYOOK6nwRw999E/9mqeZ3LTOmufuH6V5br9pb3+sTW9zGJYioJVuhr1K6OEP0rzPUv8AkYp/9wU2yVuYbeF9G/6B8P5VXl8NaMP+YfD+VdCe9VpgMUcz7lJsxo/DWjE/8g+H8qtx+F9F/wCgdD+VWoqvR0cz7jbM9PCWhnrp0P61YXwhoI/5hsX61px1YFHO+5F2eUePNMs9L1S0SygWFGjBIXucnmuJveCn416B8Sz/AMTuxHbyf/ZjXn98OUrrpO8dTojsischcg/jSsVLBuc96iJKkihWxnPcVRqLgbyR0prMD1qRSuAew6g0m1Tg4zzQFiewihecGdmWNQWO0ZzjtSvMzL5ca7VOCQO5qeOzLWsUkb4MpIYlsAAdjV62tY7fTHumA81mKoDzkd/wpmdzJuI5Ys7jt3KDtJ6g+lUzVmbG87TkHoPT2qEigtLQixzTsU/bRii4WG44pQKdtzTttK47CIMSJ9asyDLCq6KfOT61cZfnFS2O2h23i+wtrTQLdoYwpFztyPTyxXCyzyy7d7khRtA9BXoPjY58NW59bz/2mK87Ip3M6auhuferMZS3YGVPMYEHy84/P/Cq2KcASc00y3E7TR9Ya6YI45J4AwqIPqetdCoBGR0riNAsmkuFle2MqZxuY4Vf8a7VGLIGVht7YFaJnnV4JS0EuB+5NPI4HsKikLlDk8Z9KQyleWbjPpRcy5dCXFRSzJCDuIyB09PrVd7p5spbjAH3mJxj8e386sabos+oEzHAhU4aaQYVfoO5/X6VMp22LVNWvJ2RRM1xeyLDAp+bgYHJ+gra0/w7HHIDd757hjxEDxn3Pf6Vs6ZpYy0Gmxc4/eXL9cfXt9K6FYrDQNOe6upljgQEyXMnVj/dUevsK48RiFTfLvJ7I2owlVfuaR7kGnaKluElmCvKq5CYASIDv6f0rkvE/wARUtpnsPDzJPOB+8vTyqn0T/4r8qwvFXja88UKbGyR7LSc5z/y0m/3sHp7dPrWn4J8GadfWy3d/LIqknyY0x26sx+tZ0MJKc/a13eX4L0OmdWNKHLDRfizlLPSJLmU3N3JIxbks5yzE9evStqO3hgKJEgVeSfU8VvarpEVnHJNDNvReV+YMCM+3SsCScRsDgnrXrKKijznUlUZMRSEA02KdJhkH8KkNO5nZrcbtBqvPMbeVWAyCCOaW5u1gyvIYjINZst4ZYwrdR0PcVnKpbQ6KVJvV7GtDI7rl+/IA61LsHesYah5SlQDu45q5FqkbEB1Kj1ojNEzpSvoi2yKRggEe9QtZ2zD5oIj9UFOju4pIw+duSQM0l3II42TcVkI49605kZcsr2KM9rpyk7oEznHyjHNY8tvb7uEI/HrVp53djuAJ6E460ht5FhW4dD5e8puxwTjOP1rNzZ1wjyrUz2tY8A7mBP6Uz7FuUFZO+PmFX5F3OMHANNK4wExnNNTZqZz2kqReYcFR1welQc1oXTFbULnl25+gqhitE9AR1ngW2M11dOQ+CiwKQONzuox/wB8hq9ZlYPKzAYBOQPSuI+HlkIbK3mlVh5sk1yAehEaeWp/77c/lXZmvkOJKl5Qh6s9bKo/FP5BTc80Zppr5c9pCk5ppoJpDTKQlRyxxzIUkQOp6hhkU880lXCUoPmi7MbipKzMW58NWkxLQO8D+3I/Ks2TT9ZtB8yrdxDsPm/Tr+VdXS17GHzvEU9KnvLz/wAzzq2VUJ6x91+RxjXFlc/ur62Knphl3Y/PkfnVKfwvpd8+60laNvRDu/8AHTz+tdzPawXClZokcf7S5rIuPDVux3W0jwn0PzCvYoZvhKnxXg/vR59XLMTT+B8y+44Wbwrf22WiCzqpzhD82P8AdPNYk6vatsIZXU8hlwa9N+x6xZMApW4jHY4b9DUU9xZ3B8vULBkJ4IaPePybkfga9KM1UV6clJeRxvmp6VItHmqXBYgEnGeQT+tWo97LuYYyePpXVTeEbG6lL6dchCckIOf/AB08/wA6ypPD2o2au0kRkAONyZOB7jqPyrSFWzs9BSUZLQrwD9yfrUyjimwphGHfPSpQtaNkpAq/MPrUWor/AKJcH2NWVHI+tQaiP9EuB/smspbouJzK824/Gsg81sIv+jD6msgjFbEtDKKdikIpkjOtGKU0lBNhKKdRigBtSgYqLvU1JjifRA6U8UxaetcRyodThyKSnAcVIxK6rwT9+++if+zVyxHFdT4J+/f/AET/ANmpItHSXf3D9K801D/kYJ/9z/CvS7v/AFZ+leaXxzr9z7J/hQ2CWo0iqs1WzVSbrUjSGR9aux9KpxirsYNHMkU02Wo6nFQRj0qyqn+6fyrJ1qa3kvvGqNR7RZ5j8ShnW7H/AK4/+zGuCvRllH+zXq3jTwzqmtatazWVr5kSRbWYuq4OT2Jz6Vgt8MtcudpzaxYGDvkP9Aa3hjcPGNnNfedVOhU00POzGc0nlGvSE+E+sHh7qzH0Zj/Spx8JL/8Ai1G2H0VjUPM8Mvto6Pq8ux5iI29KcIzjGK9Vt/hI+T9o1RQP+mcWf5mtKH4U6OgHn3d/Ie5Qoo/9BNQ81w6+0P6vLsePRF4iCvbseRV2C88q1aJwXznaD0GetevL8MvDidRfP/vTqP5LUyfDzw0ow2nzP7m6b+gqP7Yw/f8AAHhZPoeFvEu75M496aIj6V7wPh/4YHTSm/G6f/GpY/BHh6E/JpEB/wB+SRv/AGaoec0FtctYWR4KLcntTvspNfQaeG9Hj6aJph/3oSf5mpF0PTFPy6Npi/S2H+NZvO6PRMpYVnzwLfFO+zs3RSfwr6LGnWaLhdM08f8AbuKcLWJTlbKxB9oBWbzyn2KWFPnJLdhKnynr6Vb+zuz9K+hRGynIgtR9Iv8A69O3Tdo7cf8AAP8A69Q89h/L/X3D+qeZ5h4ttZp/DdskcTuwvCSFUkj5BXFDQ9Tf7mnXbfSFj/SvoMvc/wB2H/vk/wCNHm3fYQ/981Dz3tEVPAqKtc+fv+Ed1c9NKvf/AAHf/CoLjSb+xjD3VlcwITtDSxMoJ9MkV9DGS7P8UY/CsrWtIl1q3itrpw9uj7ygbGT0Bzj3P51dPPE5WktC3gl0Z4/b2l/BFDLO0/kPgrGrn5l/pW6byfVrf7FZWxg3AhnZ87gB0UhRz2xyea7RfCFmgjzEXEa7VDyEgDJOMemSa0YtOMKqqRIqr0C4AFa1M9gv4abJhlies5I4WG11e2s5Hv4J2fcWZ5EPAPTPHJ9hSpY3dwymSKbJ5EYjIJHuewr0FCqkqMkqcHapOD6cU8swAxA7jPsMfmayWfS6w/EyllUekjkLPS44wGuxu2/dgQ8D6kfyrptP0i51FElm/cWK8LgYBHoo71ejMjZ87bt/hQDge/vVoXMqqqh2AUYUA9BWk+IKcU1GGpyf2PNyvKV0Q6zrOk+FNIW4uwY4zn7Nax/fnYdefTpk+9eP6trV/wCL9US61JngtVOIrePOyJfXHf8Ar+levXUUN8ytdxR3BUYUzKHx9M9KqyaRpsv37G2/CJR/SufD5xh6bvKLbe70udUsDNq0Wl5Hks9ukcreRl4gflYjGR9K6rw1bRNolzeTsEW3mVXLjIZGHKr/ALXGa7ZvC2nPas7abAygcLGg3n6beayfE2jy/wDCP2VnpemSRxI7M+UK7XPRuDzxxk56178cRHEU/gaXmcHI6U/iTKevQaXbafvt3XzpVAjjVh93qSQO3FcfKNzDIyOc4ppFzZyNbyQRq8ZKuoHIPfpWtpj6PczrHepdQuejiVdpP4rxUU8RSw9Plcm/xNamDr1ZcyjYqRxrAu9jgY5z2quNUt9xVgw98V283hPTJkK+bdhT6SLz/wCO1TPgLSTnE15n/fX/AOJrnee4Xo/wIjlVV6zX4nD3t2J8qMFB0YVQZ8ZPPvXobeANP/gurgf7wB/wqJvAFsel/IP+2Q/xqP7YwsteY6I4GrFWSOBJ39zx6+lITtBBzjPFd4fAEXQX7fjF/wDXpv8AwgQU5W+z9Y//AK9XHNsL/ODwVbscUrsI+pApXnkdBuJO08Z7V2X/AAgkvA+2xfihpp8CXCvuS9gB9drf4Vqszwv/AD8Rk8HW/lOPUo6gYw2cnB61t6jZSQ+G9MlEbBJHkZ2PQscbePoP1rQHw+ui4P222A7nL5/9BrQ1Dw1q+oKiy3dsVTou5sZ6Z+76YraOZYS38RfeYzwdfmVos4Eggc9PWmkEkAZOelda/gXUz0ltT/wNv8KI/AWobstcWq46ZLH+lNZjhP8An4vvK+rVv5WcHcn97t/ujFRou5uld9H8NZS5M+pxjPOY4y388VsWPgHR7Vlec3Fyw6hnCqfwAz+tRUznBwXx39DWGCrv7Jd8LweXpoyjL9mgjtUz05HnSfjucD8K2Cailt1WECBShjZpFAY8seTnPrU6hXUMpyrDII7ivkM0xcMVW9pDbY9nBUXQpcstyM0lTeWKXy1rzbnXzIrGkq15a0mwUcw+dFbmkwc1a2rSFVp3HzlXBpMVa2LSFV9Kdx85WpM1ZKKaaY0JppjU0V+tDKrjDKGHoRmp/KX1pPKHrVxm4u6Y24vczpNNsnOTbqD7EinLbKihVkk2joGbdj8+n4VdMPuKb5J7V2Qx+JjopswlhcPLeKMy40uK6j/fxQSydm2lCR7sMk1nN4SSQjypGjJHch1B+vB/Suk8l/7ppu2RTwCK7qebYhKzs/kYSy3DyemnzOLufDOp2gDeR5q9cxc4/DrWDqSMlvcqwIIB616vHcXEXTke4pl3b2GqQtFf6fGyuMMyjDfn1r0KWaqVudHNUy1r4GeDon+jD6msgrXtV78NtNuedNv3t1x/q5xuGfr1/nXEar8OPEOmb2+xm6iUZ8y2O8Y9cdf0r1aeKpVPhZwTw1SG6OJK00ir0trJGxDoykdQRjFQNHXQpI53Blc0mKlK00rVXJcSOinbaMUXJaGYqUUypMUMcUfQ4GKlWmCniuJnEhwHNOpAKcKhspIQ9K6nwT1vvon/ALNXMbSxwoyTW7ov2qxjm8sqhmxknkgDPT865q2Jp0dZnRSoyqbHV30iRxEu6qMdziuAl0+efV7idAvlMAFOeT0ro/LjZt80pdvUnJqZZrSLopNedPMJyfu2S8zsjhYR3uzFt9BeZgCWJJ7cVYk8MpG+HjJ+rGty31e3iIAhA96dd63G3+rUfUiqdSDpc0q2vkNQkp2jT0MWPRYox8sCD6jNTLpoH8I/Knyaq7dwPoKgbUWP8VebKpTe8mzsjCr2SJhZIvak+zxjsKrG+J70n2vPWseamWoVOpZMaDtTSgqNJC5471citZJDwCa0hDn+FCk+T4mV9lGz2q7JbrCMuwHtVKWdFJC80qkFD4hRlzbCEY7U0iomufaozOT2rmc4myhIlOKbkVCZs00yVHMjRQZPkUuRVXzaUTD1ppofIy9DC08gSNcsegpt/H/Z+43JVAi72JPAHrUEV68DB43KsO4qpfy/2jFNFcsXWZCj89QRg1rejyWd+a/yt/mQqdTn8jMfxv4bQkHU049I3P8ASnx+L9ClXcl5lfXy2/wrwi+ge0vp7dxh4pGQ/UHFdn4NtbfXL4RS7hHFFvMYOM4IGM+nNexiMroU6ftE3b+vIVKSlJxkej/8JTo//P3/AOQ2/wAKnh1yxuBmF5ZB6rC5/pSQafZ22PJtYUx0IQZ/Or8Yya8OTo/ZT+83aiiOO5SX7qyfjGw/mKlzUzsI4duOW/lVepcEiE7i0hoppNLlKQHpVSaRpZfs0LEMRmR1P3F/xPb86luJvIiL7S7cBVXGWJ4A5pLaIxQgMQZGO5yO7H/OB7CtYxsuZj8iSONIowkahVHQCloorCTuxhiigmkzUNDFzRmkzSZpWCwpAPUD8qY0UToUaNSp6jHFOzSZrSNWpHRSf3i5E+hRfRtOfO60jJJySc5P41UufC+m3DqwR4iv/PNuv55rZzSVSxFVO6kygiRYokjQfKoCjJ7U7PtTaKx1eoWHZpOKTNNzQOw/ijimZozQFh/FHHpTM0ZoCw/ijNMzRmgLD80vWo84qvf6lBp9uHdJmcngRxFxj8Oa2oUZVp8kXr5kVJci5mW8UYrlR490jJBuFUjs0cg/9lq9p3iax1Sbyra8ty2MtuWQAD3JXA/Gu95RiV2+8w+t013+42jxUds+5ZEIP7t9oJ7jAb+uPwpsc6zxCRPuknH4HH9KdDxFIcctMfy2r/8AXrz3Bx5oy3R0pqUU11Js00tTSaQmsbFJDi1ITTM0madirDiaQmkzSUJDsLuo3UYpNppgGaM0u00m007j0G5o3UFTTcUxodmkzSUmaY7Dg1O3kdGP51HmlzVJtA0SCZx3B+ozS+bnqiH/AIDUWaM1oqs11Fyol8xe8Y/AmpEnVOQ0i/Q5qtmjNWsTNCcEyW9tNM1aExahbQXKkYDSx/MPow5H4GuP1P4YaPdIzaddy2svZZCHQ/jww/WurozXXTzStA554SnI8c1b4e69phJ+x/aogM+ZbfvB+XUfiK5WSBo3KMpDDggjBFfRwYqcgkH2qG5tbW9B+120NxkYPmxhv516NLPrfxI/ccs8tT+FnzmYj6U0p7V7heeBfD14zN9jaBiOsEhXH4HI/SuevfhbEWLWWpsFPRJ4s4/4ED/SvQp5xhp7u3qcs8vqrZXPLdvNPxXX3/w61y0+aKKK7Qd4H5/I4Nc5d2E9lM0M8MkUi9VdSDXoU8RTq/BJM5JUZw+JWPomDS7uYxBYWBlGUDDBYYzxmtODwvevzIFj9iea4G8129vvGGn6ikc0k6yKDb79xUjBIUD159a7zwt4ing1YaFf2riaQySmVjtIyxPKknAxjofwrhdRt2OP2RpweE4/+WszH6Vd/sDTrSNpZR8qjJLnirun6lb3lm8yXCSLG7K7hSgGD71yeta62oTeXGcWyH5f9r3NcmJxcaMLvfodWFwcq8+VbLcmu76Fn8u1RY4AewwW9zVY3hxgGsvzSaXzK+Yq1KlWXPJn0lPCQpx5Yo0DdsepppuCe9UDMBSfaAPWs7M0VHyNDzz60hnPrVD7SPekNyvvRaQ/Y+ReMx9aTzjVL7UnvSfao/U0csh+xfYueec1LC7yuABVKNhKfl5rVgCWsRlkIAA6mjW9jOpaKtbU19Ojjhw8xH0q1ea3DCpHmRwJ79a878ReOLTSowryNGWHygLmRvcDsPc15pqvxAv7vzUtUWBWbIlOWkx9en6V7uCoYmdPlgrLueZVo01LmrPXse36jr1nFGJPOLjuzfIo/E1zNz440yEsGvrNMdhJvP6V4bdahdXkhe4nklY93Ymq5ya7lksJO9SX3f8ABuJYuEFaMfvPZ5viNpI6aiG9kgb+oqD/AIWRpROPts3/AH4rx7BpcGtVkmGXf+vkH9oy6RX3HsifEbSCfmv2H+9A39BV2DxzpE/3dStjns2U/mK8NxSc1Msiw72b/D/IFmUusUfRVrq1veLuhkjkX1icMP0qx5yt91hXzhDczWzh4ZXjcdGRiDXUaV4/1WxUR3Gy7jz1lzvA9AR/XNcVfIpx1pSv6nRTx9KTtJWPZ/NI60u7Ncxoniuw1sGOBys4GTDJ97Ht61trPtPXivDrYedOXLNWZ6EVGa5oO5xPjvwzNNdDU7C3aQMMTLGMnP8AexWJ4PkudM8T2geOSMSuI2VlIyDxz+h/CvXEZHHD4P1qUIM58zJ/CvQpZnKND2NSN1axx1MOufmTsycDAyWX8CKtRRknpkDk49KpgsP+Wn6CpBNKAR5xweDzivLio31HKMnsPkcu5NNzTOvej8avcaVhc0hNIT70ySQIjMeQoJwKaKSIOJ7373ywYOAf4iD1+g/nVvNVbOPyYPnIMjku5HqTn9On4VYzVVN7LoJIdmkJpuaM1jYdhaDTSaN1Kw7BmjNJmjNTYdgzRmjNJmiwC0ZpM0maLDFJopM0ZpWAM0GjNJRYYtGaTNGaVgFzSZozSZosFhc0ZpM0ZosFhc0lLmkNMY1o43Pzxo3+8Aah8uyLlIooiSPmKR8H8cYNT00r827JzjHJNdFOpBU5Kd79O3zM5RlzJxtbqNCrGgRFCqOgAwKkRybWEE8/MfwLsR+mKikOyNnx90E1JHH5UMUWd3loqZPfAAz+lZp+42+pbWqFzmkNLSGsikNooqe2t2ncBRVJXCTUVdkaoWOAKlW2buK3f7L+yW/mygBcZJPasW81a2gVmU7gvVjwo/E1rOhOLSktTmhXdV/uxwgAoMY9K4/UfiJpdszILpXYdoELfr0rn7n4oQjiG1uZf9+UJ/IGuinleJqbRG5wj8U0enFRTSFHcV5DN8S7pmylhGB6PKzfyxUX/Cyb8f8ALhafm/8A8VXSsjxPb8SfrNBfa/A9gIU9CKaUryH/AIWXfZ50+1x7F/8AGrUXxPIAEmmN7lLj+hFN5JilsvxGsXQ/m/A9QKVGwxXE2nxK0uQgSfaYf99AwH5c10djr9hqQzbXMM2BkiNuR9Qea5qmBr0tZxZ006kJ/DJM0c0oNRiRXGVNOU5rmcbGzQ6ilpagkbRS4FIetABmkzRSGqGG40u6m0UWHYdmjNNpKLBYfmopooriMxzxpLGeqyKGB/A06msaqLcXdByp6M5Pw5dS2cc+qQxW8V3GWaFjIFEsQyWGzsSOc8dOKs2dvfeItXlvBHviY7/KhkG446KMsPxOe9cRp/2MaHczXEdy90JVCsqfu4o8ZJJ7kttXHpmvUrPVrTW/Bq2NtDdNd29pvR7e1kI81cbRkDAP6V9tKifHxaRu317DHax6fpcItrNF+ZEGNx75rKKt6GsdNbnsBENSaS2uHTeVKlSOSOfy/WrsXiiN/uag3/fRr5bE068qjdRH1GGhCFJKjaxcEbnopP0FNk3R/eBX61YtNeJkXfqRSPuwbOPwzUF3qjXMjD7Z52DjIfNYulZXNoym52aX9fIgaTnrQMt90E1A8hY8sT+NV5L3UrWeM6dcSQllYSGM4J6Y/rVUaKnPlNqsnCHMi8dwppJ9aj8zxlJB5sdxeumcHjn8sU118aAKHe+G7pjH8x0rq+pLu/uOVYt/3fv/AOASk+9IoLMBWLe6jrK3Vpb6jdXTKblAUl7Ehv6A10VlFvkFYYmj7FLXc3o4jni2+ho2UKwwmV8ADnJrivG3jcWEb2lpIGuzwF6iIep9/atfxd4hi0TTySNxXCoo/ifsPoK8LuLiS4nkmlcvJIxZmPUk125Tl6rP21RadPM8vGYn2a0+J/gv8yS5vbi8maa4meWRurO2TUOSTT7W2mvLhIIELyOcACvSfDnhKx063Goagwdk5LsAQp9EHf6n/wCtX1SSWiPCnVe7OV0fwVr2tRmW2sWWHGfMmIjU/TPX8K6AeA9MsbcNqeuKs+OYoIt2D6ZJ/pWpq/jK6v7hbHSY2AJwAp5Pbk/lWJPHZWFzG2o3rTTLc/vYogGUxhQwYHPOSQOcd6UppEJTn5EL6ToKMEiN1M/puHP4AVUmtdKjYobdkYdQzkEVZstVuJ713sNHWaaSLy3WNCc/NnO1QAOwI6HFSXXhTxRqtwbs6NKNygAABcAAAcE+goU3fVFcqW7Mk2WmueGkH0Yf4UxtFt5FzFdc+jLTr3QdX0zJvNOuYQO7RnH5jiqsc7KQa0ugt2ZXm0m5iBYKrAd1YVSdGjOGUqfQjFdHFc7xhuabMsUqFJY1bd0buo9qGCbRz8NxNbzLLBK8cinKsjEEfjXpvg/xeNSRdP1GQC8HEch/5aj39/515vd6fLagSfehJwHA7+lV43ZHDKxDA5BHauPF4SniIcst+/Y7MNip0ZXWx7/uKtj8qduPqa5/w1ry6/pKyMNt1BhZRnqcfe/GttHBFfHVaMqc3CS1R9TTnGpBTj1Jdx9TSbm/vH86bupC1ZWNLD/Mb+8fzp80wt9Pe5ZizbtqRh8Fj37Hp9KrlhmqmoQm5hj8v5ZomLI4OCpOOh/AV04RUvar22xzYtVPZP2W5bjuzMu5d6A5wrn5sA46UTO7QOoPJUgZNVIBcNNHJO5JRCpLOWLk45Pp90cVYdgRRiI041X7LYrD+0dNe1Wo+KUyQRyK5IdQ2c+op4dv7x/OqdpIdksZ3ZSQjnuDyMe3OPwqfdWVSNpM2VrE3mN/eP50b2/vH86h3Uu6osOyJfMb+8fzo8xv7x/Ood1G6jlCyJvNf++350vmyf32/OoN1Luo5QsibzX/AL7fnR5r/wB9vzqHdRupWCyJ/Nk/vt+dJ5sn99vzqHdS7hRYLIl86Qf8tG/Ol8+X/no3/fRqLIoyKLBZEvnS/wDPRvzNHnS/89H/AO+jUW6l3UrByol86X/no350edL/AM9G/Oot1GaLByol86X/AJ6N+dHnS/8APRvzqLNLmiwuVdiTz5f+ejfnR58399vzqPNGaLByrsSfaJv+eho+0Tf89GqLcKQmjlQcsexN9pm/56Gj7TN/fNQk0m6jlQ+WPYdcXcohI3t85VOO2SBn9an+1Tf3zVNiDNFx0Jb9CP61LmrlFcqRPKr7E32qb++aQ3U3979KizSdTUcqK5I9i3byTTShQc/hXS2txDpsPmygFv4V/vGsWxRLeIyydhmuD8e+L3hZ9OtWIuHH7xwf9Wp/hHua1wlCdaso00ebjHBp82kV+Js+M/ii6F7W0lSeXoyqT5cf/wAUa8m1HXNR1Rybu7lkHULnCj6DpVBnLHrmk2k19jQwcKer1l3e54k67tyx0XZCE5pMVcW0YJl/lHv1rUttBmPzT7LaNWAdpWAZf+Ak5/yK63yx3MNWYAQnsaDGfSui+y6NEreffTyEOQFijC5XsQeR6+n41inrQpJ7Cd0VChHakK1c2g9Sad5MBGCGz65qtBGdzT4bme3lEkMrxuvRkYgj8RVx7OP+FyPrzVWW2kjG7G5fUdqGkJSaeh1/h/x5c2rpBqbNNDn/AF38a/X1H616Xa3yTxJLG6ujDIZTkMPavn0Eius8GeITp18LO4c/ZZzgEniN+x+nrXi5hlkZxdSkrPt3PXwOYNNU6ruu56y2ohWwFz+NJ/af/TP9azLh9lwAeN/8+9M3cda+d9jE9tqJqHVcf8s/1pP7VH/PL9ayi9ML0/Yx7BaJr/2sv/PI/nR/ayf88z+dYpemmSmqEewtDb/taP8A55n86P7Yh7o1YXmU1pBVLDxFdHQjV7Y9Q/5Uf2vag4xJn/drDsbuG3v4JZyBGjhmyMjANcxPdalNKXfU23HqRM/9K6qGX06iu3Ywq11B2sehNq9qOvmD/gFNOsWX99v++TXnO7VM5GoSvj/pvJz+YrSs5J1t2NzIWIyctnI/E9a0qZZTirpkwxKbtY2b3R/EyrCljYIvmL5k8nyE7+4AGdoHQYGfetLTdBvDHjUr2+LnqoJCj9c0y3sI42WRri5ZhyrGY5H0I5FXDql9plpJM04u4Y1LlZx85x2Djp+INfQQraWaPjqkNfdZoQ+GdCLKZ1nkYdyCR+prpIND8HJApNpH5gHUqf5CvPIPGV/rC2r6RbWStITvtbnLSYH3mQhgHx3XAI9x0t6h4j1OxYH7NZvE33X8tx+B+eipOEdZIujGtJ8sH+J6XLZ+GDprReVZBWXB/dcn6jrXn+o+GdAeR/IuI4fTybWVf1FYr+M9QI/49rP/AL4f/wCKqBvFt+T/AMe1l/3w/wD8XWf1mjtb8DqWDxd7p/iMniudEm8x79prQuE2zRydCf4WZQMjrjNaZcMuQxwR2OK5fU7641SRGuCpCZKIowq59BWlpl0ZLfy2+9GADn07V42OjByVSkrH0OA9pGHJWdzVDPji4uVHos7j+tDB2XBurwj/AK+X/wAar+ZxR5prh56v8zO32dP+VfcSfZlllhaaa4m8lt8ayTMwU+oya6G2YQW7SkfdXNc/DJucZ9a1tQl8nTv94gf1/pXPWc6koqTuEoxUbRVjyrx/qbXOsrbCQssKZcdt55P6YrkURpJFRAWZjgAdyas6ndm91K5uW6ySFq1PDFk0txJeEgLAMLkZyx9PoMmvtcNSVKlGC6I+TxVXnqyl5nT+HdJi06zczeX5h5mcjJH+yD/n1pbm8udbvY9Ot5lhg3KrOxwkalgoJ/EgfU1Dql39nt1gA6jJI9abe2seg+HILue3uYtTu8NBIwBjaM87lI46EcHkHBrSTa0W7OaK6sgubgaLHb21hDJFq486C7J+cOC2F+U9CMfoD1re0XwZBBFDqPiCb5nbc0D9B357sfYfjR4W0UaXaf23qYbzpOUVh86g89ezMO/Ye54ztZ1e61LUpLSBMysdrsDwo/uj0/z3qYx6IUp9jfu/Gmk6LB5VhDbRNvI2RoOnvgYH61lL8Sbm5u1gh0+3mBOFL7gc/T/61MsfhLq+q3ETxSgW0qgiZ0xg9wRn9e9dhpvwu0Tw7qNrcXmvRvcRnJheMbScfXOK2UEtzCUooxrfxrOjAajZeXEx567cfgAf1NTz6J4e8UWwaDyLW7f7rRfLk/XofocGup1DwzA8Hn20lpcx87zCmAPwya8p8SXkGiaxtsAPMCgy4+4QedvvxjmplTW8WKnUu7GVqmj3+h3hgvIiuc7HA+Vx6ioVkLLg16Jp99B460JtPumAuVXfFL1YEcc+4yM+oNefXFpNZXc1rOu2WJyjD3FEZX0Z1RdyNSCTHIqsjcENWNdwfZ5ygJKHlCRjI7VrvwRVK9UyxgjGByAB3psoveENXOla7CXk228x8uUdsHofwOK9aJ8t8Z4PIrwUHmvYtB1E6p4YtblsebEPLf6rxn8Rg/jXg5xh/hqr0f6HuZTX3pP1Nnfz1oL+9VBLQZa8NwPa5iyW96bvquZaTzKOQXMWd/0pC4qv5lJ5lPkGpEiSBLsocDemRz3B/wDr/pU5es+aQIUlPRGBJ9B0P6GrBbBqpQ0TFfUn30m+oN9LvqOUdyffSb6h30b6OULk2+l3e9Qb6XzKOULlgNRuNQB6N9LlHcn3Uu6oQ9L5lLlBMm3Ubqi8wUb6XKO5Lupd1Q76N9HKFybdS7qg8ylD0uULk2+jdUO8Ub6OUVybdRuqHfRv5o5QuTbqTf71Fvppenyhcm3Uhaod9LvyaaiO45WUzu38SqFznp3P/stSB6rIy7Ayj75LE+vPH6AUvmVU462Ii+pZ3+9SW43yge9UfMzWlpowWkPQDNZTVolSlaNyLxRrC6PpEswxlF+VT/E56D+teGTzyXM7zSuXkc7mY9Sa7P4j6q019DYKTtQea/PVj0/Ifzrh0BdwqglicADvX1GUYVUqHO95fkfN5hVvPkWy/MsWttLdTrFDGzuxwAoroZNNt9MRU+W5u3wOOin0Hr9a0LW1i8P6QzMEa8mHzP8A3f8AZH+f5VFB5UGjXmpXsYaSeMLZ55IYPy3Xjp+NerKXKjzE3J+QsMa6aZ47iN21cMFgiSNZR/gDn6nj8a2bPwZe30X2zxJetapkFYmYb8erE9P1NaukWsXhjT5Nd1o+bqtzH543DJiQ9/ryB9SB71UgN545ka4RtkCNtCBs7T7+p/8A1VMYuTIqVbbbD5P+EQ03CRWdrOq8eY53Z9+Q2f0qBta8MSMETT9JI9oVB/MpWvb+C2ViwiWRkOGZIixz+ANcbr3w+1EXV3c2yOYy5fY0LLgE9uvStnSsjmjVUnqzpv7D8LaxEVEUVtMfutE+cfipwPxWuW8QeB73R4xc2zG7tTkl0XlPrj+Y/Ss/R9J1uCfcsnlwxNySc/gtd3omvPHOLedFViQJAeAw9SP6jke44rnalF3Rup22Z5Ypp2CD7V3vi7wojJJrOmR7YutxBjBjI6ke3+Oe9cPsyK1jJSRqndFG7tB5YmhA4HzqB096oqea2OUcH86ypU8qVlHQdPpVAz0nRNSk1PwxDMxzPZv5bc8sAAQT+Bx+BrZEgZAwPBGRXBeCr4RahPYsfku4yBzxuGSP6iustJiqtC3VDx9K+bxmH5KjS23+/wD4J9Hg6/tKSb32L7Se9RtJ71A0lRmSuRQOvmJzJ70wy+9QGSmF81agTzExlNNMlQ7jRk1fKTzD2fNRFVJ+6KXmnKpqkrCbuIqqB90UllZT+IdXTS7ZvLgX57q4AyEQdR9T0Hv+NQyi6vb2PS9OjMl5L1x0Re5PpxXpOi6NDoGlpYW53tndLLtwZXPfH6AV34Wh9uXyPJzHGqmvZw3PK/8AhIrPaAdMlwOxvZKjGu6djB0ptvcG8lP8zWeI7LjFxN16eSP/AIqrUVpDMAytcEL1Itxx+tehyQ/q543MyaDW9JgdXj0VY3XkMk75U5zleeD9K7PRvFFh4iD2N7GEkPQyMAZfcEYAYe3X69eZtdNWWVYmeRRggs1kP51oDwpC+HXUYw+OhhAIx9DWU3T2YrtO6LGraRJp85ABaFvuPjr/APXrLZTnkV2tgWitFtru4iuk2hTuGM//AF/eqd1o1rIS1tOoB6JIMH6Z6V59SOt4nsYbGwkuWo7M5M8VJa3Bt59w6Hg/Sto6DcMG2RGTHXZ82PyqlLpckfDIVPoRWEmtmenCXVEhux6ik+1j1qqbSQcYpn2d896y9lE19qzTguxvU571p+IbvOh7kPOx249lNcyIZAeKmu5JX0yWJicCNsflWboJzi+zKdRuLPLm5Ndzpy/YtFtIFAG9fNkOOrNyP021wx612l26phBjCRomR7KBX1h8jIksbS51rV9kNqboRfvZIQ4UugYAgEkcnIHrzTnaDxF46trSAyzafbqiRLJkHaiAYI92wDU3hGDVF1F9T0y6it2tpIo3MgLbvMYrjGORwT+FWvhsif8ACR3l07qMLtBYerbv/ZaybvJ+QS0gdD4zuhpsP2aKRSLckq3ZmbHJ9x1/EGq/w/0SK5uUubsDk+Y2/PIHPNc/8Q75JpnMY4dmJPr85H8lH5VZ+Gt48djcmSV2DM67SxIAWMngfjWkPdRzzTcdDuvEviy7ubgabpj/AGeNOSo7DsTjqT1x0A61x9zPNIxJluJWzn5V3YFRR3Id55nA3Sykq38QJ5x716Bpt7d6fpyw6dbrgqGeZ0GXyAc5/lVPzM72MDT7qO1sBdQ6h9mk/iSRSNw9GAHI9wfwrL8RaZB4j0lb6EYkcE7VAJD9sexIwR6kEd6b4rkPnWs5CxrdFhtTnkHBPFXPDyy/2bdWzkEtGZQ2OQVOB+mKL2DzOO8DpqthqyyRwSrGcglkIUMAeCTxyMj8a6rxFs07xTpeuRWsdxFKql0kUFHYcYOf9kr/ADrfukdhDNMN6iReD7kD+tZPiuAHwbavnmOVMfipH9KxnqzWE22jmfHlsYtca6XS302K5QSJC0iPnsSNnA5HSuMnc+ScYFelfE6FXbSr5II0Se2zvhfdGx4JwMDaeeR715nL901VOV4nWUGG1j6V3fw+v/3V5p7sNpxKg/Q/0rhpxiT6itTwvcG38Q2pzgOTGfxGB+uKxxlL2tCUTfCVPZ14v+tT0oTYJGehxS+d71UKsGOe5pOa+b5EfS85c873o873qnzSZPrR7NC5y753vS+aPWqOTS5NLkHzluVlkiZG5Vhgj1FPhnZ4EZ8bsYYj1HBqluOKW3ZhJJH1z849ux/p+dPkvFopS1L3m+9Hm+9VsN3oAao5B8xZ80+tKJPcVV+alG70o5A5y15nuKPM96rfN6UDPpS5B85a8z3pwk96pndSjdR7MOcueb70ebVPJoBal7MOcu+ZS+bVLLe9GT70vZj5y55lL5lUsn3pQze9L2Ycxd8yjzKp7m96C7e9Hsw5i7vo8yqQc0nmH3o9mHMXvMpN/vVLzDR5ho9mHMXfMpPMql5hpPMNP2Ycxd8ymSzFEJUjd/D7ntVXzTSeaPMXeAVBJwe/Bx+uKqNPUHPQuM6oojVvlQbR9BTPN96pNKSc0wymj2dyVI0BL83Wtu1OLAnoW4rlYnJcc1v3NyLXRDKzYEcbyE/QVlVp3aiupalpc8f8R3v27xBez5yDKVX6Dgfyqx4atle7N04yIvu59awXYtIzHqTk11emJ9msoo2IyyiTgevP8sV9pTgoRUV0Pjq03OTl3L12smrapb6fE2N7hQfT1NbWn6dY6v41s7CDYdLsoFeQbiV7tzk8dRkfWsPw+Fl8TwPJ5xEYklBhBLBlRmU8c8EA1s+CI3mXxBMXHnyBE3j/AGid386znfmIbtCxl+PPEFxqGqGySUkHaXRfX+BP+AgjP+0T7V1vw70RtItrrUby9NtbBQs+4DDH0HsOmepORVPTvDGm6osupzowuUlYhkPUjPUHitXxJcwpo+naRC5iiD/vj64Ax/M10QtFHHKfNoS6x4w13WTL/ZxNrpsZCjy1AYj19fyrGWbU44pLmHWt6oQGEjMeTnjac+nJHSruiW8eq6lPFMxhsrYDcsY+Zh0AHufWr2u6PZR2zzaX5kUUR3TQM2S49R7ilcSSKmnaimqQNbzokd4BkEdJfcGsm+tTE4uIyVkQfKQ2AR/nv2NVoZ4bS+txFKHEkoO0jBU4yKyvH91cfbYzHII7aRm/dx8DcArEn2w44+tJ6lxjroejeH7lbyyRJUR1m/dTg8deAcfofTOO1eb69pDaTrdxaAHy1bMZx1U9P8PwrvPB2JdOUAgzT2gaPI6N6/mM/jVL4kQRtdWd0nB2mNvcEBh/M1nHRmkJWlY80uU21lXfO1seor0Hxf4bstK0fTL+zvjN9rT5o2wSpCqSRjtkkfhXn9wv7o+xrSMk1dGzF0y4NrqdtODjZKrfhnmvSbiPybxiOn868sTlwB3NeshTc28Mo/iX+XFeXmK1i/U9TLZe7JehVzmjBParQtmp/wBkfGT09cV5tj0+Yo7T6UoQmrRWFfvTxj/gQpjTWqZ/ehvYA07BqQbKeIiR0py3tuW2pHIzHoMAUy71EWQHnpHbkjIErYOPoapQk9kTKSjq3YesBPaodRmXTrCS4bqOEHq3aq0GtQXkzRDUIoCBlXlyiE+mf/rVJeaFY6nta88Y2Kbeka7cD835rro4STknPRHFiMfThFqDuzoPAttZ2NmLozx3etagCWjhYPIq5+7gdOgJ6ds9K9QtdP8As6q8uxpsevC/T1+teK2mnW2mxqll4+Nuq9Fhuwg564UPXqHg3Tr60tp57zWbzUVuAhjNyzHbjOSA3IzkflXpSjofOVJc0nI44aNpZYN9mhxg9V6086TpwXAtIgAORyDmp/OjEoVMZBKjI6D1pFuVbZiQE8qcDnp3rzuaXcLsWOzSABI4QoAO45NPaFFZMpGA33TtzxUK3LDkEY5znpSm5dNpaQKQpGQO3NKw7lgeX0GwLt4+XrSGVVG7bjavTHGTUCTsI0zIQGXAOMCgzgqAZduB/wB9GpsNMsDYWOWVjwR8veuC1O48barqDQJDPbrCWEaxt5a7c9SxPzdu9dqXIDbmKtjccj3oE+12ZnTpkew960pz5HtcpTa2ZzNhpnifyx9q1hI8DlDEsh/Mj/GtY6ddmIj7erMBnLQr178DFajMSjBZUYgY3YpN7MHZJI+eFXHT60p2l0X3GscXWjtJnMXln4ht03QLZ3XcquUOPxODWBqGt6xaxSR3Wm+RkFdzxsBz79K9HcuefNQDgnaO4/8A11I7ArKrPGy8URVNbxRusfXtbmPAsc9a62+lEsrOARuVXwfQqD6e9d7daLpV87LPZWxywO4RgE/iOa5HxLYx2d8Y4QUi8tdi88ADGMnnHFehTrKeiOdS5mange2hu9P1iGXU/wCz22xPHKHCkOC2OvbJAP1rH8HSFbu+iU/vNisMd/nCn/0OpPCet2uialcSX0cr289tJAxhVWdC2MMAxAJBAqrJqFiPG0+oW/mpZXEzkBlVSobOCVBxw2DgHtVJPmY57MXxLZktcRquCSSHlbjg7sL9Qw611ngnwzLp+kOLq5QtK4lCRLnaChVhu7kq3b061U8RafueK5h+T5mRdy5wR/C3t1q94N1lYQmnXGQCSsLHofVD9P5Vs0+U5nK6IZNLaO9kSYZy5IyMc9McdulbOn+I2spoLCePfKMIsg5GDwBjvWrf/YFAhnmQ5H7tSfnHsCeo9OahsdJtmvUluPKdQQM3Ecquo9MjANCaktTJ3M3xRomo/bLa6kiWQZKwoo5Vic9KsQwjTdKuLmR/mC+XyOSoUFz7/dwPUkV6Jqt5o1np8dzEkEkiqEG0Y49CTzjivDPiDr95PdNaCNlSdQQ+MAr/AHV9s4z6nFS10RcdXY1YvHMfiFVsobI29xHiV5FffHhTnjjPXAqXxTdKvhmztmYeZJIrAewQHP8A4+Kz/A3h6SyLRzvsuZiHlCjPloP4TnqSeoHp61uzWN74p8cn+zYYJItOwxWQ4R9hA29MZYjFKSSWhUfj0Mb4ix2ljp+iWFpcNIvkGaQeYXXJwoYZJwDt6DivMpDwT7103jG80+48QXj6VZtaWm4KsLYypAAboSBznpxXMN0A7mlTjyxsdlyrPzIPpSwSNBcRzIcNGwYfUHNIWR5Gyec4FPEQPRs/Sra7iT1uj0pL15VSQ4ZWUEcY4NWk2yKGXkfyrjtK1hbe2S3ut/y8K+M8ehrYg1e0Vw6XKficZrwKuGnCTVj6WlWp1YJp6m35ftSGL2NQp4h0rA3SgN3AII/nTv8AhINJP/LY/kP8aw9lPsPmXcf5fsaXy/Y00a5pJP8Ar8fl/jTv7a0r/n5X8SP8al059hqce4eX7Ux4iGR/MaMggZHcEgY/l+VOOt6SP+XlD9CP8abJrGkyxtG04wwwen+NOEJp7MblF6XJcOP+Wjfp/hS4k/56P+AX/CmRa9pRiQvP8+Pm4A5796X+3tH/AOex/T/Gm41L7fgF13HbSessv4bf/iaXb/00n/NP/iaZ/b+kjpL/AC/xo/t/Sf8Anp+q/wCNLlqdvwD3e4/aP+etx+af/EUmwf8APW5/NP8A4im/29pH/PX9V/xpf7e0j/nr+q/40ctTt+Ae73HbfSa4/NP/AIik2d/OuPzT/wCJo/t3SP8Anr/6D/jS/wBu6Of+W/5lf8aVqvb8Cvc7/iJtP/PWf/xz/wCJo2HP+um/8c/+Jpf7c0j/AJ7j8x/jR/bWlH/lsP0/xo/e/wAv4f8AAC0O/wCIm1v+es3/AI5/8TRtb/nrL/45/wDE1INX0k/8t/5U7+1NKP8Ay3/8dNF6n8v4f8AfLH+mRbZP+esn/jv/AMTTdsv/AD2f/vlf8Ks/2jpn/Pc/98H/AApf7Q03HE//AI43+FLmn/L+C/yDlRV2T/8APdv++F/wppS4I/4+PzjFXRe6ex/16/ip/wAKd9psSf8Aj4j/ACP+FTzS7fgPlRm7Lrtcx/jD/wDZUeXd/wDPxD/35P8A8VWl59j/AM/Ef5H/AApfMsj/AMvEf60ueXb8A5EZgjvP+fmH/vwf/i6Xy7zvcQ/9+D/8XWmHsv8An4j/AFpc2Z6TpT9o+34BymV5d3/z8Q/9+D/8XR5d3/z8Qf8Afg//ABdapFt2mj/Om4g/56x/99Cl7V9vwDlMspd4/wCPiD/vwf8A4umxrP8AaP3skbgIeFjKYyR7n0rUZIT/AMtov++hTY4EcyMrKQDtz9P/AK5NUqmj0/ATVigQf7v5GmkHH+rJ/EVqfZV9RSG1A7ip5kMzUOxgSjAe2DVnxdcG28HzHIy8aoAf9o/4U+VYoULO6gDnGeTXG+NNae6t7ezJJAO8j0wMD+tbYai6teFtk7meIqqnQk/I5CNPMlRM43EDJrs7p9t6VBOAgAyMcDj0FcXFJsmjf0YGux1QGO+LOwZiATgYxX073Plrk/hdbuXxHDHYSpHdPHMI96bgx8tjtx79PxrY8IvPCNfhZPLulkXMeOhBbI/PFcvY6ncaLq9vqNoV8+3cOm4ZGfcd62vD3iBbvxjLNLFFZDUVMTCAbUWTqDjPGSP1rJxblcU/hOz8MHfpOoCWaK3CXDgtIwULk5HX2o8aWMZtLe+s1SaLem8qxIcc8gjtyBn2rz7xxpzpcC5jA8vaCRjBH/6jx+VbPgHxWj2jaFqCmQSDbEQB6Yxz37f55uztc5nHqjXtrtNGu1LOrRzjMixrjZjpg9TjvW8NStrqCV4bm3klYfKiEkntyOw+tYWp6JK7OLctNCihcIMsn+yQcfTkio/D2mXVjq8cs0Gy3zhi5AZR643c1Voy1M3ojSXwFLHLZ3zGNEmmjk29TgHP4cZrB8b+GrvUbCPULKJTFA8jyIWAIUhACM9eF5r1ee6W5hFnYh3Ljb5rDC474/lWdqcUAiXSIgsyxFZr3J4UZyqfVmA49B7ik3d6BGUtzi/DjSWA01UY74wsLDHQkAEfgTVDxVcySWttHKSW3ZBPoEUf1rvLHSo7YJNO2JcnaMdO5J+nJ/KuE1q2Oq+KLXSrf5Sg8t2c8IfvOT7KOv8Au0pKyNKUrzuReN7LToPDmk3Vu9u166qkvlSZJXykPzLng5J5715tN/qX6f5Nd98StTS91O1tnslt72zh8i5KfcbBJTae67SCM+tcdbaZe6mWhsraa4k4JSGMscepwOmcfnUU9InU3oUtNgSW+iErqkYOWLHHTtXZrr8VvCkS3SBVzjbz1NUbP4b+Lbv/AFWiTr7yssf/AKERW9afBnxLMitPLYW+eqPKWZf++VI/Ws69GFVpyZ0YfG+wi0ktTIl8TgcJNM49uKpv4ikkJAhdx/tS/wD1q9H0/wCCFusatqOsyu5HzJbwhQD9STn8hXa6J4C8P6B5clrp6yXKDH2if52J9cHgH6AVksPRXS455nVezt8jwqBdevQhs9JuHRxlWS3dgfxxita08HeO70Ax6XJCCcEzGOLHvhjmvoJmO371Rl/9oVSjBbRRyzx1aXU8p0f4Y6+rONS1G3COmADNK2w+oClcn8cVrQ/CSy+1l77Vpbq1PLQLbJEW9jIPmx+vvXemT/aH4im+YT3Wq5uxzSqzerZix+BvC8TRFdEtP3Qwu5M/nnr+OasS+H9DQADRbBnY4Vfsyc/p0rReXapPJ9MDrSQI6Au5QzN95gPyA9h/9fvRzMhyZFa6Nplngw2FoknXekCqc+2BxV0p/tGmeZIvp+VBmfPQH60mTds8im8P+Iw26WyuJGyT8ig4HbBqE6R4oSFCNKumkThdqAZHPXnrivXgx/2acHY8cVn7NGvtF2PI49F8SBY2Gk3eVzlCAOT/AEoOkeJS4X+y7oqM7iY8E/TmvXstjtS5fsRS9nEftV2PHptO8RxWnmvpd+zEj90sW45yPT2zTfsHiI/8we9KhAwBhPX0r2Vd3fFL83bFHs4h7RdjxZrbxJGQJdJvmEvZYWOwZ9cU0W3iJMu+m3CiRQoURHK9ueK9sAPc/rSgkd6XJEftF2PGTba2AYjZTruP9xuBn8v8/hUaxaztkL2sw2/KoMDZz9MV7Vz/AJNHP+TR7ND512PE2GsICwtXJ9RG3P4Yz3qRJdR2MWsrlWXB5hYZ5+le05b1pwLDrS9kg9oux4oLnWNzbbByM7gfLP8ALrWfr8N7e2E8txaSDycNG5BGQeDkfrXvjSiNd0jBF9WOBVW5vdMuraa2nv7MxyoUdTOnQjB71cKfLK6Gqi7HytISpIzyPSo8k9a2/FeiHQdZksxcRXMY+aOWJg29D0Jxnn1FYitjBFd8Wmi9zu/C+rDVrV9OvyZZEAwN3zyKO6/7Q9O4x6VNf6NJbyl0dsnDAqOvow9/cc+orh4zuIZThgcgg45rt9I8WIsAtdWj3DvMF3B/99fXH8Qwau9jCcGndHNazba2bw3kNzJc7xtKqOQPTb3HuOK1PCmu6zJqNvp9w00MB3DcqFADgkZxgcniu0tU0jVFY2l9GhLfcEynj6Ptb9D9auwaLMswbe23++I8nH/fOKLJkOelmi7pWkS6rKCDJMyZ3EnIX8TwP51X1rwtP9uj+1WzyQryrtgJG2OD6sf/ANWK7fQL3TdLscS3qB84PmMob8FFUvEuuSXkBg0qN/MdSv2hl+6Mc7VPOfcj86yk1EIq5wOszR6Bp8dvBzqdwpX5h8yqerbex6Yz9cDFQNnwj4Ha+i1J7fVLhlKRIwwwO5ee5Iw+fQke1XbGLSvB5tta1WVLgXgdFYN5snQ5Yc5PIAJOOteW+JNfute1N7m4ldlHyxKxHyJk4HHGeeT3OTWWs5W6HTTikjGlfcx5qrLIUVmHpgcVI5ydufqaoTyb2AByqjH/ANeuhItsYOtdB4a0J9WvNzq4tYiDIyg8/wCzn3wau+EvBE/iC4Sa8vLfTtNB+e4nkUM3sik5J9+n8q+hNLv/AAjoOmQadZahp0UEK4A85cse7H1J9azqydrR3IvY8mk8I6LKSsaXUYA/glOT/wB9ZqI+B9JVyUuL3HUKzLnH/fNezN4l8Lt97UtOb/gamk/4SPwvuDfb9OyOMgrXHar/ADFe08jxaTwTp5LFJ7xSCRlowwGPwFRt4HtghYX0wHZvKBGfzr27/hI/DB66hp/5ikHiDwp/z/6Z+a/4Ufvf5vwGqnkeLP8AD+BU3jVX2nHP2fp/49VKTwLcCSQR38O2PktKhX+RNe7tr3hKQfPqGlN9Shp39v8AhPcW/tLSsngnenNNOquv4D9p5HgEngjUUGVmgf6ZHHr0pD4N1JAdpifGMYbr/n3r6BOu+FGHOoaUf+BpUg1fw24+W+005H99KfNV7/gL2vkfPK+D9UbHESgvsyzYGfyqNvCGqLtLCIZYr9//AOtX0X9r8Osf9dphPrmOnG58OtjL6WQOmTHRzVe/4B7XyPm+TwpqsZAMSEnphqYvhnVJFDCNNp6HdX0j9o8OBdofSguc4zHjNHmeHe7aX+cdHPU/pC9r5HzanhfVpArJbhg/TDAfzxUT6DqaY3Wj89MYPfH86+mRJ4dbjdpZHpmOgDw9nj+y/wAPLo56ge18j5pk8N6tGAzWpwe+9f8AGoX0XUoyAbKfJzwEJx9a+nPK8PNkbNMbPUfuzThDoWc+Xp5PrhKaqVB+18j5kk8P6tGqsbCYqwzlRuA+pHApg0HVD5hFhOfLOGwmfy9fwr6eW30MfdgsQPZE4pTa6LsGbay2qd2Si8e9HtJh7U+Xf7I1DdtFnPnGceWc4oGk6iWKrZXBYdQIicc4r6YSbwvPmNJtLfZ1XfHxSm38MnqNKOOR88f+NHtJdh+2PmZtN1Jd3+i3I2gMfkPAPelXTdWJ4tbrOccIf896+nE07w/cA7LewkH+ztP8qVtE0I8mxsz7bRT9pLsL2x8wCz1R1LCC7YDrhG4pf7O1UDd9lu8euxv89xX1B/ZWjAHbZ2wyMH5BTv7L0lzlrS2fH+wDR7SXYftj5dey1OMZe3ulHqUamSJfQ/6wXCc4+bcK+pv7J0ncG+xwbgcg+WOKH0vSZE2PY2rqTu2vApGfXkdafP3Qe3fmfKvnXA/5aS/maX7Rc/8APWb/AL6NfUh0PQyf+QXYf+Aqf4Un9h6F30rTz/26p/hT512D6zLufLn2i4/57yf99mlF3c9riT6bic19Rf2JofbSdP8A/AVP8KX+xdEPXSdO/wDAVP8AClzrsP6zNdT5eF7eZ+WeQdzzT0vtRK4hnnIzwFr6ujaONQke1VAwFUYAHpT959TReP8AKH1up3Z8oSXuqRY8yW4TPTdkZqxDD4hu5AkFtqcrMMgRwu2fyFfUrfvFwVJ/ClXzY1wAzgdFPUfQ1N4/yi+t1O7PlTVl1/QLmOLUYbm2lkjEiLOOqn/9XSucuriW5naWViznqa+svFvhWw8ZaLJYXOI7lPmgmKfNC/8Ageh9fwFfMfifwnrHhW/+zaraNCW+5IPmSQeqsOD/ADrai4PVKzCVec42kzCDV2Ly/btLgvE5GAsihOjAcnj6da4w1saHeKvm2cr7UlwUJGQrDvj6ZrdozTsXZfm59qq4KOCpKkHIPcVZIKllbscGo2HNCNHqeh2N1F4o0Uu+wXSfLPG3OTjG7Hoe/p+FZekaemgalLcwQeZNu2eW/wB9Af7nZs/nXL2N7Pp90lzbOUlQ8eh9j7V3dv4g0rWrYRzubK6IwVbGwn2P+f61VkzmknH0N2LV9PuWAm2JMOCsqlHHtg4NR3TXj3Df2bNpkMKRbpZb+ZgqZJAwoPPQ9c1nyaVcG2dIpmaFgCudwT2Pdf0qvYaRNazbmvLTB5IURA/otT7HqmZOaM7SL/xGPFy3dlqMtwFkEf2nZshdOmAp42+gr3vRND057ANEG8x38yWXdlpJD1Zj3/pXnVhYRo3ms7Pk581YyVH1Y/KPxIro7PxZDZKkVv8Av2j6RxOGB/33xgf7q59zSfKhKfMzT8SxRaZazyNKhwm2KNl+8euB/X2GO9ea6PayQx6t4ia7iSeyRpGjmXcLhWyHQ9/myBx611OpNLfkapqT+WkhYK+07IwoJ5IGFHHU/wA6848e+M011ILGzlme0jZZm8xQB5mxVwoAyFGD165zWLfM7I6acEjk9Z1K41fVbi+uWDTTuWbHQegHsBgfhXrfwb0gw6bd6rJGwMxEMRPQqOWI/HA/CvJNG0q71zV4LCziMk0rYAxwB3J9AK+oNOsItM0y2sYB+7gjCLwBnHf8etVPRWCrLSxazjsKAw9P1pCD6UmD2WsDAdv9v1o8z2pu0/3aPLPpSAGlyOVH60wlT1UfmaUo3pSFH/u/nQBGyoevX86aI1JOCp/SpCjE/dB/Gk8pj/CB+NAiMx/MDsY46YBPNKZQDg7gad5Lj+DOKCjkYIPuDTQCB165el3Kf4j+NJgjqin07fypCueMEfrQIn2D0pdg9D+VHngdf5Un2pR/CTWZQ7aB3I/CkJX+/wDpTftS+hppuU96Vxqw8lf79JuHHz1H56n+E0hkU87T+VTdjsibeo/i5qG6vfs6Bktri5JONkIUkD1O5gMUocHscVkeJLPWb+xWDRr2Gzcn9475DEezDp+X404u7KsN1LxbZaTGHv5prDd91JrMsx/J8VgS/FTSlBEV5Ox7E6fwf/Iormrz4ZeIriZpZb20nkbks0rkn8StUH+F/iUE7IYHHtMBn866oqC3Y9C/qfxX1aWd0sBbxQcbZDBhz74LMB+tYT/ELxPyBrNyM/3SF/kKs/8ACsvFP/PjH/4EJ/jTT8L/ABSf+XGP/wACE/xrRciKTic9fa/qOoHde3k9yf8AptIXx+ZqkdQkA4OB7V1p+Fnik/8ALin/AIEJ/jTf+FUeKT/y4xD63Cf40+aPcfMjjpb55F2uSy9wTVfcA+A25T37iu2Pwm8Vk8WUP/gQn+NNPwn8WLk/YYcDrm5QD+dPmj3KUkccjlDwa0bW+RcK4BHoazb23+wXT27zQyOpwxhkEij/AIEOD+BqJZB2aquDsztbR9KmUeaCv0rorJvDqIPNugB6Fa8rE2OjEfjSidv+eh/OhszdK/U95GpeG9I0BL9by3zNHIYYvMG5nUkAbAM4ODzmsDUPivBp2pRvotos0CQFGa4GC7tgk8c4GMe/NeSGQ9S1NMgPesnC71LjBJF6+1a7vhGs8zOIwVRSeFBJJA9OSTWa8nYcn1pHJPSo/KZh0IrRJbFNkEsmflU8dz60yJ2icOuNw6ZANWhaMR92lFkx7VVhXH/2tfMctOxJ7mnjVLnHMhNN+xGpE06V/uoT+FKyGmA1O4/vmnDUrj++alTRbthlbeU/RDU6+HdRYgLZXBJ9Im/wpOw1Iqf2jP8A36X+0Z/79akfg3XZRlNHv2HqLZv8K0Ifhp4quIjLHo8oQdfMdEP/AHySCfypXiPmOb/tGf8AvUv9ozf3j+dXpPC+rRMVl066Rh1DQsD/ACpo8Paj/wA+U/8A37P+FF0HMU/7Sm/vfrQNSmH8X61dPhzUP+fKf/v2aQ+HdQ/58p/+/Zp6BzIqf2pP/e/WnDVph3P51Y/4R3Uf+fKf/v2aX/hHdR/58p/+/Zo0C5ANYm9f1o/tibuT+dSnw9qA/wCXOf8A79mmtoN8Bk2kw/7ZmloFyP8AtaU//rpP7Vl/yad/Yl7/AM+03/fBpP7Fu/8An3l/74NPQNBP7Vk/yaP7Vf8Auig6Pdj/AJd5P++DSf2Rdf8APCT/AL5NLQNBw1Vv7opRq0gPAAqL+y7gdY2/Kk/s2b+4fyo0DQsf2vL2P60f2vIevP41X/s+b+4fypDYSgfdpj0J11Mq25VAb1AqT+2pfU/nVL7FJ6Un2N6BOxfGuTDufzpRr06n5XZfoaz/ALG9H2N6BGl/wkN1/wA9pP8Avo0h1+5brM//AH0azvsb0n2V6LArGh/bk/8Az0b/AL6NL/bc/wDz0b/vqs/7K9H2V/SiwaGh/bc//PRv++qP7cnH/LRv++qzvsr0fZXoDQ0v+EguR0mcfRjS/wDCSXn/AD8S/wDfZrKNo/pTfsz+lAaGyPE98Ol1MPpIacPF2qpwuoXQHtM3+NYn2Z/Smm1k9KYtDeTxjqkcgkW+uRIOjiZgR+Oaj1HxfqOq2ptdRuri7hzuCTys4B9Rk8H3rE+ySelH2ST0pWQFKdULkxqVHoTmo13KQRkEcgir/wBjc9qabR89Komxet70Xcah+JUXGB3HsKeW59qzhbujBlyCOQRVlbgkYl6jv61JaZOCR1qZGB4JwKq7yehpwfj0+lNMGbdjqeoWChbW+uIU6hY5CB+XStqx1/Xby5jt47+4eWRgiKMZYngDpXGCRl/iqxbX89rOk0MhSWNg6OOqkHIIpt6EOCe56fLoPiOaUjWL1o412eYtxPu2qzBQSoJ4ycdK07680rwbrmn2N8Glt3jEsssZAKcsMbfqBXk1zr+pXXmebeysJAquA20MF+6CBwQO1Z0tw8jZdyT7mseWT3YciR12r+PdVu9Kk0eG4MenmaR9o4ZwzFtrHuBnpXGvIScnrTWf0NRnJq4xUSjf0LX7vQZHm0+6kt5pF2u0Zxkelby/EfxH0/te4/MVwg3DsaeA2eKuxLSZ3q/EjxGOmqy/jj/Cnf8ACx/EnfVJD/wFf8K4MB6eBJ70WQuVHdD4jeISedRY/VF/wp3/AAsXxF/0E3H0Vf8ACuEAf3pwD+9HKuwcqO6HxD8RHj+05PyX/Cl/4WD4j/6Ckv5L/hXDDeD3p4L+9Oy7C5UdqfiD4k7arJ/3yv8AhR/wn/iQ/wDMWk/75X/CuLG/3p6lsd6El2E4o7QePvEn/QVk/wC+V/wpR498Rnrqkn5L/hXGhj70/efenyx7E2O3tviL4gtn3PcRTr/cliXH5jB/Wte3+K1zuButMhde/kyFP57q8z3H3pQT70OnB9CbH0mCT2I/AUAdMseKT5/XFJhz/EPxrzrGdx3ydxn8KVdn900gU9z+VOANILigr2BpwAP/AOqmYPFKM9P6U7Idx/A7jP0/+vS9v/rVHgjr1oI9OKLBzEgHc/y/+vThgdGP5VEDjuPzo349KLD5ifp/F+lLv9x+VVvMPqBRu47UBzFoOPUUu8f5NUgx9qM+p/WgOYubyOgFJ5p9Kq7vcUb/AKfnQFytdaFod67Pc6Fp07scl5LVGJ/EiqD+CPCjnLeHdPB/2YwP5Vs78DJzVGTVDKfKsEMzlipkx+6THct357Lk/TrT5mPmZlzeB/BUAD3Gh2cYJwMlhk+gGeT7VWj+H/ha+IYeHIraPceCz73HbPzYX6cn6V0FpYiMrNczNc3QH+ukAGPZQOFH069ya0I1564p8zHdnPJ8NfCgA2+HoD9Wc/1p/wDwrfwt/wBC7b/+Pf411CySIOGNP8+RhkM350+Z9xXZzC/DzwmB/wAi9b5/4F/jT18A+FQMjQbUfgf8a6MyN6tn61E8rep/OjmfcLswx4L8MR/d0Oz+hhB/nTx4W8PJ93Q7Af8AbpF/hWp5h54agtnnkVLk+4XZmr4e0dDlNKsl+lug/kKsJZW0J/dW0Sf7qAVYJX3pCR/tUrjuxoG08KB9BThg9VH5Um7rwaNx6YNJsabHcAfd/KkyvdT+dG446Yoyx5pXGLlB2/WnBk/un86YT14o59KLjJg6Y+5/49/9anB0/ugfj/8AWqDn0H5Uiludygc9jmjmYFgSJn7n/j3/ANaneZH/AHP/AB7/AOtVbnjtScjH+FK4y2Jov+eZ/Ol82I8eXn8ap7j60mT7UXYXLu+L/nl+tJvi7RH86phwSRlTjqM07zD7fnRzMdyyzRn/AJZmmFYWHKfoKi8wHt+tG4e3Si4D/Kt+nlfoKaba1JyYQfqopu4A9aXzF7/zouAhsbJutuh+sYqJ9J05z81lbt9YVNWN6eppQUz1PT1pXYXKR0PSj1020P8A27rTf7C0j/oGWn/gOtX2Kg9aBg/xfrRcVzPOg6R/0DLT/wAB1pv9haR/0DLT/wAB1/wrTKjJ+cfnTdv+0KLgZ39haQf+YXZn/t3X/Ck/4R7RTydIsT9bZP8ACtLYO5FGweo/OncDN/4R3Qz10fT/AMbZP8KP+Ea8PnrommH62kf+FaYhB7r1/vCjyfTH5ii7AzP+Eb8Pf9AHS/8AwEj/AMKafDHhvPOg6Zn/AK9k/wAK1Rbk9MfnThat7fnT5mBjnwp4bPXQ9M/8Bk/wpp8IeGT/AMwLTvwt1/wra+ysO6/nR9mP94fnRzMDEHg3wz30Sx/CIUh8FeFj10O1/BcVuG3x3H50ogz/ABL+dHNIVznv+EI8Lf8AQEt/1/xpp8B+Fm/5gcP5n/GuhMDDoV/Ojyj6j86fOwuc4fAXhZeuiQ/99N/8VR/wg3hUD/kCW347j/Wuj8vdgH+dIYcdKOZiOabwH4UY5/sW3z9GIP4ZrJvvhd4UvXYC0uLEnoYJiV/8eBxXctCev9aTyTzwfzp88u4XPL5/ghpJY/Z9Wvoz/thGH8hVQ/A5c/L4kcfWyB/9qV6w0BVSIiYz7dPy6U3zJEYiRGA7MuSP8R/L3qlVl3DmZ5SPgax/5mU/+AP/ANspf+FFv/0MZ/8AAH/7ZXrKzpgEfMD3BpwnT+6fzp+1l3FzyPJf+FFSH/mY/wDyR/8As6T/AIUQxPPiHP8A25f/AGdevi6j7o3/AH1ThdR/3X/76p+0l3DnZ5CPgSR/zHx/4Bn/AOLp3/Cjgp51sH6Wn/2devC8Vf4H/Og6gOnlfmaftJdw52eSD4LRL11r/wAlP/s6X/hTUX/Qb/8AJP8A+zr1hruJvvREfSomkibkK4o9pLuHMzzBPg3bA/Pq8j/7tsB/7MauR/CHRl/1l7fMf9kov81Nd8WXHBYUzd/t/rS9pLuLmZyEXwr8OxDDLdy+7y/4AVaT4d+G4xtOmB/dpH/xrpg2f4/1pSf9r/x6lzy7hzM5r/hX/hr/AKBSD/gbf40h+H3hrP8AyDF/7+P/AI10+R/fH500nPf8c0ueXcV2c1/wr3wz/wBAtf8Av4/+NL/wr3w1/wBA1Pp5j/410ZwOmaTcR3NHPLuFznT8PfDY/wCYYP8Av4/+NJ/wr7w3/wBAsf8Afx/8a6TzcDqaT7Rzg5p+0l3Fc5o+AvDo/wCYYP8Av4/+NJ/wgfh3/oGj/v4/+NdP54OaduBo9pLuK5XDH1NLu6ZJqvv9F/I0AtngEVJKLO/p1o349ar5b0NJyR0/WgCx5nNHm47n86gA9jTgB/d/WgLkvm57t+dJvpuP9ninKqnqtAXDzO3OaC/t+Zp2xD2oCL60DG59v1oP0qTYuOn40BAenSgCI8Z4pMn2qbyuTTZnit4XmmkWNFBZixwABQMZk+1Vb7UIbCNTJueRziKGMZeVvRR3/p34qGS9udQDR6ZGyRkD/S5kIUZ/uKQN/Hf7vuelaFhpFrbs0uwPcP8Afnfl2/H09hge1CQFGK2u9SQHUP8AR4GUZtYny3uHcdfouB15ataGKOKNI40VY0G1VXgAegFWhapg5wPxzUiwRr0HNOwDIo0bkhqmEcXqfypQoHQD60vXtTGJsQcjOaDwOAcUHpx/OomzUgK2DTCikUmD70u0kHk0gGbOMU0qKftPoaaVPPynpQMZtpCPwpxXnpTduPWkAY96MD3NGDzwaNvpSGLgYpDgdqUA/hSEHsKAFyPSjd7H86Z83oaUg45oGO3e5pufY0cjt+tNOQfumkA/J9D+dIT7HNM5/umjHqDiiwxCR3pM/Wl2jPek8sHvSsAnHrRu6UeUKBGR2/WiwXELccZqpJd3aPhbCRl9RIo/rV3Z7frRg4osFyvb3EkyZlt5IT6OR/QmrGQTS7fbjHrTwgI6UWHcYGHoaXdjtUgRaTyx6UWAbuBpQc9jTvLHPFLsA6UWC4gPPSl3f7P5Gl2A5/xpdg7ZoAbn2pCfqKcV57n8aClAXGZ9/wBKAzDnI/Kl2nPQ0m09OfzoC4od+/8AKlD5puxv8mk8s96Yrku760m4d800Bh1pdp6UWAduHGDS7j70zaaXZQIkDAjo3SlPPrTAo75/Onbf85phcTgdjTww96TA7/zoxnP+NArik5HQ0hz2FOB5/wDr07/PWmFyHcfQ0E+oqQr3IppUHt+NAFc2ybmeMmNm5OOhPqR0P86ryu0G3zlyuPmkRTgH3HJA/P8ACtDGBTSPWgCkHVkV0Ksjchgcg/SlEntinyWURZniJjkbqVPBPqR0NQsksQAljz/txgkH8Oo/X60XFYkEqk+/1pdwIFQAhl3DkeoNGcetO4ifK+tHy1X3fjQGHfI/GgCxxjqable/FRZJAw1HzUCH7kpwK5xUJB7gUhGDQFycbT0NBUZ4quQQeM0Bj7/nTsK5OV/CjYO5P51Flvel3MB/9eiwXJNoHajA9DUe49hS7x6frRYLj9opdo9vzpm+l3nHXvTFczlj6HYOtP2AfwD8RUgt3OMAdfWni3fA6D8aCSBVXqVX8qeAvTaPyqYQuPT86cEIHXt60DIlUE8KBTwh9vzqRVAIzg/jT+B1x7e9AXGCNj6/nS+VLng/rUvmLwOKdnjgjpQMgMMm37x59WNN+yseN789xK3+NWc+hAP1pwYDnI96AKwsSDw8h+sz/wCNO+zFT1b8ZG/xp13qFrp9u01zPHFGoyWdgBXKSalq3iQgWAl0/TifmupExLIPRFPTP94/rTsUjU1bWYNMljtkSe6vJMFLa3YlgM9Tk4Vfcmo00+4vZI5tVmWTy33pbRZ8pSOhbPMhHXnAz271NYaZaacri3iCtI26R2JZnPqzHk1dyM5H86BNjzPJjOc8+lL9rkx/9YVAwLKQHYZ/iGMj8xS4x6596AJxdzAZB59MCj7fP/ex+FQdB/8AXpCcAcfhSGWvt0w/iH5Un26bAJIz9KqFschR1o3c5xQBbF/Ngcr+VH26X0WqgYDtT8jrt5pBcnN/IOy0fb5scBfyP+NQkFgBjB/OkC+1AXLH9oTDjYp/A/40f2hIRgqv5f8A16r4JHvSFWHpmkMs/bWP8A/z+NIbtz/yzH51Dg9MGjbzjmgZL9qfOCi/nTvtJH/LMfnUOOen60EfWkBObpgOEH/fX/1qPtR7oPz/APrVBg4PagjuKAJvtXP3B19aX7Rnt+tVtpx1zzThSGWvMJ/hH504OD1H61XBPbA5xmgE98UwLG4dSD+dGFPYn8ag3c/z5oB9T9KB3Jwqen60YXt/OoMnPBpAxzgmgLkxHsD+NKCTjC/rUIc98YoMpzwP1oAl59B+dJkg/dGPrUPmtjnr9aPMPQntQFyXceOP1pRI3ZePrUJOcfTrSkk+nT1oC5L5rf3DS+Yc52H8/wD69Q7iAcn8qPM4PP50rBcmM5/55n9P8aTzjnlG/DH+NRb8Z4H50hkx9O1AE3nHk+W36f40n2og/wCpf8x/jUZfrzSE9/60wuSm7P8Azxkx/wAB/wAaT7XnnyZR+X+NRbm/D60bj7UguTfae/lSfp/jTTc88wTfp/jTA5/ClLYGT0osK48XIH/LGX9P8actyP8AnlKPy/xqDdwCBnn1oZgew6+tMLljz1HRG/Kl+0AfwP8AkP8AGqwbkY6fWnA8Z/rQBN9qX/nm/wCQ/wAaPtS8fupPyH+NQdSMg/nSgD0P50Bcn+1oDyjnHoKQ3yqeYZceoXNQgD0pe3pSAm+2Rnosn/fJpftUQ/56f98H/Cq/PXA6YoHA6fWmIsfaoh2f/vg/4U4XkIP8f/fDf4VVyucU/cB6Y+tAFn7RF2Y/98n/AAo+0R5+8f8Avk/4VV3c5yKcHHrj8aALP2iI5w4/I0nmJ13j9ahGDSgDp/WgVyQzRj+IUn2iP+9Ue3OTj9aNv0FMZBNFG0pkjYo56lejfUdDVZ52gAE67gWI3RKxwPcY4/M1ocAUhUGhCKasrAEK4B5BPFH8I4b8BUzwg9DtPtVdvlI3AJnuW+Un69vxpiJVZeM7h9QaeGB7n8jUXp1/OlC8j1NNCZJnjO4YpmByc0oGRnP60uD/AHv1oFcZ8v8AepDs9T+dOwfc/jRjsDyKAG5QA4OfxpRICOmKQqeeCM+9JsOM5oAcGQnqKUlfVfxNRhev9DS459/c0wA4Azx+dISnTcP++hSH3/nSHOeCPzosK5//2Q==" + ] + } + }, + "widgets_values": [ + "[{\"x\":374.36899413239337,\"y\":315.67555013706055},{\"x\":377.5416127267357,\"y\":142.76783674540425,\"fix\":null}]", + "[{\"x\":374.3689880371094,\"y\":315.675537109375},{\"x\":374.4350891113281,\"y\":312.07330322265625},{\"x\":374.5011901855469,\"y\":308.4710388183594},{\"x\":374.5672912597656,\"y\":304.8688049316406},{\"x\":374.6333923339844,\"y\":301.26654052734375},{\"x\":374.6994934082031,\"y\":297.664306640625},{\"x\":374.76556396484375,\"y\":294.06207275390625},{\"x\":374.8316650390625,\"y\":290.4598083496094},{\"x\":374.89776611328125,\"y\":286.8575744628906},{\"x\":374.9638671875,\"y\":283.25531005859375},{\"x\":375.02996826171875,\"y\":279.653076171875},{\"x\":375.0960693359375,\"y\":276.05084228515625},{\"x\":375.1621398925781,\"y\":272.4486083984375},{\"x\":375.2282409667969,\"y\":268.84637451171875},{\"x\":375.2943420410156,\"y\":265.2441101074219},{\"x\":375.3604431152344,\"y\":261.6418762207031},{\"x\":375.4265441894531,\"y\":258.03961181640625},{\"x\":375.4926452636719,\"y\":254.4373779296875},{\"x\":375.5587463378906,\"y\":250.83514404296875},{\"x\":375.62481689453125,\"y\":247.23291015625},{\"x\":375.69091796875,\"y\":243.63064575195312},{\"x\":375.75701904296875,\"y\":240.02841186523438},{\"x\":375.8231201171875,\"y\":236.42617797851562},{\"x\":375.88922119140625,\"y\":232.8239288330078},{\"x\":375.955322265625,\"y\":229.2216796875},{\"x\":376.02142333984375,\"y\":225.61944580078125},{\"x\":376.0874938964844,\"y\":222.01718139648438},{\"x\":376.1535949707031,\"y\":218.41494750976562},{\"x\":376.2196960449219,\"y\":214.81271362304688},{\"x\":376.2857971191406,\"y\":211.21046447753906},{\"x\":376.3518981933594,\"y\":207.60821533203125},{\"x\":376.4179992675781,\"y\":204.0059814453125},{\"x\":376.48406982421875,\"y\":200.4037322998047},{\"x\":376.5501708984375,\"y\":196.80148315429688},{\"x\":376.61627197265625,\"y\":193.19924926757812},{\"x\":376.682373046875,\"y\":189.5970001220703},{\"x\":376.74847412109375,\"y\":185.9947509765625},{\"x\":376.8145751953125,\"y\":182.39251708984375},{\"x\":376.88067626953125,\"y\":178.790283203125},{\"x\":376.9467468261719,\"y\":175.18801879882812},{\"x\":377.0128479003906,\"y\":171.58578491210938},{\"x\":377.0789489746094,\"y\":167.98355102539062},{\"x\":377.1450500488281,\"y\":164.38128662109375},{\"x\":377.2111511230469,\"y\":160.779052734375},{\"x\":377.2772521972656,\"y\":157.17681884765625},{\"x\":377.34332275390625,\"y\":153.57456970214844},{\"x\":377.409423828125,\"y\":149.97232055664062},{\"x\":377.47552490234375,\"y\":146.3700714111328},{\"x\":377.5416259765625,\"y\":142.76783752441406}]", + 720, + 480, + 49, + "path", + "basis", + 0.5, + 1, + "list", + 0, + 1, + null, + null, + null + ] + }, + { + "id": 75, + "type": "DownloadAndLoadToraModel", + "pos": { + "0": 1074, + "1": 937 + }, + "size": { + "0": 315, + "1": 58 + }, + "flags": {}, + "order": 3, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "tora_model", + "type": "TORAMODEL", + "links": [ + 193 + ] + } + ], + "properties": { + "Node name for S&R": "DownloadAndLoadToraModel" + }, + "widgets_values": [ + "kijai/CogVideoX-5b-Tora" + ] + }, + { + "id": 66, + "type": "VHS_VideoCombine", + "pos": { + "0": 1485, + "1": 436 + }, + "size": [ + 605.3909912109375, + 714.2606608072917 + ], + "flags": {}, + "order": 20, + "mode": 0, + "inputs": [ + { + "name": "images", + "type": "IMAGE", + "link": 203 + }, + { + "name": "audio", + "type": "AUDIO", + "link": null, + "shape": 7 + }, + { + "name": "meta_batch", + "type": "VHS_BatchManager", + "link": null, + "shape": 7 + }, + { + "name": "vae", + "type": "VAE", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "Filenames", + "type": "VHS_FILENAMES", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "VHS_VideoCombine" + }, + "widgets_values": { + "frame_rate": 8, + "loop_count": 0, + "filename_prefix": "CogVideoX-Tora-trajectory", + "format": "video/h264-mp4", + "pix_fmt": "yuv420p", + "crf": 19, + "save_metadata": true, + "pingpong": false, + "save_output": false, + "videopreview": { + "hidden": false, + "paused": false, + "params": { + "filename": "CogVideoX-Tora-trajectory_00011.mp4", + "subfolder": "", + "type": "temp", + "format": "video/h264-mp4", + "frame_rate": 8 + }, + "muted": false + } + } + }, + { + "id": 90, + "type": "Note", + "pos": { + "0": 339, + "1": 1066 + }, + "size": [ + 251.63747656176258, + 73.90463053872986 + ], + "flags": {}, + "order": 4, + "mode": 0, + "inputs": [], + "outputs": [], + "properties": {}, + "widgets_values": [ + "Three sets of coordinates are created here and appened to a list" + ], + "color": "#432", + "bgcolor": "#653" + }, + { + "id": 92, + "type": "Note", + "pos": { + "0": 1200, + "1": 1045 + }, + "size": [ + 251.63747656176258, + 73.90463053872986 + ], + "flags": {}, + "order": 5, + "mode": 0, + "inputs": [], + "outputs": [], + "properties": {}, + "widgets_values": [ + "Coordinates are used to create optical flow video, which is then encoded for Tora" + ], + "color": "#432", + "bgcolor": "#653" + }, + { + "id": 79, + "type": "CogVideoSampler", + "pos": { + "0": 1089, + "1": 17 + }, + "size": [ + 330, + 570 + ], + "flags": {}, + "order": 19, + "mode": 0, + "inputs": [ + { + "name": "model", + "type": "COGVIDEOMODEL", + "link": 204 + }, + { + "name": "positive", + "type": "CONDITIONING", + "link": 197 + }, + { + "name": "negative", + "type": "CONDITIONING", + "link": 198 + }, + { + "name": "samples", + "type": "LATENT", + "link": null, + "shape": 7 + }, + { + "name": "image_cond_latents", + "type": "LATENT", + "link": 226, + "shape": 7 + }, + { + "name": "context_options", + "type": "COGCONTEXT", + "link": null, + "shape": 7 + }, + { + "name": "controlnet", + "type": "COGVIDECONTROLNET", + "link": null, + "shape": 7 + }, + { + "name": "tora_trajectory", + "type": "TORAFEATURES", + "link": 200, + "shape": 7 + }, + { + "name": "fastercache", + "type": "FASTERCACHEARGS", + "link": null, + "shape": 7 + }, + { + "name": "num_frames", + "type": "INT", + "link": 201, + "widget": { + "name": "num_frames" + } + } + ], + "outputs": [ + { + "name": "samples", + "type": "LATENT", + "links": [ + 202 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "CogVideoSampler" + }, + "widgets_values": [ + 49, + 40, + 6, + 3, + "fixed", + "CogVideoXDDIM", + 1 + ] + }, + { + "id": 80, + "type": "DownloadAndLoadCogVideoModel", + "pos": { + "0": 118, + "1": -85 + }, + "size": [ + 378.8459921214321, + 218 + ], + "flags": {}, + "order": 6, + "mode": 0, + "inputs": [ + { + "name": "block_edit", + "type": "TRANSFORMERBLOCKS", + "link": null, + "shape": 7 + }, + { + "name": "lora", + "type": "COGLORA", + "link": null, + "shape": 7 + }, + { + "name": "compile_args", + "type": "COMPILEARGS", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "model", + "type": "COGVIDEOMODEL", + "links": [ + 204 + ] + }, + { + "name": "vae", + "type": "VAE", + "links": [ + 205, + 206, + 224 + ] + } + ], + "properties": { + "Node name for S&R": "DownloadAndLoadCogVideoModel" + }, + "widgets_values": [ + "alibaba-pai/CogVideoX-Fun-V1.1-5b-InP", + "bf16", + "disabled", + false, + "sdpa", + "main_device" + ] + }, + { + "id": 93, + "type": "CogVideoImageEncodeFunInP", + "pos": { + "0": 623, + "1": 79 + }, + "size": { + "0": 380.4000244140625, + "1": 146 + }, + "flags": {}, + "order": 12, + "mode": 0, + "inputs": [ + { + "name": "vae", + "type": "VAE", + "link": 224 + }, + { + "name": "start_image", + "type": "IMAGE", + "link": 225 + }, + { + "name": "end_image", + "type": "IMAGE", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "image_cond_latents", + "type": "LATENT", + "links": [ + 226 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "CogVideoImageEncodeFunInP" + }, + "widgets_values": [ + 49, + false, + 0 + ] + } + ], + "links": [ + [ + 54, + 20, + 0, + 30, + 0, + "CLIP" + ], + [ + 146, + 60, + 0, + 67, + 0, + "MASK" + ], + [ + 149, + 67, + 1, + 65, + 2, + "INT" + ], + [ + 150, + 67, + 2, + 65, + 3, + "INT" + ], + [ + 153, + 65, + 0, + 68, + 1, + "IMAGE" + ], + [ + 154, + 65, + 1, + 68, + 2, + "MASK" + ], + [ + 155, + 56, + 0, + 68, + 0, + "IMAGE" + ], + [ + 156, + 68, + 0, + 44, + 0, + "IMAGE" + ], + [ + 166, + 72, + 0, + 73, + 0, + "IMAGE" + ], + [ + 187, + 73, + 0, + 60, + 0, + "IMAGE" + ], + [ + 189, + 67, + 3, + 78, + 3, + "INT" + ], + [ + 190, + 67, + 1, + 78, + 4, + "INT" + ], + [ + 191, + 67, + 2, + 78, + 5, + "INT" + ], + [ + 193, + 75, + 0, + 78, + 0, + "TORAMODEL" + ], + [ + 197, + 30, + 0, + 79, + 1, + "CONDITIONING" + ], + [ + 198, + 31, + 0, + 79, + 2, + "CONDITIONING" + ], + [ + 200, + 78, + 0, + 79, + 7, + "TORAFEATURES" + ], + [ + 201, + 67, + 3, + 79, + 9, + "INT" + ], + [ + 202, + 79, + 0, + 56, + 1, + "LATENT" + ], + [ + 203, + 78, + 1, + 66, + 0, + "IMAGE" + ], + [ + 204, + 80, + 0, + 79, + 0, + "COGVIDEOMODEL" + ], + [ + 205, + 80, + 1, + 78, + 1, + "VAE" + ], + [ + 206, + 80, + 1, + 56, + 0, + "VAE" + ], + [ + 209, + 30, + 1, + 31, + 0, + "CLIP" + ], + [ + 210, + 73, + 0, + 82, + 0, + "IMAGE" + ], + [ + 211, + 82, + 1, + 83, + 1, + "STRING" + ], + [ + 212, + 60, + 1, + 83, + 0, + "STRING" + ], + [ + 216, + 73, + 0, + 85, + 0, + "IMAGE" + ], + [ + 217, + 83, + 0, + 86, + 0, + "STRING" + ], + [ + 218, + 85, + 1, + 86, + 1, + "STRING" + ], + [ + 219, + 86, + 0, + 65, + 0, + "STRING" + ], + [ + 220, + 86, + 0, + 78, + 2, + "STRING" + ], + [ + 224, + 80, + 1, + 93, + 0, + "VAE" + ], + [ + 225, + 73, + 0, + 93, + 1, + "IMAGE" + ], + [ + 226, + 93, + 0, + 79, + 4, + "LATENT" + ] + ], + "groups": [ + { + "title": "VisualizeTrajectories", + "bounding": [ + 1124, + 1198, + 832, + 413 + ], + "color": "#3f789e", + "font_size": 24, + "flags": {} + } + ], + "config": {}, + "extra": { + "ds": { + "scale": 0.5209868481925474, + "offset": [ + 1223.1532630983777, + 259.0053418875374 + ] + } + }, + "version": 0.4 +} \ No newline at end of file diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_Fun_pose_02.json b/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_Fun_pose_02.json new file mode 100644 index 0000000000000000000000000000000000000000..5ee7e823d2f1a65c1f58902349dba75e50821160 --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cogvideox_Fun_pose_02.json @@ -0,0 +1,1121 @@ +{ + "last_node_id": 86, + "last_link_id": 195, + "nodes": [ + { + "id": 60, + "type": "WidgetToString", + "pos": { + "0": 1084, + "1": 76 + }, + "size": { + "0": 315, + "1": 130 + }, + "flags": {}, + "order": 5, + "mode": 0, + "inputs": [ + { + "name": "any_input", + "type": "*", + "link": 128, + "shape": 7 + } + ], + "outputs": [ + { + "name": "STRING", + "type": "STRING", + "links": [ + 129 + ], + "slot_index": 0, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "WidgetToString" + }, + "widgets_values": [ + 0, + "prompt", + false, + "" + ] + }, + { + "id": 59, + "type": "AddLabel", + "pos": { + "0": 1466, + "1": -5 + }, + "size": { + "0": 315, + "1": 274 + }, + "flags": {}, + "order": 14, + "mode": 0, + "inputs": [ + { + "name": "image", + "type": "IMAGE", + "link": 126 + }, + { + "name": "caption", + "type": "STRING", + "link": null, + "widget": { + "name": "caption" + } + }, + { + "name": "text", + "type": "STRING", + "link": 129, + "widget": { + "name": "text" + } + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 150 + ], + "slot_index": 0, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "AddLabel" + }, + "widgets_values": [ + 10, + 2, + 48, + 12, + "white", + "black", + "FreeMono.ttf", + "Text", + "up", + "" + ] + }, + { + "id": 44, + "type": "VHS_VideoCombine", + "pos": { + "0": 1842, + "1": -5 + }, + "size": [ + 1186.0863037109375, + 1457.6950174967449 + ], + "flags": {}, + "order": 15, + "mode": 0, + "inputs": [ + { + "name": "images", + "type": "IMAGE", + "link": 150 + }, + { + "name": "audio", + "type": "AUDIO", + "link": null, + "shape": 7 + }, + { + "name": "meta_batch", + "type": "VHS_BatchManager", + "link": null, + "shape": 7 + }, + { + "name": "vae", + "type": "VAE", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "Filenames", + "type": "VHS_FILENAMES", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "VHS_VideoCombine" + }, + "widgets_values": { + "frame_rate": 8, + "loop_count": 0, + "filename_prefix": "CogVideoX_Fun_Pose", + "format": "video/h264-mp4", + "pix_fmt": "yuv420p", + "crf": 19, + "save_metadata": true, + "pingpong": false, + "save_output": true, + "videopreview": { + "hidden": false, + "paused": false, + "params": { + "filename": "CogVideoX_Fun_Pose_00001.mp4", + "subfolder": "", + "type": "temp", + "format": "video/h264-mp4", + "frame_rate": 8 + }, + "muted": false + } + } + }, + { + "id": 84, + "type": "DownloadAndLoadCogVideoModel", + "pos": { + "0": 605, + "1": -12 + }, + "size": [ + 377.9334482359568, + 218 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "block_edit", + "type": "TRANSFORMERBLOCKS", + "link": null, + "shape": 7 + }, + { + "name": "lora", + "type": "COGLORA", + "link": null, + "shape": 7 + }, + { + "name": "compile_args", + "type": "COMPILEARGS", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "model", + "type": "COGVIDEOMODEL", + "links": [ + 186 + ], + "slot_index": 0 + }, + { + "name": "vae", + "type": "VAE", + "links": [ + 188, + 191 + ], + "slot_index": 1 + } + ], + "properties": { + "Node name for S&R": "DownloadAndLoadCogVideoModel" + }, + "widgets_values": [ + "alibaba-pai/CogVideoX-Fun-V1.1-5b-Pose", + "bf16", + "disabled", + false, + "sdpa", + "main_device" + ] + }, + { + "id": 85, + "type": "CogVideoDecode", + "pos": { + "0": 1461, + "1": 357 + }, + "size": { + "0": 315, + "1": 198 + }, + "flags": {}, + "order": 12, + "mode": 0, + "inputs": [ + { + "name": "vae", + "type": "VAE", + "link": 188 + }, + { + "name": "samples", + "type": "LATENT", + "link": 189 + } + ], + "outputs": [ + { + "name": "images", + "type": "IMAGE", + "links": [ + 190 + ] + } + ], + "properties": { + "Node name for S&R": "CogVideoDecode" + }, + "widgets_values": [ + true, + 240, + 360, + 0.2, + 0.2, + true + ] + }, + { + "id": 30, + "type": "CogVideoTextEncode", + "pos": { + "0": 513, + "1": 286 + }, + "size": { + "0": 471.90142822265625, + "1": 168.08047485351562 + }, + "flags": {}, + "order": 3, + "mode": 0, + "inputs": [ + { + "name": "clip", + "type": "CLIP", + "link": 54 + } + ], + "outputs": [ + { + "name": "conditioning", + "type": "CONDITIONING", + "links": [ + 128, + 183 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "clip", + "type": "CLIP", + "links": [ + 194 + ], + "slot_index": 1 + } + ], + "properties": { + "Node name for S&R": "CogVideoTextEncode" + }, + "widgets_values": [ + "a brown bear is dancing in a forest, in front of a waterfall", + 1, + false + ] + }, + { + "id": 31, + "type": "CogVideoTextEncode", + "pos": { + "0": 507, + "1": 517 + }, + "size": { + "0": 501.0985412597656, + "1": 144 + }, + "flags": {}, + "order": 6, + "mode": 0, + "inputs": [ + { + "name": "clip", + "type": "CLIP", + "link": 194 + } + ], + "outputs": [ + { + "name": "conditioning", + "type": "CONDITIONING", + "links": [ + 184 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "clip", + "type": "CLIP", + "links": null + } + ], + "properties": { + "Node name for S&R": "CogVideoTextEncode" + }, + "widgets_values": [ + "The video is not of a high quality, it has a low resolution. Watermark present in each frame. Strange motion trajectory. Character is speaking", + 1, + true + ] + }, + { + "id": 20, + "type": "CLIPLoader", + "pos": { + "0": 2, + "1": 412 + }, + "size": { + "0": 451.30548095703125, + "1": 82 + }, + "flags": {}, + "order": 1, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "CLIP", + "type": "CLIP", + "links": [ + 54 + ], + "slot_index": 0, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "CLIPLoader" + }, + "widgets_values": [ + "t5\\google_t5-v1_1-xxl_encoderonly-fp8_e4m3fn.safetensors", + "sd3" + ] + }, + { + "id": 72, + "type": "INTConstant", + "pos": { + "0": -498, + "1": 276 + }, + "size": { + "0": 210, + "1": 58 + }, + "flags": {}, + "order": 2, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "value", + "type": "INT", + "links": [ + 152, + 195 + ], + "slot_index": 0, + "shape": 3 + } + ], + "title": "Frames", + "properties": { + "Node name for S&R": "INTConstant" + }, + "widgets_values": [ + 49 + ], + "color": "#1b4669", + "bgcolor": "#29699c" + }, + { + "id": 65, + "type": "VHS_LoadVideo", + "pos": { + "0": -506, + "1": 477 + }, + "size": [ + 390.1356201171875, + 910.0188802083334 + ], + "flags": {}, + "order": 4, + "mode": 0, + "inputs": [ + { + "name": "meta_batch", + "type": "VHS_BatchManager", + "link": null, + "shape": 7 + }, + { + "name": "vae", + "type": "VAE", + "link": null, + "shape": 7 + }, + { + "name": "frame_load_cap", + "type": "INT", + "link": 152, + "widget": { + "name": "frame_load_cap" + } + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 173 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "frame_count", + "type": "INT", + "links": null, + "shape": 3 + }, + { + "name": "audio", + "type": "AUDIO", + "links": null, + "shape": 3 + }, + { + "name": "video_info", + "type": "VHS_VIDEOINFO", + "links": [], + "slot_index": 3, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "VHS_LoadVideo" + }, + "widgets_values": { + "video": "01.mp4", + "force_rate": 0, + "force_size": "Disabled", + "custom_width": 512, + "custom_height": 512, + "frame_load_cap": 17, + "skip_first_frames": 0, + "select_every_nth": 1, + "choose video to upload": "image", + "videopreview": { + "hidden": false, + "paused": false, + "params": { + "frame_load_cap": 17, + "skip_first_frames": 0, + "force_rate": 0, + "filename": "01.mp4", + "type": "input", + "format": "video/mp4", + "select_every_nth": 1 + }, + "muted": false + } + } + }, + { + "id": 80, + "type": "DWPreprocessor", + "pos": { + "0": -66, + "1": 583 + }, + "size": { + "0": 364.7358703613281, + "1": 198 + }, + "flags": {}, + "order": 7, + "mode": 0, + "inputs": [ + { + "name": "image", + "type": "IMAGE", + "link": 173 + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 174 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "POSE_KEYPOINT", + "type": "POSE_KEYPOINT", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "DWPreprocessor" + }, + "widgets_values": [ + "enable", + "enable", + "enable", + 512, + "yolox_l.torchscript.pt", + "dw-ll_ucoco_384_bs5.torchscript.pt" + ] + }, + { + "id": 37, + "type": "ImageResizeKJ", + "pos": { + "0": -4, + "1": 829 + }, + "size": { + "0": 315, + "1": 266 + }, + "flags": {}, + "order": 8, + "mode": 0, + "inputs": [ + { + "name": "image", + "type": "IMAGE", + "link": 174 + }, + { + "name": "get_image_size", + "type": "IMAGE", + "link": null, + "shape": 7 + }, + { + "name": "width_input", + "type": "INT", + "link": null, + "widget": { + "name": "width_input" + } + }, + { + "name": "height_input", + "type": "INT", + "link": null, + "widget": { + "name": "height_input" + } + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 130 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "width", + "type": "INT", + "links": null, + "shape": 3 + }, + { + "name": "height", + "type": "INT", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "ImageResizeKJ" + }, + "widgets_values": [ + 512, + 512, + "lanczos", + true, + 16, + 0, + 0, + "disabled" + ] + }, + { + "id": 61, + "type": "GetImageSizeAndCount", + "pos": { + "0": 378, + "1": 828 + }, + "size": { + "0": 277.20001220703125, + "1": 86 + }, + "flags": {}, + "order": 9, + "mode": 0, + "inputs": [ + { + "name": "image", + "type": "IMAGE", + "link": 130 + } + ], + "outputs": [ + { + "name": "image", + "type": "IMAGE", + "links": [ + 135, + 192 + ], + "slot_index": 0, + "shape": 3 + }, + { + "name": "288 width", + "type": "INT", + "links": null, + "shape": 3 + }, + { + "name": "512 height", + "type": "INT", + "links": null, + "shape": 3 + }, + { + "name": "49 count", + "type": "INT", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "GetImageSizeAndCount" + }, + "widgets_values": [] + }, + { + "id": 86, + "type": "CogVideoImageEncode", + "pos": { + "0": 717, + "1": 808 + }, + "size": { + "0": 315, + "1": 122 + }, + "flags": {}, + "order": 10, + "mode": 0, + "inputs": [ + { + "name": "vae", + "type": "VAE", + "link": 191 + }, + { + "name": "start_image", + "type": "IMAGE", + "link": 192 + }, + { + "name": "end_image", + "type": "IMAGE", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "samples", + "type": "LATENT", + "links": [ + 193 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "CogVideoImageEncode" + }, + "widgets_values": [ + false, + 0 + ] + }, + { + "id": 83, + "type": "CogVideoSampler", + "pos": { + "0": 1089, + "1": 316 + }, + "size": [ + 330, + 570 + ], + "flags": {}, + "order": 11, + "mode": 0, + "inputs": [ + { + "name": "model", + "type": "COGVIDEOMODEL", + "link": 186 + }, + { + "name": "positive", + "type": "CONDITIONING", + "link": 183 + }, + { + "name": "negative", + "type": "CONDITIONING", + "link": 184 + }, + { + "name": "samples", + "type": "LATENT", + "link": null, + "shape": 7 + }, + { + "name": "image_cond_latents", + "type": "LATENT", + "link": 193, + "shape": 7 + }, + { + "name": "context_options", + "type": "COGCONTEXT", + "link": null, + "shape": 7 + }, + { + "name": "controlnet", + "type": "COGVIDECONTROLNET", + "link": null, + "shape": 7 + }, + { + "name": "tora_trajectory", + "type": "TORAFEATURES", + "link": null, + "shape": 7 + }, + { + "name": "fastercache", + "type": "FASTERCACHEARGS", + "link": null, + "shape": 7 + }, + { + "name": "num_frames", + "type": "INT", + "link": 195, + "widget": { + "name": "num_frames" + } + } + ], + "outputs": [ + { + "name": "samples", + "type": "LATENT", + "links": [ + 189 + ] + } + ], + "properties": { + "Node name for S&R": "CogVideoSampler" + }, + "widgets_values": [ + 49, + 50, + 6, + 0, + "fixed", + "CogVideoXDDIM", + 1 + ] + }, + { + "id": 58, + "type": "ImageConcatMulti", + "pos": { + "0": 1545, + "1": 679 + }, + "size": { + "0": 210, + "1": 150 + }, + "flags": {}, + "order": 13, + "mode": 0, + "inputs": [ + { + "name": "image_1", + "type": "IMAGE", + "link": 135 + }, + { + "name": "image_2", + "type": "IMAGE", + "link": 190 + } + ], + "outputs": [ + { + "name": "images", + "type": "IMAGE", + "links": [ + 126 + ], + "slot_index": 0, + "shape": 3 + } + ], + "properties": {}, + "widgets_values": [ + 2, + "right", + true, + null + ] + } + ], + "links": [ + [ + 54, + 20, + 0, + 30, + 0, + "CLIP" + ], + [ + 126, + 58, + 0, + 59, + 0, + "IMAGE" + ], + [ + 128, + 30, + 0, + 60, + 0, + "*" + ], + [ + 129, + 60, + 0, + 59, + 2, + "STRING" + ], + [ + 130, + 37, + 0, + 61, + 0, + "IMAGE" + ], + [ + 135, + 61, + 0, + 58, + 0, + "IMAGE" + ], + [ + 150, + 59, + 0, + 44, + 0, + "IMAGE" + ], + [ + 152, + 72, + 0, + 65, + 2, + "INT" + ], + [ + 173, + 65, + 0, + 80, + 0, + "IMAGE" + ], + [ + 174, + 80, + 0, + 37, + 0, + "IMAGE" + ], + [ + 183, + 30, + 0, + 83, + 1, + "CONDITIONING" + ], + [ + 184, + 31, + 0, + 83, + 2, + "CONDITIONING" + ], + [ + 186, + 84, + 0, + 83, + 0, + "COGVIDEOMODEL" + ], + [ + 188, + 84, + 1, + 85, + 0, + "VAE" + ], + [ + 189, + 83, + 0, + 85, + 1, + "LATENT" + ], + [ + 190, + 85, + 0, + 58, + 1, + "IMAGE" + ], + [ + 191, + 84, + 1, + 86, + 0, + "VAE" + ], + [ + 192, + 61, + 0, + 86, + 1, + "IMAGE" + ], + [ + 193, + 86, + 0, + 83, + 4, + "LATENT" + ], + [ + 194, + 30, + 1, + 31, + 0, + "CLIP" + ], + [ + 195, + 72, + 0, + 83, + 9, + "INT" + ] + ], + "groups": [], + "config": {}, + "extra": { + "ds": { + "scale": 0.6303940863129809, + "offset": [ + 814.9475817376318, + 180.21736528457424 + ] + } + }, + "version": 0.4 +} \ No newline at end of file diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cut_and_drag_for_noisewarp_01.json b/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cut_and_drag_for_noisewarp_01.json new file mode 100644 index 0000000000000000000000000000000000000000..0ce6b8c26d2a0dd324917ed985819b3170f201eb --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/cut_and_drag_for_noisewarp_01.json @@ -0,0 +1,454 @@ +{ + "last_node_id": 26, + "last_link_id": 31, + "nodes": [ + { + "id": 12, + "type": "SplineEditor", + "pos": [ + -688.39111328125, + 700.787353515625 + ], + "size": [ + 1069, + 1198 + ], + "flags": {}, + "order": 2, + "mode": 0, + "inputs": [ + { + "name": "bg_image", + "type": "IMAGE", + "link": 12, + "shape": 7 + } + ], + "outputs": [ + { + "name": "mask", + "type": "MASK", + "links": null + }, + { + "name": "coord_str", + "type": "STRING", + "links": [ + 14 + ], + "slot_index": 1 + }, + { + "name": "float", + "type": "FLOAT", + "links": [], + "slot_index": 2 + }, + { + "name": "count", + "type": "INT", + "links": null + }, + { + "name": "normalized_str", + "type": "STRING", + "links": null + } + ], + "properties": { + "Node name for S&R": "SplineEditor", + "points": "SplineEditor", + "imgData": { + "name": "bg_image", + "base64": [ + "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" + ] + } + }, + "widgets_values": [ + "[{\"x\":492.1590523879336,\"y\":385.8788583506722},{\"x\":711.2597600955187,\"y\":448.01189486476346},{\"x\":923.8201481700415,\"y\":618.0602053243817}]", + "[{\"x\":492.1590576171875,\"y\":385.87884521484375},{\"x\":502.47125244140625,\"y\":387.5565185546875},{\"x\":512.7724609375,\"y\":389.300537109375},{\"x\":523.0609130859375,\"y\":391.1180725097656},{\"x\":533.3355712890625,\"y\":393.0121154785156},{\"x\":543.5950927734375,\"y\":394.9867248535156},{\"x\":553.8377075195312,\"y\":397.046875},{\"x\":564.0616455078125,\"y\":399.1977844238281},{\"x\":574.2648315429688,\"y\":401.4451599121094},{\"x\":584.4448852539062,\"y\":403.7951354980469},{\"x\":594.5986938476562,\"y\":406.2559814453125},{\"x\":604.7234497070312,\"y\":408.8337707519531},{\"x\":614.8148193359375,\"y\":411.53912353515625},{\"x\":624.8687133789062,\"y\":414.38067626953125},{\"x\":634.879638671875,\"y\":417.3697814941406},{\"x\":644.8414306640625,\"y\":420.5189208984375},{\"x\":654.7462768554688,\"y\":423.8428039550781},{\"x\":664.5849609375,\"y\":427.3575134277344},{\"x\":674.3461303710938,\"y\":431.0820007324219},{\"x\":684.015869140625,\"y\":435.03741455078125},{\"x\":693.5767822265625,\"y\":439.2491455078125},{\"x\":703.0067138671875,\"y\":443.7462158203125},{\"x\":712.277587890625,\"y\":448.56243896484375},{\"x\":721.3695678710938,\"y\":453.7084045410156},{\"x\":730.3035888671875,\"y\":459.12445068359375},{\"x\":739.1012573242188,\"y\":464.7593994140625},{\"x\":747.7813110351562,\"y\":470.5741271972656},{\"x\":756.35791015625,\"y\":476.540283203125},{\"x\":764.8431396484375,\"y\":482.6358642578125},{\"x\":773.2467041015625,\"y\":488.8434753417969},{\"x\":781.576416015625,\"y\":495.1499328613281},{\"x\":789.8392333984375,\"y\":501.54388427734375},{\"x\":798.0416870117188,\"y\":508.0149841308594},{\"x\":806.1887817382812,\"y\":514.5556640625},{\"x\":814.2850952148438,\"y\":521.1590576171875},{\"x\":822.3330688476562,\"y\":527.8214111328125},{\"x\":830.3378295898438,\"y\":534.5355834960938},{\"x\":838.3020629882812,\"y\":541.2977294921875},{\"x\":846.228271484375,\"y\":548.1045532226562},{\"x\":854.1182861328125,\"y\":554.9531860351562},{\"x\":861.974609375,\"y\":561.8403930664062},{\"x\":869.799560546875,\"y\":568.7633056640625},{\"x\":877.5947265625,\"y\":575.7197265625},{\"x\":885.3613891601562,\"y\":582.7079467773438},{\"x\":893.1011352539062,\"y\":589.7260131835938},{\"x\":900.8156127929688,\"y\":596.7717895507812},{\"x\":908.506103515625,\"y\":603.8438110351562},{\"x\":916.1738891601562,\"y\":610.9403686523438},{\"x\":923.8201293945312,\"y\":618.0601806640625}]", + 1024, + 768, + 49, + "path", + "cardinal", + 0.5, + 1, + "list", + 0, + 1, + null, + null, + null + ] + }, + { + "id": 17, + "type": "INPAINT_LoadInpaintModel", + "pos": [ + -631.4315795898438, + 152.6876220703125 + ], + "size": [ + 405.83160400390625, + 80.33563232421875 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "INPAINT_MODEL", + "type": "INPAINT_MODEL", + "links": [ + 18 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "INPAINT_LoadInpaintModel" + }, + "widgets_values": [ + "big-lama.pt" + ] + }, + { + "id": 11, + "type": "LoadImage", + "pos": [ + -620.6697998046875, + 302.7655029296875 + ], + "size": [ + 315, + 314 + ], + "flags": {}, + "order": 1, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 12, + 19, + 22 + ], + "slot_index": 0 + }, + { + "name": "MASK", + "type": "MASK", + "links": [ + 10, + 20 + ], + "slot_index": 1 + } + ], + "properties": { + "Node name for S&R": "LoadImage" + }, + "widgets_values": [ + "clipspace/clipspace-mask-6709059.199999999.png [input]", + "image" + ] + }, + { + "id": 18, + "type": "INPAINT_InpaintWithModel", + "pos": [ + -32.909523010253906, + 158.2882843017578 + ], + "size": [ + 355.20001220703125, + 142 + ], + "flags": {}, + "order": 3, + "mode": 0, + "inputs": [ + { + "name": "inpaint_model", + "type": "INPAINT_MODEL", + "link": 18 + }, + { + "name": "image", + "type": "IMAGE", + "link": 19 + }, + { + "name": "mask", + "type": "MASK", + "link": 20 + }, + { + "name": "optional_upscale_model", + "type": "UPSCALE_MODEL", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 24 + ], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "INPAINT_InpaintWithModel" + }, + "widgets_values": [ + 534667941392889, + "fixed" + ] + }, + { + "id": 10, + "type": "CutAndDragOnPath", + "pos": [ + 8.958178520202637, + 395.44854736328125 + ], + "size": [ + 315, + 166 + ], + "flags": {}, + "order": 4, + "mode": 0, + "inputs": [ + { + "name": "image", + "type": "IMAGE", + "link": 22 + }, + { + "name": "mask", + "type": "MASK", + "link": 10 + }, + { + "name": "coordinates", + "type": "STRING", + "link": 14, + "widget": { + "name": "coordinates" + } + }, + { + "name": "bg_image", + "type": "IMAGE", + "link": 24, + "shape": 7 + } + ], + "outputs": [ + { + "name": "image", + "type": "IMAGE", + "links": [ + 17 + ], + "slot_index": 0 + }, + { + "name": "mask", + "type": "MASK", + "links": [], + "slot_index": 1 + } + ], + "properties": { + "Node name for S&R": "CutAndDragOnPath" + }, + "widgets_values": [ + "", + 1024, + 768, + false + ] + }, + { + "id": 16, + "type": "VHS_VideoCombine", + "pos": [ + 442.3276672363281, + 149.1554412841797 + ], + "size": [ + 680.5087890625, + 843.381591796875 + ], + "flags": {}, + "order": 5, + "mode": 0, + "inputs": [ + { + "name": "images", + "type": "IMAGE", + "link": 17 + }, + { + "name": "audio", + "type": "AUDIO", + "link": null, + "shape": 7 + }, + { + "name": "meta_batch", + "type": "VHS_BatchManager", + "link": null, + "shape": 7 + }, + { + "name": "vae", + "type": "VAE", + "link": null, + "shape": 7 + } + ], + "outputs": [ + { + "name": "Filenames", + "type": "VHS_FILENAMES", + "links": null + } + ], + "properties": { + "Node name for S&R": "VHS_VideoCombine" + }, + "widgets_values": { + "frame_rate": 8, + "loop_count": 0, + "filename_prefix": "AnimateDiff", + "format": "video/h264-mp4", + "pix_fmt": "yuv420p", + "crf": 19, + "save_metadata": true, + "trim_to_audio": false, + "pingpong": false, + "save_output": false, + "videopreview": { + "hidden": false, + "paused": false, + "params": { + "filename": "AnimateDiff_00023.mp4", + "subfolder": "", + "type": "temp", + "format": "video/h264-mp4", + "frame_rate": 8, + "workflow": "AnimateDiff_00023.png", + "fullpath": "N:\\AI\\ComfyUI\\temp\\AnimateDiff_00023.mp4" + }, + "muted": false + } + } + } + ], + "links": [ + [ + 10, + 11, + 1, + 10, + 1, + "MASK" + ], + [ + 12, + 11, + 0, + 12, + 0, + "IMAGE" + ], + [ + 14, + 12, + 1, + 10, + 2, + "STRING" + ], + [ + 17, + 10, + 0, + 16, + 0, + "IMAGE" + ], + [ + 18, + 17, + 0, + 18, + 0, + "INPAINT_MODEL" + ], + [ + 19, + 11, + 0, + 18, + 1, + "IMAGE" + ], + [ + 20, + 11, + 1, + 18, + 2, + "MASK" + ], + [ + 22, + 11, + 0, + 10, + 0, + "IMAGE" + ], + [ + 24, + 18, + 0, + 10, + 3, + "IMAGE" + ] + ], + "groups": [], + "config": {}, + "extra": { + "ds": { + "scale": 0.6115909044841531, + "offset": [ + 1484.5868334338145, + 0.8454987040198461 + ] + }, + "node_versions": { + "ComfyUI-KJNodes": "c9c8dcd5e7ed2f7669f130a5ced1e3005264a2de", + "comfyui-inpaint-nodes": "6fcdf5523d53e82029e0af6cf4887e17d182b7ec", + "comfy-core": "0.3.12", + "ComfyUI-VideoHelperSuite": "c47b10ca1798b4925ff5a5f07d80c51ca80a837d" + }, + "VHS_latentpreview": true, + "VHS_latentpreviewrate": 0 + }, + "version": 0.4 +} \ No newline at end of file diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/noise_warp_example_input_video.mp4 b/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/noise_warp_example_input_video.mp4 new file mode 100644 index 0000000000000000000000000000000000000000..40fe40b37f1e1cb14654f421a9f52167b8446328 --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/example_workflows/noise_warp_example_input_video.mp4 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4793529481f1239840796185f3841ff286626649f972d7b56f4c290490a823bc +size 578949 diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/fp8_optimization.py b/custom_nodes/ComfyUI-CogVideoXWrapper/fp8_optimization.py new file mode 100644 index 0000000000000000000000000000000000000000..b06bef9615d691cc3b5bf7e1466d77e482067867 --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/fp8_optimization.py @@ -0,0 +1,47 @@ +#based on ComfyUI's and MinusZoneAI's fp8_linear optimization + +import torch +import torch.nn as nn + +def fp8_linear_forward(cls, original_dtype, input): + weight_dtype = cls.weight.dtype + if weight_dtype in [torch.float8_e4m3fn, torch.float8_e5m2]: + if len(input.shape) == 3: + if weight_dtype == torch.float8_e4m3fn: + inn = input.reshape(-1, input.shape[2]).to(torch.float8_e5m2) + else: + inn = input.reshape(-1, input.shape[2]).to(torch.float8_e4m3fn) + w = cls.weight.t() + + scale_weight = torch.ones((1), device=input.device, dtype=torch.float32) + scale_input = scale_weight + + bias = cls.bias.to(original_dtype) if cls.bias is not None else None + out_dtype = original_dtype + + if bias is not None: + o = torch._scaled_mm(inn, w, out_dtype=out_dtype, bias=bias, scale_a=scale_input, scale_b=scale_weight) + else: + o = torch._scaled_mm(inn, w, out_dtype=out_dtype, scale_a=scale_input, scale_b=scale_weight) + + if isinstance(o, tuple): + o = o[0] + + return o.reshape((-1, input.shape[1], cls.weight.shape[0])) + else: + cls.to(original_dtype) + out = cls.original_forward(input.to(original_dtype)) + cls.to(original_dtype) + return out + else: + return cls.original_forward(input) + +def convert_fp8_linear(module, original_dtype, params_to_keep={}): + setattr(module, "fp8_matmul_enabled", True) + + for name, module in module.named_modules(): + if not any(keyword in name for keyword in params_to_keep): + if isinstance(module, nn.Linear): + original_forward = module.forward + setattr(module, "original_forward", original_forward) + setattr(module, "forward", lambda input, m=module: fp8_linear_forward(m, original_dtype, input)) diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/lora_utils.py b/custom_nodes/ComfyUI-CogVideoXWrapper/lora_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..ac36dbb8fda197c200f4a6db9ffc7b96b9ae066b --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/lora_utils.py @@ -0,0 +1,560 @@ +# LoRA network module +# reference: +# https://github.com/microsoft/LoRA/blob/main/loralib/layers.py +# https://github.com/cloneofsimo/lora/blob/master/lora_diffusion/lora.py +# https://github.com/bmaltais/kohya_ss + +import hashlib +import math +import os +from collections import defaultdict +from io import BytesIO +from typing import List, Optional, Type, Union + +import safetensors.torch +import torch +import torch.utils.checkpoint +from diffusers.models.lora import LoRACompatibleConv, LoRACompatibleLinear +from safetensors.torch import load_file +from transformers import T5EncoderModel + + +class LoRAModule(torch.nn.Module): + """ + replaces forward method of the original Linear, instead of replacing the original Linear module. + """ + + def __init__( + self, + lora_name, + org_module: torch.nn.Module, + multiplier=1.0, + lora_dim=4, + alpha=1, + dropout=None, + rank_dropout=None, + module_dropout=None, + ): + """if alpha == 0 or None, alpha is rank (no scaling).""" + super().__init__() + self.lora_name = lora_name + + if org_module.__class__.__name__ == "Conv2d": + in_dim = org_module.in_channels + out_dim = org_module.out_channels + else: + in_dim = org_module.in_features + out_dim = org_module.out_features + + self.lora_dim = lora_dim + if org_module.__class__.__name__ == "Conv2d": + kernel_size = org_module.kernel_size + stride = org_module.stride + padding = org_module.padding + self.lora_down = torch.nn.Conv2d(in_dim, self.lora_dim, kernel_size, stride, padding, bias=False) + self.lora_up = torch.nn.Conv2d(self.lora_dim, out_dim, (1, 1), (1, 1), bias=False) + else: + self.lora_down = torch.nn.Linear(in_dim, self.lora_dim, bias=False) + self.lora_up = torch.nn.Linear(self.lora_dim, out_dim, bias=False) + + if type(alpha) == torch.Tensor: + alpha = alpha.detach().float().numpy() # without casting, bf16 causes error + alpha = self.lora_dim if alpha is None or alpha == 0 else alpha + self.scale = alpha / self.lora_dim + self.register_buffer("alpha", torch.tensor(alpha)) + + # same as microsoft's + torch.nn.init.kaiming_uniform_(self.lora_down.weight, a=math.sqrt(5)) + torch.nn.init.zeros_(self.lora_up.weight) + + self.multiplier = multiplier + self.org_module = org_module # remove in applying + self.dropout = dropout + self.rank_dropout = rank_dropout + self.module_dropout = module_dropout + + def apply_to(self): + self.org_forward = self.org_module.forward + self.org_module.forward = self.forward + del self.org_module + + def forward(self, x, *args, **kwargs): + weight_dtype = x.dtype + org_forwarded = self.org_forward(x) + + # module dropout + if self.module_dropout is not None and self.training: + if torch.rand(1) < self.module_dropout: + return org_forwarded + + lx = self.lora_down(x.to(self.lora_down.weight.dtype)) + + # normal dropout + if self.dropout is not None and self.training: + lx = torch.nn.functional.dropout(lx, p=self.dropout) + + # rank dropout + if self.rank_dropout is not None and self.training: + mask = torch.rand((lx.size(0), self.lora_dim), device=lx.device) > self.rank_dropout + if len(lx.size()) == 3: + mask = mask.unsqueeze(1) # for Text Encoder + elif len(lx.size()) == 4: + mask = mask.unsqueeze(-1).unsqueeze(-1) # for Conv2d + lx = lx * mask + + # scaling for rank dropout: treat as if the rank is changed + scale = self.scale * (1.0 / (1.0 - self.rank_dropout)) # redundant for readability + else: + scale = self.scale + + lx = self.lora_up(lx) + + return org_forwarded.to(weight_dtype) + lx.to(weight_dtype) * self.multiplier * scale + + +def addnet_hash_legacy(b): + """Old model hash used by sd-webui-additional-networks for .safetensors format files""" + m = hashlib.sha256() + + b.seek(0x100000) + m.update(b.read(0x10000)) + return m.hexdigest()[0:8] + + +def addnet_hash_safetensors(b): + """New model hash used by sd-webui-additional-networks for .safetensors format files""" + hash_sha256 = hashlib.sha256() + blksize = 1024 * 1024 + + b.seek(0) + header = b.read(8) + n = int.from_bytes(header, "little") + + offset = n + 8 + b.seek(offset) + for chunk in iter(lambda: b.read(blksize), b""): + hash_sha256.update(chunk) + + return hash_sha256.hexdigest() + + +def precalculate_safetensors_hashes(tensors, metadata): + """Precalculate the model hashes needed by sd-webui-additional-networks to + save time on indexing the model later.""" + + # Because writing user metadata to the file can change the result of + # sd_models.model_hash(), only retain the training metadata for purposes of + # calculating the hash, as they are meant to be immutable + metadata = {k: v for k, v in metadata.items() if k.startswith("ss_")} + + bytes = safetensors.torch.save(tensors, metadata) + b = BytesIO(bytes) + + model_hash = addnet_hash_safetensors(b) + legacy_hash = addnet_hash_legacy(b) + return model_hash, legacy_hash + + +class LoRANetwork(torch.nn.Module): + TRANSFORMER_TARGET_REPLACE_MODULE = ["CogVideoXTransformer3DModel"] + TEXT_ENCODER_TARGET_REPLACE_MODULE = ["T5LayerSelfAttention", "T5LayerFF", "BertEncoder"] + LORA_PREFIX_TRANSFORMER = "lora_unet" + LORA_PREFIX_TEXT_ENCODER = "lora_te" + def __init__( + self, + text_encoder: Union[List[T5EncoderModel], T5EncoderModel], + unet, + multiplier: float = 1.0, + lora_dim: int = 4, + alpha: float = 1, + dropout: Optional[float] = None, + module_class: Type[object] = LoRAModule, + add_lora_in_attn_temporal: bool = False, + varbose: Optional[bool] = False, + ) -> None: + super().__init__() + self.multiplier = multiplier + + self.lora_dim = lora_dim + self.alpha = alpha + self.dropout = dropout + + print(f"create LoRA network. base dim (rank): {lora_dim}, alpha: {alpha}") + print(f"neuron dropout: p={self.dropout}") + + # create module instances + def create_modules( + is_unet: bool, + root_module: torch.nn.Module, + target_replace_modules: List[torch.nn.Module], + ) -> List[LoRAModule]: + prefix = ( + self.LORA_PREFIX_TRANSFORMER + if is_unet + else self.LORA_PREFIX_TEXT_ENCODER + ) + loras = [] + skipped = [] + for name, module in root_module.named_modules(): + if module.__class__.__name__ in target_replace_modules: + for child_name, child_module in module.named_modules(): + is_linear = child_module.__class__.__name__ == "Linear" or child_module.__class__.__name__ == "LoRACompatibleLinear" + is_conv2d = child_module.__class__.__name__ == "Conv2d" or child_module.__class__.__name__ == "LoRACompatibleConv" + is_conv2d_1x1 = is_conv2d and child_module.kernel_size == (1, 1) + + if not add_lora_in_attn_temporal: + if "attn_temporal" in child_name: + continue + + if is_linear or is_conv2d: + lora_name = prefix + "." + name + "." + child_name + lora_name = lora_name.replace(".", "_") + + dim = None + alpha = None + + if is_linear or is_conv2d_1x1: + dim = self.lora_dim + alpha = self.alpha + + if dim is None or dim == 0: + if is_linear or is_conv2d_1x1: + skipped.append(lora_name) + continue + + lora = module_class( + lora_name, + child_module, + self.multiplier, + dim, + alpha, + dropout=dropout, + ) + loras.append(lora) + return loras, skipped + + text_encoders = text_encoder if type(text_encoder) == list else [text_encoder] + + self.text_encoder_loras = [] + skipped_te = [] + for i, text_encoder in enumerate(text_encoders): + if text_encoder is not None: + text_encoder_loras, skipped = create_modules(False, text_encoder, LoRANetwork.TEXT_ENCODER_TARGET_REPLACE_MODULE) + self.text_encoder_loras.extend(text_encoder_loras) + skipped_te += skipped + print(f"create LoRA for Text Encoder: {len(self.text_encoder_loras)} modules.") + + self.unet_loras, skipped_un = create_modules(True, unet, LoRANetwork.TRANSFORMER_TARGET_REPLACE_MODULE) + print(f"create LoRA for U-Net: {len(self.unet_loras)} modules.") + + # assertion + names = set() + for lora in self.text_encoder_loras + self.unet_loras: + assert lora.lora_name not in names, f"duplicated lora name: {lora.lora_name}" + names.add(lora.lora_name) + + def apply_to(self, text_encoder, unet, apply_text_encoder=True, apply_unet=True): + if apply_text_encoder: + print("enable LoRA for text encoder") + else: + self.text_encoder_loras = [] + + if apply_unet: + print("enable LoRA for U-Net") + else: + self.unet_loras = [] + + for lora in self.text_encoder_loras + self.unet_loras: + lora.apply_to() + self.add_module(lora.lora_name, lora) + + def set_multiplier(self, multiplier): + self.multiplier = multiplier + for lora in self.text_encoder_loras + self.unet_loras: + lora.multiplier = self.multiplier + + def load_weights(self, file): + if os.path.splitext(file)[1] == ".safetensors": + from safetensors.torch import load_file + + weights_sd = load_file(file) + else: + weights_sd = torch.load(file, map_location="cpu") + info = self.load_state_dict(weights_sd, False) + return info + + def prepare_optimizer_params(self, text_encoder_lr, unet_lr, default_lr): + self.requires_grad_(True) + all_params = [] + + def enumerate_params(loras): + params = [] + for lora in loras: + params.extend(lora.parameters()) + return params + + if self.text_encoder_loras: + param_data = {"params": enumerate_params(self.text_encoder_loras)} + if text_encoder_lr is not None: + param_data["lr"] = text_encoder_lr + all_params.append(param_data) + + if self.unet_loras: + param_data = {"params": enumerate_params(self.unet_loras)} + if unet_lr is not None: + param_data["lr"] = unet_lr + all_params.append(param_data) + + return all_params + + def enable_gradient_checkpointing(self): + pass + + def get_trainable_params(self): + return self.parameters() + + def save_weights(self, file, dtype, metadata): + if metadata is not None and len(metadata) == 0: + metadata = None + + state_dict = self.state_dict() + + if dtype is not None: + for key in list(state_dict.keys()): + v = state_dict[key] + v = v.detach().clone().to("cpu").to(dtype) + state_dict[key] = v + + if os.path.splitext(file)[1] == ".safetensors": + from safetensors.torch import save_file + + # Precalculate model hashes to save time on indexing + if metadata is None: + metadata = {} + model_hash, legacy_hash = precalculate_safetensors_hashes(state_dict, metadata) + metadata["sshs_model_hash"] = model_hash + metadata["sshs_legacy_hash"] = legacy_hash + + save_file(state_dict, file, metadata) + else: + torch.save(state_dict, file) + +def create_network( + multiplier: float, + network_dim: Optional[int], + network_alpha: Optional[float], + text_encoder: Union[T5EncoderModel, List[T5EncoderModel]], + transformer, + neuron_dropout: Optional[float] = None, + add_lora_in_attn_temporal: bool = False, + **kwargs, +): + if network_dim is None: + network_dim = 4 # default + if network_alpha is None: + network_alpha = 1.0 + + network = LoRANetwork( + text_encoder, + transformer, + multiplier=multiplier, + lora_dim=network_dim, + alpha=network_alpha, + dropout=neuron_dropout, + add_lora_in_attn_temporal=add_lora_in_attn_temporal, + varbose=True, + ) + return network + +def merge_lora(transformer, lora_path, multiplier, device='cpu', dtype=torch.float32, state_dict=None): + LORA_PREFIX_TRANSFORMER = "lora_unet" + LORA_PREFIX_TEXT_ENCODER = "lora_te" + if state_dict is None: + state_dict = load_file(lora_path, device=device) + else: + state_dict = state_dict + updates = defaultdict(dict) + for key, value in state_dict.items(): + layer, elem = key.split('.', 1) + updates[layer][elem] = value + + for layer, elems in updates.items(): + + # if "lora_te" in layer: + # if transformer_only: + # continue + # else: + # layer_infos = layer.split(LORA_PREFIX_TEXT_ENCODER + "_")[-1].split("_") + # curr_layer = pipeline.text_encoder + #else: + layer_infos = layer.split(LORA_PREFIX_TRANSFORMER + "_")[-1].split("_") + curr_layer = transformer + + temp_name = layer_infos.pop(0) + while len(layer_infos) > -1: + try: + curr_layer = curr_layer.__getattr__(temp_name) + if len(layer_infos) > 0: + temp_name = layer_infos.pop(0) + elif len(layer_infos) == 0: + break + except Exception: + if len(layer_infos) == 0: + print('Error loading layer') + if len(temp_name) > 0: + temp_name += "_" + layer_infos.pop(0) + else: + temp_name = layer_infos.pop(0) + + weight_up = elems['lora_up.weight'].to(dtype).to(device) + weight_down = elems['lora_down.weight'].to(dtype).to(device) + if 'alpha' in elems.keys(): + alpha = elems['alpha'].item() / weight_up.shape[1] + else: + alpha = 1.0 + + curr_layer.weight.data = curr_layer.weight.data.to(device) + try: + if len(weight_up.shape) == 4: + curr_layer.weight.data += multiplier * alpha * torch.mm(weight_up.squeeze(3).squeeze(2), + weight_down.squeeze(3).squeeze(2)).unsqueeze( + 2).unsqueeze(3) + else: + curr_layer.weight.data += multiplier * alpha * torch.mm(weight_up, weight_down) + except: + print(f"Could not apply LoRA weight in layer {layer}") + + return transformer + +# TODO: Refactor with merge_lora. +def unmerge_lora(pipeline, lora_path, multiplier=1, device="cpu", dtype=torch.float32): + """Unmerge state_dict in LoRANetwork from the pipeline in diffusers.""" + LORA_PREFIX_UNET = "lora_unet" + LORA_PREFIX_TEXT_ENCODER = "lora_te" + state_dict = load_file(lora_path, device=device) + + updates = defaultdict(dict) + for key, value in state_dict.items(): + layer, elem = key.split('.', 1) + updates[layer][elem] = value + + for layer, elems in updates.items(): + + if "lora_te" in layer: + layer_infos = layer.split(LORA_PREFIX_TEXT_ENCODER + "_")[-1].split("_") + curr_layer = pipeline.text_encoder + else: + layer_infos = layer.split(LORA_PREFIX_UNET + "_")[-1].split("_") + curr_layer = pipeline.transformer + + temp_name = layer_infos.pop(0) + while len(layer_infos) > -1: + try: + curr_layer = curr_layer.__getattr__(temp_name) + if len(layer_infos) > 0: + temp_name = layer_infos.pop(0) + elif len(layer_infos) == 0: + break + except Exception: + if len(layer_infos) == 0: + print('Error loading layer') + if len(temp_name) > 0: + temp_name += "_" + layer_infos.pop(0) + else: + temp_name = layer_infos.pop(0) + + weight_up = elems['lora_up.weight'].to(dtype) + weight_down = elems['lora_down.weight'].to(dtype) + if 'alpha' in elems.keys(): + alpha = elems['alpha'].item() / weight_up.shape[1] + else: + alpha = 1.0 + + curr_layer.weight.data = curr_layer.weight.data.to(device) + if len(weight_up.shape) == 4: + curr_layer.weight.data -= multiplier * alpha * torch.mm(weight_up.squeeze(3).squeeze(2), + weight_down.squeeze(3).squeeze(2)).unsqueeze(2).unsqueeze(3) + else: + curr_layer.weight.data -= multiplier * alpha * torch.mm(weight_up, weight_down) + + return pipeline + +def load_lora_into_transformer(lora, transformer): + from peft import LoraConfig, set_peft_model_state_dict + from peft.mapping import PEFT_TYPE_TO_TUNER_MAPPING + from peft.tuners.tuners_utils import BaseTunerLayer + from diffusers.utils.peft_utils import get_peft_kwargs + from diffusers.utils.import_utils import is_peft_version + from diffusers.utils.state_dict_utils import convert_unet_state_dict_to_peft + + state_dict_list = [] + adapter_name_list = [] + strength_list = [] + lora_config_list = [] + + for l in lora: + state_dict = load_file(l["path"]) + adapter_name_list.append(l["name"]) + strength_list.append(l["strength"]) + + keys = list(state_dict.keys()) + transformer_keys = [k for k in keys if k.startswith("transformer")] + state_dict = { + k.replace(f"transformer.", ""): v for k, v in state_dict.items() if k in transformer_keys + } + + # check with first key if is not in peft format + first_key = next(iter(state_dict.keys())) + if "lora_A" not in first_key: + state_dict = convert_unet_state_dict_to_peft(state_dict) + + rank = {} + for key, val in state_dict.items(): + if "lora_B" in key: + rank[key] = val.shape[1] + lora_config_kwargs = get_peft_kwargs(rank, network_alpha_dict=None, peft_state_dict=state_dict) + if "use_dora" in lora_config_kwargs: + if lora_config_kwargs["use_dora"] and is_peft_version("<", "0.9.0"): + raise ValueError( + "You need `peft` 0.9.0 at least to use DoRA-enabled LoRAs. Please upgrade your installation of `peft`." + ) + else: + lora_config_kwargs.pop("use_dora") + + lora_config_list.append(LoraConfig(**lora_config_kwargs)) + state_dict_list.append(state_dict) + + + peft_models = [] + + for i in range(len(lora_config_list)): + tuner_cls = PEFT_TYPE_TO_TUNER_MAPPING[lora_config_list[i].peft_type] + peft_model = tuner_cls(transformer, lora_config_list[i], adapter_name=adapter_name_list[i]) + incompatible_keys = set_peft_model_state_dict(peft_model.model, state_dict_list[i], adapter_name_list[i]) + + if incompatible_keys is not None: + # check only for unexpected keys + unexpected_keys = getattr(incompatible_keys, "unexpected_keys", None) + if unexpected_keys: + print( + f"Loading adapter weights from state_dict led to unexpected keys not found in the model: " + f" {unexpected_keys}. " + ) + + peft_models.append(peft_model) + + if len(peft_models) > 1: + peft_models[0].add_weighted_adapter( + adapters=adapter_name_list, + weights=strength_list, + combination_type="linear", + adapter_name="combined_adapter" + ) + peft_models[0].set_adapter("combined_adapter") + else: + if strength_list[0] != 1.0: + for module in transformer.modules(): + if isinstance(module, BaseTunerLayer): + #print(f"Setting strength for {module}") + module.scale_layer(strength_list[0]) + return peft_model.model \ No newline at end of file diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/model_loading.py b/custom_nodes/ComfyUI-CogVideoXWrapper/model_loading.py new file mode 100644 index 0000000000000000000000000000000000000000..787ab33b75e7c5ac371c0a3d12bbc3fe916fca5e --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/model_loading.py @@ -0,0 +1,1146 @@ +import os +import json +import folder_paths +import comfy.model_management as mm +from typing import Union + +def patched_write_atomic( + path_: str, + content: Union[str, bytes], + make_dirs: bool = False, + encode_utf_8: bool = False, +) -> None: + # Write into temporary file first to avoid conflicts between threads + # Avoid using a named temporary file, as those have restricted permissions + from pathlib import Path + import os + import shutil + import threading + assert isinstance( + content, (str, bytes) + ), "Only strings and byte arrays can be saved in the cache" + path = Path(path_) + if make_dirs: + path.parent.mkdir(parents=True, exist_ok=True) + tmp_path = path.parent / f".{os.getpid()}.{threading.get_ident()}.tmp" + write_mode = "w" if isinstance(content, str) else "wb" + with tmp_path.open(write_mode, encoding="utf-8" if encode_utf_8 else None) as f: + f.write(content) + shutil.copy2(src=tmp_path, dst=path) #changed to allow overwriting cache files + os.remove(tmp_path) +try: + import torch._inductor.codecache + torch._inductor.codecache.write_atomic = patched_write_atomic +except: + pass + +import torch +import torch.nn as nn + +from diffusers.models import AutoencoderKLCogVideoX +from diffusers.schedulers import CogVideoXDDIMScheduler +from .custom_cogvideox_transformer_3d import CogVideoXTransformer3DModel +from .pipeline_cogvideox import CogVideoXPipeline +from contextlib import nullcontext + +from accelerate import init_empty_weights +from accelerate.utils import set_module_tensor_to_device + +from .utils import remove_specific_blocks, log +from comfy.utils import load_torch_file + +script_directory = os.path.dirname(os.path.abspath(__file__)) + +class CogVideoLoraSelect: + @classmethod + def INPUT_TYPES(s): + return { + "required": { + "lora": (folder_paths.get_filename_list("cogvideox_loras"), + {"tooltip": "LORA models are expected to be in ComfyUI/models/CogVideo/loras with .safetensors extension"}), + "strength": ("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.0001, "tooltip": "LORA strength, set to 0.0 to unmerge the LORA"}), + }, + "optional": { + "prev_lora":("COGLORA", {"default": None, "tooltip": "For loading multiple LoRAs"}), + "fuse_lora": ("BOOLEAN", {"default": False, "tooltip": "Fuse the LoRA weights into the transformer"}), + } + } + + RETURN_TYPES = ("COGLORA",) + RETURN_NAMES = ("lora", ) + FUNCTION = "getlorapath" + CATEGORY = "CogVideoWrapper" + DESCRIPTION = "Select a LoRA model from ComfyUI/models/CogVideo/loras" + + def getlorapath(self, lora, strength, prev_lora=None, fuse_lora=False): + cog_loras_list = [] + + cog_lora = { + "path": folder_paths.get_full_path("cogvideox_loras", lora), + "strength": strength, + "name": lora.split(".")[0], + "fuse_lora": fuse_lora + } + if prev_lora is not None: + cog_loras_list.extend(prev_lora) + + cog_loras_list.append(cog_lora) + print(cog_loras_list) + return (cog_loras_list,) + +class CogVideoLoraSelectComfy: + @classmethod + def INPUT_TYPES(s): + return { + "required": { + "lora": (folder_paths.get_filename_list("loras"), + {"tooltip": "LORA models are expected to be in ComfyUI/models/loras with .safetensors extension"}), + "strength": ("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.0001, "tooltip": "LORA strength, set to 0.0 to unmerge the LORA"}), + }, + "optional": { + "prev_lora":("COGLORA", {"default": None, "tooltip": "For loading multiple LoRAs"}), + "fuse_lora": ("BOOLEAN", {"default": False, "tooltip": "Fuse the LoRA weights into the transformer"}), + } + } + + RETURN_TYPES = ("COGLORA",) + RETURN_NAMES = ("lora", ) + FUNCTION = "getlorapath" + CATEGORY = "CogVideoWrapper" + DESCRIPTION = "Select a LoRA model from ComfyUI/models/loras" + + def getlorapath(self, lora, strength, prev_lora=None, fuse_lora=False): + cog_loras_list = [] + + cog_lora = { + "path": folder_paths.get_full_path("loras", lora), + "strength": strength, + "name": lora.split(".")[0], + "fuse_lora": fuse_lora + } + if prev_lora is not None: + cog_loras_list.extend(prev_lora) + + cog_loras_list.append(cog_lora) + print(cog_loras_list) + return (cog_loras_list,) + +#region DownloadAndLoadCogVideoModel +class DownloadAndLoadCogVideoModel: + @classmethod + def INPUT_TYPES(s): + return { + "required": { + "model": ( + [ + "THUDM/CogVideoX-2b", + "THUDM/CogVideoX-5b", + "THUDM/CogVideoX-5b-I2V", + "kijai/CogVideoX-5b-1.5-T2V", + "kijai/CogVideoX-5b-1.5-I2V", + "bertjiazheng/KoolCogVideoX-5b", + "kijai/CogVideoX-Fun-2b", + "kijai/CogVideoX-Fun-5b", + "kijai/CogVideoX-5b-Tora", + "alibaba-pai/CogVideoX-Fun-V1.1-2b-InP", + "alibaba-pai/CogVideoX-Fun-V1.1-5b-InP", + "alibaba-pai/CogVideoX-Fun-V1.1-2b-Pose", + "alibaba-pai/CogVideoX-Fun-V1.1-5b-Pose", + "alibaba-pai/CogVideoX-Fun-V1.1-5b-Control", + "alibaba-pai/CogVideoX-Fun-V1.5-5b-InP", + "feizhengcong/CogvideoX-Interpolation", + "NimVideo/cogvideox-2b-img2vid" + ], + ), + + }, + "optional": { + "precision": (["fp16", "fp32", "bf16"], + {"default": "bf16", "tooltip": "official recommendation is that 2b model should be fp16, 5b model should be bf16"} + ), + "quantization": (['disabled', 'fp8_e4m3fn', 'fp8_e4m3fn_fastmode', 'torchao_fp8dq', "torchao_fp8dqrow", "torchao_int8dq", "torchao_fp6"], {"default": 'disabled', "tooltip": "enabled casts the transformer to torch.float8_e4m3fn, fastmode is only for latest nvidia GPUs and requires torch 2.4.0 and cu124 minimum"}), + "enable_sequential_cpu_offload": ("BOOLEAN", {"default": False, "tooltip": "significantly reducing memory usage and slows down the inference"}), + "block_edit": ("TRANSFORMERBLOCKS", {"default": None}), + "lora": ("COGLORA", {"default": None}), + "compile_args":("COMPILEARGS", ), + "attention_mode": ([ + "sdpa", + "fused_sdpa", + "sageattn", + "fused_sageattn", + "sageattn_qk_int8_pv_fp8_cuda", + "sageattn_qk_int8_pv_fp16_cuda", + "sageattn_qk_int8_pv_fp16_triton", + "fused_sageattn_qk_int8_pv_fp8_cuda", + "fused_sageattn_qk_int8_pv_fp16_cuda", + "fused_sageattn_qk_int8_pv_fp16_triton", + "comfy" + ], {"default": "sdpa"}), + "load_device": (["main_device", "offload_device"], {"default": "main_device"}), + } + } + + RETURN_TYPES = ("COGVIDEOMODEL", "VAE",) + RETURN_NAMES = ("model", "vae", ) + FUNCTION = "loadmodel" + CATEGORY = "CogVideoWrapper" + DESCRIPTION = "Downloads and loads the selected CogVideo model from Huggingface to 'ComfyUI/models/CogVideo'" + + def loadmodel(self, model, precision, quantization="disabled", compile="disabled", + enable_sequential_cpu_offload=False, block_edit=None, lora=None, compile_args=None, + attention_mode="sdpa", load_device="main_device"): + + transformer = None + + if "sage" in attention_mode: + try: + from sageattention import sageattn + except Exception as e: + raise ValueError(f"Can't import SageAttention: {str(e)}") + if "qk_int8" in attention_mode: + try: + from sageattention import sageattn_qk_int8_pv_fp16_cuda + except Exception as e: + raise ValueError(f"Can't import SageAttention 2.0.0: {str(e)}") + + if precision == "fp16" and "1.5" in model: + raise ValueError("1.5 models do not currently work in fp16") + + device = mm.get_torch_device() + offload_device = mm.unet_offload_device() + manual_offloading = True + transformer_load_device = device if load_device == "main_device" else offload_device + mm.soft_empty_cache() + + dtype = {"bf16": torch.bfloat16, "fp16": torch.float16, "fp32": torch.float32}[precision] + download_path = folder_paths.get_folder_paths("CogVideo")[0] + + if "Fun" in model: + if "1.1" not in model and "1.5" not in model: + repo_id = "kijai/CogVideoX-Fun-pruned" + if "2b" in model: + base_path = os.path.join(folder_paths.models_dir, "CogVideoX_Fun", "CogVideoX-Fun-2b-InP") # location of the official model + if not os.path.exists(base_path): + base_path = os.path.join(download_path, "CogVideoX-Fun-2b-InP") + elif "5b" in model: + base_path = os.path.join(folder_paths.models_dir, "CogVideoX_Fun", "CogVideoX-Fun-5b-InP") # location of the official model + if not os.path.exists(base_path): + base_path = os.path.join(download_path, "CogVideoX-Fun-5b-InP") + else: + repo_id = model + base_path = os.path.join(folder_paths.models_dir, "CogVideoX_Fun", (model.split("/")[-1])) # location of the official model + if not os.path.exists(base_path): + base_path = os.path.join(download_path, (model.split("/")[-1])) + download_path = base_path + subfolder = "transformer" + allow_patterns = ["*transformer*", "*scheduler*", "*vae*"] + + elif "2b" in model: + if 'img2vid' in model: + base_path = os.path.join(download_path, "cogvideox-2b-img2vid") + download_path = base_path + repo_id = model + else: + base_path = os.path.join(download_path, "CogVideo2B") + download_path = base_path + repo_id = model + subfolder = "transformer" + allow_patterns = ["*transformer*", "*scheduler*", "*vae*"] + elif "1.5-T2V" in model or "1.5-I2V" in model: + base_path = os.path.join(download_path, "CogVideoX-5b-1.5") + download_path = base_path + subfolder = "transformer_T2V" if "1.5-T2V" in model else "transformer_I2V" + allow_patterns = [f"*{subfolder}*", "*vae*", "*scheduler*"] + repo_id = "kijai/CogVideoX-5b-1.5" + else: + base_path = os.path.join(download_path, (model.split("/")[-1])) + download_path = base_path + repo_id = model + subfolder = "transformer" + allow_patterns = ["*transformer*", "*scheduler*", "*vae*"] + + if "2b" in model: + scheduler_path = os.path.join(script_directory, 'configs', 'scheduler_config_2b.json') + else: + scheduler_path = os.path.join(script_directory, 'configs', 'scheduler_config_5b.json') + + if not os.path.exists(base_path) or not os.path.exists(os.path.join(base_path, subfolder)): + log.info(f"Downloading model to: {base_path}") + from huggingface_hub import snapshot_download + + snapshot_download( + repo_id=repo_id, + allow_patterns=allow_patterns, + ignore_patterns=["*text_encoder*", "*tokenizer*"], + local_dir=download_path, + local_dir_use_symlinks=False, + ) + + transformer = CogVideoXTransformer3DModel.from_pretrained(base_path, subfolder=subfolder, attention_mode=attention_mode) + transformer = transformer.to(dtype).to(transformer_load_device) + + if "1.5" in model and not "fun" in model: + transformer.config.sample_height = 300 + transformer.config.sample_width = 300 + + if block_edit is not None: + transformer = remove_specific_blocks(transformer, block_edit) + + with open(scheduler_path) as f: + scheduler_config = json.load(f) + scheduler = CogVideoXDDIMScheduler.from_config(scheduler_config) + + # VAE + vae = AutoencoderKLCogVideoX.from_pretrained(base_path, subfolder="vae").to(dtype).to(offload_device) + + #pipeline + pipe = CogVideoXPipeline( + transformer, + scheduler, + dtype=dtype, + is_fun_inpaint="fun" in model.lower() and not ("pose" in model.lower() or "control" in model.lower()) + ) + if "cogvideox-2b-img2vid" in model: + pipe.input_with_padding = False + + #LoRAs + if lora is not None: + dimensionx_loras = ["orbit", "dimensionx"] # for now dimensionx loras need scaling + dimensionx_lora = False + adapter_list = [] + adapter_weights = [] + for l in lora: + if any(item in l["path"].lower() for item in dimensionx_loras): + dimensionx_lora = True + fuse = True if l["fuse_lora"] else False + lora_sd = load_torch_file(l["path"]) + lora_rank = None + for key, val in lora_sd.items(): + if "lora_B" in key: + lora_rank = val.shape[1] + break + if lora_rank is not None: + log.info(f"Merging rank {lora_rank} LoRA weights from {l['path']} with strength {l['strength']}") + adapter_name = l['path'].split("/")[-1].split(".")[0] + adapter_weight = l['strength'] + pipe.load_lora_weights(l['path'], weight_name=l['path'].split("/")[-1], lora_rank=lora_rank, adapter_name=adapter_name) + + adapter_list.append(adapter_name) + adapter_weights.append(adapter_weight) + else: + try: #Fun trainer LoRAs are loaded differently + from .lora_utils import merge_lora + log.info(f"Merging LoRA weights from {l['path']} with strength {l['strength']}") + pipe.transformer = merge_lora(pipe.transformer, l["path"], l["strength"], device=transformer_load_device, state_dict=lora_sd) + except: + raise ValueError(f"Can't recognize LoRA {l['path']}") + del lora_sd + mm.soft_empty_cache() + if adapter_list: + pipe.set_adapters(adapter_list, adapter_weights=adapter_weights) + if fuse: + lora_scale = 1 + if dimensionx_lora: + lora_scale = lora_scale / lora_rank + pipe.fuse_lora(lora_scale=lora_scale, components=["transformer"]) + pipe.delete_adapters(adapter_list) + + + if "fused" in attention_mode: + from diffusers.models.attention import Attention + pipe.transformer.fuse_qkv_projections = True + for module in pipe.transformer.modules(): + if isinstance(module, Attention): + module.fuse_projections(fuse=True) + + if compile_args is not None: + pipe.transformer.to(memory_format=torch.channels_last) + + #fp8 + if quantization == "fp8_e4m3fn" or quantization == "fp8_e4m3fn_fastmode": + params_to_keep = {"patch_embed", "lora", "pos_embedding", "time_embedding", "norm_k", "norm_q", "to_k.bias", "to_q.bias", "to_v.bias"} + if "1.5" in model: + params_to_keep.update({"norm1.linear.weight", "ofs_embedding", "norm_final", "norm_out", "proj_out"}) + for name, param in pipe.transformer.named_parameters(): + if not any(keyword in name for keyword in params_to_keep): + param.data = param.data.to(torch.float8_e4m3fn) + + if quantization == "fp8_e4m3fn_fastmode": + from .fp8_optimization import convert_fp8_linear + if "1.5" in model: + params_to_keep.update({"ff"}) #otherwise NaNs + convert_fp8_linear(pipe.transformer, dtype, params_to_keep=params_to_keep) + + # compilation + if compile_args is not None: + torch._dynamo.config.cache_size_limit = compile_args["dynamo_cache_size_limit"] + for i, block in enumerate(pipe.transformer.transformer_blocks): + if "CogVideoXBlock" in str(block): + pipe.transformer.transformer_blocks[i] = torch.compile(block, fullgraph=compile_args["fullgraph"], dynamic=compile_args["dynamic"], backend=compile_args["backend"], mode=compile_args["mode"]) + + if "torchao" in quantization: + try: + from torchao.quantization import ( + quantize_, + fpx_weight_only, + float8_dynamic_activation_float8_weight, + int8_dynamic_activation_int8_weight + ) + except: + raise ImportError("torchao is not installed, please install torchao to use fp8dq") + + def filter_fn(module: nn.Module, fqn: str) -> bool: + target_submodules = {'attn1', 'ff'} # avoid norm layers, 1.5 at least won't work with quantized norm1 #todo: test other models + if any(sub in fqn for sub in target_submodules): + return isinstance(module, nn.Linear) + return False + + if "fp6" in quantization: #slower for some reason on 4090 + quant_func = fpx_weight_only(3, 2) + elif "fp8dq" in quantization: #very fast on 4090 when compiled + quant_func = float8_dynamic_activation_float8_weight() + elif 'fp8dqrow' in quantization: + from torchao.quantization.quant_api import PerRow + quant_func = float8_dynamic_activation_float8_weight(granularity=PerRow()) + elif 'int8dq' in quantization: + quant_func = int8_dynamic_activation_int8_weight() + + for i, block in enumerate(pipe.transformer.transformer_blocks): + if "CogVideoXBlock" in str(block): + quantize_(block, quant_func, filter_fn=filter_fn) + + manual_offloading = False # to disable manual .to(device) calls + + if enable_sequential_cpu_offload: + pipe.enable_sequential_cpu_offload() + manual_offloading = False + + # CogVideoXBlock( + # (norm1): CogVideoXLayerNormZero( + # (silu): SiLU() + # (linear): Linear(in_features=512, out_features=18432, bias=True) + # (norm): LayerNorm((3072,), eps=1e-05, elementwise_affine=True) + # ) + # (attn1): Attention( + # (norm_q): LayerNorm((64,), eps=1e-06, elementwise_affine=True) + # (norm_k): LayerNorm((64,), eps=1e-06, elementwise_affine=True) + # (to_q): Linear(in_features=3072, out_features=3072, bias=True) + # (to_k): Linear(in_features=3072, out_features=3072, bias=True) + # (to_v): Linear(in_features=3072, out_features=3072, bias=True) + # (to_out): ModuleList( + # (0): Linear(in_features=3072, out_features=3072, bias=True) + # (1): Dropout(p=0.0, inplace=False) + # ) + # ) + # (norm2): CogVideoXLayerNormZero( + # (silu): SiLU() + # (linear): Linear(in_features=512, out_features=18432, bias=True) + # (norm): LayerNorm((3072,), eps=1e-05, elementwise_affine=True) + # ) + # (ff): FeedForward( + # (net): ModuleList( + # (0): GELU( + # (proj): Linear(in_features=3072, out_features=12288, bias=True) + # ) + # (1): Dropout(p=0.0, inplace=False) + # (2): Linear(in_features=12288, out_features=3072, bias=True) + # (3): Dropout(p=0.0, inplace=False) + # ) + # ) + # ) + + # if compile == "onediff": + # from onediffx import compile_pipe + # os.environ['NEXFORT_FX_FORCE_TRITON_SDPA'] = '1' + + # pipe = compile_pipe( + # pipe, + # backend="nexfort", + # options= {"mode": "max-optimize:max-autotune:max-autotune", "memory_format": "channels_last", "options": {"inductor.optimize_linear_epilogue": False, "triton.fuse_attention_allow_fp16_reduction": False}}, + # ignores=["vae"], + # fuse_qkv_projections= False, + # ) + + pipeline = { + "pipe": pipe, + "dtype": dtype, + "quantization": quantization, + "base_path": base_path, + "onediff": True if compile == "onediff" else False, + "cpu_offloading": enable_sequential_cpu_offload, + "manual_offloading": manual_offloading, + "scheduler_config": scheduler_config, + "model_name": model, + } + + return (pipeline, vae) +#region GGUF +class DownloadAndLoadCogVideoGGUFModel: + @classmethod + def INPUT_TYPES(s): + return { + "required": { + "model": ( + [ + "CogVideoX_5b_GGUF_Q4_0.safetensors", + "CogVideoX_5b_I2V_GGUF_Q4_0.safetensors", + "CogVideoX_5b_1_5_I2V_GGUF_Q4_0.safetensors", + "CogVideoX_5b_fun_GGUF_Q4_0.safetensors", + "CogVideoX_5b_fun_1_1_GGUF_Q4_0.safetensors", + "CogVideoX_5b_fun_1_1_Pose_GGUF_Q4_0.safetensors", + "CogVideoX_5b_Interpolation_GGUF_Q4_0.safetensors", + "CogVideoX_5b_Tora_GGUF_Q4_0.safetensors", + ], + ), + "vae_precision": (["fp16", "fp32", "bf16"], {"default": "bf16", "tooltip": "VAE dtype"}), + "fp8_fastmode": ("BOOLEAN", {"default": False, "tooltip": "only supported on 4090 and later GPUs, also requires torch 2.4.0 with cu124 minimum"}), + "load_device": (["main_device", "offload_device"], {"default": "main_device"}), + "enable_sequential_cpu_offload": ("BOOLEAN", {"default": False, "tooltip": "significantly reducing memory usage and slows down the inference"}), + }, + "optional": { + "block_edit": ("TRANSFORMERBLOCKS", {"default": None}), + #"compile_args":("COMPILEARGS", ), + "attention_mode": (["sdpa", "sageattn"], {"default": "sdpa"}), + } + } + + RETURN_TYPES = ("COGVIDEOMODEL", "VAE",) + RETURN_NAMES = ("model", "vae",) + FUNCTION = "loadmodel" + CATEGORY = "CogVideoWrapper" + + def loadmodel(self, model, vae_precision, fp8_fastmode, load_device, enable_sequential_cpu_offload, + block_edit=None, compile_args=None, attention_mode="sdpa"): + + if "sage" in attention_mode: + try: + from sageattention import sageattn + except Exception as e: + raise ValueError(f"Can't import SageAttention: {str(e)}") + + device = mm.get_torch_device() + offload_device = mm.unet_offload_device() + mm.soft_empty_cache() + + vae_dtype = {"bf16": torch.bfloat16, "fp16": torch.float16, "fp32": torch.float32}[vae_precision] + download_path = os.path.join(folder_paths.models_dir, 'CogVideo', 'GGUF') + gguf_path = os.path.join(folder_paths.models_dir, 'diffusion_models', model) # check MinusZone's model path first + if not os.path.exists(gguf_path): + gguf_path = os.path.join(download_path, model) + if not os.path.exists(gguf_path): + if "I2V" in model or "1_1" in model or "Interpolation" in model or "Tora" in model: + repo_id = "Kijai/CogVideoX_GGUF" + else: + repo_id = "MinusZoneAI/ComfyUI-CogVideoX-MZ" + log.info(f"Downloading model to: {gguf_path}") + from huggingface_hub import snapshot_download + + snapshot_download( + repo_id=repo_id, + allow_patterns=[f"*{model}*"], + local_dir=download_path, + local_dir_use_symlinks=False, + ) + + if "5b" in model: + scheduler_path = os.path.join(script_directory, 'configs', 'scheduler_config_5b.json') + transformer_path = os.path.join(script_directory, 'configs', 'transformer_config_5b.json') + elif "2b" in model: + scheduler_path = os.path.join(script_directory, 'configs', 'scheduler_config_2b.json') + transformer_path = os.path.join(script_directory, 'configs', 'transformer_config_2b.json') + + with open(transformer_path) as f: + transformer_config = json.load(f) + + + from . import mz_gguf_loader + import importlib + importlib.reload(mz_gguf_loader) + + with mz_gguf_loader.quantize_lazy_load(): + if "fun" in model: + if "Pose" in model: + transformer_config["in_channels"] = 32 + else: + transformer_config["in_channels"] = 33 + elif "I2V" in model or "Interpolation" in model: + transformer_config["in_channels"] = 32 + if "1_5" in model: + transformer_config["ofs_embed_dim"] = 512 + transformer_config["use_learned_positional_embeddings"] = False + transformer_config["patch_size_t"] = 2 + transformer_config["patch_bias"] = False + transformer_config["sample_height"] = 300 + transformer_config["sample_width"] = 300 + else: + transformer_config["in_channels"] = 16 + + transformer = CogVideoXTransformer3DModel.from_config(transformer_config, attention_mode=attention_mode) + cast_dtype = vae_dtype + params_to_keep = {"patch_embed", "pos_embedding", "time_embedding"} + if "2b" in model: + cast_dtype = torch.float16 + elif "1_5" in model: + params_to_keep = {"norm1.linear.weight", "patch_embed", "time_embedding", "ofs_embedding", "norm_final", "norm_out", "proj_out"} + cast_dtype = torch.bfloat16 + for name, param in transformer.named_parameters(): + if not any(keyword in name for keyword in params_to_keep): + param.data = param.data.to(torch.float8_e4m3fn) + else: + param.data = param.data.to(cast_dtype) + #for name, param in transformer.named_parameters(): + # print(name, param.data.dtype) + + if block_edit is not None: + transformer = remove_specific_blocks(transformer, block_edit) + + transformer.attention_mode = attention_mode + + if fp8_fastmode: + params_to_keep = {"patch_embed", "lora", "pos_embedding", "time_embedding"} + if "1.5" in model: + params_to_keep.update({"ff","norm1.linear.weight", "norm_k", "norm_q","ofs_embedding", "norm_final", "norm_out", "proj_out"}) + from .fp8_optimization import convert_fp8_linear + convert_fp8_linear(transformer, vae_dtype, params_to_keep=params_to_keep) + + with open(scheduler_path) as f: + scheduler_config = json.load(f) + + scheduler = CogVideoXDDIMScheduler.from_config(scheduler_config, subfolder="scheduler") + + # VAE + vae_dl_path = os.path.join(folder_paths.models_dir, 'CogVideo', 'VAE') + vae_path = os.path.join(vae_dl_path, "cogvideox_vae.safetensors") + if not os.path.exists(vae_path): + log.info(f"Downloading VAE model to: {vae_path}") + from huggingface_hub import snapshot_download + + snapshot_download( + repo_id="Kijai/CogVideoX-Fun-pruned", + allow_patterns=["*cogvideox_vae.safetensors*"], + local_dir=vae_dl_path, + local_dir_use_symlinks=False, + ) + with open(os.path.join(script_directory, 'configs', 'vae_config.json')) as f: + vae_config = json.load(f) + + #VAE + vae_sd = load_torch_file(vae_path) + vae = AutoencoderKLCogVideoX.from_config(vae_config).to(vae_dtype).to(offload_device) + vae.load_state_dict(vae_sd) + del vae_sd + pipe = CogVideoXPipeline( + transformer, + scheduler, + dtype=vae_dtype, + is_fun_inpaint="fun" in model.lower() and not ("pose" in model.lower() or "control" in model.lower()) + ) + + if enable_sequential_cpu_offload: + pipe.enable_sequential_cpu_offload() + + sd = load_torch_file(gguf_path) + pipe.transformer = mz_gguf_loader.quantize_load_state_dict(pipe.transformer, sd, device="cpu") + del sd + + if load_device == "offload_device": + pipe.transformer.to(offload_device) + else: + pipe.transformer.to(device) + + pipeline = { + "pipe": pipe, + "dtype": vae_dtype, + "quantization": "GGUF", + "base_path": model, + "onediff": False, + "cpu_offloading": enable_sequential_cpu_offload, + "scheduler_config": scheduler_config, + "model_name": model, + "manual_offloading": True, + } + + return (pipeline, vae) + +#region ModelLoader +class CogVideoXModelLoader: + @classmethod + def INPUT_TYPES(s): + return { + "required": { + "model": (folder_paths.get_filename_list("diffusion_models"), {"tooltip": "These models are loaded from the 'ComfyUI/models/diffusion_models' -folder",}), + + "base_precision": (["fp16", "fp32", "bf16"], {"default": "bf16"}), + "quantization": (['disabled', 'fp8_e4m3fn', 'fp8_e4m3fn_fast', 'torchao_fp8dq', "torchao_fp8dqrow", "torchao_int8dq", "torchao_fp6"], {"default": 'disabled', "tooltip": "optional quantization method"}), + "load_device": (["main_device", "offload_device"], {"default": "main_device"}), + "enable_sequential_cpu_offload": ("BOOLEAN", {"default": False, "tooltip": "significantly reducing memory usage and slows down the inference"}), + }, + "optional": { + "block_edit": ("TRANSFORMERBLOCKS", {"default": None}), + "lora": ("COGLORA", {"default": None}), + "compile_args":("COMPILEARGS", ), + "attention_mode": ([ + "sdpa", + "fused_sdpa", + "sageattn", + "fused_sageattn", + "sageattn_qk_int8_pv_fp8_cuda", + "sageattn_qk_int8_pv_fp16_cuda", + "sageattn_qk_int8_pv_fp16_triton", + "fused_sageattn_qk_int8_pv_fp8_cuda", + "fused_sageattn_qk_int8_pv_fp16_cuda", + "fused_sageattn_qk_int8_pv_fp16_triton", + "comfy" + ], {"default": "sdpa"}), + } + } + + RETURN_TYPES = ("COGVIDEOMODEL",) + RETURN_NAMES = ("model", ) + FUNCTION = "loadmodel" + CATEGORY = "CogVideoWrapper" + + def loadmodel(self, model, base_precision, load_device, enable_sequential_cpu_offload, + block_edit=None, compile_args=None, lora=None, attention_mode="sdpa", quantization="disabled"): + transformer = None + if "sage" in attention_mode: + try: + from sageattention import sageattn + except Exception as e: + raise ValueError(f"Can't import SageAttention: {str(e)}") + + device = mm.get_torch_device() + offload_device = mm.unet_offload_device() + manual_offloading = True + transformer_load_device = device if load_device == "main_device" else offload_device + mm.soft_empty_cache() + + base_dtype = {"fp8_e4m3fn": torch.float8_e4m3fn, "fp8_e4m3fn_fast": torch.float8_e4m3fn, "bf16": torch.bfloat16, "fp16": torch.float16, "fp32": torch.float32}[base_precision] + + model_path = folder_paths.get_full_path_or_raise("diffusion_models", model) + sd = load_torch_file(model_path, device=transformer_load_device) + + model_type = "" + if sd["patch_embed.proj.weight"].shape == (3072, 33, 2, 2): + model_type = "fun_5b" + elif sd["patch_embed.proj.weight"].shape == (3072, 16, 2, 2): + model_type = "5b" + elif sd["patch_embed.proj.weight"].shape == (3072, 128): + model_type = "5b_1_5" + elif sd["patch_embed.proj.weight"].shape == (3072, 256): + model_type = "5b_I2V_1_5" + elif sd["patch_embed.proj.weight"].shape == (1920, 33, 2, 2): + model_type = "fun_2b" + elif sd["patch_embed.proj.weight"].shape == (1920, 32, 2, 2): + model_type = "cogvideox-2b-img2vid" + elif sd["patch_embed.proj.weight"].shape == (1920, 16, 2, 2): + model_type = "2b" + elif sd["patch_embed.proj.weight"].shape == (3072, 32, 2, 2): + if "pos_embedding" in sd: + model_type = "fun_5b_pose" + else: + model_type = "I2V_5b" + else: + raise Exception("Selected model is not recognized") + log.info(f"Detected CogVideoX model type: {model_type}") + + if "5b" in model_type: + scheduler_config_path = os.path.join(script_directory, 'configs', 'scheduler_config_5b.json') + transformer_config_path = os.path.join(script_directory, 'configs', 'transformer_config_5b.json') + elif "2b" in model_type: + scheduler_config_path = os.path.join(script_directory, 'configs', 'scheduler_config_2b.json') + transformer_config_path = os.path.join(script_directory, 'configs', 'transformer_config_2b.json') + + with open(transformer_config_path) as f: + transformer_config = json.load(f) + + if model_type in ["I2V", "I2V_5b", "fun_5b_pose", "5b_I2V_1_5", "cogvideox-2b-img2vid"]: + transformer_config["in_channels"] = 32 + if "1_5" in model_type: + transformer_config["ofs_embed_dim"] = 512 + elif "fun" in model_type: + transformer_config["in_channels"] = 33 + else: + transformer_config["in_channels"] = 16 + if "1_5" in model_type: + transformer_config["use_learned_positional_embeddings"] = False + transformer_config["patch_size_t"] = 2 + transformer_config["patch_bias"] = False + transformer_config["sample_height"] = 300 + transformer_config["sample_width"] = 300 + + with init_empty_weights(): + transformer = CogVideoXTransformer3DModel.from_config(transformer_config, attention_mode=attention_mode) + + #load weights + #params_to_keep = {} + log.info("Using accelerate to load and assign model weights to device...") + + for name, param in transformer.named_parameters(): + #dtype_to_use = base_dtype if any(keyword in name for keyword in params_to_keep) else dtype + set_module_tensor_to_device(transformer, name, device=transformer_load_device, dtype=base_dtype, value=sd[name]) + del sd + # TODO fix for transformer model patch_embed.pos_embedding dtype + # or at add line ComfyUI-CogVideoXWrapper/embeddings.py:129 code + # pos_embedding = pos_embedding.to(embeds.device, dtype=embeds.dtype) + transformer = transformer.to(base_dtype).to(transformer_load_device) + + #scheduler + with open(scheduler_config_path) as f: + scheduler_config = json.load(f) + scheduler = CogVideoXDDIMScheduler.from_config(scheduler_config, subfolder="scheduler") + + if block_edit is not None: + transformer = remove_specific_blocks(transformer, block_edit) + + if "fused" in attention_mode: + from diffusers.models.attention import Attention + transformer.fuse_qkv_projections = True + for module in transformer.modules(): + if isinstance(module, Attention): + module.fuse_projections(fuse=True) + transformer.attention_mode = attention_mode + + pipe = CogVideoXPipeline( + transformer, + scheduler, + dtype=base_dtype, + is_fun_inpaint="fun" in model.lower() and not ("pose" in model.lower() or "control" in model.lower()) + ) + if "cogvideox-2b-img2vid" == model_type: + pipe.input_with_padding = False + if enable_sequential_cpu_offload: + pipe.enable_sequential_cpu_offload() + + #LoRAs + if lora is not None: + dimensionx_loras = ["orbit", "dimensionx"] # for now dimensionx loras need scaling + dimensionx_lora = False + adapter_list = [] + adapter_weights = [] + for l in lora: + if any(item in l["path"].lower() for item in dimensionx_loras): + dimensionx_lora = True + fuse = True if l["fuse_lora"] else False + lora_sd = load_torch_file(l["path"]) + lora_rank = None + for key, val in lora_sd.items(): + if "lora_B" in key: + lora_rank = val.shape[1] + break + if lora_rank is not None: + log.info(f"Merging rank {lora_rank} LoRA weights from {l['path']} with strength {l['strength']}") + adapter_name = l['path'].split("/")[-1].split(".")[0] + adapter_weight = l['strength'] + pipe.load_lora_weights(l['path'], weight_name=l['path'].split("/")[-1], lora_rank=lora_rank, adapter_name=adapter_name) + + adapter_list.append(adapter_name) + adapter_weights.append(adapter_weight) + else: + try: #Fun trainer LoRAs are loaded differently + from .lora_utils import merge_lora + log.info(f"Merging LoRA weights from {l['path']} with strength {l['strength']}") + pipe.transformer = merge_lora(pipe.transformer, l["path"], l["strength"], device=transformer_load_device, state_dict=lora_sd) + except: + raise ValueError(f"Can't recognize LoRA {l['path']}") + if adapter_list: + pipe.set_adapters(adapter_list, adapter_weights=adapter_weights) + if fuse: + lora_scale = 1 + if dimensionx_lora: + lora_scale = lora_scale / lora_rank + pipe.fuse_lora(lora_scale=lora_scale, components=["transformer"]) + + if compile_args is not None: + pipe.transformer.to(memory_format=torch.channels_last) + + #quantization + if quantization == "fp8_e4m3fn" or quantization == "fp8_e4m3fn_fast": + params_to_keep = {"patch_embed", "lora", "pos_embedding", "time_embedding", "norm_k", "norm_q", "to_k.bias", "to_q.bias", "to_v.bias"} + if "1.5" in model: + params_to_keep.update({"norm1.linear.weight", "ofs_embedding", "norm_final", "norm_out", "proj_out"}) + for name, param in pipe.transformer.named_parameters(): + if not any(keyword in name for keyword in params_to_keep): + param.data = param.data.to(torch.float8_e4m3fn) + + if quantization == "fp8_e4m3fn_fast": + from .fp8_optimization import convert_fp8_linear + if "1.5" in model: + params_to_keep.update({"ff"}) #otherwise NaNs + convert_fp8_linear(pipe.transformer, base_dtype, params_to_keep=params_to_keep) + + #compile + if compile_args is not None: + torch._dynamo.config.cache_size_limit = compile_args["dynamo_cache_size_limit"] + for i, block in enumerate(pipe.transformer.transformer_blocks): + if "CogVideoXBlock" in str(block): + pipe.transformer.transformer_blocks[i] = torch.compile(block, fullgraph=compile_args["fullgraph"], dynamic=compile_args["dynamic"], backend=compile_args["backend"], mode=compile_args["mode"]) + + if "torchao" in quantization: + try: + from torchao.quantization import ( + quantize_, + fpx_weight_only, + float8_dynamic_activation_float8_weight, + int8_dynamic_activation_int8_weight + ) + except: + raise ImportError("torchao is not installed, please install torchao to use fp8dq") + + def filter_fn(module: nn.Module, fqn: str) -> bool: + target_submodules = {'attn1', 'ff'} # avoid norm layers, 1.5 at least won't work with quantized norm1 #todo: test other models + if any(sub in fqn for sub in target_submodules): + return isinstance(module, nn.Linear) + return False + + if "fp6" in quantization: #slower for some reason on 4090 + quant_func = fpx_weight_only(3, 2) + elif "fp8dq" in quantization: #very fast on 4090 when compiled + quant_func = float8_dynamic_activation_float8_weight() + elif 'fp8dqrow' in quantization: + from torchao.quantization.quant_api import PerRow + quant_func = float8_dynamic_activation_float8_weight(granularity=PerRow()) + elif 'int8dq' in quantization: + quant_func = int8_dynamic_activation_int8_weight() + + for i, block in enumerate(pipe.transformer.transformer_blocks): + if "CogVideoXBlock" in str(block): + quantize_(block, quant_func, filter_fn=filter_fn) + + manual_offloading = False # to disable manual .to(device) calls + log.info(f"Quantized transformer blocks to {quantization}") + + pipeline = { + "pipe": pipe, + "dtype": base_dtype, + "quantization": quantization, + "base_path": model, + "onediff": False, + "cpu_offloading": enable_sequential_cpu_offload, + "scheduler_config": scheduler_config, + "model_name": model, + "manual_offloading": manual_offloading, + } + return (pipeline,) + +#region VAE + +class CogVideoXVAELoader: + @classmethod + def INPUT_TYPES(s): + return { + "required": { + "model_name": (folder_paths.get_filename_list("vae"), {"tooltip": "These models are loaded from 'ComfyUI/models/vae'"}), + }, + "optional": { + "precision": (["fp16", "fp32", "bf16"], + {"default": "bf16"} + ), + "compile_args":("COMPILEARGS", ), + } + } + + RETURN_TYPES = ("VAE",) + RETURN_NAMES = ("vae", ) + FUNCTION = "loadmodel" + CATEGORY = "CogVideoWrapper" + DESCRIPTION = "Loads CogVideoX VAE model from 'ComfyUI/models/vae'" + + def loadmodel(self, model_name, precision, compile_args=None): + device = mm.get_torch_device() + offload_device = mm.unet_offload_device() + + dtype = {"bf16": torch.bfloat16, "fp16": torch.float16, "fp32": torch.float32}[precision] + with open(os.path.join(script_directory, 'configs', 'vae_config.json')) as f: + vae_config = json.load(f) + model_path = folder_paths.get_full_path("vae", model_name) + vae_sd = load_torch_file(model_path) + + vae = AutoencoderKLCogVideoX.from_config(vae_config).to(dtype).to(offload_device) + vae.load_state_dict(vae_sd) + #compile + if compile_args is not None: + torch._dynamo.config.cache_size_limit = compile_args["dynamo_cache_size_limit"] + vae = torch.compile(vae, fullgraph=compile_args["fullgraph"], dynamic=compile_args["dynamic"], backend=compile_args["backend"], mode=compile_args["mode"]) + + return (vae,) + +#region Tora +class DownloadAndLoadToraModel: + @classmethod + def INPUT_TYPES(s): + return { + "required": { + "model": ( + [ + "kijai/CogVideoX-5b-Tora", + "kijai/CogVideoX-5b-Tora-I2V", + ], + ), + }, + } + + RETURN_TYPES = ("TORAMODEL",) + RETURN_NAMES = ("tora_model", ) + FUNCTION = "loadmodel" + CATEGORY = "CogVideoWrapper" + DESCRIPTION = "Downloads and loads the the Tora model from Huggingface to 'ComfyUI/models/CogVideo/CogVideoX-5b-Tora'" + + def loadmodel(self, model): + device = mm.get_torch_device() + offload_device = mm.unet_offload_device() + mm.soft_empty_cache() + + download_path = folder_paths.get_folder_paths("CogVideo")[0] + + from .tora.traj_module import MGF + + try: + from accelerate import init_empty_weights + from accelerate.utils import set_module_tensor_to_device + is_accelerate_available = True + except: + is_accelerate_available = False + pass + + download_path = os.path.join(folder_paths.models_dir, 'CogVideo', "CogVideoX-5b-Tora") + + + fuser_model = "fuser.safetensors" if not "I2V" in model else "fuser_I2V.safetensors" + fuser_path = os.path.join(download_path, "fuser", fuser_model) + if not os.path.exists(fuser_path): + log.info(f"Downloading Fuser model to: {fuser_path}") + from huggingface_hub import snapshot_download + + snapshot_download( + repo_id=model, + allow_patterns=[fuser_model], + local_dir=download_path, + local_dir_use_symlinks=False, + ) + + hidden_size = 3072 + num_layers = 42 + + with (init_empty_weights() if is_accelerate_available else nullcontext()): + fuser_list = nn.ModuleList([MGF(128, hidden_size) for _ in range(num_layers)]) + + fuser_sd = load_torch_file(fuser_path) + if is_accelerate_available: + for key in fuser_sd: + set_module_tensor_to_device(fuser_list, key, dtype=torch.float16, device=device, value=fuser_sd[key]) + else: + fuser_list.load_state_dict(fuser_sd) + for module in fuser_list: + for param in module.parameters(): + param.data = param.data.to(torch.bfloat16).to(device) + del fuser_sd + + traj_extractor_model = "traj_extractor.safetensors" if not "I2V" in model else "traj_extractor_I2V.safetensors" + traj_extractor_path = os.path.join(download_path, "traj_extractor", traj_extractor_model) + if not os.path.exists(traj_extractor_path): + log.info(f"Downloading trajectory extractor model to: {traj_extractor_path}") + from huggingface_hub import snapshot_download + + snapshot_download( + repo_id="kijai/CogVideoX-5b-Tora", + allow_patterns=[traj_extractor_model], + local_dir=download_path, + local_dir_use_symlinks=False, + ) + + from .tora.traj_module import TrajExtractor + with (init_empty_weights() if is_accelerate_available else nullcontext()): + traj_extractor = TrajExtractor( + vae_downsize=(4, 8, 8), + patch_size=2, + nums_rb=2, + cin=16, + channels=[128] * 42, + sk=True, + use_conv=False, + ) + + traj_sd = load_torch_file(traj_extractor_path) + if is_accelerate_available: + for key in traj_sd: + set_module_tensor_to_device(traj_extractor, key, dtype=torch.float32, device=device, value=traj_sd[key]) + else: + traj_extractor.load_state_dict(traj_sd) + traj_extractor.to(torch.float32).to(device) + + toramodel = { + "fuser_list": fuser_list, + "traj_extractor": traj_extractor, + } + + return (toramodel,) +#region controlnet +class DownloadAndLoadCogVideoControlNet: + @classmethod + def INPUT_TYPES(s): + return { + "required": { + "model": ( + [ + "TheDenk/cogvideox-2b-controlnet-hed-v1", + "TheDenk/cogvideox-2b-controlnet-canny-v1", + "TheDenk/cogvideox-5b-controlnet-hed-v1", + "TheDenk/cogvideox-5b-controlnet-canny-v1" + ], + ), + + }, + } + + RETURN_TYPES = ("COGVIDECONTROLNETMODEL",) + RETURN_NAMES = ("cogvideo_controlnet", ) + FUNCTION = "loadmodel" + CATEGORY = "CogVideoWrapper" + + def loadmodel(self, model): + from .cogvideo_controlnet import CogVideoXControlnet + + device = mm.get_torch_device() + offload_device = mm.unet_offload_device() + mm.soft_empty_cache() + + + download_path = os.path.join(folder_paths.models_dir, 'CogVideo', 'ControlNet') + base_path = os.path.join(download_path, (model.split("/")[-1])) + + if not os.path.exists(base_path): + log.info(f"Downloading model to: {base_path}") + from huggingface_hub import snapshot_download + + snapshot_download( + repo_id=model, + ignore_patterns=["*text_encoder*", "*tokenizer*"], + local_dir=base_path, + local_dir_use_symlinks=False, + ) + + controlnet = CogVideoXControlnet.from_pretrained(base_path) + + return (controlnet,) + +NODE_CLASS_MAPPINGS = { + "DownloadAndLoadCogVideoModel": DownloadAndLoadCogVideoModel, + "DownloadAndLoadCogVideoGGUFModel": DownloadAndLoadCogVideoGGUFModel, + "DownloadAndLoadCogVideoControlNet": DownloadAndLoadCogVideoControlNet, + "DownloadAndLoadToraModel": DownloadAndLoadToraModel, + "CogVideoLoraSelect": CogVideoLoraSelect, + "CogVideoXVAELoader": CogVideoXVAELoader, + "CogVideoXModelLoader": CogVideoXModelLoader, + "CogVideoLoraSelectComfy": CogVideoLoraSelectComfy +} +NODE_DISPLAY_NAME_MAPPINGS = { + "DownloadAndLoadCogVideoModel": "(Down)load CogVideo Model", + "DownloadAndLoadCogVideoGGUFModel": "(Down)load CogVideo GGUF Model", + "DownloadAndLoadCogVideoControlNet": "(Down)load CogVideo ControlNet", + "DownloadAndLoadToraModel": "(Down)load Tora Model", + "CogVideoLoraSelect": "CogVideo LoraSelect", + "CogVideoXVAELoader": "CogVideoX VAE Loader", + "CogVideoXModelLoader": "CogVideoX Model Loader", + "CogVideoLoraSelectComfy": "CogVideo LoraSelect Comfy" + } \ No newline at end of file diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/mz_enable_vae_encode_tiling.py b/custom_nodes/ComfyUI-CogVideoXWrapper/mz_enable_vae_encode_tiling.py new file mode 100644 index 0000000000000000000000000000000000000000..f97f6a0407b55b950540cb21701aa481c2159f04 --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/mz_enable_vae_encode_tiling.py @@ -0,0 +1,197 @@ +# thanks to MinusZoneAI: https://github.com/MinusZoneAI/ComfyUI-CogVideoX-MZ/blob/b98b98bd04621e4c85547866c12de2ec723ae98a/mz_enable_vae_encode_tiling.py +from typing import Optional +import torch +from diffusers.utils.accelerate_utils import apply_forward_hook +from diffusers.models.autoencoders.vae import DecoderOutput, DiagonalGaussianDistribution +from diffusers.models.modeling_outputs import AutoencoderKLOutput + + +@apply_forward_hook +def encode( + self, x: torch.Tensor, return_dict: bool = True +): + """ + Encode a batch of images into latents. + Args: + x (`torch.Tensor`): Input batch of images. + return_dict (`bool`, *optional*, defaults to `True`): + Whether to return a [`~models.autoencoder_kl.AutoencoderKLOutput`] instead of a plain tuple. + Returns: + The latent representations of the encoded videos. If `return_dict` is True, a + [`~models.autoencoder_kl.AutoencoderKLOutput`] is returned, otherwise a plain `tuple` is returned. + """ + if self.use_slicing and x.shape[0] > 1: + encoded_slices = [self._encode(x_slice) for x_slice in x.split(1)] + h = torch.cat(encoded_slices) + else: + h = self._encode(x) + posterior = DiagonalGaussianDistribution(h) + + if not return_dict: + return (posterior,) + return AutoencoderKLOutput(latent_dist=posterior) + + +def tiled_encode(self, x: torch.Tensor) -> torch.Tensor: + r"""Encode a batch of images using a tiled encoder. + When this option is enabled, the VAE will split the input tensor into tiles to compute encoding in several + steps. This is useful to keep memory use constant regardless of image size. The end result of tiled encoding is + different from non-tiled encoding because each tile uses a different encoder. To avoid tiling artifacts, the + tiles overlap and are blended together to form a smooth output. You may still see tile-sized changes in the + output, but they should be much less noticeable. + Args: + x (`torch.Tensor`): Input batch of videos. + Returns: + `torch.Tensor`: + The latent representation of the encoded videos. + """ + # For a rough memory estimate, take a look at the `tiled_decode` method. + batch_size, num_channels, num_frames, height, width = x.shape + overlap_height = int(self.tile_sample_min_height * + (1 - self.tile_overlap_factor_height)) + overlap_width = int(self.tile_sample_min_width * + (1 - self.tile_overlap_factor_width)) + blend_extent_height = int( + self.tile_latent_min_height * self.tile_overlap_factor_height) + blend_extent_width = int( + self.tile_latent_min_width * self.tile_overlap_factor_width) + row_limit_height = self.tile_latent_min_height - blend_extent_height + row_limit_width = self.tile_latent_min_width - blend_extent_width + frame_batch_size = 4 + # Split x into overlapping tiles and encode them separately. + # The tiles have an overlap to avoid seams between tiles. + rows = [] + for i in range(0, height, overlap_height): + row = [] + for j in range(0, width, overlap_width): + # Note: We expect the number of frames to be either `1` or `frame_batch_size * k` or `frame_batch_size * k + 1` for some k. + num_batches = num_frames // frame_batch_size if num_frames > 1 else 1 + time = [] + for k in range(num_batches): + remaining_frames = num_frames % frame_batch_size + start_frame = frame_batch_size * k + \ + (0 if k == 0 else remaining_frames) + end_frame = frame_batch_size * (k + 1) + remaining_frames + tile = x[ + :, + :, + start_frame:end_frame, + i: i + self.tile_sample_min_height, + j: j + self.tile_sample_min_width, + ] + + tile = self.encoder(tile) + if not isinstance(tile, tuple): + tile = (tile,) + if self.quant_conv is not None: + tile = self.quant_conv(tile) + time.append(tile[0]) + try: + self._clear_fake_context_parallel_cache() + except: + pass + row.append(torch.cat(time, dim=2)) + 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_height) + if j > 0: + tile = self.blend_h(row[j - 1], tile, blend_extent_width) + result_row.append( + tile[:, :, :, :row_limit_height, :row_limit_width]) + result_rows.append(torch.cat(result_row, dim=4)) + enc = torch.cat(result_rows, dim=3) + return enc + + +def _encode( + self, x: torch.Tensor, return_dict: bool = True +): + batch_size, num_channels, num_frames, height, width = x.shape + + if self.use_encode_tiling and (width > self.tile_sample_min_width or height > self.tile_sample_min_height): + return self.tiled_encode(x) + + if num_frames == 1: + h = self.encoder(x) + if self.quant_conv is not None: + h = self.quant_conv(h) + posterior = DiagonalGaussianDistribution(h) + else: + frame_batch_size = 4 + h = [] + for i in range(num_frames // frame_batch_size): + remaining_frames = num_frames % frame_batch_size + start_frame = frame_batch_size * i + \ + (0 if i == 0 else remaining_frames) + end_frame = frame_batch_size * (i + 1) + remaining_frames + z_intermediate = x[:, :, start_frame:end_frame] + z_intermediate = self.encoder(z_intermediate) + if self.quant_conv is not None: + z_intermediate = self.quant_conv(z_intermediate) + h.append(z_intermediate) + try: + self._clear_fake_context_parallel_cache() + except: + pass + h = torch.cat(h, dim=2) + return h + + +def enable_encode_tiling( + self, + tile_sample_min_height: Optional[int] = None, + tile_sample_min_width: Optional[int] = None, + tile_overlap_factor_height: Optional[float] = None, + tile_overlap_factor_width: Optional[float] = None, +) -> None: + r""" + Enable tiled VAE decoding. When this option is enabled, the VAE will split the input tensor into tiles to + compute decoding and encoding in several steps. This is useful for saving a large amount of memory and to allow + processing larger images. + + Args: + tile_sample_min_height (`int`, *optional*): + The minimum height required for a sample to be separated into tiles across the height dimension. + tile_sample_min_width (`int`, *optional*): + The minimum width required for a sample to be separated into tiles across the width dimension. + tile_overlap_factor_height (`int`, *optional*): + The minimum amount of overlap between two consecutive vertical tiles. This is to ensure that there are + no tiling artifacts produced across the height dimension. Must be between 0 and 1. Setting a higher + value might cause more tiles to be processed leading to slow down of the decoding process. + tile_overlap_factor_width (`int`, *optional*): + The minimum amount of overlap between two consecutive horizontal tiles. This is to ensure that there + are no tiling artifacts produced across the width dimension. Must be between 0 and 1. Setting a higher + value might cause more tiles to be processed leading to slow down of the decoding process. + """ + self.use_encode_tiling = True + self.tile_sample_min_height = tile_sample_min_height or self.tile_sample_min_height + self.tile_sample_min_width = tile_sample_min_width or self.tile_sample_min_width + self.tile_latent_min_height = int( + self.tile_sample_min_height / + (2 ** (len(self.config.block_out_channels) - 1)) + ) + self.tile_latent_min_width = int( + self.tile_sample_min_width / (2 ** (len(self.config.block_out_channels) - 1))) + self.tile_overlap_factor_height = tile_overlap_factor_height or self.tile_overlap_factor_height + self.tile_overlap_factor_width = tile_overlap_factor_width or self.tile_overlap_factor_width + + +from types import MethodType + + +def enable_vae_encode_tiling(vae): + vae.encode = MethodType(encode, vae) + setattr(vae, "_encode", MethodType(_encode, vae)) + setattr(vae, "tiled_encode", MethodType(tiled_encode, vae)) + setattr(vae, "use_encode_tiling", True) + + setattr(vae, "enable_encode_tiling", MethodType(enable_encode_tiling, vae)) + vae.enable_encode_tiling() + return vae diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/mz_gguf_loader.py b/custom_nodes/ComfyUI-CogVideoXWrapper/mz_gguf_loader.py new file mode 100644 index 0000000000000000000000000000000000000000..50c2154ba276f91868e4c12c5efb3304327ebafa --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/mz_gguf_loader.py @@ -0,0 +1,221 @@ +# https://github.com/MinusZoneAI/ComfyUI-CogVideoX-MZ/blob/9616415220fd09388622f40f6609e4ed81f048a5/mz_gguf_loader.py + +import torch +import torch.nn as nn +import gc + + +class quantize_lazy_load(): + def __init__(self): + self.device = None + + def __enter__(self): + self.device = torch.device("meta") + self.device.__enter__() + return self + + def __exit__(self, exc_type, exc_value, traceback): + self.device.__exit__(exc_type, exc_value, traceback) + + +def quantize_load_state_dict(model, state_dict, device="cpu"): + quant_keys = [] + for key in state_dict.keys(): + if key.endswith(".Q4_0_qweight"): + quant_keys.append(key.replace(".Q4_0_qweight", "")) + qtype = "Q4_0" + elif key.endswith(".Q8_0_qweight"): + quant_keys.append(key.replace(".Q8_0_qweight", "")) + qtype = "Q8_0" + + for name, module in model.named_modules(): + if name in quant_keys: + q_linear = WQLinear_GGUF.from_linear( + linear=module, + device=device, + qtype=qtype, + ) + set_op_by_name(model, name, q_linear) + + model.to_empty(device=device) + model.load_state_dict(state_dict, strict=False) + model.to(device) + return model + + +def set_op_by_name(layer, name, new_module): + levels = name.split(".") + if len(levels) > 1: + mod_ = layer + for l_idx in range(len(levels) - 1): + if levels[l_idx].isdigit(): + mod_ = mod_[int(levels[l_idx])] + else: + mod_ = getattr(mod_, levels[l_idx]) + setattr(mod_, levels[-1], new_module) + else: + setattr(layer, name, new_module) + + +import torch.nn.functional as F + + +class WQLinear_GGUF(nn.Module): + def __init__( + self, in_features, out_features, bias, dev, qtype="Q4_0" + ): + super().__init__() + + self.in_features = in_features + self.out_features = out_features + self.qtype = qtype + + qweight_shape = quant_shape_to_byte_shape( + (out_features, in_features), qtype + ) + self.register_buffer( + f"{qtype}_qweight", + torch.zeros( + qweight_shape, + dtype=torch.uint8, + device=dev, + ), + ) + if bias: + self.register_buffer( + "bias", + torch.zeros( + (out_features), + dtype=torch.float16, + device=dev, + ), + ) + else: + self.bias = None + + @classmethod + def from_linear( + cls, linear, + device="cpu", + qtype="Q4_0", + ): + q_linear = cls( + linear.in_features, + linear.out_features, + linear.bias is not None, + device, + qtype=qtype, + ) + return q_linear + + def extra_repr(self) -> str: + return ( + "in_features={}, out_features={}, bias={}, w_bit={}, group_size={}".format( + self.in_features, + self.out_features, + self.bias is not None, + self.w_bit, + self.group_size, + ) + ) + + @torch.no_grad() + def forward(self, x): + if self.qtype == "Q4_0": + dequant = dequantize_blocks_Q4_0(self.Q4_0_qweight, x.dtype) + elif self.qtype == "Q8_0": + dequant = dequantize_blocks_Q8_0(self.Q8_0_qweight, x.dtype) + else: + raise ValueError(f"Unknown qtype: {self.qtype}") + + return F.linear(x, dequant, bias=self.bias.to(x.dtype) if self.bias is not None else None) + + +def split_block_dims(blocks, *args): + n_max = blocks.shape[1] + dims = list(args) + [n_max - sum(args)] + return torch.split(blocks, dims, dim=1) + + +def quant_shape_to_byte_shape(shape, qtype) -> tuple[int, ...]: + # shape = shape[::-1] + block_size, type_size = GGML_QUANT_SIZES[qtype] + if shape[-1] % block_size != 0: + raise ValueError( + f"Quantized tensor row size ({shape[-1]}) is not a multiple of Q4_0 block size ({block_size})") + return (*shape[:-1], shape[-1] // block_size * type_size) + + +def quant_shape_from_byte_shape(shape, qtype) -> tuple[int, ...]: + # shape = shape[::-1] + block_size, type_size = GGML_QUANT_SIZES[qtype] + if shape[-1] % type_size != 0: + raise ValueError( + f"Quantized tensor bytes per row ({shape[-1]}) is not a multiple of Q4_0 type size ({type_size})") + return (*shape[:-1], shape[-1] // type_size * block_size) + + +GGML_QUANT_SIZES = { + "Q4_0": (32, 2 + 16), + "Q8_0": (32, 2 + 32), +} + + +def dequantize_blocks_Q4_0(data, dtype=torch.float16): + block_size, type_size = GGML_QUANT_SIZES["Q4_0"] + + data = data.to(torch.uint8) + shape = data.shape + + rows = data.reshape( + (-1, data.shape[-1]) + ).view(torch.uint8) + + n_blocks = rows.numel() // type_size + blocks = data.reshape((n_blocks, type_size)) + + n_blocks = blocks.shape[0] + + d, qs = split_block_dims(blocks, 2) + d = d.view(torch.float16) + + qs = qs.reshape((n_blocks, -1, 1, block_size // 2)) >> torch.tensor( + [0, 4], device=d.device, dtype=torch.uint8).reshape((1, 1, 2, 1)) + qs = (qs & 0x0F).reshape((n_blocks, -1)).to(torch.int8) - 8 + + out = (d * qs) + + out = out.reshape(quant_shape_from_byte_shape( + shape, + qtype="Q4_0", + )).to(dtype) + return out + +def dequantize_blocks_Q8_0(data, dtype=torch.float16): + block_size, type_size = GGML_QUANT_SIZES["Q8_0"] + + data = data.to(torch.uint8) + shape = data.shape + + rows = data.reshape( + (-1, data.shape[-1]) + ).view(torch.uint8) + + n_blocks = rows.numel() // type_size + blocks = data.reshape((n_blocks, type_size)) + + n_blocks = blocks.shape[0] + + d, qs = split_block_dims(blocks, 2) + d = d.view(torch.float16).to(torch.float32) + + qs = qs.view(torch.int8).to(torch.float32) + + out = (d * qs) + + out = out.reshape(quant_shape_from_byte_shape( + shape, + qtype="Q8_0", + )).to(dtype) + return out + diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/nodes.py b/custom_nodes/ComfyUI-CogVideoXWrapper/nodes.py new file mode 100644 index 0000000000000000000000000000000000000000..9d061e7eee59c77f7c6025e799c99740fa715b90 --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/nodes.py @@ -0,0 +1,1036 @@ +import os +import torch +import json +from einops import rearrange +from contextlib import nullcontext + +from .utils import log, check_diffusers_version, print_memory +check_diffusers_version() +from diffusers.schedulers import ( + CogVideoXDDIMScheduler, + CogVideoXDPMScheduler, + DDIMScheduler, + PNDMScheduler, + DPMSolverMultistepScheduler, + EulerDiscreteScheduler, + EulerAncestralDiscreteScheduler, + UniPCMultistepScheduler, + HeunDiscreteScheduler, + SASolverScheduler, + DEISMultistepScheduler, + LCMScheduler + ) + +scheduler_mapping = { + "DPM++": DPMSolverMultistepScheduler, + "Euler": EulerDiscreteScheduler, + "Euler A": EulerAncestralDiscreteScheduler, + "PNDM": PNDMScheduler, + "DDIM": DDIMScheduler, + "CogVideoXDDIM": CogVideoXDDIMScheduler, + "CogVideoXDPMScheduler": CogVideoXDPMScheduler, + "SASolverScheduler": SASolverScheduler, + "UniPCMultistepScheduler": UniPCMultistepScheduler, + "HeunDiscreteScheduler": HeunDiscreteScheduler, + "DEISMultistepScheduler": DEISMultistepScheduler, + "LCMScheduler": LCMScheduler +} +available_schedulers = list(scheduler_mapping.keys()) + +from diffusers.video_processor import VideoProcessor + +import folder_paths +import comfy.model_management as mm + +script_directory = os.path.dirname(os.path.abspath(__file__)) + +if not "CogVideo" in folder_paths.folder_names_and_paths: + folder_paths.add_model_folder_path("CogVideo", os.path.join(folder_paths.models_dir, "CogVideo")) +if not "cogvideox_loras" in folder_paths.folder_names_and_paths: + folder_paths.add_model_folder_path("cogvideox_loras", os.path.join(folder_paths.models_dir, "CogVideo", "loras")) + +class CogVideoEnhanceAVideo: + @classmethod + def INPUT_TYPES(s): + return { + "required": { + "weight": ("FLOAT", {"default": 1.0, "min": 0, "max": 100, "step": 0.01, "tooltip": "The feta Weight of the Enhance-A-Video"}), + "start_percent": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.01, "tooltip": "Start percentage of the steps to apply Enhance-A-Video"}), + "end_percent": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01, "tooltip": "End percentage of the steps to apply Enhance-A-Video"}), + }, + } + RETURN_TYPES = ("FETAARGS",) + RETURN_NAMES = ("feta_args",) + FUNCTION = "setargs" + CATEGORY = "CogVideoWrapper" + DESCRIPTION = "https://github.com/NUS-HPC-AI-Lab/Enhance-A-Video" + + def setargs(self, **kwargs): + return (kwargs, ) + +class CogVideoContextOptions: + @classmethod + def INPUT_TYPES(s): + return {"required": { + "context_schedule": (["uniform_standard", "uniform_looped", "static_standard"],), + "context_frames": ("INT", {"default": 48, "min": 2, "max": 100, "step": 1, "tooltip": "Number of pixel frames in the context, NOTE: the latent space has 4 frames in 1"} ), + "context_stride": ("INT", {"default": 4, "min": 4, "max": 100, "step": 1, "tooltip": "Context stride as pixel frames, NOTE: the latent space has 4 frames in 1"} ), + "context_overlap": ("INT", {"default": 4, "min": 4, "max": 100, "step": 1, "tooltip": "Context overlap as pixel frames, NOTE: the latent space has 4 frames in 1"} ), + "freenoise": ("BOOLEAN", {"default": True, "tooltip": "Shuffle the noise"}), + } + } + + RETURN_TYPES = ("COGCONTEXT", ) + RETURN_NAMES = ("context_options",) + FUNCTION = "process" + CATEGORY = "CogVideoWrapper" + + def process(self, context_schedule, context_frames, context_stride, context_overlap, freenoise): + context_options = { + "context_schedule":context_schedule, + "context_frames":context_frames, + "context_stride":context_stride, + "context_overlap":context_overlap, + "freenoise":freenoise + } + + return (context_options,) + +class CogVideoTransformerEdit: + @classmethod + def INPUT_TYPES(s): + return {"required": { + "remove_blocks": ("STRING", {"default": "15, 25, 37", "multiline": True, "tooltip": "Comma separated list of block indices to remove, 5b blocks: 0-41, 2b model blocks 0-29"} ), + } + } + + RETURN_TYPES = ("TRANSFORMERBLOCKS",) + RETURN_NAMES = ("block_list", ) + FUNCTION = "process" + CATEGORY = "CogVideoWrapper" + DESCRIPTION = "EXPERIMENTAL:Remove specific transformer blocks from the model" + + def process(self, remove_blocks): + blocks_to_remove = [int(x.strip()) for x in remove_blocks.split(',')] + log.info(f"Blocks selected for removal: {blocks_to_remove}") + return (blocks_to_remove,) + +class CogVideoXTorchCompileSettings: + @classmethod + def INPUT_TYPES(s): + return { + "required": { + "backend": (["inductor","cudagraphs"], {"default": "inductor"}), + "fullgraph": ("BOOLEAN", {"default": False, "tooltip": "Enable full graph mode"}), + "mode": (["default", "max-autotune", "max-autotune-no-cudagraphs", "reduce-overhead"], {"default": "default"}), + "dynamic": ("BOOLEAN", {"default": False, "tooltip": "Enable dynamic mode"}), + "dynamo_cache_size_limit": ("INT", {"default": 64, "min": 0, "max": 1024, "step": 1, "tooltip": "torch._dynamo.config.cache_size_limit"}), + }, + } + RETURN_TYPES = ("COMPILEARGS",) + RETURN_NAMES = ("torch_compile_args",) + FUNCTION = "loadmodel" + CATEGORY = "MochiWrapper" + DESCRIPTION = "torch.compile settings, when connected to the model loader, torch.compile of the selected layers is attempted. Requires Triton and torch 2.5.0 is recommended" + + def loadmodel(self, backend, fullgraph, mode, dynamic, dynamo_cache_size_limit): + + compile_args = { + "backend": backend, + "fullgraph": fullgraph, + "mode": mode, + "dynamic": dynamic, + "dynamo_cache_size_limit": dynamo_cache_size_limit, + } + + return (compile_args, ) + +#region TextEncode +class CogVideoTextEncode: + @classmethod + def INPUT_TYPES(s): + return {"required": { + "clip": ("CLIP",), + "prompt": ("STRING", {"default": "", "multiline": True} ), + }, + "optional": { + "strength": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01}), + "force_offload": ("BOOLEAN", {"default": True}), + } + } + + RETURN_TYPES = ("CONDITIONING", "CLIP",) + RETURN_NAMES = ("conditioning", "clip") + FUNCTION = "process" + CATEGORY = "CogVideoWrapper" + + def process(self, clip, prompt, strength=1.0, force_offload=True): + max_tokens = 226 + load_device = mm.text_encoder_device() + offload_device = mm.text_encoder_offload_device() + clip.tokenizer.t5xxl.pad_to_max_length = True + clip.tokenizer.t5xxl.max_length = max_tokens + clip.cond_stage_model.to(load_device) + tokens = clip.tokenize(prompt, return_word_ids=True) + + embeds = clip.encode_from_tokens(tokens, return_pooled=False, return_dict=False) + + if embeds.shape[1] > max_tokens: + raise ValueError(f"Prompt is too long, max tokens supported is {max_tokens} or less, got {embeds.shape[1]}") + embeds *= strength + if force_offload: + clip.cond_stage_model.to(offload_device) + + return (embeds, clip, ) + +class CogVideoTextEncodeCombine: + @classmethod + def INPUT_TYPES(s): + return {"required": { + "conditioning_1": ("CONDITIONING",), + "conditioning_2": ("CONDITIONING",), + "combination_mode": (["average", "weighted_average", "concatenate"], {"default": "weighted_average"}), + "weighted_average_ratio": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 10.0, "step": 0.01}), + }, + } + + RETURN_TYPES = ("CONDITIONING",) + RETURN_NAMES = ("conditioning",) + FUNCTION = "process" + CATEGORY = "CogVideoWrapper" + + def process(self, conditioning_1, conditioning_2, combination_mode, weighted_average_ratio): + if conditioning_1.shape != conditioning_2.shape: + raise ValueError("conditioning_1 and conditioning_2 must have the same shape") + + if combination_mode == "average": + embeds = (conditioning_1 + conditioning_2) / 2 + elif combination_mode == "weighted_average": + embeds = conditioning_1 * (1 - weighted_average_ratio) + conditioning_2 * weighted_average_ratio + elif combination_mode == "concatenate": + embeds = torch.cat((conditioning_1, conditioning_2), dim=-2) + else: + raise ValueError("Invalid combination mode") + + return (embeds, ) + +#region ImageEncode + +def add_noise_to_reference_video(image, ratio=None): + if ratio is None: + sigma = torch.normal(mean=-3.0, std=0.5, size=(image.shape[0],)).to(image.device) + sigma = torch.exp(sigma).to(image.dtype) + else: + sigma = torch.ones((image.shape[0],)).to(image.device, image.dtype) * ratio + + image_noise = torch.randn_like(image) * sigma[:, None, None, None, None] + image_noise = torch.where(image==-1, torch.zeros_like(image), image_noise) + image = image + image_noise + return image + +class CogVideoImageEncode: + @classmethod + def INPUT_TYPES(s): + return {"required": { + "vae": ("VAE",), + "start_image": ("IMAGE", ), + }, + "optional": { + "end_image": ("IMAGE", ), + "enable_tiling": ("BOOLEAN", {"default": False, "tooltip": "Enable tiling for the VAE to reduce memory usage"}), + "noise_aug_strength": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.001, "tooltip": "Augment image with noise"}), + "strength": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01}), + "start_percent": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.01}), + "end_percent": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01}), + }, + } + + RETURN_TYPES = ("LATENT",) + RETURN_NAMES = ("samples",) + FUNCTION = "encode" + CATEGORY = "CogVideoWrapper" + + def encode(self, vae, start_image, end_image=None, enable_tiling=False, noise_aug_strength=0.0, strength=1.0, start_percent=0.0, end_percent=1.0): + device = mm.get_torch_device() + offload_device = mm.unet_offload_device() + generator = torch.Generator(device=device).manual_seed(0) + + try: + vae.enable_slicing() + except: + pass + + vae_scaling_factor = vae.config.scaling_factor + + if enable_tiling: + from .mz_enable_vae_encode_tiling import enable_vae_encode_tiling + enable_vae_encode_tiling(vae) + + vae.to(device) + + try: + vae._clear_fake_context_parallel_cache() + except: + pass + + + latents_list = [] + + start_image = (start_image * 2.0 - 1.0).to(vae.dtype).to(device).unsqueeze(0).permute(0, 4, 1, 2, 3) # B, C, T, H, W + if noise_aug_strength > 0: + start_image = add_noise_to_reference_video(start_image, ratio=noise_aug_strength) + start_latents = vae.encode(start_image).latent_dist.sample(generator) + start_latents = start_latents.permute(0, 2, 1, 3, 4) # B, T, C, H, W + + + if end_image is not None: + end_image = (end_image * 2.0 - 1.0).to(vae.dtype).to(device).unsqueeze(0).permute(0, 4, 1, 2, 3) + if noise_aug_strength > 0: + end_image = add_noise_to_reference_video(end_image, ratio=noise_aug_strength) + end_latents = vae.encode(end_image).latent_dist.sample(generator) + end_latents = end_latents.permute(0, 2, 1, 3, 4) # B, T, C, H, W + latents_list = [start_latents, end_latents] + final_latents = torch.cat(latents_list, dim=1) + else: + final_latents = start_latents + + final_latents = final_latents * vae_scaling_factor * strength + + log.info(f"Encoded latents shape: {final_latents.shape}") + vae.to(offload_device) + + return ({ + "samples": final_latents, + "start_percent": start_percent, + "end_percent": end_percent + }, ) + +class CogVideoImageEncodeFunInP: + @classmethod + def INPUT_TYPES(s): + return {"required": { + "vae": ("VAE",), + "start_image": ("IMAGE", ), + "num_frames": ("INT", {"default": 49, "min": 2, "max": 1024, "step": 1}), + }, + "optional": { + "end_image": ("IMAGE", ), + "enable_tiling": ("BOOLEAN", {"default": False, "tooltip": "Enable tiling for the VAE to reduce memory usage"}), + "noise_aug_strength": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.001, "tooltip": "Augment image with noise"}), + }, + } + + RETURN_TYPES = ("LATENT",) + RETURN_NAMES = ("image_cond_latents",) + FUNCTION = "encode" + CATEGORY = "CogVideoWrapper" + + def encode(self, vae, start_image, num_frames, end_image=None, enable_tiling=False, noise_aug_strength=0.0): + + device = mm.get_torch_device() + offload_device = mm.unet_offload_device() + generator = torch.Generator(device=device).manual_seed(0) + + try: + vae.enable_slicing() + except: + pass + + vae_scaling_factor = vae.config.scaling_factor + + if enable_tiling: + from .mz_enable_vae_encode_tiling import enable_vae_encode_tiling + enable_vae_encode_tiling(vae) + + vae.to(device) + + try: + vae._clear_fake_context_parallel_cache() + except: + pass + + if end_image is not None: + # Create a tensor of zeros for padding + padding = torch.zeros((num_frames - 2, start_image.shape[1], start_image.shape[2], 3), device=end_image.device, dtype=end_image.dtype) * -1 + # Concatenate start_image, padding, and end_image + input_image = torch.cat([start_image, padding, end_image], dim=0) + else: + # Create a tensor of zeros for padding + padding = torch.zeros((num_frames - 1, start_image.shape[1], start_image.shape[2], 3), device=start_image.device, dtype=start_image.dtype) * -1 + # Concatenate start_image and padding + input_image = torch.cat([start_image, padding], dim=0) + + input_image = input_image * 2.0 - 1.0 + input_image = input_image.to(vae.dtype).to(device) + input_image = input_image.unsqueeze(0).permute(0, 4, 1, 2, 3) # B, C, T, H, W + + B, C, T, H, W = input_image.shape + if noise_aug_strength > 0: + input_image = add_noise_to_reference_video(input_image, ratio=noise_aug_strength) + + bs = 1 + new_mask_pixel_values = [] + for i in range(0, input_image.shape[0], bs): + mask_pixel_values_bs = input_image[i : i + bs] + mask_pixel_values_bs = vae.encode(mask_pixel_values_bs)[0] + mask_pixel_values_bs = mask_pixel_values_bs.mode() + new_mask_pixel_values.append(mask_pixel_values_bs) + masked_image_latents = torch.cat(new_mask_pixel_values, dim = 0) + masked_image_latents = masked_image_latents.permute(0, 2, 1, 3, 4) # B, T, C, H, W + + mask = torch.zeros_like(masked_image_latents[:, :, :1, :, :]) + #if end_image is not None: + # mask[:, -1, :, :, :] = 0 + mask[:, 0, :, :, :] = vae_scaling_factor + + final_latents = masked_image_latents * vae_scaling_factor + + log.info(f"Encoded latents shape: {final_latents.shape}") + vae.to(offload_device) + + return ({ + "samples": final_latents, + "mask": mask + },) + +#region Tora +from .tora.traj_utils import process_traj, scale_traj_list_to_256 +from torchvision.utils import flow_to_image + +class ToraEncodeTrajectory: + @classmethod + def INPUT_TYPES(s): + return {"required": { + "tora_model": ("TORAMODEL",), + "vae": ("VAE",), + "coordinates": ("STRING", {"forceInput": True}), + "width": ("INT", {"default": 720, "min": 128, "max": 2048, "step": 8}), + "height": ("INT", {"default": 480, "min": 128, "max": 2048, "step": 8}), + "num_frames": ("INT", {"default": 49, "min": 2, "max": 1024, "step": 1}), + "strength": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01}), + "start_percent": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.01}), + "end_percent": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01}), + }, + "optional": { + "enable_tiling": ("BOOLEAN", {"default": True}), + } + } + + RETURN_TYPES = ("TORAFEATURES", "IMAGE", ) + RETURN_NAMES = ("tora_trajectory", "video_flow_images", ) + FUNCTION = "encode" + CATEGORY = "CogVideoWrapper" + + def encode(self, vae, width, height, num_frames, coordinates, strength, start_percent, end_percent, tora_model, enable_tiling=False): + check_diffusers_version() + device = mm.get_torch_device() + offload_device = mm.unet_offload_device() + generator = torch.Generator(device=device).manual_seed(0) + + try: + vae.enable_slicing() + except: + pass + try: + vae._clear_fake_context_parallel_cache() + except: + pass + + if enable_tiling: + from .mz_enable_vae_encode_tiling import enable_vae_encode_tiling + enable_vae_encode_tiling(vae) + + if len(coordinates) < 10: + coords_list = [] + for coords in coordinates: + coords = json.loads(coords.replace("'", '"')) + coords = [(coord['x'], coord['y']) for coord in coords] + traj_list_range_256 = scale_traj_list_to_256(coords, width, height) + coords_list.append(traj_list_range_256) + else: + coords = json.loads(coordinates.replace("'", '"')) + coords = [(coord['x'], coord['y']) for coord in coords] + coords_list = scale_traj_list_to_256(coords, width, height) + + + video_flow, points = process_traj(coords_list, num_frames, (height,width), device=device) + video_flow = rearrange(video_flow, "T H W C -> T C H W") + video_flow = flow_to_image(video_flow).unsqueeze_(0).to(device) # [1 T C H W] + video_flow = (rearrange(video_flow / 255.0 * 2 - 1, "B T C H W -> B C T H W").contiguous().to(vae.dtype)) + video_flow_image = rearrange(video_flow, "B C T H W -> (B T) H W C") + #print(video_flow_image.shape) + mm.soft_empty_cache() + + # VAE encode + vae.to(device) + video_flow = vae.encode(video_flow).latent_dist.sample(generator) * vae.config.scaling_factor + log.info(f"video_flow shape after encoding: {video_flow.shape}") #torch.Size([1, 16, 4, 80, 80]) + vae.to(offload_device) + + tora_model["traj_extractor"].to(device) + #print("video_flow shape before traj_extractor: ", video_flow.shape) #torch.Size([1, 16, 4, 80, 80]) + video_flow_features = tora_model["traj_extractor"](video_flow.to(torch.float32)) + tora_model["traj_extractor"].to(offload_device) + video_flow_features = torch.stack(video_flow_features) + #print("video_flow_features after traj_extractor: ", video_flow_features.shape) #torch.Size([42, 4, 128, 40, 40]) + + video_flow_features = video_flow_features * strength + + tora = { + "video_flow_features" : video_flow_features, + "start_percent" : start_percent, + "end_percent" : end_percent, + "traj_extractor" : tora_model["traj_extractor"], + "fuser_list" : tora_model["fuser_list"], + } + + return (tora, video_flow_image.cpu().float()) + +class ToraEncodeOpticalFlow: + @classmethod + def INPUT_TYPES(s): + return {"required": { + "vae": ("VAE",), + "tora_model": ("TORAMODEL",), + "optical_flow": ("IMAGE", ), + "strength": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01}), + "start_percent": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.01}), + "end_percent": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01}), + }, + + } + + RETURN_TYPES = ("TORAFEATURES",) + RETURN_NAMES = ("tora_trajectory",) + FUNCTION = "encode" + CATEGORY = "CogVideoWrapper" + + def encode(self, vae, optical_flow, strength, tora_model, start_percent, end_percent): + check_diffusers_version() + B, H, W, C = optical_flow.shape + device = mm.get_torch_device() + offload_device = mm.unet_offload_device() + generator = torch.Generator(device=device).manual_seed(0) + + try: + vae.enable_slicing() + except: + pass + + try: + vae._clear_fake_context_parallel_cache() + except: + pass + + video_flow = optical_flow * 2 - 1 + video_flow = rearrange(video_flow, "(B T) H W C -> B C T H W", T=B, B=1) + print(video_flow.shape) + mm.soft_empty_cache() + + # VAE encode + + vae.to(device) + video_flow = video_flow.to(vae.dtype).to(vae.device) + video_flow = vae.encode(video_flow).latent_dist.sample(generator) * vae.config.scaling_factor + vae.to(offload_device) + + video_flow_features = tora_model["traj_extractor"](video_flow.to(torch.float32)) + video_flow_features = torch.stack(video_flow_features) + video_flow_features = video_flow_features * strength + + log.info(f"video_flow shape: {video_flow.shape}") + + tora = { + "video_flow_features" : video_flow_features, + "start_percent" : start_percent, + "end_percent" : end_percent, + "traj_extractor" : tora_model["traj_extractor"], + "fuser_list" : tora_model["fuser_list"], + } + + return (tora, ) + + + +#region FasterCache +class CogVideoXFasterCache: + @classmethod + def INPUT_TYPES(s): + return { + "required": { + "start_step": ("INT", {"default": 15, "min": 0, "max": 1024, "step": 1}), + "hf_step": ("INT", {"default": 30, "min": 0, "max": 1024, "step": 1}), + "lf_step": ("INT", {"default": 40, "min": 0, "max": 1024, "step": 1}), + "cache_device": (["main_device", "offload_device", "cuda:1"], {"default": "main_device", "tooltip": "The device to use for the cache, main_device is on GPU and uses a lot of VRAM"}), + "num_blocks_to_cache": ("INT", {"default": 42, "min": 0, "max": 1024, "step": 1, "tooltip": "Number of transformer blocks to cache, 5b model has 42 blocks, tradeoff between speed and memory"}), + }, + } + + RETURN_TYPES = ("FASTERCACHEARGS",) + RETURN_NAMES = ("fastercache", ) + FUNCTION = "args" + CATEGORY = "CogVideoWrapper" + + def args(self, start_step, hf_step, lf_step, cache_device, num_blocks_to_cache): + device = mm.get_torch_device() + offload_device = mm.unet_offload_device() + if cache_device == "cuda:1": + device = torch.device("cuda:1") + fastercache = { + "start_step" : start_step, + "hf_step" : hf_step, + "lf_step" : lf_step, + "cache_device" : device if cache_device != "offload_device" else offload_device, + "num_blocks_to_cache" : num_blocks_to_cache, + } + return (fastercache,) + +class CogVideoXTeaCache: + @classmethod + def INPUT_TYPES(s): + return { + "required": { + "rel_l1_thresh": ("FLOAT", {"default": 0.3, "min": 0.0, "max": 10.0, "step": 0.01, "tooltip": "Cache threshold, higher values are faster while sacrificing quality"}), + } + } + + RETURN_TYPES = ("TEACACHEARGS",) + RETURN_NAMES = ("teacache_args",) + FUNCTION = "args" + CATEGORY = "CogVideoWrapper" + + def args(self, rel_l1_thresh): + teacache = { + "rel_l1_thresh": rel_l1_thresh + } + return (teacache,) + +#region Sampler +class CogVideoSampler: + @classmethod + def INPUT_TYPES(s): + return { + "required": { + "model": ("COGVIDEOMODEL",), + "positive": ("CONDITIONING", ), + "negative": ("CONDITIONING", ), + "num_frames": ("INT", {"default": 49, "min": 1, "max": 1024, "step": 1}), + "steps": ("INT", {"default": 50, "min": 1}), + "cfg": ("FLOAT", {"default": 6.0, "min": 0.0, "max": 30.0, "step": 0.01}), + "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}), + "scheduler": (available_schedulers, + { + "default": 'CogVideoXDDIM' + }), + }, + "optional": { + "samples": ("LATENT", {"tooltip": "init Latents to use for video2video process"} ), + "image_cond_latents": ("LATENT",{"tooltip": "Latent to use for image2video conditioning"} ), + "denoise_strength": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01}), + "context_options": ("COGCONTEXT", ), + "controlnet": ("COGVIDECONTROLNET",), + "tora_trajectory": ("TORAFEATURES", ), + "fastercache": ("FASTERCACHEARGS", ), + "feta_args": ("FETAARGS", ), + "teacache_args": ("TEACACHEARGS", ), + } + } + + RETURN_TYPES = ("LATENT",) + RETURN_NAMES = ("samples",) + FUNCTION = "process" + CATEGORY = "CogVideoWrapper" + + def process(self, model, positive, negative, steps, cfg, seed, scheduler, num_frames, samples=None, + denoise_strength=1.0, image_cond_latents=None, context_options=None, controlnet=None, tora_trajectory=None, fastercache=None, feta_args=None, teacache_args=None): + mm.unload_all_models() + mm.soft_empty_cache() + + model_name = model.get("model_name", "") + supports_image_conds = True if ( + "I2V" in model_name or + "interpolation" in model_name.lower() or + "fun" in model_name.lower() or + "img2vid" in model_name.lower() + ) else False + if "fun" in model_name.lower() and not ("pose" in model_name.lower() or "control" in model_name.lower()) and image_cond_latents is not None: + assert image_cond_latents["mask"] is not None, "For fun inpaint models use CogVideoImageEncodeFunInP" + fun_mask = image_cond_latents["mask"] + else: + fun_mask = None + + if image_cond_latents is not None: + assert supports_image_conds, "Image condition latents only supported for I2V and Interpolation models" + image_conds = image_cond_latents["samples"] + image_cond_start_percent = image_cond_latents.get("start_percent", 0.0) + image_cond_end_percent = image_cond_latents.get("end_percent", 1.0) + if ("1.5" in model_name or "1_5" in model_name) and not "fun" in model_name.lower(): + image_conds = image_conds / 0.7 # needed for 1.5 models + else: + if not "fun" in model_name.lower(): + assert not supports_image_conds, "Image condition latents required for I2V models" + image_conds = None + + if samples is not None: + if len(samples["samples"].shape) == 5: + B, T, C, H, W = samples["samples"].shape + latents = samples["samples"] + if len(samples["samples"].shape) == 4: + B, C, H, W = samples["samples"].shape + latents = None + if image_cond_latents is not None: + B, T, C, H, W = image_cond_latents["samples"].shape + height = H * 8 + width = W * 8 + + device = mm.get_torch_device() + offload_device = mm.unet_offload_device() + pipe = model["pipe"] + dtype = model["dtype"] + scheduler_config = model["scheduler_config"] + + if not model["cpu_offloading"] and model["manual_offloading"]: + pipe.transformer.to(device) + generator = torch.Generator(device=torch.device("cpu")).manual_seed(seed) + + if scheduler in scheduler_mapping: + noise_scheduler = scheduler_mapping[scheduler].from_config(scheduler_config) + pipe.scheduler = noise_scheduler + else: + raise ValueError(f"Unknown scheduler: {scheduler}") + + if tora_trajectory is not None: + pipe.transformer.fuser_list = tora_trajectory["fuser_list"] + + if context_options is not None: + context_frames = context_options["context_frames"] // 4 + context_stride = context_options["context_stride"] // 4 + context_overlap = context_options["context_overlap"] // 4 + else: + context_frames, context_stride, context_overlap = None, None, None + + if negative.shape[1] < positive.shape[1]: + target_length = positive.shape[1] + padding = torch.zeros((negative.shape[0], target_length - negative.shape[1], negative.shape[2]), device=negative.device) + negative = torch.cat((negative, padding), dim=1) + + if fastercache is not None: + pipe.transformer.use_fastercache = True + pipe.transformer.fastercache_counter = 0 + pipe.transformer.fastercache_start_step = fastercache["start_step"] + pipe.transformer.fastercache_lf_step = fastercache["lf_step"] + pipe.transformer.fastercache_hf_step = fastercache["hf_step"] + pipe.transformer.fastercache_device = fastercache["cache_device"] + pipe.transformer.fastercache_num_blocks_to_cache = fastercache["num_blocks_to_cache"] + log.info(f"FasterCache enabled for {pipe.transformer.fastercache_num_blocks_to_cache} blocks out of {len(pipe.transformer.transformer_blocks)}") + else: + pipe.transformer.use_fastercache = False + pipe.transformer.fastercache_counter = 0 + + if teacache_args is not None: + pipe.transformer.use_teacache = True + pipe.transformer.teacache_rel_l1_thresh = teacache_args["rel_l1_thresh"] + log.info(f"TeaCache enabled with rel_l1_thresh: {pipe.transformer.teacache_rel_l1_thresh}") + else: + pipe.transformer.use_teacache = False + + if not isinstance(cfg, list): + cfg = [cfg for _ in range(steps)] + else: + assert len(cfg) == steps, "Length of cfg list must match number of steps" + try: + torch.cuda.reset_peak_memory_stats(device) + except: + pass + + autocast_context = torch.autocast( + mm.get_autocast_device(device), dtype=dtype + ) if any(q in model["quantization"] for q in ("e4m3fn", "GGUF")) else nullcontext() + with autocast_context: + latents = model["pipe"]( + num_inference_steps=steps, + height = height, + width = width, + num_frames = num_frames, + guidance_scale=cfg, + latents=latents if samples is not None else None, + fun_mask = fun_mask, + image_cond_latents=image_conds, + denoise_strength=denoise_strength, + prompt_embeds=positive.to(dtype).to(device), + negative_prompt_embeds=negative.to(dtype).to(device), + generator=generator, + device=device, + context_schedule=context_options["context_schedule"] if context_options is not None else None, + context_frames=context_frames, + context_stride= context_stride, + context_overlap= context_overlap, + freenoise=context_options["freenoise"] if context_options is not None else None, + controlnet=controlnet, + tora=tora_trajectory if tora_trajectory is not None else None, + image_cond_start_percent=image_cond_start_percent if image_cond_latents is not None else 0.0, + image_cond_end_percent=image_cond_end_percent if image_cond_latents is not None else 1.0, + feta_args=feta_args, + ) + if not model["cpu_offloading"] and model["manual_offloading"]: + pipe.transformer.to(offload_device) + + if fastercache is not None: + for block in pipe.transformer.transformer_blocks: + if (hasattr, block, "cached_hidden_states") and block.cached_hidden_states is not None: + block.cached_hidden_states = None + block.cached_encoder_hidden_states = None + + print_memory(device) + + if teacache_args is not None: + log.info(f"TeaCache skipped steps: {pipe.transformer.teacache_counter}") + mm.soft_empty_cache() + try: + torch.cuda.reset_peak_memory_stats(device) + except: + pass + + additional_frames = getattr(pipe, "additional_frames", 0) + return ({ + "samples": latents, + "additional_frames": additional_frames, + },) + +class CogVideoControlNet: + @classmethod + def INPUT_TYPES(s): + return {"required": { + "controlnet": ("COGVIDECONTROLNETMODEL",), + "images": ("IMAGE", ), + "control_strength": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01}), + "control_start_percent": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.01}), + "control_end_percent": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01}), + }, + } + + RETURN_TYPES = ("COGVIDECONTROLNET",) + RETURN_NAMES = ("cogvideo_controlnet",) + FUNCTION = "encode" + CATEGORY = "CogVideoWrapper" + + def encode(self, controlnet, images, control_strength, control_start_percent, control_end_percent): + control_frames = images.permute(0, 3, 1, 2).unsqueeze(0) * 2 - 1 + controlnet = { + "control_model": controlnet, + "control_frames": control_frames, + "control_weights": control_strength, + "control_start": control_start_percent, + "control_end": control_end_percent, + } + return (controlnet,) + +#region VideoDecode +class CogVideoDecode: + @classmethod + def INPUT_TYPES(s): + return {"required": { + "vae": ("VAE",), + "samples": ("LATENT",), + "enable_vae_tiling": ("BOOLEAN", {"default": True, "tooltip": "Drastically reduces memory use but may introduce seams"}), + "tile_sample_min_height": ("INT", {"default": 240, "min": 16, "max": 2048, "step": 8, "tooltip": "Minimum tile height, default is half the height"}), + "tile_sample_min_width": ("INT", {"default": 360, "min": 16, "max": 2048, "step": 8, "tooltip": "Minimum tile width, default is half the width"}), + "tile_overlap_factor_height": ("FLOAT", {"default": 0.2, "min": 0.0, "max": 1.0, "step": 0.001}), + "tile_overlap_factor_width": ("FLOAT", {"default": 0.2, "min": 0.0, "max": 1.0, "step": 0.001}), + "auto_tile_size": ("BOOLEAN", {"default": True, "tooltip": "Auto size based on height and width, default is half the size"}), + }, + } + + RETURN_TYPES = ("IMAGE",) + RETURN_NAMES = ("images",) + FUNCTION = "decode" + CATEGORY = "CogVideoWrapper" + + def decode(self, vae, samples, enable_vae_tiling, tile_sample_min_height, tile_sample_min_width, tile_overlap_factor_height, tile_overlap_factor_width, + auto_tile_size=True, pipeline=None): + device = mm.get_torch_device() + offload_device = mm.unet_offload_device() + latents = samples["samples"] + + additional_frames = samples.get("additional_frames", 0) + + try: + vae.enable_slicing() + except: + pass + + vae.to(device) + if enable_vae_tiling: + if auto_tile_size: + vae.enable_tiling() + else: + vae.enable_tiling( + tile_sample_min_height=tile_sample_min_height, + tile_sample_min_width=tile_sample_min_width, + tile_overlap_factor_height=tile_overlap_factor_height, + tile_overlap_factor_width=tile_overlap_factor_width, + ) + else: + vae.disable_tiling() + latents = latents.to(vae.dtype).to(device) + latents = latents.permute(0, 2, 1, 3, 4) # [batch_size, num_channels, num_frames, height, width] + latents = 1 / vae.config.scaling_factor * latents + + try: + vae._clear_fake_context_parallel_cache() + except: + pass + try: + frames = vae.decode(latents[:, :, additional_frames:]).sample + except: + mm.soft_empty_cache() + log.warning("Failed to decode, retrying with tiling") + vae.enable_tiling() + frames = vae.decode(latents[:, :, additional_frames:]).sample + + vae.disable_tiling() + vae.to(offload_device) + mm.soft_empty_cache() + + video_processor = VideoProcessor(vae_scale_factor=8) + video_processor.config.do_resize = False + + video = video_processor.postprocess_video(video=frames, output_type="pt") + video = video[0].permute(0, 2, 3, 1).cpu().float() + + return (video,) + +class CogVideoXFunResizeToClosestBucket: + upscale_methods = ["nearest-exact", "bilinear", "area", "bicubic", "lanczos"] + @classmethod + def INPUT_TYPES(s): + return {"required": { + "images": ("IMAGE", ), + "base_resolution": ("INT", {"min": 64, "max": 1280, "step": 64, "default": 512, "tooltip": "Base resolution, closest training data bucket resolution is chosen based on the selection."}), + "upscale_method": (s.upscale_methods, {"default": "lanczos", "tooltip": "Upscale method to use"}), + "crop": (["disabled","center"],), + }, + } + + RETURN_TYPES = ("IMAGE", "INT", "INT") + RETURN_NAMES = ("images", "width", "height") + FUNCTION = "resize" + CATEGORY = "CogVideoWrapper" + + def resize(self, images, base_resolution, upscale_method, crop): + from comfy.utils import common_upscale + from .cogvideox_fun.utils import ASPECT_RATIO_512, get_closest_ratio + + B, H, W, C = images.shape + # Find most suitable height and width + aspect_ratio_sample_size = {key : [x / 512 * base_resolution for x in ASPECT_RATIO_512[key]] for key in ASPECT_RATIO_512.keys()} + + closest_size, closest_ratio = get_closest_ratio(H, W, ratios=aspect_ratio_sample_size) + height, width = [int(x / 16) * 16 for x in closest_size] + log.info(f"Closest bucket size: {width}x{height}") + + resized_images = images.clone().movedim(-1,1) + resized_images = common_upscale(resized_images, width, height, upscale_method, crop) + resized_images = resized_images.movedim(1,-1) + + return (resized_images, width, height) + +class CogVideoLatentPreview: + @classmethod + def INPUT_TYPES(s): + return { + "required": { + "samples": ("LATENT",), + "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}), + "min_val": ("FLOAT", {"default": -0.15, "min": -1.0, "max": 0.0, "step": 0.001}), + "max_val": ("FLOAT", {"default": 0.15, "min": 0.0, "max": 1.0, "step": 0.001}), + "r_bias": ("FLOAT", {"default": 0.0, "min": -1.0, "max": 1.0, "step": 0.001}), + "g_bias": ("FLOAT", {"default": 0.0, "min": -1.0, "max": 1.0, "step": 0.001}), + "b_bias": ("FLOAT", {"default": 0.0, "min": -1.0, "max": 1.0, "step": 0.001}), + }, + } + + RETURN_TYPES = ("IMAGE", "STRING", ) + RETURN_NAMES = ("images", "latent_rgb_factors",) + FUNCTION = "sample" + CATEGORY = "PyramidFlowWrapper" + + def sample(self, samples, seed, min_val, max_val, r_bias, g_bias, b_bias): + mm.soft_empty_cache() + + latents = samples["samples"].clone() + print("in sample", latents.shape) + latents = latents.permute(0, 2, 1, 3, 4) # [batch_size, num_channels, num_frames, height, width] + + #[[0.0658900170023352, 0.04687556512203313, -0.056971557475649186], [-0.01265770449940036, -0.02814809569100843, -0.0768912512529372], [0.061456544746314665, 0.0005511617552452358, -0.0652574975291287], [-0.09020669168815276, -0.004755440180558637, -0.023763970904494294], [0.031766964513999865, -0.030959599938418375, 0.08654669098083616], [-0.005981764690055846, -0.08809119252349802, -0.06439852368217663], [-0.0212114426433989, 0.08894281999597677, 0.05155629477559985], [-0.013947446911030725, -0.08987475069900677, -0.08923124751217484], [-0.08235967967978511, 0.07268025379974379, 0.08830486164536037], [-0.08052049179735378, -0.050116143175332195, 0.02023752569687405], [-0.07607527759162447, 0.06827156419895981, 0.08678111754261035], [-0.04689089232553825, 0.017294986041038893, -0.10280492336438908], [-0.06105783150270304, 0.07311850680875913, 0.019995735372550075], [-0.09232589996527711, -0.012869815059053047, -0.04355587834255975], [-0.06679931010802251, 0.018399815879067458, 0.06802404982033876], [-0.013062632927118165, -0.04292991477896661, 0.07476243356192845]] + #latent_rgb_factors =[[0.11945946736445662, 0.09919175788574555, -0.004832707433877734], [-0.0011977028264356232, 0.05496505130267682, 0.021321622433638193], [-0.014088548986590666, -0.008701477861945644, -0.020991313281459367], [0.03063921972519621, 0.12186477097625073, 0.0139593690235148], [0.0927403067854673, 0.030293187650929136, 0.05083134241694003], [0.0379112441305742, 0.04935199882777209, 0.058562766246777774], [0.017749911959153715, 0.008839453404921545, 0.036005638019226294], [0.10610119248526109, 0.02339855688237826, 0.057154257614084596], [0.1273639464837117, -0.010959856130713416, 0.043268631260428896], [-0.01873510946881321, 0.08220930648486932, 0.10613256772247093], [0.008429116376722327, 0.07623856561000408, 0.09295712117576727], [0.12938137079617007, 0.12360403483892413, 0.04478930933220116], [0.04565908794779364, 0.041064156741596365, -0.017695041535528512], [0.00019003240570281826, -0.013965147883381978, 0.05329669529635849], [0.08082391586738358, 0.11548306825496074, -0.021464170006615893], [-0.01517932393230994, -0.0057985555313003236, 0.07216646476618871]] + latent_rgb_factors = [[0.03197404301362048, 0.04091260743347359, 0.0015679806301828524], [0.005517101026578029, 0.0052348639043457755, -0.005613441650464035], [0.0012485338264583965, -0.016096744206117782, 0.025023940031635054], [0.01760126794276171, 0.0036818415416642893, -0.0006019202528157255], [0.000444954842288864, 0.006102128982092191, 0.0008457999272962447], [-0.010531904354560697, -0.0032275501924977175, -0.00886595780267917], [-0.0001454543946122991, 0.010199210750845965, -0.00012702234832386188], [0.02078497279904325, -0.001669617778939972, 0.006712703698951264], [0.005529571599763264, 0.009733929789086743, 0.001887302765339838], [0.012138415094654218, 0.024684961927224837, 0.037211249767461915], [0.0010364484570000384, 0.01983636315929172, 0.009864602025627755], [0.006802862648143341, -0.0010509255113510681, -0.007026003345126021], [0.0003532208468418043, 0.005351971582801936, -0.01845912126717106], [-0.009045079994694397, -0.01127941143183089, 0.0042294057970470806], [0.002548289972720752, 0.025224244654428216, -0.0006086130121693347], [-0.011135669222532816, 0.0018181308593668505, 0.02794541485349922]] + import random + random.seed(seed) + latent_rgb_factors = [[random.uniform(min_val, max_val) for _ in range(3)] for _ in range(16)] + out_factors = latent_rgb_factors + print(latent_rgb_factors) + + latent_rgb_factors_bias = [0.085, 0.137, 0.158] + #latent_rgb_factors_bias = [r_bias, g_bias, b_bias] + + latent_rgb_factors = torch.tensor(latent_rgb_factors, device=latents.device, dtype=latents.dtype).transpose(0, 1) + latent_rgb_factors_bias = torch.tensor(latent_rgb_factors_bias, device=latents.device, dtype=latents.dtype) + + print("latent_rgb_factors", latent_rgb_factors.shape) + + latent_images = [] + for t in range(latents.shape[2]): + latent = latents[:, :, t, :, :] + latent = latent[0].permute(1, 2, 0) + latent_image = torch.nn.functional.linear( + latent, + latent_rgb_factors, + bias=latent_rgb_factors_bias + ) + latent_images.append(latent_image) + latent_images = torch.stack(latent_images, dim=0) + print("latent_images", latent_images.shape) + latent_images_min = latent_images.min() + latent_images_max = latent_images.max() + latent_images = (latent_images - latent_images_min) / (latent_images_max - latent_images_min) + + return (latent_images.float().cpu(), out_factors) + +NODE_CLASS_MAPPINGS = { + "CogVideoSampler": CogVideoSampler, + "CogVideoDecode": CogVideoDecode, + "CogVideoTextEncode": CogVideoTextEncode, + "CogVideoImageEncode": CogVideoImageEncode, + "CogVideoTextEncodeCombine": CogVideoTextEncodeCombine, + "CogVideoTransformerEdit": CogVideoTransformerEdit, + "CogVideoContextOptions": CogVideoContextOptions, + "CogVideoControlNet": CogVideoControlNet, + "ToraEncodeTrajectory": ToraEncodeTrajectory, + "ToraEncodeOpticalFlow": ToraEncodeOpticalFlow, + "CogVideoXFasterCache": CogVideoXFasterCache, + "CogVideoXFunResizeToClosestBucket": CogVideoXFunResizeToClosestBucket, + "CogVideoLatentPreview": CogVideoLatentPreview, + "CogVideoXTorchCompileSettings": CogVideoXTorchCompileSettings, + "CogVideoImageEncodeFunInP": CogVideoImageEncodeFunInP, + "CogVideoEnhanceAVideo": CogVideoEnhanceAVideo, + "CogVideoXTeaCache": CogVideoXTeaCache, +} +NODE_DISPLAY_NAME_MAPPINGS = { + "CogVideoSampler": "CogVideo Sampler", + "CogVideoDecode": "CogVideo Decode", + "CogVideoTextEncode": "CogVideo TextEncode", + "CogVideoImageEncode": "CogVideo ImageEncode", + "CogVideoTextEncodeCombine": "CogVideo TextEncode Combine", + "CogVideoTransformerEdit": "CogVideo TransformerEdit", + "CogVideoContextOptions": "CogVideo Context Options", + "ToraEncodeTrajectory": "Tora Encode Trajectory", + "ToraEncodeOpticalFlow": "Tora Encode OpticalFlow", + "CogVideoXFasterCache": "CogVideoX FasterCache", + "CogVideoXFunResizeToClosestBucket": "CogVideoXFun ResizeToClosestBucket", + "CogVideoLatentPreview": "CogVideo LatentPreview", + "CogVideoXTorchCompileSettings": "CogVideo TorchCompileSettings", + "CogVideoImageEncodeFunInP": "CogVideo ImageEncode FunInP", + "CogVideoEnhanceAVideo": "CogVideo Enhance-A-Video", + "CogVideoXTeaCache": "CogVideoX TeaCache", + } diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/pipeline_cogvideox.py b/custom_nodes/ComfyUI-CogVideoXWrapper/pipeline_cogvideox.py new file mode 100644 index 0000000000000000000000000000000000000000..54470ff95e11a094f8d5935c467e49e0b5add8e8 --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/pipeline_cogvideox.py @@ -0,0 +1,879 @@ +# Copyright 2024 The CogVideoX team, Tsinghua University & ZhipuAI and The HuggingFace Team. +# 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 inspect +from typing import Callable, Dict, List, Optional, Tuple, Union + +import torch +import math + +from diffusers.pipelines.pipeline_utils import DiffusionPipeline +from diffusers.schedulers import CogVideoXDDIMScheduler, CogVideoXDPMScheduler +from diffusers.utils import logging +from diffusers.utils.torch_utils import randn_tensor + +#from diffusers.models.embeddings import get_3d_rotary_pos_embed +from diffusers.loaders import CogVideoXLoraLoaderMixin + +from .embeddings import get_3d_rotary_pos_embed +from .custom_cogvideox_transformer_3d import CogVideoXTransformer3DModel +from .enhance_a_video.globals import enable_enhance, disable_enhance, set_enhance_weight + +from comfy.utils import ProgressBar + +logger = logging.get_logger(__name__) # pylint: disable=invalid-name + +def get_resize_crop_region_for_grid(src, tgt_width, tgt_height): + tw = tgt_width + th = tgt_height + h, w = src + r = h / w + if r > (th / tw): + resize_height = th + resize_width = int(round(th / h * w)) + else: + resize_width = tw + resize_height = int(round(tw / w * h)) + + crop_top = int(round((th - resize_height) / 2.0)) + crop_left = int(round((tw - resize_width) / 2.0)) + + return (crop_top, crop_left), (crop_top + resize_height, crop_left + resize_width) + +# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.retrieve_timesteps +def retrieve_timesteps( + scheduler, + num_inference_steps: Optional[int] = None, + device: Optional[Union[str, torch.device]] = None, + timesteps: Optional[List[int]] = None, + sigmas: Optional[List[float]] = None, + **kwargs, +): + """ + Calls the scheduler's `set_timesteps` method and retrieves timesteps from the scheduler after the call. Handles + custom timesteps. Any kwargs will be supplied to `scheduler.set_timesteps`. + + Args: + scheduler (`SchedulerMixin`): + The scheduler to get timesteps from. + num_inference_steps (`int`): + The number of diffusion steps used when generating samples with a pre-trained model. If used, `timesteps` + must be `None`. + device (`str` or `torch.device`, *optional*): + The device to which the timesteps should be moved to. If `None`, the timesteps are not moved. + timesteps (`List[int]`, *optional*): + Custom timesteps used to override the timestep spacing strategy of the scheduler. If `timesteps` is passed, + `num_inference_steps` and `sigmas` must be `None`. + sigmas (`List[float]`, *optional*): + Custom sigmas used to override the timestep spacing strategy of the scheduler. If `sigmas` is passed, + `num_inference_steps` and `timesteps` must be `None`. + + Returns: + `Tuple[torch.Tensor, int]`: A tuple where the first element is the timestep schedule from the scheduler and the + second element is the number of inference steps. + """ + if timesteps is not None and sigmas is not None: + raise ValueError("Only one of `timesteps` or `sigmas` can be passed. Please choose one to set custom values") + if timesteps is not None: + accepts_timesteps = "timesteps" in set(inspect.signature(scheduler.set_timesteps).parameters.keys()) + if not accepts_timesteps: + raise ValueError( + f"The current scheduler class {scheduler.__class__}'s `set_timesteps` does not support custom" + f" timestep schedules. Please check whether you are using the correct scheduler." + ) + scheduler.set_timesteps(timesteps=timesteps, device=device, **kwargs) + timesteps = scheduler.timesteps + num_inference_steps = len(timesteps) + elif sigmas is not None: + accept_sigmas = "sigmas" in set(inspect.signature(scheduler.set_timesteps).parameters.keys()) + if not accept_sigmas: + raise ValueError( + f"The current scheduler class {scheduler.__class__}'s `set_timesteps` does not support custom" + f" sigmas schedules. Please check whether you are using the correct scheduler." + ) + scheduler.set_timesteps(sigmas=sigmas, device=device, **kwargs) + timesteps = scheduler.timesteps + num_inference_steps = len(timesteps) + else: + scheduler.set_timesteps(num_inference_steps, device=device, **kwargs) + timesteps = scheduler.timesteps + return timesteps, num_inference_steps + +class CogVideoXLatentFormat(): + latent_channels = 16 + latent_dimensions = 3 + scale_factor = 0.7 + taesd_decoder_name = None + + latent_rgb_factors = [[0.03197404301362048, 0.04091260743347359, 0.0015679806301828524], + [0.005517101026578029, 0.0052348639043457755, -0.005613441650464035], + [0.0012485338264583965, -0.016096744206117782, 0.025023940031635054], + [0.01760126794276171, 0.0036818415416642893, -0.0006019202528157255], + [0.000444954842288864, 0.006102128982092191, 0.0008457999272962447], + [-0.010531904354560697, -0.0032275501924977175, -0.00886595780267917], + [-0.0001454543946122991, 0.010199210750845965, -0.00012702234832386188], + [0.02078497279904325, -0.001669617778939972, 0.006712703698951264], + [0.005529571599763264, 0.009733929789086743, 0.001887302765339838], + [0.012138415094654218, 0.024684961927224837, 0.037211249767461915], + [0.0010364484570000384, 0.01983636315929172, 0.009864602025627755], + [0.006802862648143341, -0.0010509255113510681, -0.007026003345126021], + [0.0003532208468418043, 0.005351971582801936, -0.01845912126717106], + [-0.009045079994694397, -0.01127941143183089, 0.0042294057970470806], + [0.002548289972720752, 0.025224244654428216, -0.0006086130121693347], + [-0.011135669222532816, 0.0018181308593668505, 0.02794541485349922]] + latent_rgb_factors_bias = [ -0.023, 0.0, -0.017] + +class CogVideoXModelPlaceholder(): + def __init__(self): + self.latent_format = CogVideoXLatentFormat + +class CogVideoXPipeline(DiffusionPipeline, CogVideoXLoraLoaderMixin): + r""" + Pipeline for text-to-video generation using CogVideoX. + + 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: + transformer ([`CogVideoXTransformer3DModel`]): + A text conditioned `CogVideoXTransformer3DModel` to denoise the encoded video latents. + scheduler ([`SchedulerMixin`]): + A scheduler to be used in combination with `transformer` to denoise the encoded video latents. + """ + + _optional_components = ["tokenizer", "text_encoder"] + model_cpu_offload_seq = "text_encoder->transformer->vae" + + def __init__( + self, + transformer: CogVideoXTransformer3DModel, + scheduler: Union[CogVideoXDDIMScheduler, CogVideoXDPMScheduler], + dtype: torch.dtype = torch.bfloat16, + is_fun_inpaint: bool = False, + ): + super().__init__() + + self.register_modules(transformer=transformer, scheduler=scheduler) + self.vae_scale_factor_spatial = 8 + self.vae_scale_factor_temporal = 4 + self.vae_latent_channels = 16 + self.vae_dtype = dtype + self.is_fun_inpaint = is_fun_inpaint + + self.input_with_padding = True + + + def prepare_latents( + self, batch_size, num_channels_latents, num_frames, height, width, device, generator, timesteps, denoise_strength, + num_inference_steps, latents=None, freenoise=True, context_size=None, context_overlap=None + ): + shape = ( + batch_size, + (num_frames - 1) // self.vae_scale_factor_temporal + 1, + num_channels_latents, + height // self.vae_scale_factor_spatial, + width // self.vae_scale_factor_spatial, + ) + + noise = randn_tensor(shape, generator=generator, device=torch.device("cpu"), dtype=self.vae_dtype) + if freenoise: + logger.info("Applying FreeNoise") + # code and comments from AnimateDiff-Evolved by Kosinkadink (https://github.com/Kosinkadink/ComfyUI-AnimateDiff-Evolved) + video_length = num_frames // 4 + delta = context_size - context_overlap + for start_idx in range(0, video_length-context_size, delta): + # start_idx corresponds to the beginning of a context window + # goal: place shuffled in the delta region right after the end of the context window + # if space after context window is not enough to place the noise, adjust and finish + place_idx = start_idx + context_size + # if place_idx is outside the valid indexes, we are already finished + if place_idx >= video_length: + break + end_idx = place_idx - 1 + #print("video_length:", video_length, "start_idx:", start_idx, "end_idx:", end_idx, "place_idx:", place_idx, "delta:", delta) + + # if there is not enough room to copy delta amount of indexes, copy limited amount and finish + if end_idx + delta >= video_length: + final_delta = video_length - place_idx + # generate list of indexes in final delta region + list_idx = torch.tensor(list(range(start_idx,start_idx+final_delta)), device=torch.device("cpu"), dtype=torch.long) + # shuffle list + list_idx = list_idx[torch.randperm(final_delta, generator=generator)] + # apply shuffled indexes + noise[:, place_idx:place_idx + final_delta, :, :, :] = noise[:, list_idx, :, :, :] + break + # otherwise, do normal behavior + # generate list of indexes in delta region + list_idx = torch.tensor(list(range(start_idx,start_idx+delta)), device=torch.device("cpu"), dtype=torch.long) + # shuffle list + list_idx = list_idx[torch.randperm(delta, generator=generator)] + # apply shuffled indexes + #print("place_idx:", place_idx, "delta:", delta, "list_idx:", list_idx) + noise[:, place_idx:place_idx + delta, :, :, :] = noise[:, list_idx, :, :, :] + if latents is None: + latents = noise.to(device) + elif denoise_strength < 1.0: + latents = latents.to(device) + timesteps, num_inference_steps = self.get_timesteps(num_inference_steps, denoise_strength, device) + latent_timestep = timesteps[:1] + + frames_needed = noise.shape[1] + current_frames = latents.shape[1] + + if frames_needed > current_frames: + repeat_factor = frames_needed - current_frames + additional_frame = torch.randn((latents.size(0), repeat_factor, latents.size(2), latents.size(3), latents.size(4)), dtype=latents.dtype, device=latents.device) + latents = torch.cat((additional_frame, latents), dim=1) + self.additional_frames = repeat_factor + elif frames_needed < current_frames: + latents = latents[:, :frames_needed, :, :, :] + + latents = self.scheduler.add_noise(latents, noise.to(device), latent_timestep) + else: + latents = latents.to(device) + latents = latents * self.scheduler.init_noise_sigma # scale the initial noise by the standard deviation required by the scheduler + return latents, timesteps + + # 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 + + # Copied from diffusers.pipelines.latte.pipeline_latte.LattePipeline.check_inputs + def check_inputs( + self, + height, + width, + prompt_embeds=None, + negative_prompt_embeds=None, + ): + if height % 8 != 0 or width % 8 != 0: + raise ValueError(f"`height` and `width` have to be divisible by 8 but are {height} and {width}.") + + 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}." + ) + def get_timesteps(self, num_inference_steps, strength, device): + # get the original timestep using init_timestep + init_timestep = min(int(num_inference_steps * strength), num_inference_steps) + + t_start = max(num_inference_steps - init_timestep, 0) + timesteps = self.scheduler.timesteps[t_start * self.scheduler.order :] + if hasattr(self.scheduler, "set_begin_index"): + self.scheduler.set_begin_index(t_start * self.scheduler.order) + + return timesteps.to(device), num_inference_steps - t_start + + def _prepare_rotary_positional_embeddings( + self, + height: int, + width: int, + num_frames: int, + device: torch.device, + ) -> Tuple[torch.Tensor, torch.Tensor]: + grid_height = height // (self.vae_scale_factor_spatial * self.transformer.config.patch_size) + grid_width = width // (self.vae_scale_factor_spatial * self.transformer.config.patch_size) + + p = self.transformer.config.patch_size + p_t = self.transformer.config.patch_size_t + + if p_t is None: + # CogVideoX 1.0 I2V + base_size_width = self.transformer.config.sample_width // p + base_size_height = self.transformer.config.sample_height // p + + grid_crops_coords = get_resize_crop_region_for_grid( + (grid_height, grid_width), base_size_width, base_size_height + ) + freqs_cos, freqs_sin = get_3d_rotary_pos_embed( + embed_dim=self.transformer.config.attention_head_dim, + crops_coords=grid_crops_coords, + grid_size=(grid_height, grid_width), + temporal_size=num_frames, + ) + else: + # CogVideoX 1.5 I2V + base_size_width = self.transformer.config.sample_width // p + base_size_height = self.transformer.config.sample_height // p + base_num_frames = (num_frames + p_t - 1) // p_t + + freqs_cos, freqs_sin = get_3d_rotary_pos_embed( + embed_dim=self.transformer.config.attention_head_dim, + crops_coords=None, + grid_size=(grid_height, grid_width), + temporal_size=base_num_frames, + grid_type="slice", + max_size=(base_size_height, base_size_width), + ) + + freqs_cos = freqs_cos.to(device=device) + freqs_sin = freqs_sin.to(device=device) + return freqs_cos, freqs_sin + + # 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. + @property + def do_classifier_free_guidance(self): + return self._guidance_scale > 1 + + @property + def num_timesteps(self): + return self._num_timesteps + + @property + def interrupt(self): + return self._interrupt + + @torch.no_grad() + def __call__( + self, + height: int = 480, + width: int = 720, + num_frames: int = 48, + num_inference_steps: int = 50, + timesteps: Optional[List[int]] = None, + guidance_scale: float = 6, + denoise_strength: float = 1.0, + sigmas: Optional[List[float]] = None, + eta: float = 0.0, + generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None, + latents: Optional[torch.Tensor] = None, + fun_mask: Optional[torch.Tensor] = None, + image_cond_latents: Optional[torch.Tensor] = None, + prompt_embeds: Optional[torch.Tensor] = None, + negative_prompt_embeds: Optional[torch.Tensor] = None, + device = torch.device("cuda"), + context_schedule: Optional[str] = None, + context_frames: Optional[int] = None, + context_stride: Optional[int] = None, + context_overlap: Optional[int] = None, + freenoise: Optional[bool] = True, + controlnet: Optional[dict] = None, + tora: Optional[dict] = None, + image_cond_start_percent: float = 0.0, + image_cond_end_percent: float = 1.0, + feta_args: Optional[dict] = None, + + ): + """ + Function invoked when calling the pipeline for generation. + + Args: + height (`int`, *optional*, defaults to self.unet.config.sample_size * self.vae_scale_factor): + The height in pixels of the generated image. This is set to 1024 by default for the best results. + width (`int`, *optional*, defaults to self.unet.config.sample_size * self.vae_scale_factor): + The width in pixels of the generated image. This is set to 1024 by default for the best results. + num_frames (`int`, defaults to `48`): + Number of frames to generate. Must be divisible by self.vae_scale_factor_temporal. Generated video will + contain 1 extra frame because CogVideoX is conditioned with (num_seconds * fps + 1) frames where + num_seconds is 6 and fps is 4. However, since videos can be saved at any fps, the only condition that + needs to be satisfied is that of divisibility mentioned above. + num_inference_steps (`int`, *optional*, defaults to 50): + The number of denoising steps. More denoising steps usually lead to a higher quality image at the + expense of slower inference. + timesteps (`List[int]`, *optional*): + Custom timesteps to use for the denoising process with schedulers which support a `timesteps` argument + in their `set_timesteps` method. If not defined, the default behavior when `num_inference_steps` is + passed will be used. Must be in descending order. + 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. + generator (`torch.Generator` or `List[torch.Generator]`, *optional*): + One or a list of [torch generator(s)](https://pytorch.org/docs/stable/generated/torch.Generator.html) + to make generation deterministic. + latents (`torch.FloatTensor`, *optional*): + Pre-generated noisy latents, sampled from a Gaussian distribution, to be used as inputs for image + generation. Can be used to tweak the same generation with different prompts. If not provided, a latents + tensor will ge generated by sampling using the supplied random `generator`. + prompt_embeds (`torch.FloatTensor`, *optional*): + Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not + provided, text embeddings will be generated from `prompt` input argument. + negative_prompt_embeds (`torch.FloatTensor`, *optional*): + Pre-generated negative text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt + weighting. If not provided, negative_prompt_embeds will be generated from `negative_prompt` input + argument. + """ + + height = height or self.transformer.config.sample_size * self.vae_scale_factor_spatial + width = width or self.transformer.config.sample_size * self.vae_scale_factor_spatial + + self.num_frames = num_frames + + # 1. Check inputs. Raise error if not correct + self.check_inputs( + height, + width, + prompt_embeds, + negative_prompt_embeds, + ) + self._guidance_scale = guidance_scale + self._interrupt = False + + # 2. Default call parameters + + batch_size = prompt_embeds.shape[0] + + # 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[0] > 1.0 + + if do_classifier_free_guidance: + prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds], dim=0) + prompt_embeds = prompt_embeds.to(self.vae_dtype) + + # 4. Prepare timesteps + if sigmas is None: + timesteps, num_inference_steps = retrieve_timesteps(self.scheduler, num_inference_steps, device, timesteps) + else: + timesteps, num_inference_steps = retrieve_timesteps(self.scheduler, sigmas=sigmas, device=device) + self._num_timesteps = len(timesteps) + + # 5. Prepare latents. + latent_channels = self.vae_latent_channels + latent_frames = (num_frames - 1) // self.vae_scale_factor_temporal + 1 + + # For CogVideoX 1.5, the latent frames should be padded to make it divisible by patch_size_t + patch_size_t = getattr(self.transformer.config, "patch_size_t", None) + if patch_size_t is None: + self.transformer.config.patch_size_t = None + ofs_embed_dim = getattr(self.transformer.config, "ofs_embed_dim", None) + if ofs_embed_dim is None: + self.transformer.config.ofs_embed_dim = None + + self.additional_frames = 0 + if patch_size_t is not None and latent_frames % patch_size_t != 0: + self.additional_frames = patch_size_t - latent_frames % patch_size_t + num_frames += self.additional_frames * self.vae_scale_factor_temporal + + latents, timesteps = self.prepare_latents( + batch_size, + latent_channels, + num_frames, + height, + width, + device, + generator, + timesteps, + denoise_strength, + num_inference_steps, + latents, + context_size=context_frames, + context_overlap=context_overlap, + freenoise=freenoise, + ) + latents = latents.to(self.vae_dtype) + + if self.is_fun_inpaint and fun_mask is None: # For FUN inpaint vid2vid, we need to mask all the latents + fun_mask = torch.zeros_like(latents[:, :, :1, :, :], device=latents.device, dtype=latents.dtype) + fun_masked_video_latents = torch.zeros_like(latents, device=latents.device, dtype=latents.dtype) + + # 5.5. + if image_cond_latents is not None: + image_cond_frame_count = image_cond_latents.size(1) + patch_size_t = self.transformer.config.patch_size_t + if image_cond_frame_count == 2: + logger.info("More than one image conditioning frame received, interpolating") + padding_shape = ( + batch_size, + (latents.shape[1] - 2), + self.vae_latent_channels, + height // self.vae_scale_factor_spatial, + width // self.vae_scale_factor_spatial, + ) + latent_padding = torch.zeros(padding_shape, device=device, dtype=self.vae_dtype) + image_cond_latents = torch.cat([image_cond_latents[:, 0, :, :, :].unsqueeze(1), latent_padding, image_cond_latents[:, -1, :, :, :].unsqueeze(1)], dim=1) + if patch_size_t: + first_frame = image_cond_latents[:, : image_cond_latents.size(1) % patch_size_t, ...] + image_cond_latents = torch.cat([first_frame, image_cond_latents], dim=1) + + logger.info(f"image cond latents shape: {image_cond_latents.shape}") + elif image_cond_frame_count == 1: + logger.info("Only one image conditioning frame received, img2vid") + if self.input_with_padding: + padding_shape = ( + batch_size, + (latents.shape[1] - 1), + self.vae_latent_channels, + height // self.vae_scale_factor_spatial, + width // self.vae_scale_factor_spatial, + ) + latent_padding = torch.zeros(padding_shape, device=device, dtype=self.vae_dtype) + image_cond_latents = torch.cat([image_cond_latents, latent_padding], dim=1) + # Select the first frame along the second dimension + if patch_size_t: + first_frame = image_cond_latents[:, : image_cond_latents.size(1) % patch_size_t, ...] + image_cond_latents = torch.cat([first_frame, image_cond_latents], dim=1) + else: + image_cond_latents = image_cond_latents.repeat(1, latents.shape[1], 1, 1, 1) + else: + logger.info(f"Received {image_cond_latents.shape[1]} image conditioning frames") + if fun_mask is not None and patch_size_t: + logger.info(f"1.5 model received {fun_mask.shape[1]} masks") + first_frame = image_cond_latents[:, : image_cond_frame_count % patch_size_t, ...] + image_cond_latents = torch.cat([first_frame, image_cond_latents], dim=1) + fun_mask_first_frame = fun_mask[:, : image_cond_frame_count % patch_size_t, ...] + fun_mask = torch.cat([fun_mask_first_frame, fun_mask], dim=1) + fun_mask[:, 1:, ...] = 0 + image_cond_latents = image_cond_latents.to(self.vae_dtype) + + # 6. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline + extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta) + + num_warmup_steps = max(len(timesteps) - num_inference_steps * self.scheduler.order, 0) + + # 7. context schedule + if context_schedule is not None: + # if image_cond_latents is not None: + # raise NotImplementedError("Context schedule not currently supported with image conditioning") + logger.info(f"Context schedule enabled: {context_frames} frames, {context_stride} stride, {context_overlap} overlap") + use_context_schedule = True + from .context import get_context_scheduler + context = get_context_scheduler(context_schedule) + #todo ofs embeds? + + else: + use_context_schedule = False + logger.info("Context schedule disabled") + # 7.5. Create rotary embeds if required + image_rotary_emb = ( + self._prepare_rotary_positional_embeddings(height, width, latents.size(1), device) + if self.transformer.config.use_rotary_positional_embeddings + else None + ) + # 7.6. Create ofs embeds if required + ofs_emb = None if self.transformer.config.ofs_embed_dim is None else latents.new_full((1,), fill_value=2.0) + + if tora is not None and do_classifier_free_guidance: + video_flow_features = tora["video_flow_features"].repeat(1, 2, 1, 1, 1).contiguous() + + #8. Controlnet + if controlnet is not None: + self.controlnet = controlnet["control_model"].to(device) + if self.transformer.dtype == torch.float8_e4m3fn: + for name, param in self.controlnet.named_parameters(): + if "patch_embed" not in name and param.data.dtype != torch.float8_e4m3fn: + param.data = param.data.to(torch.float8_e4m3fn) + else: + self.controlnet.to(self.transformer.dtype) + + if getattr(self.transformer, 'fp8_matmul_enabled', False): + from .fp8_optimization import convert_fp8_linear + if not hasattr(self.controlnet, 'fp8_matmul_enabled') or not self.controlnet.fp8_matmul_enabled: + convert_fp8_linear(self.controlnet, torch.float16) + setattr(self.controlnet, "fp8_matmul_enabled", True) + + control_frames = controlnet["control_frames"].to(device).to(self.controlnet.dtype).contiguous() + control_frames = torch.cat([control_frames] * 2) if do_classifier_free_guidance else control_frames + control_weights = controlnet["control_weights"] + logger.info(f"Controlnet enabled with weights: {control_weights}") + control_start = controlnet["control_start"] + control_end = controlnet["control_end"] + else: + controlnet_states = None + control_weights= None + # 9. Tora + if tora is not None: + trajectory_length = tora["video_flow_features"].shape[1] + logger.info(f"Tora trajectory length: {trajectory_length}") + #if trajectory_length != latents.shape[1]: + # raise ValueError(f"Tora trajectory length {trajectory_length} does not match inpaint_latents count {latents.shape[2]}") + for module in self.transformer.fuser_list: + for param in module.parameters(): + param.data = param.data.to(self.vae_dtype).to(device) + + logger.info(f"Sampling {num_frames} frames in {latent_frames} latent frames at {width}x{height} with {num_inference_steps} inference steps") + + if feta_args is not None: + set_enhance_weight(feta_args["weight"]) + feta_start_percent = feta_args["start_percent"] + feta_end_percent = feta_args["end_percent"] + enable_enhance() + else: + disable_enhance() + + # reset TeaCache + if hasattr(self.transformer, 'accumulated_rel_l1_distance'): + delattr(self.transformer, 'accumulated_rel_l1_distance') + self.transformer.teacache_counter = 0 + + # 11. Denoising loop + #from .latent_preview import prepare_callback + #callback = prepare_callback(self.transformer, num_inference_steps) + from latent_preview import prepare_callback + self.model = CogVideoXModelPlaceholder() + self.load_device = device + callback = prepare_callback(self, num_inference_steps) + + comfy_pbar = ProgressBar(len(timesteps)) + with self.progress_bar(total=len(timesteps)) as progress_bar: + old_pred_original_sample = None # for DPM-solver++ + for i, t in enumerate(timesteps): + if self.interrupt: + continue + + current_step_percentage = i / num_inference_steps + + if feta_args is not None: + if feta_start_percent <= current_step_percentage <= feta_end_percent: + enable_enhance() + else: + disable_enhance() + # region context schedule sampling + if use_context_schedule: + 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) + counter = torch.zeros_like(latent_model_input) + noise_pred = torch.zeros_like(latent_model_input) + + if image_cond_latents is not None: + latent_image_input = torch.cat([image_cond_latents] * 2) if do_classifier_free_guidance else image_cond_latents + + # broadcast to batch dimension in a way that's compatible with ONNX/Core ML + timestep = t.expand(latent_model_input.shape[0]) + + # use same rotary embeddings for all context windows + image_rotary_emb = ( + self._prepare_rotary_positional_embeddings(height, width, context_frames, device) + if self.transformer.config.use_rotary_positional_embeddings + else None + ) + + context_queue = list(context( + i, num_inference_steps, latents.shape[1], context_frames, context_stride, context_overlap, + )) + + if controlnet is not None: + # controlnet frames are not temporally compressed, so try to match the context frames that are + control_context_queue = list(context( + i, + num_inference_steps, + control_frames.shape[1], + context_frames * self.vae_scale_factor_temporal, + context_stride * self.vae_scale_factor_temporal, + context_overlap * self.vae_scale_factor_temporal, + )) + + for c, control_c in zip(context_queue, control_context_queue): + partial_latent_model_input = latent_model_input[:, c, :, :, :] + partial_control_frames = control_frames[:, control_c, :, :, :] + + controlnet_states = None + + if (control_start <= current_step_percentage <= control_end): + # extract controlnet hidden state + controlnet_states = self.controlnet( + hidden_states=partial_latent_model_input, + encoder_hidden_states=prompt_embeds, + image_rotary_emb=image_rotary_emb, + controlnet_states=partial_control_frames, + timestep=timestep, + return_dict=False, + )[0] + if isinstance(controlnet_states, (tuple, list)): + controlnet_states = [x.to(dtype=self.controlnet.dtype) for x in controlnet_states] + else: + controlnet_states = controlnet_states.to(dtype=self.controlnet.dtype) + + # predict noise model_output + noise_pred[:, c, :, :, :] += self.transformer( + hidden_states=partial_latent_model_input, + encoder_hidden_states=prompt_embeds, + timestep=timestep, + image_rotary_emb=image_rotary_emb, + return_dict=False, + controlnet_states=controlnet_states, + controlnet_weights=control_weights, + )[0] + + counter[:, c, :, :, :] += 1 + noise_pred = noise_pred.float() + else: + for c in context_queue: + print("c:", c) + + partial_latent_model_input = latent_model_input[:, c, :, :, :] + if image_cond_latents is not None: + partial_latent_image_input = latent_image_input[:, :len(c), :, :, :] + partial_latent_model_input = torch.cat([partial_latent_model_input,partial_latent_image_input], dim=2) + + print(partial_latent_model_input.shape) + if (tora is not None and tora["start_percent"] <= current_step_percentage <= tora["end_percent"]): + if do_classifier_free_guidance: + partial_video_flow_features = tora["video_flow_features"][:, c, :, :, :].repeat(1, 2, 1, 1, 1).contiguous() + else: + partial_video_flow_features = tora["video_flow_features"][:, c, :, :, :] + else: + partial_video_flow_features = None + + # predict noise model_output + noise_pred[:, c, :, :, :] += self.transformer( + hidden_states=partial_latent_model_input, + encoder_hidden_states=prompt_embeds, + timestep=timestep, + image_rotary_emb=image_rotary_emb, + video_flow_features=partial_video_flow_features, + return_dict=False + )[0] + + counter[:, c, :, :, :] += 1 + noise_pred = noise_pred.float() + + noise_pred /= counter + if do_classifier_free_guidance: + noise_pred_uncond, noise_pred_text = noise_pred.chunk(2) + noise_pred = noise_pred_uncond + self._guidance_scale[i] * (noise_pred_text - noise_pred_uncond) + + # compute the previous noisy sample x_t -> x_t-1 + if not isinstance(self.scheduler, CogVideoXDPMScheduler): + latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs, return_dict=False)[0] + else: + latents, old_pred_original_sample = self.scheduler.step( + noise_pred, + old_pred_original_sample, + t, + timesteps[i - 1] if i > 0 else None, + latents, + **extra_step_kwargs, + return_dict=False, + ) + latents = latents.to(prompt_embeds.dtype) + + 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: + alpha_prod_t = self.scheduler.alphas_cumprod[t] + beta_prod_t = 1 - alpha_prod_t + callback_tensor = (alpha_prod_t**0.5) * latent_model_input[0][:, :16, :, :] - (beta_prod_t**0.5) * noise_pred.detach()[0] + callback(i, callback_tensor * 5, None, num_inference_steps) + else: + comfy_pbar.update(1) + + # region sampling + else: + 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) + + if image_cond_latents is not None: + if not image_cond_start_percent <= current_step_percentage <= image_cond_end_percent: + latent_image_input = torch.zeros_like(latent_model_input) + else: + latent_image_input = torch.cat([image_cond_latents] * 2) if do_classifier_free_guidance else image_cond_latents + if fun_mask is not None: #for fun img2vid and interpolation + fun_inpaint_mask = torch.cat([fun_mask] * 2) if do_classifier_free_guidance else fun_mask + masks_input = torch.cat([fun_inpaint_mask, latent_image_input], dim=2) + latent_model_input = torch.cat([latent_model_input, masks_input], dim=2) + else: + latent_model_input = torch.cat([latent_model_input, latent_image_input], dim=2) + else: # for Fun inpaint vid2vid + if fun_mask is not None: + fun_inpaint_mask = torch.cat([fun_mask] * 2) if do_classifier_free_guidance else fun_mask + fun_inpaint_masked_video_latents = torch.cat([fun_masked_video_latents] * 2) if do_classifier_free_guidance else fun_masked_video_latents + fun_inpaint_latents = torch.cat([fun_inpaint_mask, fun_inpaint_masked_video_latents], dim=2).to(latents.dtype) + latent_model_input = torch.cat([latent_model_input, fun_inpaint_latents], dim=2) + + # broadcast to batch dimension in a way that's compatible with ONNX/Core ML + timestep = t.expand(latent_model_input.shape[0]) + + if controlnet is not None: + controlnet_states = None + if (control_start <= current_step_percentage <= control_end): + # extract controlnet hidden state + controlnet_states = self.controlnet( + hidden_states=latent_model_input, + encoder_hidden_states=prompt_embeds, + image_rotary_emb=image_rotary_emb, + controlnet_states=control_frames, + timestep=timestep, + return_dict=False, + )[0] + if isinstance(controlnet_states, (tuple, list)): + controlnet_states = [x.to(dtype=self.vae_dtype) for x in controlnet_states] + else: + controlnet_states = controlnet_states.to(dtype=self.vae_dtype) + + # predict noise model_output + noise_pred = self.transformer( + hidden_states=latent_model_input, + encoder_hidden_states=prompt_embeds, + timestep=timestep, + image_rotary_emb=image_rotary_emb, + ofs=ofs_emb, + return_dict=False, + controlnet_states=controlnet_states, + controlnet_weights=control_weights, + video_flow_features=video_flow_features if (tora is not None and tora["start_percent"] <= current_step_percentage <= tora["end_percent"]) else None, + )[0] + noise_pred = noise_pred.float() + if isinstance(self.scheduler, CogVideoXDPMScheduler): + self._guidance_scale[i] = 1 + guidance_scale[i] * ( + (1 - math.cos(math.pi * ((num_inference_steps - t.item()) / num_inference_steps) ** 5.0)) / 2 + ) + + if do_classifier_free_guidance: + noise_pred_uncond, noise_pred_text = noise_pred.chunk(2) + noise_pred = noise_pred_uncond + self._guidance_scale[i] * (noise_pred_text - noise_pred_uncond) + + # compute the previous noisy sample x_t -> x_t-1 + if not isinstance(self.scheduler, CogVideoXDPMScheduler): + latents = self.scheduler.step(noise_pred, t, latents.to(self.vae_dtype), **extra_step_kwargs, return_dict=False)[0] + else: + latents, old_pred_original_sample = self.scheduler.step( + noise_pred, + old_pred_original_sample, + t, + timesteps[i - 1] if i > 0 else None, + latents.to(self.vae_dtype), + **extra_step_kwargs, + return_dict=False, + ) + latents = latents.to(prompt_embeds.dtype) + + 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: + alpha_prod_t = self.scheduler.alphas_cumprod[t] + beta_prod_t = 1 - alpha_prod_t + callback_tensor = (alpha_prod_t**0.5) * latent_model_input[0][:, :16, :, :] - (beta_prod_t**0.5) * noise_pred.detach()[0] + callback(i, callback_tensor * 5, None, num_inference_steps) + else: + comfy_pbar.update(1) + + + # Offload all models + self.maybe_free_model_hooks() + + return latents \ No newline at end of file diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/pyproject.toml b/custom_nodes/ComfyUI-CogVideoXWrapper/pyproject.toml new file mode 100644 index 0000000000000000000000000000000000000000..060d4c561980e24086b15878ec5395464fabf0f4 --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/pyproject.toml @@ -0,0 +1,15 @@ +[project] +name = "comfyui-cogvideoxwrapper" +description = "Diffusers wrapper for CogVideoX -models: https://github.com/THUDM/CogVideo" +version = "1.5.1" +license = {file = "LICENSE"} +dependencies = ["huggingface_hub", "diffusers>=0.31.0", "accelerate>=0.33.0"] + +[project.urls] +Repository = "https://github.com/kijai/ComfyUI-CogVideoXWrapper" +# Used by Comfy Registry https://comfyregistry.org + +[tool.comfy] +PublisherId = "kijai" +DisplayName = "ComfyUI-CogVideoXWrapper" +Icon = "" diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/readme.md b/custom_nodes/ComfyUI-CogVideoXWrapper/readme.md new file mode 100644 index 0000000000000000000000000000000000000000..f8e8c24394f15c9f4f7699b67aac8b8eaaa9e367 --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/readme.md @@ -0,0 +1,147 @@ +# WORK IN PROGRESS + +Spreadsheet (WIP) of supported models and their supported features: https://docs.google.com/spreadsheets/d/16eA6mSL8XkTcu9fSWkPSHfRIqyAKJbR1O99xnuGdCKY/edit?usp=sharing + +## Update 9 +Added preliminary support for [Go-with-the-Flow](https://github.com/VGenAI-Netflix-Eyeline-Research/Go-with-the-Flow) + +This uses LoRA weights available here: https://huggingface.co/Eyeline-Research/Go-with-the-Flow/tree/main + +To create the input videos for the NoiseWarp process, I've added a node to KJNodes that works alongside my SplineEditor, and either [comfyui-inpaint-nodes](https://github.com/Acly/comfyui-inpaint-nodes) or just cv2 inpainting to create the cut and drag input videos. + +The workflows are in the example_workflows -folder. + +Quick video to showcase: First mask the subject, then use the cut and drag -workflow to create a video as seen here, then that video is used as input to the NoiseWarp node in the main workflow. + +https://github.com/user-attachments/assets/112706b0-a38b-4c3c-b779-deba0827af4f + +## BREAKING Update8 + +This is big one, and unfortunately to do the necessary cleanup and refactoring this will break every old workflow as they are. +I apologize for the inconvenience, if I don't do this now I'll keep making it worse until maintaining becomes too much of a chore, so from my pov there was no choice. + +*Please either use the new workflows or fix the nodes in your old ones before posting issue reports!* + +Old version will be kept in a legacy branch, but not maintained + +- Support CogVideoX 1.5 models +- Major code cleanup (it was bad, still isn't great, wip) +- Merge Fun -model functionality into main pipeline: + - All Fun specific nodes, besides image encode node for Fun -InP models are gone + - Main CogVideo Sampler works with Fun models + - DimensionX LoRAs now work with Fun models as well + +- Remove width/height from the sampler widgets and detect from input instead, this meanst text2vid now requires using empty latents +- Separate VAE from the model, allow using fp32 VAE +- Add ability to load some of the non-GGUF models as single files (only few available for now: https://huggingface.co/Kijai/CogVideoX-comfy) +- Add some torchao quantizations as options +- Add interpolation as option for the main encode node, old interpolation specific node is gone +- torch.compile optimizations +- Remove PAB in favor of FasterCache and cleaner code +- other smaller things I forgot about at this point + +For Fun -model based workflows it's more drastic change, for others migrating generally means re-setting many of the nodes. + +## Update7 + +- Refactored the Fun version's sampler to accept any resolution, this should make it lot simpler to use with Tora. **BREAKS OLD WORKFLOWS**, old FunSampler nodes need to be remade. +- The old bucket resizing is now on it's own node (CogVideoXFunResizeToClosestBucket) to keep the functionality, I honestly don't know if it matters at all, but just in case. +- Fun version's vid2vid is now also in the same node, the old vid2vid node is deprecated. +- Added support for FasterCache, this trades more VRAM use for speed with slight quality hit, similar to PAB: https://github.com/Vchitect/FasterCache +- Improved torch.compile support, it actually works now + +## Update6 + +Initial support for Tora (https://github.com/alibaba/Tora) + +Converted model (included in the autodownload node): + +https://huggingface.co/Kijai/CogVideoX-5b-Tora/tree/main + + +https://github.com/user-attachments/assets/d5334237-03dc-48f5-8bec-3ae5998660c6 + + +## Update5 +This week there's been some bigger updates that will most likely affect some old workflows, sampler node especially probably need to be refreshed (re-created) if it errors out! + +New features: +- Initial context windowing with FreeNoise noise shuffling mainly for vid2vid and pose2vid pipelines for longer generations, haven't figured it out for img2vid yet +- GGUF models and tiled encoding for I2V and pose pipelines (thanks to MinusZoneAI) +- [sageattention](https://github.com/thu-ml/SageAttention) support (Linux only) for a speed boost, I experienced ~20-30% increase with it, stacks with fp8 fast mode, doesn't need compiling +- Support CogVideoX-Fun 1.1 and it's pose models with additional control strength and application step settings, this model's input does NOT have to be just dwpose skeletons, just about anything can work +- Support LoRAs + +https://github.com/user-attachments/assets/ddeb8f38-a647-42b3-a4b1-c6936f961deb + +https://github.com/user-attachments/assets/c78b2832-9571-4941-8c97-fbcc1a4cc23d + +https://github.com/user-attachments/assets/d9ed98b1-f917-432b-a16e-e01e87efb1f9 + + + +## Update4 +Initial support for the official I2V version of CogVideoX: https://huggingface.co/THUDM/CogVideoX-5b-I2V + +**Also needs diffusers 0.30.3** + +https://github.com/user-attachments/assets/c672d0af-a676-495d-a42c-7e3dd802b4b0 + + + +## Update3 + +Added initial support for CogVideoX-Fun: https://github.com/aigc-apps/CogVideoX-Fun + +Note that while this one can do image2vid, this is NOT the official I2V model yet, though it should also be released very soon. + +https://github.com/user-attachments/assets/68f9ed16-ee53-4955-b931-1799461ac561 + + +## Updade2 + +Added **experimental** support for onediff, this reduced sampling time by ~40% for me, reaching 4.23 s/it on 4090 with 49 frames. +This requires using Linux, torch 2.4.0, onediff and nexfort installation: + +`pip install --pre onediff onediffx` + +`pip install nexfort` + +First run will take around 5 mins for the compilation. + +## Update +5b model is now also supported for basic text2vid: https://huggingface.co/THUDM/CogVideoX-5b + +It is also autodownloaded to `ComfyUI/models/CogVideo/CogVideoX-5b`, text encoder is not needed as we use the ComfyUI T5. + +https://github.com/user-attachments/assets/991205cc-826e-4f93-831a-c10441f0f2ce + +Requires diffusers 0.30.1 (this is specified in requirements.txt) + +Uses same T5 model than SD3 and Flux, fp8 works fine too. Memory requirements depend mostly on the video length. +VAE decoding seems to be the only big that takes a lot of VRAM when everything is offloaded, peaks at around 13-14GB momentarily at that stage. +Sampling itself takes only maybe 5-6GB. + + +Hacked in img2img to attempt vid2vid workflow, works interestingly with some inputs, highly experimental. + +https://github.com/user-attachments/assets/e6951ef4-ea7a-4752-94f6-cf24f2503d83 + +https://github.com/user-attachments/assets/9e41f37b-2bb3-411c-81fa-e91b80da2559 + +Also added temporal tiling as means of generating endless videos: + +https://github.com/kijai/ComfyUI-CogVideoXWrapper + +https://github.com/user-attachments/assets/ecdac8b8-d434-48b6-abd6-90755b6b552d + + + +Original repo: +https://github.com/THUDM/CogVideo + +CogVideoX-Fun: +https://github.com/aigc-apps/CogVideoX-Fun + +Controlnet: +https://github.com/TheDenk/cogvideox-controlnet diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/requirements.txt b/custom_nodes/ComfyUI-CogVideoXWrapper/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..293519b4b674e7a6f79035ab901962358242ec68 --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/requirements.txt @@ -0,0 +1,6 @@ +huggingface_hub +diffusers>=0.31.0 +accelerate>=0.33.0 +einops +peft +opencv-python \ No newline at end of file diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/tora/__pycache__/traj_utils.cpython-311.pyc b/custom_nodes/ComfyUI-CogVideoXWrapper/tora/__pycache__/traj_utils.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..12e67b2752e8c6ef9359aba571828c292673eed0 Binary files /dev/null and b/custom_nodes/ComfyUI-CogVideoXWrapper/tora/__pycache__/traj_utils.cpython-311.pyc differ diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/tora/__pycache__/traj_utils.cpython-312.pyc b/custom_nodes/ComfyUI-CogVideoXWrapper/tora/__pycache__/traj_utils.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4fa78db787a698006b144ab9e213114f41633c8d Binary files /dev/null and b/custom_nodes/ComfyUI-CogVideoXWrapper/tora/__pycache__/traj_utils.cpython-312.pyc differ diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/tora/traj_module.py b/custom_nodes/ComfyUI-CogVideoXWrapper/tora/traj_module.py new file mode 100644 index 0000000000000000000000000000000000000000..297a01802bc4919ec2b1ccc1696d31be3bfaa504 --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/tora/traj_module.py @@ -0,0 +1,307 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F +from einops import rearrange, reduce + + +def avg_pool_nd(dims, *args, **kwargs): + """ + Create a 1D, 2D, or 3D average pooling module. + """ + if dims == 1: + return nn.AvgPool1d(*args, **kwargs) + elif dims == 2: + return nn.AvgPool2d(*args, **kwargs) + elif dims == 3: + return nn.AvgPool3d(*args, **kwargs) + raise ValueError(f"unsupported dimensions: {dims}") + + +def conv_nd(dims, *args, **kwargs): + """ + Create a 1D, 2D, or 3D convolution module. + """ + if dims == 1: + return nn.Conv1d(*args, **kwargs) + elif dims == 2: + return nn.Conv2d(*args, **kwargs) + elif dims == 3: + return nn.Conv3d(*args, **kwargs) + raise ValueError(f"unsupported dimensions: {dims}") + + +class Downsample(nn.Module): + """ + A downsampling layer with an optional convolution. + :param channels: channels in the inputs and outputs. + :param use_conv: a bool determining if a convolution is applied. + :param dims: determines if the signal is 1D, 2D, or 3D. If 3D, then + downsampling occurs in the inner-two dimensions. + """ + + def __init__(self, channels, use_conv, dims=2, out_channels=None, padding=1): + super().__init__() + self.channels = channels + self.out_channels = out_channels or channels + self.use_conv = use_conv + self.dims = dims + stride = 2 if dims != 3 else (1, 2, 2) + if use_conv: + self.op = conv_nd( + dims, + self.channels, + self.out_channels, + 3, + stride=stride, + padding=padding, + ) + else: + assert self.channels == self.out_channels + self.op = avg_pool_nd(dims, kernel_size=stride, stride=stride) + + def forward(self, x): + assert x.shape[1] == self.channels + return self.op(x) + + +class ResnetBlock(nn.Module): + def __init__(self, in_c, out_c, down, ksize=3, sk=False, use_conv=True): + super().__init__() + ps = ksize // 2 + if in_c != out_c or sk == False: + self.in_conv = nn.Conv2d(in_c, out_c, ksize, 1, ps) + else: + # print('n_in') + self.in_conv = None + self.block1 = nn.Conv2d(out_c, out_c, 3, 1, 1) + self.act = nn.ReLU() + self.block2 = nn.Conv2d(out_c, out_c, ksize, 1, ps) + self.bn1 = nn.BatchNorm2d(out_c) + self.bn2 = nn.BatchNorm2d(out_c) + if sk == False: + # self.skep = nn.Conv2d(in_c, out_c, ksize, 1, ps) # edit by zhouxiawang + self.skep = nn.Conv2d(out_c, out_c, ksize, 1, ps) + else: + self.skep = None + + self.down = down + if self.down == True: + self.down_opt = Downsample(in_c, use_conv=use_conv) + + def forward(self, x): + if self.down == True: + x = self.down_opt(x) + if self.in_conv is not None: # edit + x = self.in_conv(x) + + h = self.bn1(x) + h = self.act(h) + h = self.block1(h) + h = self.bn2(h) + h = self.act(h) + h = self.block2(h) + if self.skep is not None: + return h + self.skep(x) + else: + return h + x + + +class VAESpatialEmulator(nn.Module): + def __init__(self, kernel_size=(8, 8)): + super().__init__() + self.kernel_size = kernel_size + + def forward(self, x): + """ + x: torch.Tensor: shape [B C T H W] + """ + Hp, Wp = self.kernel_size + H, W = x.shape[-2], x.shape[-1] + valid_h = H - H % Hp + valid_w = W - W % Wp + x = x[..., :valid_h, :valid_w] + x = rearrange( + x, + "B C T (Nh Hp) (Nw Wp) -> B (Hp Wp C) T Nh Nw", + Hp=Hp, + Wp=Wp, + ) + return x + + +class VAETemporalEmulator(nn.Module): + def __init__(self, micro_frame_size, kernel_size=4): + super().__init__() + self.micro_frame_size = micro_frame_size + self.kernel_size = kernel_size + + def forward(self, x_z): + """ + x_z: torch.Tensor: shape [B C T H W] + """ + + z_list = [] + for i in range(0, x_z.shape[2], self.micro_frame_size): + x_z_bs = x_z[:, :, i : i + self.micro_frame_size] + z_list.append(x_z_bs[:, :, 0:1]) + x_z_bs = x_z_bs[:, :, 1:] + t_valid = x_z_bs.shape[2] - x_z_bs.shape[2] % self.kernel_size + x_z_bs = x_z_bs[:, :, :t_valid] + x_z_bs = reduce(x_z_bs, "B C (T n) H W -> B C T H W", n=self.kernel_size, reduction="mean") + z_list.append(x_z_bs) + z = torch.cat(z_list, dim=2) + return z + + +class TrajExtractor(nn.Module): + def __init__( + self, + vae_downsize=(4, 8, 8), + patch_size=2, + channels=[320, 640, 1280, 1280], + nums_rb=3, + cin=2, + ksize=3, + sk=False, + use_conv=True, + ): + super(TrajExtractor, self).__init__() + self.vae_downsize = vae_downsize + # self.vae_spatial_emulator = VAESpatialEmulator(kernel_size=vae_downsize[-2:]) + self.downsize_patchify = nn.PixelUnshuffle(patch_size) + self.patch_size = (1, patch_size, patch_size) + self.channels = channels + self.nums_rb = nums_rb + self.body = [] + for i in range(len(channels)): + for j in range(nums_rb): + if (i != 0) and (j == 0): + self.body.append( + ResnetBlock( + channels[i - 1], + channels[i], + down=False, + ksize=ksize, + sk=sk, + use_conv=use_conv, + ) + ) + else: + self.body.append( + ResnetBlock( + channels[i], + channels[i], + down=False, + ksize=ksize, + sk=sk, + use_conv=use_conv, + ) + ) + self.body = nn.ModuleList(self.body) + cin_ = cin * patch_size**2 + self.conv_in = nn.Conv2d(cin_, channels[0], 3, 1, 1) + + # Initialize weights + def conv_init(module): + if isinstance(module, (nn.Conv2d, nn.Conv1d)): + nn.init.kaiming_normal_(module.weight, nonlinearity="relu") + if module.bias is not None: + nn.init.constant_(module.bias, 0) + + self.apply(conv_init) + + def forward(self, x): + """ + x: torch.Tensor: shape [B C T H W] + """ + # downsize + T, H, W = x.shape[-3:] + if W % self.patch_size[2] != 0: + x = F.pad(x, (0, self.patch_size[2] - W % self.patch_size[2])) + if H % self.patch_size[1] != 0: + x = F.pad(x, (0, 0, 0, self.patch_size[1] - H % self.patch_size[1])) + if T % self.patch_size[0] != 0: + x = F.pad( + x, + (0, 0, 0, 0, 0, self.patch_size[0] - T % self.patch_size[0]), + ) + x = rearrange(x, "B C T H W -> (B T) C H W") + x = self.downsize_patchify(x) + + # extract features + features = [] + x = self.conv_in(x) + for i in range(len(self.channels)): + for j in range(self.nums_rb): + idx = i * self.nums_rb + j + x = self.body[idx](x) + features.append(x) + + return features + + +class FloatGroupNorm(nn.GroupNorm): + def forward(self, x): + return super().forward(x.to(self.bias.dtype)).type(x.dtype) + + +def zero_module(module): + """ + Zero out the parameters of a module and return it. + """ + for p in module.parameters(): + p.detach().zero_() + return module + + +class MGF(nn.Module): + def __init__(self, flow_in_channel=128, out_channels=1152): + super().__init__() + self.out_channels = out_channels + self.flow_gamma_spatial = nn.Conv2d(flow_in_channel, self.out_channels // 4, 3, padding=1) + self.flow_gamma_temporal = zero_module( + nn.Conv1d( + self.out_channels // 4, + self.out_channels, + kernel_size=3, + stride=1, + padding=1, + padding_mode="replicate", + ) + ) + self.flow_beta_spatial = nn.Conv2d(flow_in_channel, self.out_channels // 4, 3, padding=1) + self.flow_beta_temporal = zero_module( + nn.Conv1d( + self.out_channels // 4, + self.out_channels, + kernel_size=3, + stride=1, + padding=1, + padding_mode="replicate", + ) + ) + self.flow_cond_norm = FloatGroupNorm(32, self.out_channels) + + def forward(self, h, flow, T): + if flow is not None: + gamma_flow = self.flow_gamma_spatial(flow) + beta_flow = self.flow_beta_spatial(flow) + _, _, hh, wh = beta_flow.shape + + if gamma_flow.shape[0] == 1: # Check if batch size is 1 + gamma_flow = rearrange(gamma_flow, "b c h w -> b c (h w)") + beta_flow = rearrange(beta_flow, "b c h w -> b c (h w)") + gamma_flow = self.flow_gamma_temporal(gamma_flow) + beta_flow = self.flow_beta_temporal(beta_flow) + gamma_flow = rearrange(gamma_flow, "b c (h w) -> b c h w", h=hh, w=wh) + beta_flow = rearrange(beta_flow, "b c (h w) -> b c h w", h=hh, w=wh) + else: + gamma_flow = rearrange(gamma_flow, "(b f) c h w -> (b h w) c f", f=T) + beta_flow = rearrange(beta_flow, "(b f) c h w -> (b h w) c f", f=T) + gamma_flow = self.flow_gamma_temporal(gamma_flow) + beta_flow = self.flow_beta_temporal(beta_flow) + gamma_flow = rearrange(gamma_flow, "(b h w) c f -> (b f) c h w", h=hh, w=wh) + beta_flow = rearrange(beta_flow, "(b h w) c f -> (b f) c h w", h=hh, w=wh) + + h = h + self.flow_cond_norm(h) * gamma_flow + beta_flow + return h diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/tora/traj_utils.py b/custom_nodes/ComfyUI-CogVideoXWrapper/tora/traj_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..9e12365bbbc3b00f5ed6aa470233bf1dd2b81ef2 --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/tora/traj_utils.py @@ -0,0 +1,209 @@ +import numpy as np +import cv2 +import torch + +# Note that the coordinates passed to the model must not exceed 256. +# xy range 256 + +def pdf2(sigma_matrix, grid): + """Calculate PDF of the bivariate Gaussian distribution. + Args: + sigma_matrix (ndarray): with the shape (2, 2) + grid (ndarray): generated by :func:`mesh_grid`, + with the shape (K, K, 2), K is the kernel size. + Returns: + kernel (ndarrray): un-normalized kernel. + """ + inverse_sigma = np.linalg.inv(sigma_matrix) + kernel = np.exp(-0.5 * np.sum(np.dot(grid, inverse_sigma) * grid, 2)) + return kernel + + +def mesh_grid(kernel_size): + """Generate the mesh grid, centering at zero. + Args: + kernel_size (int): + Returns: + xy (ndarray): with the shape (kernel_size, kernel_size, 2) + xx (ndarray): with the shape (kernel_size, kernel_size) + yy (ndarray): with the shape (kernel_size, kernel_size) + """ + ax = np.arange(-kernel_size // 2 + 1.0, kernel_size // 2 + 1.0) + xx, yy = np.meshgrid(ax, ax) + xy = np.hstack( + ( + xx.reshape((kernel_size * kernel_size, 1)), + yy.reshape(kernel_size * kernel_size, 1), + ) + ).reshape(kernel_size, kernel_size, 2) + return xy, xx, yy + + +def sigma_matrix2(sig_x, sig_y, theta): + """Calculate the rotated sigma matrix (two dimensional matrix). + Args: + sig_x (float): + sig_y (float): + theta (float): Radian measurement. + Returns: + ndarray: Rotated sigma matrix. + """ + d_matrix = np.array([[sig_x**2, 0], [0, sig_y**2]]) + u_matrix = np.array([[np.cos(theta), -np.sin(theta)], [np.sin(theta), np.cos(theta)]]) + return np.dot(u_matrix, np.dot(d_matrix, u_matrix.T)) + + +def bivariate_Gaussian(kernel_size, sig_x, sig_y, theta, grid=None, isotropic=True): + """Generate a bivariate isotropic or anisotropic Gaussian kernel. + In the isotropic mode, only `sig_x` is used. `sig_y` and `theta` is ignored. + Args: + kernel_size (int): + sig_x (float): + sig_y (float): + theta (float): Radian measurement. + grid (ndarray, optional): generated by :func:`mesh_grid`, + with the shape (K, K, 2), K is the kernel size. Default: None + isotropic (bool): + Returns: + kernel (ndarray): normalized kernel. + """ + if grid is None: + grid, _, _ = mesh_grid(kernel_size) + if isotropic: + sigma_matrix = np.array([[sig_x**2, 0], [0, sig_x**2]]) + else: + sigma_matrix = sigma_matrix2(sig_x, sig_y, theta) + kernel = pdf2(sigma_matrix, grid) + kernel = kernel / np.sum(kernel) + return kernel + +size = 99 +sigma = 10 +blur_kernel = bivariate_Gaussian(size, sigma, sigma, 0, grid=None, isotropic=True) +blur_kernel = blur_kernel / blur_kernel[size // 2, size // 2] + +canvas_width, canvas_height = 256, 256 + +def get_flow(points, optical_flow, video_len): + for i in range(video_len - 1): + p = points[i] + p1 = points[i + 1] + optical_flow[i + 1, p[1], p[0], 0] = p1[0] - p[0] + optical_flow[i + 1, p[1], p[0], 1] = p1[1] - p[1] + + return optical_flow + + +def process_points(points, frames=49): + defualt_points = [[128, 128]] * frames + + if len(points) < 2: + return defualt_points + + elif len(points) >= frames: + skip = len(points) // frames + return points[::skip][: frames - 1] + points[-1:] + else: + insert_num = frames - len(points) + insert_num_dict = {} + interval = len(points) - 1 + n = insert_num // interval + m = insert_num % interval + for i in range(interval): + insert_num_dict[i] = n + for i in range(m): + insert_num_dict[i] += 1 + + res = [] + for i in range(interval): + insert_points = [] + x0, y0 = points[i] + x1, y1 = points[i + 1] + + delta_x = x1 - x0 + delta_y = y1 - y0 + for j in range(insert_num_dict[i]): + x = x0 + (j + 1) / (insert_num_dict[i] + 1) * delta_x + y = y0 + (j + 1) / (insert_num_dict[i] + 1) * delta_y + insert_points.append([int(x), int(y)]) + + res += points[i : i + 1] + insert_points + res += points[-1:] + return res + + +def read_points_from_list(traj_list, video_len=16, reverse=False): + points = [] + for point in traj_list: + if isinstance(point, str): + x, y = point.strip().split(",") + else: + x, y = point[0], point[1] + points.append((int(x), int(y))) + if reverse: + points = points[::-1] + + if len(points) > video_len: + skip = len(points) // video_len + points = points[::skip] + points = points[:video_len] + + return points + + +def read_points_from_file(file, video_len=16, reverse=False): + with open(file, "r") as f: + lines = f.readlines() + points = [] + for line in lines: + x, y = line.strip().split(",") + points.append((int(x), int(y))) + if reverse: + points = points[::-1] + + if len(points) > video_len: + skip = len(points) // video_len + points = points[::skip] + points = points[:video_len] + + return points + + +def process_traj(trajs_list, num_frames, video_size, device="cpu"): + if trajs_list and trajs_list[0] and (not isinstance(trajs_list[0][0], (list, tuple))): + tmp = trajs_list + trajs_list = [tmp] + + optical_flow = np.zeros((num_frames, video_size[0], video_size[1], 2), dtype=np.float32) + processed_points = [] + for traj_list in trajs_list: + points = read_points_from_list(traj_list, video_len=num_frames) + xy_range = 256 + h, w = video_size + points = process_points(points, num_frames) + points = [[int(w * x / xy_range), int(h * y / xy_range)] for x, y in points] + optical_flow = get_flow(points, optical_flow, video_len=num_frames) + processed_points.append(points) + + print(f"received {len(trajs_list)} trajectorie(s)") + + for i in range(1, num_frames): + optical_flow[i] = cv2.filter2D(optical_flow[i], -1, blur_kernel) + + optical_flow = torch.tensor(optical_flow).to(device) + + return optical_flow, processed_points + + +def add_provided_traj(traj_name): + global traj_list + traj_list = PROVIDED_TRAJS[traj_name] + traj_str = [f"{traj}" for traj in traj_list] + return ", ".join(traj_str) + + +def scale_traj_list_to_256(traj_list, canvas_width, canvas_height): + scale_x = 256 / canvas_width + scale_y = 256 / canvas_height + scaled_traj_list = [[int(x * scale_x), int(y * scale_y)] for x, y in traj_list] + return scaled_traj_list \ No newline at end of file diff --git a/custom_nodes/ComfyUI-CogVideoXWrapper/utils.py b/custom_nodes/ComfyUI-CogVideoXWrapper/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..3b33d5b603f7a04a44fcbce5cf4b28b8695fe722 --- /dev/null +++ b/custom_nodes/ComfyUI-CogVideoXWrapper/utils.py @@ -0,0 +1,30 @@ +import importlib.metadata +import torch +import logging +logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') +log = logging.getLogger(__name__) + +def check_diffusers_version(): + try: + version = importlib.metadata.version('diffusers') + required_version = '0.31.0' + if version < required_version: + raise AssertionError(f"diffusers version {version} is installed, but version {required_version} or higher is required.") + except importlib.metadata.PackageNotFoundError: + raise AssertionError("diffusers is not installed.") + +def remove_specific_blocks(model, block_indices_to_remove): + import torch.nn as nn + transformer_blocks = model.transformer_blocks + new_blocks = [block for i, block in enumerate(transformer_blocks) if i not in block_indices_to_remove] + model.transformer_blocks = nn.ModuleList(new_blocks) + + return model + +def print_memory(device): + memory = torch.cuda.memory_allocated(device) / 1024**3 + max_memory = torch.cuda.max_memory_allocated(device) / 1024**3 + max_reserved = torch.cuda.max_memory_reserved(device) / 1024**3 + log.info(f"Allocated memory: {memory=:.3f} GB") + log.info(f"Max allocated memory: {max_memory=:.3f} GB") + log.info(f"Max reserved memory: {max_reserved=:.3f} GB") \ No newline at end of file