404 lines
12 KiB
Python
404 lines
12 KiB
Python
# Copyright (c) 2023 Amphion.
|
|
#
|
|
# This source code is licensed under the MIT license found in the
|
|
# LICENSE file in the root directory of this source tree.
|
|
|
|
import torch
|
|
import torch.nn as nn
|
|
import torch.nn.functional as F
|
|
|
|
from modules.distributions.distributions import DiagonalGaussianDistribution
|
|
|
|
|
|
def nonlinearity(x):
|
|
# swish
|
|
return x * torch.sigmoid(x)
|
|
|
|
|
|
def Normalize(in_channels):
|
|
return torch.nn.GroupNorm(
|
|
num_groups=32, num_channels=in_channels, eps=1e-6, affine=True
|
|
)
|
|
|
|
|
|
class Upsample2d(nn.Module):
|
|
def __init__(self, in_channels, with_conv):
|
|
super().__init__()
|
|
self.with_conv = with_conv
|
|
if self.with_conv:
|
|
self.conv = torch.nn.Conv2d(
|
|
in_channels, in_channels, kernel_size=3, stride=1, padding=1
|
|
)
|
|
|
|
def forward(self, x):
|
|
x = torch.nn.functional.interpolate(x, scale_factor=2.0, mode="nearest")
|
|
if self.with_conv:
|
|
x = self.conv(x)
|
|
return x
|
|
|
|
|
|
class Upsample1d(Upsample2d):
|
|
def __init__(self, in_channels, with_conv):
|
|
super().__init__(in_channels, with_conv)
|
|
if self.with_conv:
|
|
self.conv = torch.nn.Conv1d(
|
|
in_channels, in_channels, kernel_size=3, stride=1, padding=1
|
|
)
|
|
|
|
|
|
class Downsample2d(nn.Module):
|
|
def __init__(self, in_channels, with_conv):
|
|
super().__init__()
|
|
self.with_conv = with_conv
|
|
if self.with_conv:
|
|
# no asymmetric padding in torch conv, must do it ourselves
|
|
self.conv = torch.nn.Conv2d(
|
|
in_channels, in_channels, kernel_size=3, stride=2, padding=0
|
|
)
|
|
self.pad = (0, 1, 0, 1)
|
|
else:
|
|
self.avg_pool = nn.AvgPool2d(kernel_size=2, stride=2)
|
|
|
|
def forward(self, x):
|
|
if self.with_conv: # bp: check self.avgpool and self.pad
|
|
x = torch.nn.functional.pad(x, self.pad, mode="constant", value=0)
|
|
x = self.conv(x)
|
|
else:
|
|
x = self.avg_pool(x)
|
|
return x
|
|
|
|
|
|
class Downsample1d(Downsample2d):
|
|
def __init__(self, in_channels, with_conv):
|
|
super().__init__(in_channels, with_conv)
|
|
if self.with_conv:
|
|
# no asymmetric padding in torch conv, must do it ourselves
|
|
# TODO: can we replace it just with conv2d with padding 1?
|
|
self.conv = torch.nn.Conv1d(
|
|
in_channels, in_channels, kernel_size=3, stride=2, padding=0
|
|
)
|
|
self.pad = (1, 1)
|
|
else:
|
|
self.avg_pool = nn.AvgPool1d(kernel_size=2, stride=2)
|
|
|
|
|
|
class ResnetBlock(nn.Module):
|
|
def __init__(self, *, in_channels, out_channels=None, conv_shortcut=False, dropout):
|
|
super().__init__()
|
|
self.in_channels = in_channels
|
|
out_channels = in_channels if out_channels is None else out_channels
|
|
self.out_channels = out_channels
|
|
self.use_conv_shortcut = conv_shortcut
|
|
|
|
self.norm1 = Normalize(in_channels)
|
|
self.conv1 = torch.nn.Conv2d(
|
|
in_channels, out_channels, kernel_size=3, stride=1, padding=1
|
|
)
|
|
|
|
self.norm2 = Normalize(out_channels)
|
|
self.dropout = torch.nn.Dropout(dropout)
|
|
self.conv2 = torch.nn.Conv2d(
|
|
out_channels, out_channels, kernel_size=3, stride=1, padding=1
|
|
)
|
|
if self.in_channels != self.out_channels:
|
|
if self.use_conv_shortcut:
|
|
self.conv_shortcut = torch.nn.Conv2d(
|
|
in_channels, out_channels, kernel_size=3, stride=1, padding=1
|
|
)
|
|
else:
|
|
self.nin_shortcut = torch.nn.Conv2d(
|
|
in_channels, out_channels, kernel_size=1, stride=1, padding=0
|
|
)
|
|
|
|
def forward(self, x):
|
|
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)
|
|
|
|
if self.in_channels != self.out_channels:
|
|
if self.use_conv_shortcut:
|
|
x = self.conv_shortcut(x)
|
|
else:
|
|
x = self.nin_shortcut(x)
|
|
|
|
return x + h
|
|
|
|
|
|
class ResnetBlock1d(ResnetBlock):
|
|
def __init__(
|
|
self,
|
|
*,
|
|
in_channels,
|
|
out_channels=None,
|
|
conv_shortcut=False,
|
|
dropout,
|
|
temb_channels=512
|
|
):
|
|
super().__init__(
|
|
in_channels=in_channels,
|
|
out_channels=out_channels,
|
|
conv_shortcut=conv_shortcut,
|
|
dropout=dropout,
|
|
)
|
|
|
|
self.conv1 = torch.nn.Conv1d(
|
|
in_channels, out_channels, kernel_size=3, stride=1, padding=1
|
|
)
|
|
self.conv2 = torch.nn.Conv1d(
|
|
out_channels, out_channels, kernel_size=3, stride=1, padding=1
|
|
)
|
|
if self.in_channels != self.out_channels:
|
|
if self.use_conv_shortcut:
|
|
self.conv_shortcut = torch.nn.Conv1d(
|
|
in_channels, out_channels, kernel_size=3, stride=1, padding=1
|
|
)
|
|
else:
|
|
self.nin_shortcut = torch.nn.Conv1d(
|
|
in_channels, out_channels, kernel_size=1, stride=1, padding=0
|
|
)
|
|
|
|
|
|
class Encoder2d(nn.Module):
|
|
def __init__(
|
|
self,
|
|
*,
|
|
ch,
|
|
ch_mult=(1, 2, 4, 8),
|
|
num_res_blocks,
|
|
dropout=0.0,
|
|
resamp_with_conv=True,
|
|
in_channels,
|
|
z_channels,
|
|
double_z=True,
|
|
**ignore_kwargs
|
|
):
|
|
super().__init__()
|
|
self.ch = ch
|
|
self.num_resolutions = len(ch_mult)
|
|
self.num_res_blocks = num_res_blocks
|
|
self.in_channels = in_channels
|
|
|
|
# downsampling
|
|
self.conv_in = torch.nn.Conv2d(
|
|
in_channels, self.ch, kernel_size=3, stride=1, padding=1
|
|
)
|
|
|
|
in_ch_mult = (1,) + tuple(ch_mult)
|
|
self.down = nn.ModuleList()
|
|
for i_level in range(self.num_resolutions):
|
|
block = nn.ModuleList()
|
|
block_in = ch * in_ch_mult[i_level]
|
|
block_out = ch * ch_mult[i_level]
|
|
for i_block in range(self.num_res_blocks):
|
|
block.append(
|
|
ResnetBlock(
|
|
in_channels=block_in, out_channels=block_out, dropout=dropout
|
|
)
|
|
)
|
|
block_in = block_out
|
|
down = nn.Module()
|
|
down.block = block
|
|
if i_level != self.num_resolutions - 1:
|
|
down.downsample = Downsample2d(block_in, resamp_with_conv)
|
|
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.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,
|
|
2 * z_channels if double_z else z_channels,
|
|
kernel_size=3,
|
|
stride=1,
|
|
padding=1,
|
|
)
|
|
|
|
def forward(self, 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])
|
|
hs.append(h)
|
|
if i_level != self.num_resolutions - 1:
|
|
hs.append(self.down[i_level].downsample(hs[-1]))
|
|
|
|
# middle
|
|
h = hs[-1]
|
|
h = self.mid.block_1(h)
|
|
h = self.mid.block_2(h)
|
|
|
|
# end
|
|
h = self.norm_out(h)
|
|
h = nonlinearity(h)
|
|
h = self.conv_out(h)
|
|
return h
|
|
|
|
|
|
# TODO: Encoder1d
|
|
class Encoder1d(Encoder2d): ...
|
|
|
|
|
|
class Decoder2d(nn.Module):
|
|
def __init__(
|
|
self,
|
|
*,
|
|
ch,
|
|
out_ch,
|
|
ch_mult=(1, 2, 4, 8),
|
|
num_res_blocks,
|
|
dropout=0.0,
|
|
resamp_with_conv=True,
|
|
in_channels,
|
|
z_channels,
|
|
give_pre_end=False,
|
|
**ignorekwargs
|
|
):
|
|
super().__init__()
|
|
self.ch = ch
|
|
self.num_resolutions = len(ch_mult)
|
|
self.num_res_blocks = num_res_blocks
|
|
self.in_channels = in_channels
|
|
self.give_pre_end = give_pre_end
|
|
|
|
# compute in_ch_mult, block_in and curr_res at lowest res
|
|
in_ch_mult = (1,) + tuple(ch_mult)
|
|
block_in = ch * ch_mult[self.num_resolutions - 1]
|
|
# self.z_shape = (1,z_channels,curr_res,curr_res)
|
|
# print("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.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 = ch * ch_mult[i_level]
|
|
for i_block in range(self.num_res_blocks + 1):
|
|
block.append(
|
|
ResnetBlock(
|
|
in_channels=block_in, out_channels=block_out, dropout=dropout
|
|
)
|
|
)
|
|
block_in = block_out
|
|
up = nn.Module()
|
|
up.block = block
|
|
up.attn = attn
|
|
if i_level != 0:
|
|
up.upsample = Upsample2d(block_in, resamp_with_conv)
|
|
self.up.insert(0, up) # prepend to get consistent order
|
|
|
|
# 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):
|
|
self.last_z_shape = z.shape
|
|
|
|
# z to block_in
|
|
h = self.conv_in(z)
|
|
|
|
# middle
|
|
h = self.mid.block_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 i_level != 0:
|
|
h = self.up[i_level].upsample(h)
|
|
|
|
# end
|
|
if self.give_pre_end:
|
|
return h
|
|
|
|
h = self.norm_out(h)
|
|
h = nonlinearity(h)
|
|
h = self.conv_out(h)
|
|
return h
|
|
|
|
|
|
# TODO: decoder1d
|
|
class Decoder1d(Decoder2d): ...
|
|
|
|
|
|
class AutoencoderKL(nn.Module):
|
|
def __init__(self, cfg):
|
|
super().__init__()
|
|
self.cfg = cfg
|
|
self.encoder = Encoder2d(
|
|
ch=cfg.ch,
|
|
ch_mult=cfg.ch_mult,
|
|
num_res_blocks=cfg.num_res_blocks,
|
|
in_channels=cfg.in_channels,
|
|
z_channels=cfg.z_channels,
|
|
double_z=cfg.double_z,
|
|
)
|
|
self.decoder = Decoder2d(
|
|
ch=cfg.ch,
|
|
ch_mult=cfg.ch_mult,
|
|
num_res_blocks=cfg.num_res_blocks,
|
|
out_ch=cfg.out_ch,
|
|
z_channels=cfg.z_channels,
|
|
in_channels=None,
|
|
)
|
|
assert self.cfg.double_z
|
|
|
|
self.quant_conv = torch.nn.Conv2d(2 * cfg.z_channels, 2 * cfg.z_channels, 1)
|
|
self.post_quant_conv = torch.nn.Conv2d(cfg.z_channels, cfg.z_channels, 1)
|
|
self.embed_dim = cfg.z_channels
|
|
|
|
def encode(self, x):
|
|
h = self.encoder(x)
|
|
moments = self.quant_conv(h)
|
|
posterior = DiagonalGaussianDistribution(moments)
|
|
return posterior
|
|
|
|
def decode(self, z):
|
|
z = self.post_quant_conv(z)
|
|
dec = self.decoder(z)
|
|
return dec
|
|
|
|
def forward(self, input, sample_posterior=True):
|
|
posterior = self.encode(input)
|
|
if sample_posterior:
|
|
z = posterior.sample()
|
|
else:
|
|
z = posterior.mode()
|
|
dec = self.decode(z)
|
|
return dec, posterior
|
|
|
|
def get_last_layer(self):
|
|
return self.decoder.conv_out.weight
|