| import torch |
| import torch.nn as nn |
| import torch.nn.functional as F |
| from torch.nn import init |
| import math |
| from typing import Tuple, Optional |
| from einops import rearrange, repeat |
| from .wan_video_camera_controller import SimpleAdapter |
| from ..core.gradient import gradient_checkpoint_forward |
| from .latent_state import (LatentStateRollout, LatentStateToVisualAttention, |
| GameTransitionTokenizer, LatentTransitionPredictor) |
|
|
| try: |
| import flash_attn_interface |
| FLASH_ATTN_3_AVAILABLE = True |
| except ModuleNotFoundError: |
| FLASH_ATTN_3_AVAILABLE = False |
|
|
| try: |
| import flash_attn |
| FLASH_ATTN_2_AVAILABLE = True |
| except ModuleNotFoundError: |
| FLASH_ATTN_2_AVAILABLE = False |
|
|
| try: |
| from sageattention import sageattn |
| SAGE_ATTN_AVAILABLE = True |
| except ModuleNotFoundError: |
| SAGE_ATTN_AVAILABLE = False |
|
|
|
|
| def flash_attention(q: torch.Tensor, k: torch.Tensor, v: torch.Tensor, num_heads: int, compatibility_mode=False): |
| if compatibility_mode: |
| q = rearrange(q, "b s (n d) -> b n s d", n=num_heads) |
| k = rearrange(k, "b s (n d) -> b n s d", n=num_heads) |
| v = rearrange(v, "b s (n d) -> b n s d", n=num_heads) |
| x = F.scaled_dot_product_attention(q, k, v) |
| x = rearrange(x, "b n s d -> b s (n d)", n=num_heads) |
| elif FLASH_ATTN_3_AVAILABLE: |
| q = rearrange(q, "b s (n d) -> b s n d", n=num_heads) |
| k = rearrange(k, "b s (n d) -> b s n d", n=num_heads) |
| v = rearrange(v, "b s (n d) -> b s n d", n=num_heads) |
| x = flash_attn_interface.flash_attn_func(q, k, v) |
| if isinstance(x,tuple): |
| x = x[0] |
| x = rearrange(x, "b s n d -> b s (n d)", n=num_heads) |
| elif FLASH_ATTN_2_AVAILABLE: |
| q = rearrange(q, "b s (n d) -> b s n d", n=num_heads) |
| k = rearrange(k, "b s (n d) -> b s n d", n=num_heads) |
| v = rearrange(v, "b s (n d) -> b s n d", n=num_heads) |
| x = flash_attn.flash_attn_func(q, k, v) |
| x = rearrange(x, "b s n d -> b s (n d)", n=num_heads) |
| elif SAGE_ATTN_AVAILABLE: |
| q = rearrange(q, "b s (n d) -> b n s d", n=num_heads) |
| k = rearrange(k, "b s (n d) -> b n s d", n=num_heads) |
| v = rearrange(v, "b s (n d) -> b n s d", n=num_heads) |
| x = sageattn(q, k, v) |
| x = rearrange(x, "b n s d -> b s (n d)", n=num_heads) |
| else: |
| q = rearrange(q, "b s (n d) -> b n s d", n=num_heads) |
| k = rearrange(k, "b s (n d) -> b n s d", n=num_heads) |
| v = rearrange(v, "b s (n d) -> b n s d", n=num_heads) |
| x = F.scaled_dot_product_attention(q, k, v) |
| x = rearrange(x, "b n s d -> b s (n d)", n=num_heads) |
| return x |
|
|
|
|
| def modulate(x: torch.Tensor, shift: torch.Tensor, scale: torch.Tensor): |
| return (x * (1 + scale) + shift) |
|
|
|
|
| def sinusoidal_embedding_1d(dim, position): |
| sinusoid = torch.outer(position.type(torch.float64), torch.pow( |
| 10000, -torch.arange(dim//2, dtype=torch.float64, device=position.device).div(dim//2))) |
| x = torch.cat([torch.cos(sinusoid), torch.sin(sinusoid)], dim=1) |
| return x.to(position.dtype) |
|
|
|
|
| def precompute_freqs_cis_3d(dim: int, end: int = 1024, theta: float = 10000.0): |
| |
| f_freqs_cis = precompute_freqs_cis(dim - 2 * (dim // 3), end, theta) |
| h_freqs_cis = precompute_freqs_cis(dim // 3, end, theta) |
| w_freqs_cis = precompute_freqs_cis(dim // 3, end, theta) |
| return f_freqs_cis, h_freqs_cis, w_freqs_cis |
|
|
|
|
| def precompute_freqs_cis(dim: int, end: int = 1024, theta: float = 10000.0): |
| |
| freqs = 1.0 / (theta ** (torch.arange(0, dim, 2) |
| [: (dim // 2)].double() / dim)) |
| freqs = torch.outer(torch.arange(end, device=freqs.device), freqs) |
| freqs_cis = torch.polar(torch.ones_like(freqs), freqs) |
| return freqs_cis |
|
|
|
|
| def rope_apply(x, freqs, num_heads): |
| x = rearrange(x, "b s (n d) -> b s n d", n=num_heads) |
| x_out = torch.view_as_complex(x.to(torch.float64).reshape( |
| x.shape[0], x.shape[1], x.shape[2], -1, 2)) |
| freqs = freqs.to(torch.complex64) if freqs.device.type == "npu" else freqs |
| x_out = torch.view_as_real(x_out * freqs).flatten(2) |
| return x_out.to(x.dtype) |
|
|
|
|
| class RMSNorm(nn.Module): |
| def __init__(self, dim, eps=1e-5): |
| super().__init__() |
| self.eps = eps |
| self.weight = nn.Parameter(torch.ones(dim)) |
|
|
| def norm(self, x): |
| return x * torch.rsqrt(x.pow(2).mean(dim=-1, keepdim=True) + self.eps) |
|
|
| def forward(self, x): |
| dtype = x.dtype |
| return self.norm(x.float()).to(dtype) * self.weight |
|
|
|
|
| class AttentionModule(nn.Module): |
| def __init__(self, num_heads): |
| super().__init__() |
| self.num_heads = num_heads |
|
|
| def forward(self, q, k, v): |
| x = flash_attention(q=q, k=k, v=v, num_heads=self.num_heads) |
| return x |
|
|
|
|
| class SelfAttention(nn.Module): |
| def __init__(self, dim: int, num_heads: int, eps: float = 1e-6): |
| super().__init__() |
| self.dim = dim |
| self.num_heads = num_heads |
| self.head_dim = dim // num_heads |
|
|
| self.q = nn.Linear(dim, dim) |
| self.k = nn.Linear(dim, dim) |
| self.v = nn.Linear(dim, dim) |
| self.o = nn.Linear(dim, dim) |
| self.norm_q = RMSNorm(dim, eps=eps) |
| self.norm_k = RMSNorm(dim, eps=eps) |
|
|
| self.attn = AttentionModule(self.num_heads) |
|
|
| def forward(self, x, freqs): |
| q = self.norm_q(self.q(x)) |
| k = self.norm_k(self.k(x)) |
| v = self.v(x) |
| q = rope_apply(q, freqs, self.num_heads) |
| k = rope_apply(k, freqs, self.num_heads) |
| x = self.attn(q, k, v) |
| return self.o(x) |
|
|
|
|
| class CrossAttention(nn.Module): |
| def __init__(self, dim: int, num_heads: int, eps: float = 1e-6, has_image_input: bool = False): |
| super().__init__() |
| self.dim = dim |
| self.num_heads = num_heads |
| self.head_dim = dim // num_heads |
|
|
| self.q = nn.Linear(dim, dim) |
| self.k = nn.Linear(dim, dim) |
| self.v = nn.Linear(dim, dim) |
| self.o = nn.Linear(dim, dim) |
| self.norm_q = RMSNorm(dim, eps=eps) |
| self.norm_k = RMSNorm(dim, eps=eps) |
| self.has_image_input = has_image_input |
| if has_image_input: |
| self.k_img = nn.Linear(dim, dim) |
| self.v_img = nn.Linear(dim, dim) |
| self.norm_k_img = RMSNorm(dim, eps=eps) |
|
|
| self.attn = AttentionModule(self.num_heads) |
|
|
| def forward(self, x: torch.Tensor, y: torch.Tensor): |
| if self.has_image_input: |
| img = y[:, :257] |
| ctx = y[:, 257:] |
| else: |
| ctx = y |
| q = self.norm_q(self.q(x)) |
| k = self.norm_k(self.k(ctx)) |
| v = self.v(ctx) |
| x = self.attn(q, k, v) |
| if self.has_image_input: |
| k_img = self.norm_k_img(self.k_img(img)) |
| v_img = self.v_img(img) |
| y = flash_attention(q, k_img, v_img, num_heads=self.num_heads) |
| x = x + y |
| return self.o(x) |
|
|
|
|
| class MutualCrossAttention(nn.Module): |
| def __init__(self, dim: int, num_heads: int, eps: float = 1e-6): |
| super().__init__() |
| self.dim = dim |
| self.num_heads = num_heads |
| self.head_dim = dim // num_heads |
|
|
| self.q = nn.Linear(dim, dim) |
| self.k = nn.Linear(dim, dim) |
| self.v = nn.Linear(dim, dim) |
| self.o = nn.Linear(dim, dim) |
| self.norm_q = RMSNorm(dim, eps=eps) |
| self.norm_k = RMSNorm(dim, eps=eps) |
| self.attn = AttentionModule(self.num_heads) |
|
|
| def forward(self, x: torch.Tensor, y: torch.Tensor): |
| q = self.norm_q(self.q(x)) |
| k = self.norm_k(self.k(y)) |
| v = self.v(y) |
| x = self.attn(q, k, v) |
| return self.o(x) |
|
|
|
|
| class BottleneckSelfAttention(nn.Module): |
| """Small state-token self-attention with Wan-dim input/output.""" |
|
|
| def __init__( |
| self, |
| dim: int, |
| inner_dim: int = 512, |
| num_heads: int = 8, |
| eps: float = 1e-6, |
| ): |
| super().__init__() |
| if inner_dim % num_heads != 0: |
| raise ValueError(f"inner_dim={inner_dim} must be divisible by num_heads={num_heads}") |
| self.dim = dim |
| self.inner_dim = inner_dim |
| self.num_heads = num_heads |
| self.q = nn.Linear(dim, inner_dim) |
| self.k = nn.Linear(dim, inner_dim) |
| self.v = nn.Linear(dim, inner_dim) |
| self.o = nn.Linear(inner_dim, dim) |
| self.norm_q = RMSNorm(inner_dim, eps=eps) |
| self.norm_k = RMSNorm(inner_dim, eps=eps) |
| self.attn = AttentionModule(self.num_heads) |
|
|
| def forward(self, x, freqs=None): |
| q = self.norm_q(self.q(x)) |
| k = self.norm_k(self.k(x)) |
| v = self.v(x) |
| x = self.attn(q, k, v) |
| return self.o(x) |
|
|
|
|
| class BottleneckCrossAttention(nn.Module): |
| """Small cross-attention with Wan-dim input/output.""" |
|
|
| def __init__( |
| self, |
| dim: int, |
| inner_dim: int = 512, |
| num_heads: int = 8, |
| eps: float = 1e-6, |
| ): |
| super().__init__() |
| if inner_dim % num_heads != 0: |
| raise ValueError(f"inner_dim={inner_dim} must be divisible by num_heads={num_heads}") |
| self.dim = dim |
| self.inner_dim = inner_dim |
| self.num_heads = num_heads |
| self.q = nn.Linear(dim, inner_dim) |
| self.k = nn.Linear(dim, inner_dim) |
| self.v = nn.Linear(dim, inner_dim) |
| self.o = nn.Linear(inner_dim, dim) |
| self.norm_q = RMSNorm(inner_dim, eps=eps) |
| self.norm_k = RMSNorm(inner_dim, eps=eps) |
| self.attn = AttentionModule(self.num_heads) |
|
|
| def forward(self, x: torch.Tensor, y: torch.Tensor): |
| q = self.norm_q(self.q(x)) |
| k = self.norm_k(self.k(y)) |
| v = self.v(y) |
| x = self.attn(q, k, v) |
| return self.o(x) |
|
|
|
|
| class BottleneckFFN(nn.Module): |
| """Small state-token FFN with Wan-dim input/output.""" |
|
|
| def __init__(self, dim: int, inner_dim: int = 1024): |
| super().__init__() |
| self.net = nn.Sequential( |
| nn.Linear(dim, inner_dim), |
| nn.GELU(approximate='tanh'), |
| nn.Linear(inner_dim, dim), |
| ) |
|
|
| def forward(self, x): |
| return self.net(x) |
|
|
|
|
| class GateModule(nn.Module): |
| def __init__(self,): |
| super().__init__() |
|
|
| def forward(self, x, gate, residual): |
| return x + gate * residual |
|
|
|
|
| class DiTBlock(nn.Module): |
| def __init__(self, has_image_input: bool, dim: int, num_heads: int, ffn_dim: int, eps: float = 1e-6): |
| super().__init__() |
| self.dim = dim |
| self.num_heads = num_heads |
| self.ffn_dim = ffn_dim |
|
|
| self.self_attn = SelfAttention(dim, num_heads, eps) |
| self.cross_attn = CrossAttention( |
| dim, num_heads, eps, has_image_input=has_image_input) |
| self.norm1 = nn.LayerNorm(dim, eps=eps, elementwise_affine=False) |
| self.norm2 = nn.LayerNorm(dim, eps=eps, elementwise_affine=False) |
| self.norm3 = nn.LayerNorm(dim, eps=eps) |
| self.ffn = nn.Sequential(nn.Linear(dim, ffn_dim), nn.GELU( |
| approximate='tanh'), nn.Linear(ffn_dim, dim)) |
| self.modulation = nn.Parameter(torch.randn(1, 6, dim) / dim**0.5) |
| self.gate = GateModule() |
|
|
| def forward(self, x, context, t_mod, freqs, cross_attn_video_len: Optional[int] = None): |
| has_seq = len(t_mod.shape) == 4 |
| chunk_dim = 2 if has_seq else 1 |
| shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = ( |
| self.modulation.to(dtype=t_mod.dtype, device=t_mod.device) + t_mod).chunk(6, dim=chunk_dim) |
| if has_seq: |
| shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = ( |
| shift_msa.squeeze(2), scale_msa.squeeze(2), gate_msa.squeeze(2), |
| shift_mlp.squeeze(2), scale_mlp.squeeze(2), gate_mlp.squeeze(2), |
| ) |
| input_x = modulate(self.norm1(x), shift_msa, scale_msa) |
| x = self.gate(x, gate_msa, self.self_attn(input_x, freqs)) |
| if cross_attn_video_len is None: |
| x = x + self.cross_attn(self.norm3(x), context) |
| else: |
| if cross_attn_video_len < 0 or cross_attn_video_len > x.shape[1]: |
| raise AssertionError( |
| f"cross_attn_video_len={cross_attn_video_len} is invalid for sequence length {x.shape[1]}" |
| ) |
| x_video = x[:, :cross_attn_video_len] |
| x_state = x[:, cross_attn_video_len:] |
| x_video = x_video + self.cross_attn(self.norm3(x_video), context) |
| x = torch.cat([x_video, x_state], dim=1) |
| input_x = modulate(self.norm2(x), shift_mlp, scale_mlp) |
| x = self.gate(x, gate_mlp, self.ffn(input_x)) |
| return x |
|
|
|
|
| class LatentStateVideoDiTBlock(DiTBlock): |
| """Wan video block with read-only access to action-driven latent states.""" |
|
|
| def __init__(self, has_image_input, dim, num_heads, ffn_dim, eps=1e-6, |
| latent_dim=256, latent_heads=8): |
| super().__init__(has_image_input, dim, num_heads, ffn_dim, eps) |
| self.latent_state_attention = LatentStateToVisualAttention(dim, latent_dim, latent_heads) |
|
|
| def forward(self, video, latent_state_tokens, context, t_mod_video, video_freqs): |
| chunks = (self.modulation + t_mod_video).chunk(6, dim=2 if t_mod_video.ndim == 4 else 1) |
| if t_mod_video.ndim == 4: |
| chunks = tuple(chunk.squeeze(2) for chunk in chunks) |
| shift, scale, gate, shift_ffn, scale_ffn, gate_ffn = chunks |
| video = self.gate(video, gate, self.self_attn(modulate(self.norm1(video), shift, scale), video_freqs)) |
| video = video + self.cross_attn(self.norm3(video), context) |
| video = self.latent_state_attention(video, latent_state_tokens) |
| return self.gate(video, gate_ffn, self.ffn(modulate(self.norm2(video), shift_ffn, scale_ffn))) |
|
|
|
|
| class StateVideoDiTBlock(nn.Module): |
| """StatePlay block: separate video/state self-attn + FFN with mutual cross-attn.""" |
|
|
| def __init__(self, has_image_input: bool, dim: int, num_heads: int, ffn_dim: int, eps: float = 1e-6): |
| super().__init__() |
| self.dim = dim |
| self.num_heads = num_heads |
| self.ffn_dim = ffn_dim |
|
|
| |
| |
| self.self_attn = SelfAttention(dim, num_heads, eps) |
| self.cross_attn = CrossAttention( |
| dim, num_heads, eps, has_image_input=has_image_input) |
| self.norm1 = nn.LayerNorm(dim, eps=eps, elementwise_affine=False) |
| self.norm2 = nn.LayerNorm(dim, eps=eps, elementwise_affine=False) |
| self.norm3 = nn.LayerNorm(dim, eps=eps) |
| self.ffn = nn.Sequential(nn.Linear(dim, ffn_dim), nn.GELU( |
| approximate='tanh'), nn.Linear(ffn_dim, dim)) |
|
|
| self.state_self_attn = BottleneckSelfAttention( |
| dim, inner_dim=512, num_heads=8, eps=eps, |
| ) |
| self.state_norm1 = nn.LayerNorm(dim, eps=eps, elementwise_affine=False) |
| self.state_norm2 = nn.LayerNorm(dim, eps=eps, elementwise_affine=False) |
| self.state_ffn = BottleneckFFN(dim, inner_dim=1024) |
|
|
| self.video_to_state_attn = BottleneckCrossAttention( |
| dim, inner_dim=512, num_heads=8, eps=eps, |
| ) |
| self.state_to_video_attn = BottleneckCrossAttention( |
| dim, inner_dim=512, num_heads=8, eps=eps, |
| ) |
| self.norm_video_to_state_q = nn.LayerNorm(dim, eps=eps) |
| self.norm_video_to_state_kv = nn.LayerNorm(dim, eps=eps) |
| self.norm_state_to_video_q = nn.LayerNorm(dim, eps=eps) |
| self.norm_state_to_video_kv = nn.LayerNorm(dim, eps=eps) |
|
|
| self.modulation = nn.Parameter(torch.randn(1, 6, dim) / dim**0.5) |
| self.gate = GateModule() |
|
|
| def _modulation_chunks(self, t_mod): |
| has_seq = len(t_mod.shape) == 4 |
| chunk_dim = 2 if has_seq else 1 |
| chunks = ( |
| self.modulation.to(dtype=t_mod.dtype, device=t_mod.device) + t_mod |
| ).chunk(6, dim=chunk_dim) |
| if has_seq: |
| chunks = tuple(chunk.squeeze(2) for chunk in chunks) |
| return chunks |
|
|
| def forward(self, video, state, context, t_mod_video, t_mod_state, video_freqs, state_freqs): |
| shift_msa_v, scale_msa_v, gate_msa_v, shift_mlp_v, scale_mlp_v, gate_mlp_v = ( |
| self._modulation_chunks(t_mod_video) |
| ) |
| shift_msa_s, scale_msa_s, gate_msa_s, shift_mlp_s, scale_mlp_s, gate_mlp_s = ( |
| self._modulation_chunks(t_mod_state) |
| ) |
|
|
| input_video = modulate(self.norm1(video), shift_msa_v, scale_msa_v) |
| video = self.gate(video, gate_msa_v, self.self_attn(input_video, video_freqs)) |
|
|
| input_state = modulate(self.state_norm1(state), shift_msa_s, scale_msa_s) |
| state = self.gate(state, gate_msa_s, self.state_self_attn(input_state, state_freqs)) |
|
|
| video = video + self.cross_attn(self.norm3(video), context) |
|
|
| video_kv = video |
| state_kv = state |
| video = video + self.video_to_state_attn( |
| self.norm_video_to_state_q(video), |
| self.norm_video_to_state_kv(state_kv), |
| ) |
| state = state + self.state_to_video_attn( |
| self.norm_state_to_video_q(state), |
| self.norm_state_to_video_kv(video_kv), |
| ) |
|
|
| input_video = modulate(self.norm2(video), shift_mlp_v, scale_mlp_v) |
| video = self.gate(video, gate_mlp_v, self.ffn(input_video)) |
|
|
| input_state = modulate(self.state_norm2(state), shift_mlp_s, scale_mlp_s) |
| state = self.gate(state, gate_mlp_s, self.state_ffn(input_state)) |
| return video, state |
|
|
|
|
| class MLP(torch.nn.Module): |
| def __init__(self, in_dim, out_dim, has_pos_emb=False): |
| super().__init__() |
| self.proj = torch.nn.Sequential( |
| nn.LayerNorm(in_dim), |
| nn.Linear(in_dim, in_dim), |
| nn.GELU(), |
| nn.Linear(in_dim, out_dim), |
| nn.LayerNorm(out_dim) |
| ) |
| self.has_pos_emb = has_pos_emb |
| if has_pos_emb: |
| self.emb_pos = torch.nn.Parameter(torch.zeros((1, 514, 1280))) |
|
|
| def forward(self, x): |
| if self.has_pos_emb: |
| x = x + self.emb_pos.to(dtype=x.dtype, device=x.device) |
| return self.proj(x) |
|
|
|
|
| class Head(nn.Module): |
| def __init__(self, dim: int, out_dim: int, patch_size: Tuple[int, int, int], eps: float): |
| super().__init__() |
| self.dim = dim |
| self.patch_size = patch_size |
| self.norm = nn.LayerNorm(dim, eps=eps, elementwise_affine=False) |
| self.head = nn.Linear(dim, out_dim * math.prod(patch_size)) |
| self.modulation = nn.Parameter(torch.randn(1, 2, dim) / dim**0.5) |
|
|
| def forward(self, x, t_mod): |
| if len(t_mod.shape) == 3: |
| shift, scale = (self.modulation.unsqueeze(0).to(dtype=t_mod.dtype, device=t_mod.device) + t_mod.unsqueeze(2)).chunk(2, dim=2) |
| x = (self.head(self.norm(x) * (1 + scale.squeeze(2)) + shift.squeeze(2))) |
| else: |
| shift, scale = (self.modulation.to(dtype=t_mod.dtype, device=t_mod.device) + t_mod).chunk(2, dim=1) |
| x = (self.head(self.norm(x) * (1 + scale) + shift)) |
| return x |
|
|
|
|
| class WanModel(torch.nn.Module): |
| def __init__( |
| self, |
| dim: int, |
| in_dim: int, |
| ffn_dim: int, |
| out_dim: int, |
| text_dim: int, |
| freq_dim: int, |
| eps: float, |
| patch_size: Tuple[int, int, int], |
| num_heads: int, |
| num_layers: int, |
| has_image_input: bool, |
| has_image_pos_emb: bool = False, |
| has_ref_conv: bool = False, |
| add_control_adapter: bool = False, |
| in_dim_control_adapter: int = 24, |
| seperated_timestep: bool = False, |
| require_vae_embedding: bool = True, |
| require_clip_embedding: bool = True, |
| fuse_vae_embedding_in_latents: bool = False, |
| block_factory=None, |
| ): |
| super().__init__() |
| self.dim = dim |
| self.in_dim = in_dim |
| self.freq_dim = freq_dim |
| self.has_image_input = has_image_input |
| self.patch_size = patch_size |
| self.seperated_timestep = seperated_timestep |
| self.require_vae_embedding = require_vae_embedding |
| self.require_clip_embedding = require_clip_embedding |
| self.fuse_vae_embedding_in_latents = fuse_vae_embedding_in_latents |
|
|
| self.patch_embedding = nn.Conv3d( |
| in_dim, dim, kernel_size=patch_size, stride=patch_size) |
| self.text_embedding = nn.Sequential( |
| nn.Linear(text_dim, dim), |
| nn.GELU(approximate='tanh'), |
| nn.Linear(dim, dim) |
| ) |
| self.time_embedding = nn.Sequential( |
| nn.Linear(freq_dim, dim), |
| nn.SiLU(), |
| nn.Linear(dim, dim) |
| ) |
| self.time_projection = nn.Sequential( |
| nn.SiLU(), nn.Linear(dim, dim * 6)) |
| self.blocks = nn.ModuleList([ |
| (block_factory or DiTBlock)(has_image_input, dim, num_heads, ffn_dim, eps) |
| for _ in range(num_layers) |
| ]) |
| self.head = Head(dim, out_dim, patch_size, eps) |
| head_dim = dim // num_heads |
| self.freqs = precompute_freqs_cis_3d(head_dim) |
|
|
| if has_image_input: |
| self.img_emb = MLP(1280, dim, has_pos_emb=has_image_pos_emb) |
| if has_ref_conv: |
| self.ref_conv = nn.Conv2d(16, dim, kernel_size=(2, 2), stride=(2, 2)) |
| self.has_image_pos_emb = has_image_pos_emb |
| self.has_ref_conv = has_ref_conv |
| if add_control_adapter: |
| self.control_adapter = SimpleAdapter(in_dim_control_adapter, dim, kernel_size=patch_size[1:], stride=patch_size[1:]) |
| else: |
| self.control_adapter = None |
|
|
| def patchify(self, x: torch.Tensor, control_camera_latents_input: Optional[torch.Tensor] = None): |
| x = self.patch_embedding(x) |
| if self.control_adapter is not None and control_camera_latents_input is not None: |
| y_camera = self.control_adapter(control_camera_latents_input) |
| x = [u + v for u, v in zip(x, y_camera)] |
| x = x[0].unsqueeze(0) |
| return x |
|
|
| def unpatchify(self, x: torch.Tensor, grid_size: torch.Tensor): |
| return rearrange( |
| x, 'b (f h w) (x y z c) -> b c (f x) (h y) (w z)', |
| f=grid_size[0], h=grid_size[1], w=grid_size[2], |
| x=self.patch_size[0], y=self.patch_size[1], z=self.patch_size[2] |
| ) |
|
|
| def forward(self, |
| x: torch.Tensor, |
| timestep: torch.Tensor, |
| context: torch.Tensor, |
| clip_feature: Optional[torch.Tensor] = None, |
| y: Optional[torch.Tensor] = None, |
| use_gradient_checkpointing: bool = False, |
| use_gradient_checkpointing_offload: bool = False, |
| **kwargs, |
| ): |
| t = self.time_embedding( |
| sinusoidal_embedding_1d(self.freq_dim, timestep).to(x.dtype)) |
| t_mod = self.time_projection(t).unflatten(1, (6, self.dim)) |
| context = self.text_embedding(context) |
|
|
| if self.has_image_input: |
| x = torch.cat([x, y], dim=1) |
| clip_embdding = self.img_emb(clip_feature) |
| context = torch.cat([clip_embdding, context], dim=1) |
|
|
| x, (f, h, w) = self.patchify(x) |
|
|
| freqs = torch.cat([ |
| self.freqs[0][:f].view(f, 1, 1, -1).expand(f, h, w, -1), |
| self.freqs[1][:h].view(1, h, 1, -1).expand(f, h, w, -1), |
| self.freqs[2][:w].view(1, 1, w, -1).expand(f, h, w, -1) |
| ], dim=-1).reshape(f * h * w, 1, -1).to(x.device) |
|
|
| for block in self.blocks: |
| if self.training: |
| x = gradient_checkpoint_forward( |
| block, |
| use_gradient_checkpointing, |
| use_gradient_checkpointing_offload, |
| x, context, t_mod, freqs |
| ) |
| else: |
| x = block(x, context, t_mod, freqs) |
|
|
| x = self.head(x, t) |
| x = self.unpatchify(x, (f, h, w)) |
| return x |
|
|
|
|
| class _StatePlayActionBackbone(WanModel): |
| """ |
| Wan backbone with per-block independent action embedders. |
| |
| 30 independent `nn.Linear(num_buttons, dim)` modules (one per DiTBlock) |
| each project the downsampled keyboard action and add the result to the |
| hidden state right before their block. No LayerScale gate. |
| |
| Action-conditioning design: |
| Initial attempt A — embedder=0, gates=0 → dead gradient (both ends) |
| Initial attempt B — embedder=xavier, gates=0 → gate grew but ∂loss/∂embedder was |
| attenuated 50× by small gate → bf16 |
| round-to-zero → embedder stuck |
| Initial attempt C — embedder=xavier, gates=0.1 → gate=0.1 hit bf16 precision wall |
| (0.1/128 ≈ 7.8e-4 ≫ lr·grad ≈ 5e-5) |
| → action params bit-exact frozen |
| StatePlay — 30 independent embedders, no gate: |
| ∂loss/∂embedder_i = upstream_grad[i] (no 50× gate attn). |
| Xavier std ≈ 0.025 is the same magnitude known to be |
| bf16-learnable. Each embedder has a shorter gradient path |
| (block 29 backprops through 1 layer; block 0 through 30) |
| and learns its own projection direction, giving the model |
| strictly more representational capacity than a shared emb. |
| |
| Trade-off: NOT bit-identical at init. Expected first-step perturbation is |
| roughly sqrt(30) · xavier_std · |keyboard_action| ≈ 17% of the hidden-state |
| scale per channel. We accept this because StatePlay training start from the raw |
| Wan2.2-TI2V-5B backbone (no MG3 visual warm-start), so there is no fragile |
| baseline to preserve. |
| |
| Parameter count: 30 × (num_buttons × dim) = 30 × 10 × 3072 ≈ 920K |
| (0.018% of the 5B backbone; negligible). |
| |
| Two methods: |
| - `prepare_action_binned(keyboard_action, f)` → `[B, f, num_buttons]` |
| Pure temporal downsample. Call ONCE per forward, before the block loop. |
| - `inject_at_block(x, action_binned, block_id, f, h, w)` → `[B, L, C]` |
| Called by `diffsynth.pipelines.stateplay.model_fn_stateplay` before |
| each DiTBlock. |
| """ |
| def __init__(self, num_buttons: int = 10, **kwargs): |
| super().__init__(**kwargs) |
| self.num_buttons = num_buttons |
| self.action_embedders = nn.ModuleList([ |
| nn.Linear(num_buttons, self.dim, bias=False) |
| for _ in range(len(self.blocks)) |
| ]) |
| for emb in self.action_embedders: |
| nn.init.xavier_normal_(emb.weight) |
|
|
| def prepare_action_binned(self, keyboard_action, f): |
| """ |
| Downsample raw keyboard action to latent frame rate via adaptive max-pool. |
| |
| Called ONCE per forward; output is shared across all 30 blocks (each |
| block runs it through its own embedder in `inject_at_block`). |
| |
| keyboard_action: [B, num_raw, num_buttons] dense 0/1 (assumes hold-last |
| upsample already applied) |
| f: latent temporal dim (StatePlay 101-frame: f=26) |
| |
| Returns: [B, f, num_buttons] binned action, or None if input was None. |
| """ |
| if keyboard_action is None: |
| return None |
| |
| return F.adaptive_max_pool1d( |
| keyboard_action.transpose(1, 2), |
| output_size=f, |
| ).transpose(1, 2) |
|
|
| def inject_at_block(self, x, action_binned, block_id, f, h, w): |
| """ |
| Project action_binned with this block's own embedder and add to x. |
| |
| x: [B, L, C] hidden state before DiTBlock `block_id`. |
| L is usually f*h*w. When reference_latents is prepended |
| upstream, L = f*h*w + prefix_len; we zero-pad the bias |
| for the prefix tokens so they are untouched. |
| action_binned: [B, f, num_buttons] from prepare_action_binned, or None |
| block_id: int in [0, num_layers) |
| f, h, w: latent spatiotemporal dims captured BEFORE any |
| reference_latents concat (so f*h*w matches the emb |
| output length regardless of downstream prefixes) |
| """ |
| if action_binned is None: |
| return x |
| B = action_binned.shape[0] |
| C = self.dim |
| action_emb = self.action_embedders[block_id](action_binned.to(x.dtype)) |
| action_bias = (action_emb |
| .unsqueeze(2) |
| .expand(-1, -1, h * w, -1) |
| .reshape(B, f * h * w, C)) |
| if x.shape[1] == action_bias.shape[1]: |
| return x + action_bias |
| |
| prefix_len = x.shape[1] - action_bias.shape[1] |
| padding = torch.zeros(B, prefix_len, C, dtype=x.dtype, device=x.device) |
| padded_bias = torch.cat([padding, action_bias], dim=1) |
| return x + padded_bias |
|
|
|
|
| class _StatePlayStateBackbone(_StatePlayActionBackbone): |
| """StatePlay state backbone: joint video/state-token DiT with per-block actions.""" |
|
|
| def __init__(self, num_buttons: int = 10, state_dim: int = 5, |
| use_explicit_state: bool = True, **kwargs): |
| super().__init__(num_buttons=num_buttons, **kwargs) |
| self.state_dim = state_dim |
| self._state_shape_logged = False |
| if not use_explicit_state: |
| return |
| self.state_encoder = nn.Sequential( |
| nn.LayerNorm(state_dim), |
| nn.Linear(state_dim, 256), |
| nn.GELU(), |
| nn.Linear(256, self.dim), |
| nn.LayerNorm(self.dim), |
| ) |
| self.state_decoder = nn.Sequential( |
| nn.LayerNorm(self.dim), |
| nn.Linear(self.dim, 256), |
| nn.GELU(), |
| nn.Linear(256, state_dim), |
| ) |
| self._state_shape_logged = False |
|
|
| def encode_state(self, noisy_state: torch.Tensor) -> torch.Tensor: |
| if noisy_state is None: |
| raise ValueError("_StatePlayStateBackbone requires state/noisy_state input.") |
| if noisy_state.shape[-1] != self.state_dim: |
| raise AssertionError( |
| f"state.shape[-1] must be {self.state_dim}; got {tuple(noisy_state.shape)}" |
| ) |
| return self.state_encoder(noisy_state) |
|
|
| def decode_state(self, state_tokens: torch.Tensor) -> torch.Tensor: |
| return self.state_decoder(state_tokens) |
|
|
| def inject_at_block_state(self, x, action_binned, block_id, f, h, w): |
| """Add action bias to concatenated [video_tokens, state_tokens].""" |
| if action_binned is None: |
| return x |
| B = action_binned.shape[0] |
| C = self.dim |
| Lv = f * h * w |
| Ls = f |
| if x.shape[1] != Lv + Ls: |
| raise AssertionError( |
| f"state-aware sequence length mismatch: got {x.shape[1]}, expected {Lv + Ls}" |
| ) |
| action_emb = self.action_embedders[block_id](action_binned.to(x.dtype)) |
| video_bias = (action_emb |
| .unsqueeze(2) |
| .expand(-1, -1, h * w, -1) |
| .reshape(B, Lv, C)) |
| state_bias = action_emb |
| return x + torch.cat([video_bias, state_bias], dim=1) |
|
|
|
|
| class StatePlayModel(_StatePlayStateBackbone): |
| """Configurable explicit baseline, transition tokenizer, or latent world model.""" |
|
|
| def __init__(self, num_buttons=10, state_dim=5, use_latent_state=True, |
| use_explicit_state=False, latent_state_num_tokens=4, latent_state_dim=256, |
| latent_state_initializer_layers=2, latent_state_transition_layers=2, |
| latent_state_num_heads=8, latent_state_mlp_ratio=4.0, latent_state_dropout=0.0, |
| latent_state_max_frames=64, latent_state_bidirectional=False, |
| use_transition_tokenizer=True, transition_tokenizer_num_tokens=4, |
| transition_tokenizer_dim=256, transition_tokenizer_layers=2, |
| transition_tokenizer_heads=8, transition_tokenizer_mlp_ratio=4.0, |
| transition_tokenizer_dropout=0.0, transition_tokenizer_fsq_levels=(8, 8, 8), |
| transition_vocab_size=512, **kwargs): |
| if use_latent_state and use_explicit_state: |
| raise ValueError("Latent and explicit state branches are mutually exclusive") |
| if use_latent_state and kwargs.get("patch_size", (1,))[0] != 1: |
| raise ValueError("Latent initialization requires temporal patch size 1 to isolate the first frame") |
| if latent_state_bidirectional: |
| raise ValueError("Bidirectional latent state attention would leak future video information") |
| if use_transition_tokenizer and math.prod(transition_tokenizer_fsq_levels) != transition_vocab_size: |
| raise ValueError("transition_vocab_size must equal the product of FSQ levels") |
| if use_latent_state and latent_state_num_tokens != transition_tokenizer_num_tokens: |
| raise ValueError("Predictor and tokenizer must have the same number of transition tokens") |
| if use_explicit_state: |
| factory = StateVideoDiTBlock |
| elif use_latent_state: |
| from functools import partial |
| factory = partial(LatentStateVideoDiTBlock, latent_dim=latent_state_dim, |
| latent_heads=latent_state_num_heads) |
| else: |
| factory = DiTBlock |
| |
| super().__init__(num_buttons=num_buttons, state_dim=state_dim, |
| use_explicit_state=use_explicit_state, block_factory=factory, **kwargs) |
| self.use_latent_state = use_latent_state |
| self.use_explicit_state = use_explicit_state |
| if use_latent_state: |
| self.latent_state_rollout = LatentStateRollout( |
| self.dim, latent_state_num_tokens, latent_state_dim, num_buttons, |
| latent_state_initializer_layers, latent_state_transition_layers, |
| latent_state_num_heads, latent_state_mlp_ratio, latent_state_dropout, latent_state_max_frames) |
| self.latent_transition_predictor = LatentTransitionPredictor( |
| latent_state_dim, num_buttons, transition_vocab_size, latent_state_mlp_ratio) |
| if use_transition_tokenizer: |
| self.transition_tokenizer = GameTransitionTokenizer( |
| self.dim, transition_tokenizer_num_tokens, transition_tokenizer_dim, |
| transition_tokenizer_layers, transition_tokenizer_heads, |
| transition_tokenizer_mlp_ratio, transition_tokenizer_dropout, transition_tokenizer_fsq_levels) |
|
|
| def extract_clean_visual_tokens(self, clean_latents): |
| x = self.patchify(clean_latents) |
| f, h, w = x.shape[2:] |
| tokens = rearrange(x, "b c f h w -> b (f h w) c").contiguous() |
| return tokens, {"f": f, "h": h, "w": w, "tokens_per_frame": h * w, |
| "patchified": tuple(x.shape)} |
|
|
| def init_state_branch_from_pretrained(self, pretrained_state): |
| if not self.use_explicit_state: |
| return 0 |
| own_state = self.state_dict() |
| mapped = {} |
| for block_id in range(len(self.blocks)): |
| for dst_prefix, src_prefix in ( |
| (f"blocks.{block_id}.state_self_attn.", f"blocks.{block_id}.self_attn."), |
| (f"blocks.{block_id}.state_ffn.", f"blocks.{block_id}.ffn."), |
| ): |
| for dst_name in own_state: |
| if not dst_name.startswith(dst_prefix): |
| continue |
| src_name = src_prefix + dst_name[len(dst_prefix):] |
| src = pretrained_state.get(src_name) |
| if src is not None and src.shape == own_state[dst_name].shape: |
| mapped[dst_name] = src |
| if mapped: |
| self.load_state_dict(mapped, strict=False) |
| return len(mapped) |
|
|
