Skip to content
FastVideo
Esc
↑↓navigate↵open⌘Jpreview
On this page

hunyuan15

fastvideo.models.upsamplers.hunyuan15.HunyuanVideo15CausalConv3d

HunyuanVideo15CausalConv3d(in_channels: int, out_channels: int, kernel_size: Union[int, Tuple[int, int, int]] = 3, stride: Union[int, Tuple[int, int, int]] = 1, padding: Union[int, Tuple[int, int, int]] = 0, dilation: Union[int, Tuple[int, int, int]] = 1, bias: bool = True, pad_mode: str = 'replicate')

fastvideo.models.upsamplers.hunyuan15.HunyuanVideo15CausalConv3d.forward

forward(hidden_states: torch.Tensor) -> torch.Tensor

fastvideo.models.upsamplers.hunyuan15.HunyuanVideo15RMS_norm

HunyuanVideo15RMS_norm(dim: int, channel_first: bool = True, images: bool = True, bias: bool = False)

A custom RMS normalization layer.

Parameters

dim: int

The number of dimensions to normalize over.

channel_first: bool

Whether the input tensor has channels as the first dimension. Default is True.

images: bool

Whether the input represents image data. Default is True.

bias: bool

Whether to include a learnable bias term. Default is False.

fastvideo.models.upsamplers.hunyuan15.HunyuanVideo15RMS_norm.forward

forward(x)

fastvideo.models.upsamplers.hunyuan15.get_act_fn

get_act_fn(act_fn_name: str) -> nn.Module

Get an activation function by name.

fastvideo.models.upsamplers.hunyuan15.SRTo720pUpsamplerConfig

SRTo720pUpsamplerConfig(arch_config: ArchConfig = ArchConfig(), in_channels: int = 0, out_channels: int = 0, hidden_channels: int = 64, num_blocks: int = 6, global_residual: bool = False, *, _resolved_attention_backend: AttentionBackendEnum | None = None)

fastvideo.models.upsamplers.hunyuan15.SRTo1080pUpsamplerConfig

SRTo1080pUpsamplerConfig(arch_config: ArchConfig = ArchConfig(), z_channels: int = 0, out_channels: int = 0, block_out_channels: tuple[int, ...] = (0, 0), num_res_blocks: int = 2, is_residual: bool = False, *, _resolved_attention_backend: AttentionBackendEnum | None = None)

fastvideo.models.upsamplers.hunyuan15.HunyuanVideo15ResnetBlock

HunyuanVideo15ResnetBlock(in_channels: int, out_channels: int | None = None, non_linearity: str = 'swish')
Source
class HunyuanVideo15ResnetBlock(nn.Module):

def __init__(
    self,
    in_channels: int,
    out_channels: int | None = None,
    non_linearity: str = "swish",
) -> None:
    super().__init__()
    out_channels = out_channels or in_channels

    self.nonlinearity = get_act_fn(non_linearity)

    self.norm1 = HunyuanVideo15RMS_norm(in_channels, images=False)
    self.conv1 = HunyuanVideo15CausalConv3d(in_channels, out_channels, kernel_size=3)

    self.norm2 = HunyuanVideo15RMS_norm(out_channels, images=False)
    self.conv2 = HunyuanVideo15CausalConv3d(out_channels, out_channels, kernel_size=3)

    self.nin_shortcut = None
    if in_channels != out_channels:
        self.nin_shortcut = nn.Conv3d(in_channels, out_channels, kernel_size=1, stride=1, padding=0)

def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
    residual = hidden_states

    hidden_states = self.norm1(hidden_states)
    hidden_states = self.nonlinearity(hidden_states)
    hidden_states = self.conv1(hidden_states)

    hidden_states = self.norm2(hidden_states)
    hidden_states = self.nonlinearity(hidden_states)
    hidden_states = self.conv2(hidden_states)

    if self.nin_shortcut is not None:
        residual = self.nin_shortcut(residual)

    return hidden_states + residual</code></pre></details>


fastvideo.models.upsamplers.hunyuan15.HunyuanVideo15ResnetBlock.forward


forward(hidden_states: torch.Tensor) -> torch.Tensor


Source
def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
    residual = hidden_states

hidden_states = self.norm1(hidden_states)
hidden_states = self.nonlinearity(hidden_states)
hidden_states = self.conv1(hidden_states)

hidden_states = self.norm2(hidden_states)
hidden_states = self.nonlinearity(hidden_states)
hidden_states = self.conv2(hidden_states)

if self.nin_shortcut is not None:
    residual = self.nin_shortcut(residual)

return hidden_states + residual</code></pre></details>


fastvideo.models.upsamplers.hunyuan15.SRResidualCausalBlock3D


SRResidualCausalBlock3D(channels: int)


Source
class SRResidualCausalBlock3D(nn.Module):

def __init__(self, channels: int):
    super().__init__()
    self.block = nn.Sequential(
        HunyuanVideo15CausalConv3d(channels, channels, kernel_size=3),
        nn.SiLU(inplace=True),
        HunyuanVideo15CausalConv3d(channels, channels, kernel_size=3),
        nn.SiLU(inplace=True),
        HunyuanVideo15CausalConv3d(channels, channels, kernel_size=3),
    )

def forward(self, x: torch.Tensor) -&gt; torch.Tensor:
    return x + self.block(x)</code></pre></details>


fastvideo.models.upsamplers.hunyuan15.SRResidualCausalBlock3D.forward


forward(x: torch.Tensor) -> torch.Tensor


Source
def forward(self, x: torch.Tensor) -> torch.Tensor:
    return x + self.block(x)


fastvideo.models.upsamplers.hunyuan15.SRTo720pUpsampler


SRTo720pUpsampler(config: SRTo720pUpsamplerConfig)


Source
class SRTo720pUpsampler(nn.Module):

def __init__(
    self,
    config: SRTo720pUpsamplerConfig,
):
    super().__init__()
    self.in_conv = HunyuanVideo15CausalConv3d(config.in_channels, config.hidden_channels, kernel_size=3)
    self.blocks = nn.ModuleList(&#91;SRResidualCausalBlock3D(config.hidden_channels) for _ in range(config.num_blocks)&#93;)
    self.out_conv = HunyuanVideo15CausalConv3d(config.hidden_channels, config.out_channels, kernel_size=3)
    self.global_residual = bool(config.global_residual)

def forward(self, x: torch.Tensor) -&gt; torch.Tensor:
    residual = x
    y = self.in_conv(x)
    for blk in self.blocks:
        y = blk(y)
    y = self.out_conv(y)
    if self.global_residual and (y.shape == residual.shape):
        y = y + residual
    return y</code></pre></details>


fastvideo.models.upsamplers.hunyuan15.SRTo720pUpsampler.forward


forward(x: torch.Tensor) -> torch.Tensor


Source
def forward(self, x: torch.Tensor) -> torch.Tensor:
    residual = x
    y = self.in_conv(x)
    for blk in self.blocks:
        y = blk(y)
    y = self.out_conv(y)
    if self.global_residual and (y.shape == residual.shape):
        y = y + residual
    return y


fastvideo.models.upsamplers.hunyuan15.SRTo1080pUpsampler


SRTo1080pUpsampler(config: SRTo1080pUpsamplerConfig)


Source
class SRTo1080pUpsampler(nn.Module):

def __init__(
    self,
    config: SRTo1080pUpsamplerConfig,
):
    super().__init__()
    self.num_res_blocks = config.num_res_blocks
    self.block_out_channels = config.block_out_channels
    self.z_channels = config.z_channels

    block_in = config.block_out_channels&#91;0&#93;
    self.conv_in = HunyuanVideo15CausalConv3d(config.z_channels, block_in, kernel_size=3)

    self.up = nn.ModuleList()
    for i_level, ch in enumerate(config.block_out_channels):
        block = nn.ModuleList()
        block_out = ch
        for _ in range(self.num_res_blocks + 1):
            block.append(HunyuanVideo15ResnetBlock(in_channels=block_in, out_channels=block_out))
            block_in = block_out
        up = nn.Module()
        up.block = block

        self.up.append(up)

    self.norm_out = HunyuanVideo15RMS_norm(block_in, images=False)
    self.conv_out = HunyuanVideo15CausalConv3d(block_in, config.out_channels, kernel_size=3)

    self.gradient_checkpointing = False
    self.is_residual = config.is_residual

def forward(self, z: Tensor, target_shape: Sequence&#91;int&#93; = None) -&gt; Tensor:
    &quot;&quot;&quot;
    Args:
        z: (B, C, T, H, W)
        target_shape: (H, W)
    &quot;&quot;&quot;
    if target_shape is not None and z.shape&#91;-2:&#93; != target_shape:
        bsz = z.shape&#91;0&#93;
        z = rearrange(z, &quot;b c f h w -&gt; (b f) c h w&quot;)
        z = F.interpolate(z, size=target_shape, mode=&quot;bilinear&quot;, align_corners=False)
        z = rearrange(z, &quot;(b f) c h w -&gt; b c f h w&quot;, b=bsz)

    # z to block_in
    repeats = self.block_out_channels&#91;0&#93; // (self.z_channels)
    h = self.conv_in(z) + z.repeat_interleave(repeats=repeats, dim=1)

    # upsampling
    for i_level in range(len(self.block_out_channels)):
        for i_block in range(self.num_res_blocks + 1):
            h = self.up&#91;i_level&#93;.block&#91;i_block&#93;(h)
        if hasattr(self.up&#91;i_level&#93;, &quot;upsample&quot;):
            h = self.up&#91;i_level&#93;.upsample(h)

    # end
    h = self.norm_out(h)
    h = get_act_fn(&quot;swish&quot;)(h)
    h = self.conv_out(h)
    return h</code></pre></details>


fastvideo.models.upsamplers.hunyuan15.SRTo1080pUpsampler.forward


forward(z: Tensor, target_shape: Sequence[int] = None) -> Tensor


Parameters




z: Tensor
(B, C, T, H, W)


target_shape: Sequence[int]
(H, W)




Source
def forward(self, z: Tensor, target_shape: Sequence[int] = None) -> Tensor:
    """
    Args:
        z: (B, C, T, H, W)
        target_shape: (H, W)
    """
    if target_shape is not None and z.shape[-2:] != target_shape:
        bsz = z.shape[0]
        z = rearrange(z, "b c f h w -> (b f) c h w")
        z = F.interpolate(z, size=target_shape, mode="bilinear", align_corners=False)
        z = rearrange(z, "(b f) c h w -> b c f h w", b=bsz)

# z to block_in
repeats = self.block_out_channels&#91;0&#93; // (self.z_channels)
h = self.conv_in(z) + z.repeat_interleave(repeats=repeats, dim=1)

# upsampling
for i_level in range(len(self.block_out_channels)):
    for i_block in range(self.num_res_blocks + 1):
        h = self.up&#91;i_level&#93;.block&#91;i_block&#93;(h)
    if hasattr(self.up&#91;i_level&#93;, &quot;upsample&quot;):
        h = self.up&#91;i_level&#93;.upsample(h)

# end
h = self.norm_out(h)
h = get_act_fn(&quot;swish&quot;)(h)
h = self.conv_out(h)
return h</code></pre></details>

Was this page helpful?