369 lines
12 KiB
Python
369 lines
12 KiB
Python
# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
|
|
# SPDX-License-Identifier: Apache-2.0
|
|
#
|
|
# 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.
|
|
"""The model definition for Continuous 2D layers
|
|
|
|
Adapted from: https://github.com/CompVis/stable-diffusion/blob/
|
|
21f890f9da3cfbeaba8e2ac3c425ee9e998d5229/ldm/modules/diffusionmodules/model.py
|
|
|
|
[Copyright (c) 2022 Robin Rombach and Patrick Esser and contributors]
|
|
https://github.com/CompVis/stable-diffusion/blob/
|
|
21f890f9da3cfbeaba8e2ac3c425ee9e998d5229/LICENSE
|
|
"""
|
|
|
|
import math
|
|
|
|
import numpy as np
|
|
|
|
# pytorch_diffusion + derived encoder decoder
|
|
import torch
|
|
import torch.nn as nn
|
|
import torch.nn.functional as F
|
|
from loguru import logger as logging
|
|
|
|
from cosmos_tokenizer.modules.patching import Patcher, UnPatcher
|
|
from cosmos_tokenizer.modules.utils import Normalize, nonlinearity
|
|
|
|
|
|
class Upsample(nn.Module):
|
|
def __init__(self, in_channels: int):
|
|
super().__init__()
|
|
self.conv = nn.Conv2d(
|
|
in_channels, in_channels, kernel_size=3, stride=1, padding=1
|
|
)
|
|
|
|
def forward(self, x: torch.Tensor) -> torch.Tensor:
|
|
x = x.repeat_interleave(2, dim=2).repeat_interleave(2, dim=3)
|
|
return self.conv(x)
|
|
|
|
|
|
class Downsample(nn.Module):
|
|
def __init__(self, in_channels: int):
|
|
super().__init__()
|
|
self.conv = nn.Conv2d(
|
|
in_channels, in_channels, kernel_size=3, stride=2, padding=0
|
|
)
|
|
|
|
def forward(self, x: torch.Tensor) -> torch.Tensor:
|
|
pad = (0, 1, 0, 1)
|
|
x = F.pad(x, pad, mode="constant", value=0)
|
|
return self.conv(x)
|
|
|
|
|
|
class ResnetBlock(nn.Module):
|
|
def __init__(
|
|
self,
|
|
*,
|
|
in_channels: int,
|
|
out_channels: int = None,
|
|
dropout: float,
|
|
**kwargs,
|
|
):
|
|
super().__init__()
|
|
self.in_channels = in_channels
|
|
out_channels = in_channels if out_channels is None else out_channels
|
|
|
|
self.norm1 = Normalize(in_channels)
|
|
self.conv1 = nn.Conv2d(
|
|
in_channels, out_channels, kernel_size=3, stride=1, padding=1
|
|
)
|
|
self.norm2 = Normalize(out_channels)
|
|
self.dropout = nn.Dropout(dropout)
|
|
self.conv2 = nn.Conv2d(
|
|
out_channels, out_channels, kernel_size=3, stride=1, padding=1
|
|
)
|
|
self.nin_shortcut = (
|
|
nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=1, padding=0)
|
|
if in_channels != out_channels
|
|
else nn.Identity()
|
|
)
|
|
|
|
def forward(self, x: torch.Tensor) -> torch.Tensor:
|
|
h = x
|
|
h = self.norm1(h)
|
|
h = nonlinearity(h)
|
|
h = self.conv1(h)
|
|
|
|
h = self.norm2(h)
|
|
h = nonlinearity(h)
|
|
h = self.dropout(h)
|
|
h = self.conv2(h)
|
|
|
|
x = self.nin_shortcut(x)
|
|
|
|
return x + h
|
|
|
|
|
|
class AttnBlock(nn.Module):
|
|
def __init__(self, in_channels: int):
|
|
super().__init__()
|
|
|
|
self.norm = Normalize(in_channels)
|
|
self.q = nn.Conv2d(in_channels, in_channels, kernel_size=1, stride=1, padding=0)
|
|
self.k = nn.Conv2d(in_channels, in_channels, kernel_size=1, stride=1, padding=0)
|
|
self.v = nn.Conv2d(in_channels, in_channels, kernel_size=1, stride=1, padding=0)
|
|
self.proj_out = nn.Conv2d(
|
|
in_channels, in_channels, kernel_size=1, stride=1, padding=0
|
|
)
|
|
|
|
def forward(self, x: torch.Tensor) -> torch.Tensor:
|
|
# TODO (freda): Consider reusing implementations in Attn `imaginaire`,
|
|
# since than one is gonna be based on TransformerEngine's attn op,
|
|
# w/c could ease CP implementations.
|
|
h_ = x
|
|
h_ = self.norm(h_)
|
|
q = self.q(h_)
|
|
k = self.k(h_)
|
|
v = self.v(h_)
|
|
|
|
# compute attention
|
|
b, c, h, w = q.shape
|
|
q = q.reshape(b, c, h * w)
|
|
q = q.permute(0, 2, 1)
|
|
k = k.reshape(b, c, h * w)
|
|
w_ = torch.bmm(q, k)
|
|
w_ = w_ * (int(c) ** (-0.5))
|
|
w_ = F.softmax(w_, dim=2)
|
|
|
|
# attend to values
|
|
v = v.reshape(b, c, h * w)
|
|
w_ = w_.permute(0, 2, 1)
|
|
h_ = torch.bmm(v, w_)
|
|
h_ = h_.reshape(b, c, h, w)
|
|
|
|
h_ = self.proj_out(h_)
|
|
|
|
return x + h_
|
|
|
|
|
|
class Encoder(nn.Module):
|
|
def __init__(
|
|
self,
|
|
in_channels: int,
|
|
channels: int,
|
|
channels_mult: list[int],
|
|
num_res_blocks: int,
|
|
attn_resolutions: list[int],
|
|
dropout: float,
|
|
resolution: int,
|
|
z_channels: int,
|
|
spatial_compression: int,
|
|
**ignore_kwargs,
|
|
):
|
|
super().__init__()
|
|
self.num_resolutions = len(channels_mult)
|
|
self.num_res_blocks = num_res_blocks
|
|
|
|
# Patcher.
|
|
patch_size = ignore_kwargs.get("patch_size", 1)
|
|
self.patcher = Patcher(
|
|
patch_size, ignore_kwargs.get("patch_method", "rearrange")
|
|
)
|
|
in_channels = in_channels * patch_size * patch_size
|
|
|
|
# calculate the number of downsample operations
|
|
self.num_downsamples = int(math.log2(spatial_compression)) - int(
|
|
math.log2(patch_size)
|
|
)
|
|
assert (
|
|
self.num_downsamples <= self.num_resolutions
|
|
), f"we can only downsample {self.num_resolutions} times at most"
|
|
|
|
# downsampling
|
|
self.conv_in = torch.nn.Conv2d(
|
|
in_channels, channels, kernel_size=3, stride=1, padding=1
|
|
)
|
|
|
|
curr_res = resolution // patch_size
|
|
in_ch_mult = (1,) + tuple(channels_mult)
|
|
self.in_ch_mult = in_ch_mult
|
|
self.down = nn.ModuleList()
|
|
for i_level in range(self.num_resolutions):
|
|
block = nn.ModuleList()
|
|
attn = nn.ModuleList()
|
|
block_in = channels * in_ch_mult[i_level]
|
|
block_out = channels * channels_mult[i_level]
|
|
for _ in range(self.num_res_blocks):
|
|
block.append(
|
|
ResnetBlock(
|
|
in_channels=block_in,
|
|
out_channels=block_out,
|
|
dropout=dropout,
|
|
)
|
|
)
|
|
block_in = block_out
|
|
if curr_res in attn_resolutions:
|
|
attn.append(AttnBlock(block_in))
|
|
down = nn.Module()
|
|
down.block = block
|
|
down.attn = attn
|
|
if i_level < self.num_downsamples:
|
|
down.downsample = Downsample(block_in)
|
|
curr_res = curr_res // 2
|
|
self.down.append(down)
|
|
|
|
# middle
|
|
self.mid = nn.Module()
|
|
self.mid.block_1 = ResnetBlock(
|
|
in_channels=block_in, out_channels=block_in, dropout=dropout
|
|
)
|
|
self.mid.attn_1 = AttnBlock(block_in)
|
|
self.mid.block_2 = ResnetBlock(
|
|
in_channels=block_in, out_channels=block_in, dropout=dropout
|
|
)
|
|
|
|
# end
|
|
self.norm_out = Normalize(block_in)
|
|
self.conv_out = torch.nn.Conv2d(
|
|
block_in, z_channels, kernel_size=3, stride=1, padding=1
|
|
)
|
|
|
|
def forward(self, x: torch.Tensor) -> torch.Tensor:
|
|
x = self.patcher(x)
|
|
|
|
# downsampling
|
|
hs = [self.conv_in(x)]
|
|
for i_level in range(self.num_resolutions):
|
|
for i_block in range(self.num_res_blocks):
|
|
h = self.down[i_level].block[i_block](hs[-1])
|
|
if len(self.down[i_level].attn) > 0:
|
|
h = self.down[i_level].attn[i_block](h)
|
|
hs.append(h)
|
|
if i_level < self.num_downsamples:
|
|
hs.append(self.down[i_level].downsample(hs[-1]))
|
|
|
|
# middle
|
|
h = hs[-1]
|
|
h = self.mid.block_1(h)
|
|
h = self.mid.attn_1(h)
|
|
h = self.mid.block_2(h)
|
|
|
|
# end
|
|
h = self.norm_out(h)
|
|
h = nonlinearity(h)
|
|
h = self.conv_out(h)
|
|
return h
|
|
|
|
|
|
class Decoder(nn.Module):
|
|
def __init__(
|
|
self,
|
|
out_channels: int,
|
|
channels: int,
|
|
channels_mult: list[int],
|
|
num_res_blocks: int,
|
|
attn_resolutions: int,
|
|
dropout: float,
|
|
resolution: int,
|
|
z_channels: int,
|
|
spatial_compression: int,
|
|
**ignore_kwargs,
|
|
):
|
|
super().__init__()
|
|
self.num_resolutions = len(channels_mult)
|
|
self.num_res_blocks = num_res_blocks
|
|
|
|
# UnPatcher.
|
|
patch_size = ignore_kwargs.get("patch_size", 1)
|
|
self.unpatcher = UnPatcher(
|
|
patch_size, ignore_kwargs.get("patch_method", "rearrange")
|
|
)
|
|
out_ch = out_channels * patch_size * patch_size
|
|
|
|
# calculate the number of upsample operations
|
|
self.num_upsamples = int(math.log2(spatial_compression)) - int(
|
|
math.log2(patch_size)
|
|
)
|
|
assert (
|
|
self.num_upsamples <= self.num_resolutions
|
|
), f"we can only upsample {self.num_resolutions} times at most"
|
|
|
|
block_in = channels * channels_mult[self.num_resolutions - 1]
|
|
curr_res = (resolution // patch_size) // 2 ** (self.num_resolutions - 1)
|
|
self.z_shape = (1, z_channels, curr_res, curr_res)
|
|
logging.info(
|
|
"Working with z of shape {} = {} dimensions.".format(
|
|
self.z_shape, np.prod(self.z_shape)
|
|
)
|
|
)
|
|
|
|
# z to block_in
|
|
self.conv_in = torch.nn.Conv2d(
|
|
z_channels, block_in, kernel_size=3, stride=1, padding=1
|
|
)
|
|
|
|
# middle
|
|
self.mid = nn.Module()
|
|
self.mid.block_1 = ResnetBlock(
|
|
in_channels=block_in, out_channels=block_in, dropout=dropout
|
|
)
|
|
self.mid.attn_1 = AttnBlock(block_in)
|
|
self.mid.block_2 = ResnetBlock(
|
|
in_channels=block_in, out_channels=block_in, dropout=dropout
|
|
)
|
|
|
|
# upsampling
|
|
self.up = nn.ModuleList()
|
|
for i_level in reversed(range(self.num_resolutions)):
|
|
block = nn.ModuleList()
|
|
attn = nn.ModuleList()
|
|
block_out = channels * channels_mult[i_level]
|
|
for _ in range(self.num_res_blocks + 1):
|
|
block.append(
|
|
ResnetBlock(
|
|
in_channels=block_in,
|
|
out_channels=block_out,
|
|
dropout=dropout,
|
|
)
|
|
)
|
|
block_in = block_out
|
|
if curr_res in attn_resolutions:
|
|
attn.append(AttnBlock(block_in))
|
|
up = nn.Module()
|
|
up.block = block
|
|
up.attn = attn
|
|
if i_level >= (self.num_resolutions - self.num_upsamples):
|
|
up.upsample = Upsample(block_in)
|
|
curr_res = curr_res * 2
|
|
self.up.insert(0, up)
|
|
|
|
# end
|
|
self.norm_out = Normalize(block_in)
|
|
self.conv_out = torch.nn.Conv2d(
|
|
block_in, out_ch, kernel_size=3, stride=1, padding=1
|
|
)
|
|
|
|
def forward(self, z: torch.Tensor) -> torch.Tensor:
|
|
h = self.conv_in(z)
|
|
|
|
# middle
|
|
h = self.mid.block_1(h)
|
|
h = self.mid.attn_1(h)
|
|
h = self.mid.block_2(h)
|
|
|
|
# upsampling
|
|
for i_level in reversed(range(self.num_resolutions)):
|
|
for i_block in range(self.num_res_blocks + 1):
|
|
h = self.up[i_level].block[i_block](h)
|
|
if len(self.up[i_level].attn) > 0:
|
|
h = self.up[i_level].attn[i_block](h)
|
|
if i_level >= (self.num_resolutions - self.num_upsamples):
|
|
h = self.up[i_level].upsample(h)
|
|
|
|
h = self.norm_out(h)
|
|
h = nonlinearity(h)
|
|
h = self.conv_out(h)
|
|
h = self.unpatcher(h)
|
|
return h
|