The most powerful and modular diffusion model GUI, api and backend with a graph/nodes interface. The fastest local inference engine in the world.
Wan 2.2 support. (#9080)
comfyanonymousa88788dce6b0
diff --git a/comfy/latent_formats.py b/comfy/latent_formats.pyindex 82d9f9bb8..caf4991fc 100644--- a/comfy/latent_formats.py+++ b/comfy/latent_formats.py@@ -457,6 +457,82 @@ class Wan21(LatentFormat):latents_std = self.latents_std.to(latent.device, latent.dtype)return latent * latents_std / self.scale_factor + latents_mean+class Wan22(Wan21):+ latent_channels = 48+ latent_dimensions = 3++ latent_rgb_factors = [+ [ 0.0119, 0.0103, 0.0046],+ [-0.1062, -0.0504, 0.0165],+ [ 0.0140, 0.0409, 0.0491],+ [-0.0813, -0.0677, 0.0607],+ [ 0.0656, 0.0851, 0.0808],+ [ 0.0264, 0.0463, 0.0912],+ [ 0.0295, 0.0326, 0.0590],+ [-0.0244, -0.0270, 0.0025],+ [ 0.0443, -0.0102, 0.0288],+ [-0.0465, -0.0090, -0.0205],+ [ 0.0359, 0.0236, 0.0082],+ [-0.0776, 0.0854, 0.1048],+ [ 0.0564, 0.0264, 0.0561],+ [ 0.0006, 0.0594, 0.0418],+ [-0.0319, -0.0542, -0.0637],+ [-0.0268, 0.0024, 0.0260],+ [ 0.0539, 0.0265, 0.0358],+ [-0.0359, -0.0312, -0.0287],+ [-0.0285, -0.1032, -0.1237],+ [ 0.1041, 0.0537, 0.0622],+ [-0.0086, -0.0374, -0.0051],+ [ 0.0390, 0.0670, 0.2863],+ [ 0.0069, 0.0144, 0.0082],+ [ 0.0006, -0.0167, 0.0079],+ [ 0.0313, -0.0574, -0.0232],+ [-0.1454, -0.0902, -0.0481],+ [ 0.0714, 0.0827, 0.0447],+ [-0.0304, -0.0574, -0.0196],+ [ 0.0401, 0.0384, 0.0204],+ [-0.0758, -0.0297, -0.0014],+ [ 0.0568, 0.1307, 0.1372],+ [-0.0055, -0.0310, -0.0380],+ [ 0.0239, -0.0305, 0.0325],+ [-0.0663, -0.0673, -0.0140],+ [-0.0416, -0.0047, -0.0023],+ [ 0.0166, 0.0112, -0.0093],+ [-0.0211, 0.0011, 0.0331],+ [ 0.1833, 0.1466, 0.2250],+ [-0.0368, 0.0370, 0.0295],+ [-0.3441, -0.3543, -0.2008],+ [-0.0479, -0.0489, -0.0420],+ [-0.0660, -0.0153, 0.0800],+ [-0.0101, 0.0068, 0.0156],+ [-0.0690, -0.0452, -0.0927],+ [-0.0145, 0.0041, 0.0015],+ [ 0.0421, 0.0451, 0.0373],+ [ 0.0504, -0.0483, -0.0356],+ [-0.0837, 0.0168, 0.0055]+ ]++ latent_rgb_factors_bias = [0.0317, -0.0878, -0.1388]++ def __init__(self):+ self.scale_factor = 1.0+ self.latents_mean = torch.tensor([+ -0.2289, -0.0052, -0.1323, -0.2339, -0.2799, 0.0174, 0.1838, 0.1557,+ -0.1382, 0.0542, 0.2813, 0.0891, 0.1570, -0.0098, 0.0375, -0.1825,+ -0.2246, -0.1207, -0.0698, 0.5109, 0.2665, -0.2108, -0.2158, 0.2502,+ -0.2055, -0.0322, 0.1109, 0.1567, -0.0729, 0.0899, -0.2799, -0.1230,+ -0.0313, -0.1649, 0.0117, 0.0723, -0.2839, -0.2083, -0.0520, 0.3748,+ 0.0152, 0.1957, 0.1433, -0.2944, 0.3573, -0.0548, -0.1681, -0.0667,+ ]).view(1, self.latent_channels, 1, 1, 1)+ self.latents_std = torch.tensor([+ 0.4765, 1.0364, 0.4514, 1.1677, 0.5313, 0.4990, 0.4818, 0.5013,+ 0.8158, 1.0344, 0.5894, 1.0901, 0.6885, 0.6165, 0.8454, 0.4978,+ 0.5759, 0.3523, 0.7135, 0.6804, 0.5833, 1.4146, 0.8986, 0.5659,+ 0.7069, 0.5338, 0.4889, 0.4917, 0.4069, 0.4999, 0.6866, 0.4093,+ 0.5709, 0.6065, 0.6415, 0.4944, 0.5726, 1.2042, 0.5458, 1.6887,+ 0.3971, 1.0600, 0.3943, 0.5537, 0.5444, 0.4089, 0.7468, 0.7744+ ]).view(1, self.latent_channels, 1, 1, 1)+class Hunyuan3Dv2(LatentFormat):latent_channels = 64latent_dimensions = 1diff --git a/comfy/ldm/wan/model.py b/comfy/ldm/wan/model.pyindex 1d6edb354..b9e47e9f7 100644--- a/comfy/ldm/wan/model.py+++ b/comfy/ldm/wan/model.py@@ -201,8 +201,10 @@ class WanAttentionBlock(nn.Module):freqs(Tensor): Rope freqs, shape [1024, C / num_heads / 2]"""# assert e.dtype == torch.float32-- e = (comfy.model_management.cast_to(self.modulation, dtype=x.dtype, device=x.device) + e).chunk(6, dim=1)+ if e.ndim < 4:+ e = (comfy.model_management.cast_to(self.modulation, dtype=x.dtype, device=x.device) + e).chunk(6, dim=1)+ else:+ e = (comfy.model_management.cast_to(self.modulation, dtype=x.dtype, device=x.device).unsqueeze(0) + e).unbind(2)# assert e[0].dtype == torch.float32# self-attention@@ -325,7 +327,10 @@ class Head(nn.Module):e(Tensor): Shape [B, C]"""# assert e.dtype == torch.float32- e = (comfy.model_management.cast_to(self.modulation, dtype=x.dtype, device=x.device) + e.unsqueeze(1)).chunk(2, dim=1)+ if e.ndim < 3:+ e = (comfy.model_management.cast_to(self.modulation, dtype=x.dtype, device=x.device) + e.unsqueeze(1)).chunk(2, dim=1)+ else:+ e = (comfy.model_management.cast_to(self.modulation, dtype=x.dtype, device=x.device).unsqueeze(0) + e.unsqueeze(2)).unbind(2)x = (self.head(self.norm(x) * (1 + e[1]) + e[0]))return x@@ -506,8 +511,9 @@ class WanModel(torch.nn.Module):# time embeddingse = self.time_embedding(- sinusoidal_embedding_1d(self.freq_dim, t).to(dtype=x[0].dtype))- e0 = self.time_projection(e).unflatten(1, (6, self.dim))+ sinusoidal_embedding_1d(self.freq_dim, t.flatten()).to(dtype=x[0].dtype))+ e = e.reshape(t.shape[0], -1, e.shape[-1])+ e0 = self.time_projection(e).unflatten(2, (6, self.dim))# contextcontext = self.text_embedding(context)diff --git a/comfy/ldm/wan/vae2_2.py b/comfy/ldm/wan/vae2_2.pynew file mode 100644index 000000000..c2c150e10--- /dev/null+++ b/comfy/ldm/wan/vae2_2.py@@ -0,0 +1,726 @@+# original version: https://github.com/Wan-Video/Wan2.2/blob/main/wan/modules/vae2_2.py+# Copyright 2024-2025 The Alibaba Wan Team Authors. All rights reserved.++import torch+import torch.nn as nn+import torch.nn.functional as F+from einops import rearrange+from .vae import AttentionBlock, CausalConv3d, RMS_norm++import comfy.ops+ops = comfy.ops.disable_weight_init++CACHE_T = 2+++class Resample(nn.Module):++ def __init__(self, dim, mode):+ assert mode in (+ "none",+ "upsample2d",+ "upsample3d",+ "downsample2d",+ "downsample3d",+ )+ super().__init__()+ self.dim = dim+ self.mode = mode++ # layers+ if mode == "upsample2d":+ self.resample = nn.Sequential(+ nn.Upsample(scale_factor=(2.0, 2.0), mode="nearest-exact"),+ ops.Conv2d(dim, dim, 3, padding=1),+ )+ elif mode == "upsample3d":+ self.resample = nn.Sequential(+ nn.Upsample(scale_factor=(2.0, 2.0), mode="nearest-exact"),+ ops.Conv2d(dim, dim, 3, padding=1),+ # ops.Conv2d(dim, dim//2, 3, padding=1)+ )+ self.time_conv = CausalConv3d(+ dim, dim * 2, (3, 1, 1), padding=(1, 0, 0))+ elif mode == "downsample2d":+ self.resample = nn.Sequential(+ nn.ZeroPad2d((0, 1, 0, 1)),+ ops.Conv2d(dim, dim, 3, stride=(2, 2)))+ elif mode == "downsample3d":+ self.resample = nn.Sequential(+ nn.ZeroPad2d((0, 1, 0, 1)),+ ops.Conv2d(dim, dim, 3, stride=(2, 2)))+ self.time_conv = CausalConv3d(+ dim, dim, (3, 1, 1), stride=(2, 1, 1), padding=(0, 0, 0))+ else:+ self.resample = nn.Identity()++ def forward(self, x, feat_cache=None, feat_idx=[0]):+ b, c, t, h, w = x.size()+ if self.mode == "upsample3d":+ if feat_cache is not None:+ idx = feat_idx[0]+ if feat_cache[idx] is None:+ feat_cache[idx] = "Rep"+ feat_idx[0] += 1+ else:+ cache_x = x[:, :, -CACHE_T:, :, :].clone()+ if (cache_x.shape[2] < 2 and feat_cache[idx] is not None and+ feat_cache[idx] != "Rep"):+ # cache last frame of last two chunk+ cache_x = torch.cat(+ [+ feat_cache[idx][:, :, -1, :, :].unsqueeze(2).to(+ cache_x.device),+ cache_x,+ ],+ dim=2,+ )+ if (cache_x.shape[2] < 2 and feat_cache[idx] is not None and+ feat_cache[idx] == "Rep"):+ cache_x = torch.cat(+ [+ torch.zeros_like(cache_x).to(cache_x.device),+ cache_x+ ],+ dim=2,+ )+ if feat_cache[idx] == "Rep":+ x = self.time_conv(x)+ else:+ x = self.time_conv(x, feat_cache[idx])+ feat_cache[idx] = cache_x+ feat_idx[0] += 1+ x = x.reshape(b, 2, c, t, h, w)+ x = torch.stack((x[:, 0, :, :, :, :], x[:, 1, :, :, :, :]),+ 3)+ x = x.reshape(b, c, t * 2, h, w)+ t = x.shape[2]+ x = rearrange(x, "b c t h w -> (b t) c h w")+ x = self.resample(x)+ x = rearrange(x, "(b t) c h w -> b c t h w", t=t)++ if self.mode == "downsample3d":+ if feat_cache is not None:+ idx = feat_idx[0]+ if feat_cache[idx] is None:+ feat_cache[idx] = x.clone()+ feat_idx[0] += 1+ else:+ cache_x = x[:, :, -1:, :, :].clone()+ x = self.time_conv(+ torch.cat([feat_cache[idx][:, :, -1:, :, :], x], 2))+ feat_cache[idx] = cache_x+ feat_idx[0] += 1+ return x+++class ResidualBlock(nn.Module):++ def __init__(self, in_dim, out_dim, dropout=0.0):+ super().__init__()+ self.in_dim = in_dim+ self.out_dim = out_dim++ # layers+ self.residual = nn.Sequential(+ RMS_norm(in_dim, images=False),+ nn.SiLU(),+ CausalConv3d(in_dim, out_dim, 3, padding=1),+ RMS_norm(out_dim, images=False),+ nn.SiLU(),+ nn.Dropout(dropout),+ CausalConv3d(out_dim, out_dim, 3, padding=1),+ )+ self.shortcut = (+ CausalConv3d(in_dim, out_dim, 1)+ if in_dim != out_dim else nn.Identity())++ def forward(self, x, feat_cache=None, feat_idx=[0]):+ h = self.shortcut(x)+ for layer in self.residual:+ if isinstance(layer, CausalConv3d) and feat_cache is not None:+ idx = feat_idx[0]+ cache_x = x[:, :, -CACHE_T:, :, :].clone()+ if cache_x.shape[2] < 2 and feat_cache[idx] is not None:+ # cache last frame of last two chunk+ cache_x = torch.cat(+ [+ feat_cache[idx][:, :, -1, :, :].unsqueeze(2).to(+ cache_x.device),+ cache_x,+ ],+ dim=2,+ )+ x = layer(x, feat_cache[idx])+ feat_cache[idx] = cache_x+ feat_idx[0] += 1+ else:+ x = layer(x)+ return x + h+++def patchify(x, patch_size):+ if patch_size == 1:+ return x+ if x.dim() == 4:+ x = rearrange(+ x, "b c (h q) (w r) -> b (c r q) h w", q=patch_size, r=patch_size)+ elif x.dim() == 5:+ x = rearrange(+ x,+ "b c f (h q) (w r) -> b (c r q) f h w",+ q=patch_size,+ r=patch_size,+ )+ else:+ raise ValueError(f"Invalid input shape: {x.shape}")++ return x+++def unpatchify(x, patch_size):+ if patch_size == 1:+ return x++ if x.dim() == 4:+ x = rearrange(+ x, "b (c r q) h w -> b c (h q) (w r)", q=patch_size, r=patch_size)+ elif x.dim() == 5:+ x = rearrange(+ x,+ "b (c r q) f h w -> b c f (h q) (w r)",+ q=patch_size,+ r=patch_size,+ )+ return x+++class AvgDown3D(nn.Module):++ def __init__(+ self,+ in_channels,+ out_channels,+ factor_t,+ factor_s=1,+ ):+ super().__init__()+ self.in_channels = in_channels+ self.out_channels = out_channels+ self.factor_t = factor_t+ self.factor_s = factor_s+ self.factor = self.factor_t * self.factor_s * self.factor_s++ assert in_channels * self.factor % out_channels == 0+ self.group_size = in_channels * self.factor // out_channels++ def forward(self, x: torch.Tensor) -> torch.Tensor:+ pad_t = (self.factor_t - x.shape[2] % self.factor_t) % self.factor_t+ pad = (0, 0, 0, 0, pad_t, 0)+ x = F.pad(x, pad)+ B, C, T, H, W = x.shape+ x = x.view(+ B,+ C,+ T // self.factor_t,+ self.factor_t,+ H // self.factor_s,+ self.factor_s,+ W // self.factor_s,+ self.factor_s,+ )+ x = x.permute(0, 1, 3, 5, 7, 2, 4, 6).contiguous()+ x = x.view(+ B,+ C * self.factor,+ T // self.factor_t,+ H // self.factor_s,+ W // self.factor_s,+ )+ x = x.view(+ B,+ self.out_channels,+ self.group_size,+ T // self.factor_t,+ H // self.factor_s,+ W // self.factor_s,+ )+ x = x.mean(dim=2)+ return x+++class DupUp3D(nn.Module):++ def __init__(+ self,+ in_channels: int,+ out_channels: int,+ factor_t,+ factor_s=1,+ ):+ super().__init__()+ self.in_channels = in_channels+ self.out_channels = out_channels++ self.factor_t = factor_t+ self.factor_s = factor_s+ self.factor = self.factor_t * self.factor_s * self.factor_s++ assert out_channels * self.factor % in_channels == 0+ self.repeats = out_channels * self.factor // in_channels++ def forward(self, x: torch.Tensor, first_chunk=False) -> torch.Tensor:+ x = x.repeat_interleave(self.repeats, dim=1)+ x = x.view(+ x.size(0),+ self.out_channels,+ self.factor_t,+ self.factor_s,+ self.factor_s,+ x.size(2),+ x.size(3),+ x.size(4),+ )+ x = x.permute(0, 1, 5, 2, 6, 3, 7, 4).contiguous()+ x = x.view(+ x.size(0),+ self.out_channels,+ x.size(2) * self.factor_t,+ x.size(4) * self.factor_s,+ x.size(6) * self.factor_s,+ )+ if first_chunk:+ x = x[:, :, self.factor_t - 1:, :, :]+ return x+++class Down_ResidualBlock(nn.Module):++ def __init__(self,+ in_dim,+ out_dim,+ dropout,+ mult,+ temperal_downsample=False,+ down_flag=False):+ super().__init__()++ # Shortcut path with downsample+ self.avg_shortcut = AvgDown3D(+ in_dim,+ out_dim,+ factor_t=2 if temperal_downsample else 1,+ factor_s=2 if down_flag else 1,+ )++ # Main path with residual blocks and downsample+ downsamples = []+ for _ in range(mult):+ downsamples.append(ResidualBlock(in_dim, out_dim, dropout))+ in_dim = out_dim++ # Add the final downsample block+ if down_flag:+ mode = "downsample3d" if temperal_downsample else "downsample2d"+ downsamples.append(Resample(out_dim, mode=mode))++ self.downsamples = nn.Sequential(*downsamples)++ def forward(self, x, feat_cache=None, feat_idx=[0]):+ x_copy = x.clone()+ for module in self.downsamples:+ x = module(x, feat_cache, feat_idx)++ return x + self.avg_shortcut(x_copy)+++class Up_ResidualBlock(nn.Module):++ def __init__(self,+ in_dim,+ out_dim,+ dropout,+ mult,+ temperal_upsample=False,+ up_flag=False):+ super().__init__()+ # Shortcut path with upsample+ if up_flag:+ self.avg_shortcut = DupUp3D(+ in_dim,+ out_dim,+ factor_t=2 if temperal_upsample else 1,+ factor_s=2 if up_flag else 1,+ )+ else:+ self.avg_shortcut = None++ # Main path with residual blocks and upsample+ upsamples = []+ for _ in range(mult):+ upsamples.append(ResidualBlock(in_dim, out_dim, dropout))+ in_dim = out_dim++ # Add the final upsample block+ if up_flag:+ mode = "upsample3d" if temperal_upsample else "upsample2d"+ upsamples.append(Resample(out_dim, mode=mode))++ self.upsamples = nn.Sequential(*upsamples)++ def forward(self, x, feat_cache=None, feat_idx=[0], first_chunk=False):+ x_main = x.clone()+ for module in self.upsamples:+ x_main = module(x_main, feat_cache, feat_idx)+ if self.avg_shortcut is not None:+ x_shortcut = self.avg_shortcut(x, first_chunk)+ return x_main + x_shortcut+ else:+ return x_main+++class Encoder3d(nn.Module):++ def __init__(+ self,+ dim=128,+ z_dim=4,+ dim_mult=[1, 2, 4, 4],+ num_res_blocks=2,+ attn_scales=[],+ temperal_downsample=[True, True, False],+ dropout=0.0,+ ):+ super().__init__()+ self.dim = dim+ self.z_dim = z_dim+ self.dim_mult = dim_mult+ self.num_res_blocks = num_res_blocks+ self.attn_scales = attn_scales+ self.temperal_downsample = temperal_downsample++ # dimensions+ dims = [dim * u for u in [1] + dim_mult]+ scale = 1.0++ # init block+ self.conv1 = CausalConv3d(12, dims[0], 3, padding=1)++ # downsample blocks+ downsamples = []+ for i, (in_dim, out_dim) in enumerate(zip(dims[:-1], dims[1:])):+ t_down_flag = (+ temperal_downsample[i]+ if i < len(temperal_downsample) else False)+ downsamples.append(+ Down_ResidualBlock(+ in_dim=in_dim,+ out_dim=out_dim,+ dropout=dropout,+ mult=num_res_blocks,+ temperal_downsample=t_down_flag,+ down_flag=i != len(dim_mult) - 1,+ ))+ scale /= 2.0+ self.downsamples = nn.Sequential(*downsamples)++ # middle blocks+ self.middle = nn.Sequential(+ ResidualBlock(out_dim, out_dim, dropout),+ AttentionBlock(out_dim),+ ResidualBlock(out_dim, out_dim, dropout),+ )++ # # output blocks+ self.head = nn.Sequential(+ RMS_norm(out_dim, images=False),+ nn.SiLU(),+ CausalConv3d(out_dim, z_dim, 3, padding=1),+ )++ def forward(self, x, feat_cache=None, feat_idx=[0]):++ if feat_cache is not None:+ idx = feat_idx[0]+ cache_x = x[:, :, -CACHE_T:, :, :].clone()+ if cache_x.shape[2] < 2 and feat_cache[idx] is not None:+ cache_x = torch.cat(+ [+ feat_cache[idx][:, :, -1, :, :].unsqueeze(2).to(+ cache_x.device),+ cache_x,+ ],+ dim=2,+ )+ x = self.conv1(x, feat_cache[idx])+ feat_cache[idx] = cache_x+ feat_idx[0] += 1+ else:+ x = self.conv1(x)++ ## downsamples+ for layer in self.downsamples:+ if feat_cache is not None:+ x = layer(x, feat_cache, feat_idx)+ else:+ x = layer(x)++ ## middle+ for layer in self.middle:+ if isinstance(layer, ResidualBlock) and feat_cache is not None:+ x = layer(x, feat_cache, feat_idx)+ else:+ x = layer(x)++ ## head+ for layer in self.head:+ if isinstance(layer, CausalConv3d) and feat_cache is not None:+ idx = feat_idx[0]+ cache_x = x[:, :, -CACHE_T:, :, :].clone()+ if cache_x.shape[2] < 2 and feat_cache[idx] is not None:+ cache_x = torch.cat(+ [+ feat_cache[idx][:, :, -1, :, :].unsqueeze(2).to(+ cache_x.device),+ cache_x,+ ],+ dim=2,+ )+ x = layer(x, feat_cache[idx])+ feat_cache[idx] = cache_x+ feat_idx[0] += 1+ else:+ x = layer(x)++ return x+++class Decoder3d(nn.Module):++ def __init__(+ self,+ dim=128,+ z_dim=4,+ dim_mult=[1, 2, 4, 4],+ num_res_blocks=2,+ attn_scales=[],+ temperal_upsample=[False, True, True],+ dropout=0.0,+ ):+ super().__init__()+ self.dim = dim+ self.z_dim = z_dim+ self.dim_mult = dim_mult+ self.num_res_blocks = num_res_blocks+ self.attn_scales = attn_scales+ self.temperal_upsample = temperal_upsample++ # dimensions+ dims = [dim * u for u in [dim_mult[-1]] + dim_mult[::-1]]+ # init block+ self.conv1 = CausalConv3d(z_dim, dims[0], 3, padding=1)++ # middle blocks+ self.middle = nn.Sequential(+ ResidualBlock(dims[0], dims[0], dropout),+ AttentionBlock(dims[0]),+ ResidualBlock(dims[0], dims[0], dropout),+ )++ # upsample blocks+ upsamples = []+ for i, (in_dim, out_dim) in enumerate(zip(dims[:-1], dims[1:])):+ t_up_flag = temperal_upsample[i] if i < len(+ temperal_upsample) else False+ upsamples.append(+ Up_ResidualBlock(+ in_dim=in_dim,+ out_dim=out_dim,+ dropout=dropout,+ mult=num_res_blocks + 1,+ temperal_upsample=t_up_flag,+ up_flag=i != len(dim_mult) - 1,+ ))+ self.upsamples = nn.Sequential(*upsamples)++ # output blocks+ self.head = nn.Sequential(+ RMS_norm(out_dim, images=False),+ nn.SiLU(),+ CausalConv3d(out_dim, 12, 3, padding=1),+ )++ def forward(self, x, feat_cache=None, feat_idx=[0], first_chunk=False):+ if feat_cache is not None:+ idx = feat_idx[0]+ cache_x = x[:, :, -CACHE_T:, :, :].clone()+ if cache_x.shape[2] < 2 and feat_cache[idx] is not None:+ cache_x = torch.cat(+ [+ feat_cache[idx][:, :, -1, :, :].unsqueeze(2).to(+ cache_x.device),+ cache_x,+ ],+ dim=2,+ )+ x = self.conv1(x, feat_cache[idx])+ feat_cache[idx] = cache_x+ feat_idx[0] += 1+ else:+ x = self.conv1(x)++ for layer in self.middle:+ if isinstance(layer, ResidualBlock) and feat_cache is not None:+ x = layer(x, feat_cache, feat_idx)+ else:+ x = layer(x)++ ## upsamples+ for layer in self.upsamples:+ if feat_cache is not None:+ x = layer(x, feat_cache, feat_idx, first_chunk)+ else:+ x = layer(x)++ ## head+ for layer in self.head:+ if isinstance(layer, CausalConv3d) and feat_cache is not None:+ idx = feat_idx[0]+ cache_x = x[:, :, -CACHE_T:, :, :].clone()+ if cache_x.shape[2] < 2 and feat_cache[idx] is not None:+ cache_x = torch.cat(+ [+ feat_cache[idx][:, :, -1, :, :].unsqueeze(2).to(+ cache_x.device),+ cache_x,+ ],+ dim=2,+ )+ x = layer(x, feat_cache[idx])+ feat_cache[idx] = cache_x+ feat_idx[0] += 1+ else:+ x = layer(x)+ return x+++def count_conv3d(model):+ count = 0+ for m in model.modules():+ if isinstance(m, CausalConv3d):+ count += 1+ return count+++class WanVAE(nn.Module):++ def __init__(+ self,+ dim=160,+ dec_dim=256,+ z_dim=16,+ dim_mult=[1, 2, 4, 4],+ num_res_blocks=2,+ attn_scales=[],+ temperal_downsample=[True, True, False],+ dropout=0.0,+ ):+ super().__init__()+ self.dim = dim+ self.z_dim = z_dim+ self.dim_mult = dim_mult+ self.num_res_blocks = num_res_blocks+ self.attn_scales = attn_scales+ self.temperal_downsample = temperal_downsample+ self.temperal_upsample = temperal_downsample[::-1]++ # modules+ self.encoder = Encoder3d(+ dim,+ z_dim * 2,+ dim_mult,+ num_res_blocks,+ attn_scales,+ self.temperal_downsample,+ dropout,+ )+ self.conv1 = CausalConv3d(z_dim * 2, z_dim * 2, 1)+ self.conv2 = CausalConv3d(z_dim, z_dim, 1)+ self.decoder = Decoder3d(+ dec_dim,+ z_dim,+ dim_mult,+ num_res_blocks,+ attn_scales,+ self.temperal_upsample,+ dropout,+ )++ def encode(self, x):+ self.clear_cache()+ x = patchify(x, patch_size=2)+ t = x.shape[2]+ iter_ = 1 + (t - 1) // 4+ for i in range(iter_):+ self._enc_conv_idx = [0]+ if i == 0:+ out = self.encoder(+ x[:, :, :1, :, :],+ feat_cache=self._enc_feat_map,+ feat_idx=self._enc_conv_idx,+ )+ else:+ out_ = self.encoder(+ x[:, :, 1 + 4 * (i - 1):1 + 4 * i, :, :],+ feat_cache=self._enc_feat_map,+ feat_idx=self._enc_conv_idx,+ )+ out = torch.cat([out, out_], 2)+ mu, log_var = self.conv1(out).chunk(2, dim=1)+ self.clear_cache()+ return mu++ def decode(self, z):+ self.clear_cache()+ iter_ = z.shape[2]+ x = self.conv2(z)+ for i in range(iter_):+ self._conv_idx = [0]+ if i == 0:+ out = self.decoder(+ x[:, :, i:i + 1, :, :],+ feat_cache=self._feat_map,+ feat_idx=self._conv_idx,+ first_chunk=True,+ )+ else:+ out_ = self.decoder(+ x[:, :, i:i + 1, :, :],+ feat_cache=self._feat_map,+ feat_idx=self._conv_idx,+ )+ out = torch.cat([out, out_], 2)+ out = unpatchify(out, patch_size=2)+ self.clear_cache()+ return out++ def reparameterize(self, mu, log_var):+ std = torch.exp(0.5 * log_var)+ eps = torch.randn_like(std)+ return eps * std + mu++ def sample(self, imgs, deterministic=False):+ mu, log_var = self.encode(imgs)+ if deterministic:+ return mu+ std = torch.exp(0.5 * log_var.clamp(-30.0, 20.0))+ return mu + std * torch.randn_like(std)++ def clear_cache(self):+ self._conv_num = count_conv3d(self.decoder)+ self._conv_idx = [0]+ self._feat_map = [None] * self._conv_num+ # cache encode+ self._enc_conv_num = count_conv3d(self.encoder)+ self._enc_conv_idx = [0]+ self._enc_feat_map = [None] * self._enc_conv_numdiff --git a/comfy/model_base.py b/comfy/model_base.pyindex 4392355ea..d019b991a 100644--- a/comfy/model_base.py+++ b/comfy/model_base.py@@ -1097,8 +1097,9 @@ class WAN21(BaseModel):image[:, i: i + 16] = self.process_latent_in(image[:, i: i + 16])image = utils.resize_to_batch_size(image, noise.shape[0])- if not self.image_to_video or extra_channels == image.shape[1]:- return image+ if extra_channels != image.shape[1] + 4:+ if not self.image_to_video or extra_channels == image.shape[1]:+ return imageif image.shape[1] > (extra_channels - 4):image = image[:, :(extra_channels - 4)]@@ -1182,6 +1183,31 @@ class WAN21_Camera(WAN21):out['camera_conditions'] = comfy.conds.CONDRegular(camera_conditions)return out+class WAN22(BaseModel):+ def __init__(self, model_config, model_type=ModelType.FLOW, image_to_video=False, device=None):+ super().__init__(model_config, model_type, device=device, unet_model=comfy.ldm.wan.model.WanModel)+ self.image_to_video = image_to_video++ def extra_conds(self, **kwargs):+ out = super().extra_conds(**kwargs)+ cross_attn = kwargs.get("cross_attn", None)+ if cross_attn is not None:+ out['c_crossattn'] = comfy.conds.CONDRegular(cross_attn)++ denoise_mask = kwargs.get("concat_mask", kwargs.get("denoise_mask", None))+ if denoise_mask is not None:+ out["denoise_mask"] = comfy.conds.CONDRegular(denoise_mask)+ return out++ def process_timestep(self, timestep, x, denoise_mask=None, **kwargs):+ if denoise_mask is None:+ return timestep+ temp_ts = (torch.mean(denoise_mask[:, :, :, ::2, ::2], dim=1, keepdim=True) * timestep.view([timestep.shape[0]] + [1] * (denoise_mask.ndim - 1))).reshape(timestep.shape[0], -1)+ return temp_ts++ def scale_latent_inpaint(self, sigma, noise, latent_image, **kwargs):+ return latent_image+class Hunyuan3Dv2(BaseModel):def __init__(self, model_config, model_type=ModelType.FLOW, device=None):super().__init__(model_config, model_type, device=device, unet_model=comfy.ldm.hunyuan3d.model.Hunyuan3Dv2)diff --git a/comfy/model_detection.py b/comfy/model_detection.pyindex 18232ade3..9fc1f42de 100644--- a/comfy/model_detection.py+++ b/comfy/model_detection.py@@ -346,7 +346,9 @@ def detect_unet_config(state_dict, key_prefix, metadata=None):dit_config = {}dit_config["image_model"] = "wan2.1"dim = state_dict['{}head.modulation'.format(key_prefix)].shape[-1]+ out_dim = state_dict['{}head.head.weight'.format(key_prefix)].shape[0] // 4dit_config["dim"] = dim+ dit_config["out_dim"] = out_dimdit_config["num_heads"] = dim // 128dit_config["ffn_dim"] = state_dict['{}blocks.0.ffn.0.weight'.format(key_prefix)].shape[0]dit_config["num_layers"] = count_blocks(state_dict_keys, '{}blocks.'.format(key_prefix) + '{}.')diff --git a/comfy/sd.py b/comfy/sd.pyindex 8081b167c..e0498e585 100644--- a/comfy/sd.py+++ b/comfy/sd.py@@ -14,6 +14,7 @@ import comfy.ldm.genmo.vae.modelimport comfy.ldm.lightricks.vae.causal_video_autoencoderimport comfy.ldm.cosmos.vaeimport comfy.ldm.wan.vae+import comfy.ldm.wan.vae2_2import comfy.ldm.hunyuan3d.vaeimport comfy.ldm.ace.vae.music_dcae_pipelineimport yaml@@ -420,17 +421,30 @@ class VAE:self.memory_used_encode = lambda shape, dtype: (50 * (round((shape[2] + 7) / 8) * 8) * shape[3] * shape[4]) * model_management.dtype_size(dtype)self.working_dtypes = [torch.bfloat16, torch.float32]elif "decoder.middle.0.residual.0.gamma" in sd:- self.upscale_ratio = (lambda a: max(0, a * 4 - 3), 8, 8)- self.upscale_index_formula = (4, 8, 8)- self.downscale_ratio = (lambda a: max(0, math.floor((a + 3) / 4)), 8, 8)- self.downscale_index_formula = (4, 8, 8)- self.latent_dim = 3- self.latent_channels = 16- ddconfig = {"dim": 96, "z_dim": self.latent_channels, "dim_mult": [1, 2, 4, 4], "num_res_blocks": 2, "attn_scales": [], "temperal_downsample": [False, True, True], "dropout": 0.0}- self.first_stage_model = comfy.ldm.wan.vae.WanVAE(**ddconfig)- self.working_dtypes = [torch.bfloat16, torch.float16, torch.float32]- self.memory_used_encode = lambda shape, dtype: 6000 * shape[3] * shape[4] * model_management.dtype_size(dtype)- self.memory_used_decode = lambda shape, dtype: 7000 * shape[3] * shape[4] * (8 * 8) * model_management.dtype_size(dtype)+ if "decoder.upsamples.0.upsamples.0.residual.2.weight" in sd: # Wan 2.2 VAE+ self.upscale_ratio = (lambda a: max(0, a * 4 - 3), 16, 16)+ self.upscale_index_formula = (4, 16, 16)+ self.downscale_ratio = (lambda a: max(0, math.floor((a + 3) / 4)), 16, 16)+ self.downscale_index_formula = (4, 16, 16)+ self.latent_dim = 3+ self.latent_channels = 48+ ddconfig = {"dim": 160, "z_dim": self.latent_channels, "dim_mult": [1, 2, 4, 4], "num_res_blocks": 2, "attn_scales": [], "temperal_downsample": [False, True, True], "dropout": 0.0}+ self.first_stage_model = comfy.ldm.wan.vae2_2.WanVAE(**ddconfig)+ self.working_dtypes = [torch.bfloat16, torch.float16, torch.float32]+ self.memory_used_encode = lambda shape, dtype: 3300 * shape[3] * shape[4] * model_management.dtype_size(dtype)+ self.memory_used_decode = lambda shape, dtype: 8000 * shape[3] * shape[4] * (16 * 16) * model_management.dtype_size(dtype)+ else: # Wan 2.1 VAE+ self.upscale_ratio = (lambda a: max(0, a * 4 - 3), 8, 8)+ self.upscale_index_formula = (4, 8, 8)+ self.downscale_ratio = (lambda a: max(0, math.floor((a + 3) / 4)), 8, 8)+ self.downscale_index_formula = (4, 8, 8)+ self.latent_dim = 3+ self.latent_channels = 16+ ddconfig = {"dim": 96, "z_dim": self.latent_channels, "dim_mult": [1, 2, 4, 4], "num_res_blocks": 2, "attn_scales": [], "temperal_downsample": [False, True, True], "dropout": 0.0}+ self.first_stage_model = comfy.ldm.wan.vae.WanVAE(**ddconfig)+ self.working_dtypes = [torch.bfloat16, torch.float16, torch.float32]+ self.memory_used_encode = lambda shape, dtype: 6000 * shape[3] * shape[4] * model_management.dtype_size(dtype)+ self.memory_used_decode = lambda shape, dtype: 7000 * shape[3] * shape[4] * (8 * 8) * model_management.dtype_size(dtype)elif "geo_decoder.cross_attn_decoder.ln_1.bias" in sd:self.latent_dim = 1ln_post = "geo_decoder.ln_post.weight" in sddiff --git a/comfy/supported_models.py b/comfy/supported_models.pyindex 2ca3857f7..8f3f4652d 100644--- a/comfy/supported_models.py+++ b/comfy/supported_models.py@@ -1059,6 +1059,19 @@ class WAN21_Vace(WAN21_T2V):out = model_base.WAN21_Vace(self, image_to_video=False, device=device)return out+class WAN22_T2V(WAN21_T2V):+ unet_config = {+ "image_model": "wan2.1",+ "model_type": "t2v",+ "out_dim": 48,+ }++ latent_format = latent_formats.Wan22++ def get_model(self, state_dict, prefix="", device=None):+ out = model_base.WAN22(self, image_to_video=True, device=device)+ return out+class Hunyuan3Dv2(supported_models_base.BASE):unet_config = {"image_model": "hunyuan3d2",@@ -1217,6 +1230,6 @@ class Omnigen2(supported_models_base.BASE):return supported_models_base.ClipTarget(comfy.text_encoders.omnigen2.Omnigen2Tokenizer, comfy.text_encoders.omnigen2.te(**hunyuan_detect))-models = [LotusD, Stable_Zero123, SD15_instructpix2pix, SD15, SD20, SD21UnclipL, SD21UnclipH, SDXL_instructpix2pix, SDXLRefiner, SDXL, SSD1B, KOALA_700M, KOALA_1B, Segmind_Vega, SD_X4Upscaler, Stable_Cascade_C, Stable_Cascade_B, SV3D_u, SV3D_p, SD3, StableAudio, AuraFlow, PixArtAlpha, PixArtSigma, HunyuanDiT, HunyuanDiT1, FluxInpaint, Flux, FluxSchnell, GenmoMochi, LTXV, HunyuanVideoSkyreelsI2V, HunyuanVideoI2V, HunyuanVideo, CosmosT2V, CosmosI2V, CosmosT2IPredict2, CosmosI2VPredict2, Lumina2, WAN21_T2V, WAN21_I2V, WAN21_FunControl2V, WAN21_Vace, WAN21_Camera, Hunyuan3Dv2mini, Hunyuan3Dv2, HiDream, Chroma, ACEStep, Omnigen2]+models = [LotusD, Stable_Zero123, SD15_instructpix2pix, SD15, SD20, SD21UnclipL, SD21UnclipH, SDXL_instructpix2pix, SDXLRefiner, SDXL, SSD1B, KOALA_700M, KOALA_1B, Segmind_Vega, SD_X4Upscaler, Stable_Cascade_C, Stable_Cascade_B, SV3D_u, SV3D_p, SD3, StableAudio, AuraFlow, PixArtAlpha, PixArtSigma, HunyuanDiT, HunyuanDiT1, FluxInpaint, Flux, FluxSchnell, GenmoMochi, LTXV, HunyuanVideoSkyreelsI2V, HunyuanVideoI2V, HunyuanVideo, CosmosT2V, CosmosI2V, CosmosT2IPredict2, CosmosI2VPredict2, Lumina2, WAN22_T2V, WAN21_T2V, WAN21_I2V, WAN21_FunControl2V, WAN21_Vace, WAN21_Camera, Hunyuan3Dv2mini, Hunyuan3Dv2, HiDream, Chroma, ACEStep, Omnigen2]models += [SVD_img2vid]diff --git a/comfy_extras/nodes_wan.py b/comfy_extras/nodes_wan.pyindex d71908f31..0b92c68ac 100644--- a/comfy_extras/nodes_wan.py+++ b/comfy_extras/nodes_wan.py@@ -685,6 +685,49 @@ class WanTrackToVideo:out_latent["samples"] = latentreturn (positive, negative, out_latent)++class Wan22ImageToVideoLatent:+ @classmethod+ def INPUT_TYPES(s):+ return {"required": {"vae": ("VAE", ),+ "width": ("INT", {"default": 1280, "min": 32, "max": nodes.MAX_RESOLUTION, "step": 32}),+ "height": ("INT", {"default": 704, "min": 32, "max": nodes.MAX_RESOLUTION, "step": 32}),+ "length": ("INT", {"default": 49, "min": 1, "max": nodes.MAX_RESOLUTION, "step": 4}),+ "batch_size": ("INT", {"default": 1, "min": 1, "max": 4096}),+ },+ "optional": {"start_image": ("IMAGE", ),+ }}+++ RETURN_TYPES = ("LATENT",)+ FUNCTION = "encode"++ CATEGORY = "conditioning/inpaint"++ def encode(self, vae, width, height, length, batch_size, start_image=None):+ latent = torch.zeros([1, 48, ((length - 1) // 4) + 1, height // 16, width // 16], device=comfy.model_management.intermediate_device())++ if start_image is None:+ out_latent = {}+ out_latent["samples"] = latent+ return (out_latent,)++ mask = torch.ones([latent.shape[0], 1, ((length - 1) // 4) + 1, latent.shape[-2], latent.shape[-1]], device=comfy.model_management.intermediate_device())++ if start_image is not None:+ start_image = comfy.utils.common_upscale(start_image[:length].movedim(-1, 1), width, height, "bilinear", "center").movedim(1, -1)+ latent_temp = vae.encode(start_image)+ latent[:, :, :latent_temp.shape[-3]] = latent_temp+ mask[:, :, :latent_temp.shape[-3]] *= 0.0++ out_latent = {}+ latent_format = comfy.latent_formats.Wan22()+ latent = latent_format.process_out(latent) * mask + latent * (1.0 - mask)+ out_latent["samples"] = latent.repeat((batch_size, ) + (1,) * (latent.ndim - 1))+ out_latent["noise_mask"] = mask.repeat((batch_size, ) + (1,) * (mask.ndim - 1))+ return (out_latent,)++NODE_CLASS_MAPPINGS = {"WanTrackToVideo": WanTrackToVideo,"WanImageToVideo": WanImageToVideo,@@ -695,4 +738,5 @@ NODE_CLASS_MAPPINGS = {"TrimVideoLatent": TrimVideoLatent,"WanCameraImageToVideo": WanCameraImageToVideo,"WanPhantomSubjectToVideo": WanPhantomSubjectToVideo,+ "Wan22ImageToVideoLatent": Wan22ImageToVideoLatent,}