File size: 17,629 Bytes
c0bba28 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 | from typing import Optional
import torch
import torch.distributed
import torch.nn as nn
from diffusers.utils import deprecate
from diffusers.models.resnet import ResnetBlock2D
from diffusers.models.activations import get_activation
from diffusers.models.normalization import AdaGroupNorm
from diffusers.models.attention_processor import SpatialNorm
from diffusers.models.downsampling import Downsample2D
from diffusers.models.upsampling import Upsample2D
from distvae.modules.adapters.layers.norm_adapters import GroupNormAdapter
from distvae.modules.adapters.layers.conv_adapters import Conv2dAdapter
# class ResnetBlockCondNorm2D(nn.Module):
# r"""
# A Resnet block that use normalization layer that incorporate conditioning information.
# Parameters:
# in_channels (`int`): The number of channels in the input.
# out_channels (`int`, *optional*, default to be `None`):
# The number of output channels for the first conv2d layer. If None, same as `in_channels`.
# dropout (`float`, *optional*, defaults to `0.0`): The dropout probability to use.
# temb_channels (`int`, *optional*, default to `512`): the number of channels in timestep embedding.
# groups (`int`, *optional*, default to `32`): The number of groups to use for the first normalization layer.
# groups_out (`int`, *optional*, default to None):
# The number of groups to use for the second normalization layer. if set to None, same as `groups`.
# eps (`float`, *optional*, defaults to `1e-6`): The epsilon to use for the normalization.
# non_linearity (`str`, *optional*, default to `"swish"`): the activation function to use.
# time_embedding_norm (`str`, *optional*, default to `"ada_group"` ):
# The normalization layer for time embedding `temb`. Currently only support "ada_group" or "spatial".
# kernel (`torch.FloatTensor`, optional, default to None): FIR filter, see
# [`~models.resnet.FirUpsample2D`] and [`~models.resnet.FirDownsample2D`].
# output_scale_factor (`float`, *optional*, default to be `1.0`): the scale factor to use for the output.
# use_in_shortcut (`bool`, *optional*, default to `True`):
# If `True`, add a 1x1 nn.conv2d layer for skip-connection.
# up (`bool`, *optional*, default to `False`): If `True`, add an upsample layer.
# down (`bool`, *optional*, default to `False`): If `True`, add a downsample layer.
# conv_shortcut_bias (`bool`, *optional*, default to `True`): If `True`, adds a learnable bias to the
# `conv_shortcut` output.
# conv_2d_out_channels (`int`, *optional*, default to `None`): the number of channels in the output.
# If None, same as `out_channels`.
# """
# def __init__(
# self,
# *,
# in_channels: int,
# out_channels: Optional[int] = None,
# conv_shortcut: bool = False,
# dropout: float = 0.0,
# temb_channels: int = 512,
# groups: int = 32,
# groups_out: Optional[int] = None,
# eps: float = 1e-6,
# non_linearity: str = "swish",
# time_embedding_norm: str = "ada_group", # ada_group, spatial
# output_scale_factor: float = 1.0,
# use_in_shortcut: Optional[bool] = None,
# up: bool = False,
# down: bool = False,
# conv_shortcut_bias: bool = True,
# conv_2d_out_channels: Optional[int] = None,
# ):
# 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.up = up
# self.down = down
# self.output_scale_factor = output_scale_factor
# self.time_embedding_norm = time_embedding_norm
# conv_cls = nn.Conv2d
# if groups_out is None:
# groups_out = groups
# if self.time_embedding_norm == "ada_group": # ada_group
# self.norm1 = AdaGroupNorm(temb_channels, in_channels, groups, eps=eps)
# elif self.time_embedding_norm == "spatial":
# self.norm1 = SpatialNorm(in_channels, temb_channels)
# else:
# raise ValueError(f" unsupported time_embedding_norm: {self.time_embedding_norm}")
# self.conv1 = conv_cls(in_channels, out_channels, kernel_size=3, stride=1, padding=1)
# if self.time_embedding_norm == "ada_group": # ada_group
# self.norm2 = AdaGroupNorm(temb_channels, out_channels, groups_out, eps=eps)
# elif self.time_embedding_norm == "spatial": # spatial
# self.norm2 = SpatialNorm(out_channels, temb_channels)
# else:
# raise ValueError(f" unsupported time_embedding_norm: {self.time_embedding_norm}")
# self.dropout = torch.nn.Dropout(dropout)
# conv_2d_out_channels = conv_2d_out_channels or out_channels
# self.conv2 = conv_cls(out_channels, conv_2d_out_channels, kernel_size=3, stride=1, padding=1)
# self.nonlinearity = get_activation(non_linearity)
# self.upsample = self.downsample = None
# if self.up:
# self.upsample = Upsample2D(in_channels, use_conv=False)
# elif self.down:
# self.downsample = Downsample2D(in_channels, use_conv=False, padding=1, name="op")
# self.use_in_shortcut = self.in_channels != conv_2d_out_channels if use_in_shortcut is None else use_in_shortcut
# self.conv_shortcut = None
# if self.use_in_shortcut:
# self.conv_shortcut = conv_cls(
# in_channels,
# conv_2d_out_channels,
# kernel_size=1,
# stride=1,
# padding=0,
# bias=conv_shortcut_bias,
# )
# def forward(self, input_tensor: torch.FloatTensor, temb: torch.FloatTensor, *args, **kwargs) -> torch.FloatTensor:
# if len(args) > 0 or kwargs.get("scale", None) is not None:
# deprecation_message = "The `scale` argument is deprecated and will be ignored. Please remove it, as passing it will raise an error in the future. `scale` should directly be passed while calling the underlying pipeline component i.e., via `cross_attention_kwargs`."
# deprecate("scale", "1.0.0", deprecation_message)
# hidden_states = input_tensor
# hidden_states = self.norm1(hidden_states, temb)
# hidden_states = self.nonlinearity(hidden_states)
# if self.upsample is not None:
# # upsample_nearest_nhwc fails with large batch sizes. see https://github.com/huggingface/diffusers/issues/984
# if hidden_states.shape[0] >= 64:
# input_tensor = input_tensor.contiguous()
# hidden_states = hidden_states.contiguous()
# input_tensor = self.upsample(input_tensor)
# hidden_states = self.upsample(hidden_states)
# elif self.downsample is not None:
# input_tensor = self.downsample(input_tensor)
# hidden_states = self.downsample(hidden_states)
# hidden_states = self.conv1(hidden_states)
# hidden_states = self.norm2(hidden_states, temb)
# hidden_states = self.nonlinearity(hidden_states)
# hidden_states = self.dropout(hidden_states)
# hidden_states = self.conv2(hidden_states)
# if self.conv_shortcut is not None:
# input_tensor = self.conv_shortcut(input_tensor)
# output_tensor = (input_tensor + hidden_states) / self.output_scale_factor
# return output_tensor
class PatchResnetBlock2D(nn.Module):
r"""
A Resnet block.
Parameters:
in_channels (`int`): The number of channels in the input.
out_channels (`int`, *optional*, default to be `None`):
The number of output channels for the first conv2d layer. If None, same as `in_channels`.
dropout (`float`, *optional*, defaults to `0.0`): The dropout probability to use.
temb_channels (`int`, *optional*, default to `512`): the number of channels in timestep embedding.
groups (`int`, *optional*, default to `32`): The number of groups to use for the first normalization layer.
groups_out (`int`, *optional*, default to None):
The number of groups to use for the second normalization layer. if set to None, same as `groups`.
eps (`float`, *optional*, defaults to `1e-6`): The epsilon to use for the normalization.
non_linearity (`str`, *optional*, default to `"swish"`): the activation function to use.
time_embedding_norm (`str`, *optional*, default to `"default"` ): Time scale shift config.
By default, apply timestep embedding conditioning with a simple shift mechanism. Choose "scale_shift"
for a stronger conditioning with scale and shift.
kernel (`torch.FloatTensor`, optional, default to None): FIR filter, see
[`~models.resnet.FirUpsample2D`] and [`~models.resnet.FirDownsample2D`].
output_scale_factor (`float`, *optional*, default to be `1.0`): the scale factor to use for the output.
use_in_shortcut (`bool`, *optional*, default to `True`):
If `True`, add a 1x1 nn.conv2d layer for skip-connection.
up (`bool`, *optional*, default to `False`): If `True`, add an upsample layer.
down (`bool`, *optional*, default to `False`): If `True`, add a downsample layer.
conv_shortcut_bias (`bool`, *optional*, default to `True`): If `True`, adds a learnable bias to the
`conv_shortcut` output.
conv_2d_out_channels (`int`, *optional*, default to `None`): the number of channels in the output.
If None, same as `out_channels`.
"""
def __init__(
self,
*,
in_channels: int,
out_channels: Optional[int] = None,
conv_shortcut: bool = False,
dropout: float = 0.0,
temb_channels: int = 512,
groups: int = 32,
groups_out: Optional[int] = None,
pre_norm: bool = True,
eps: float = 1e-6,
non_linearity: str = "swish",
skip_time_act: bool = False,
time_embedding_norm: str = "default", # default, scale_shift,
kernel: Optional[torch.FloatTensor] = None,
output_scale_factor: float = 1.0,
use_in_shortcut: Optional[bool] = None,
up: bool = False,
down: bool = False,
conv_shortcut_bias: bool = True,
conv_2d_out_channels: Optional[int] = None,
conv_block_size = 0,
):
assert temb_channels is None, "temb_channels is not supported currently."
assert up is False, "Upsampling is not supported currently."
assert down is False, "Downsampling is not supported currently."
super().__init__()
if time_embedding_norm == "ada_group":
raise ValueError(
"This class cannot be used with `time_embedding_norm==ada_group`, please use `ResnetBlockCondNorm2D` instead",
)
if time_embedding_norm == "spatial":
raise ValueError(
"This class cannot be used with `time_embedding_norm==spatial`, please use `ResnetBlockCondNorm2D` instead",
)
self.pre_norm = True
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.up = up
self.down = down
self.output_scale_factor = output_scale_factor
self.time_embedding_norm = time_embedding_norm
self.skip_time_act = skip_time_act
linear_cls = nn.Linear
conv_cls = nn.Conv2d
if groups_out is None:
groups_out = groups
self.norm1 = GroupNormAdapter(torch.nn.GroupNorm(num_groups=groups, num_channels=in_channels, eps=eps, affine=True))
self.conv1 = Conv2dAdapter(conv_cls(in_channels, out_channels, kernel_size=3, stride=1, padding=1), block_size=conv_block_size)
#TODO: Add support for temb_channels
assert temb_channels is None, "temb_channels is not supported currently."
self.time_emb_proj = None
# if temb_channels is not None:
# if self.time_embedding_norm == "default":
# self.time_emb_proj = linear_cls(temb_channels, out_channels)
# elif self.time_embedding_norm == "scale_shift":
# self.time_emb_proj = linear_cls(temb_channels, 2 * out_channels)
# else:
# raise ValueError(f"unknown time_embedding_norm : {self.time_embedding_norm} ")
# else:
# self.time_emb_proj = None
self.norm2 = GroupNormAdapter(torch.nn.GroupNorm(num_groups=groups_out, num_channels=out_channels, eps=eps, affine=True))
self.dropout = torch.nn.Dropout(dropout)
conv_2d_out_channels = conv_2d_out_channels or out_channels
self.conv2 = Conv2dAdapter(conv_cls(out_channels, conv_2d_out_channels, kernel_size=3, stride=1, padding=1), block_size=conv_block_size)
self.nonlinearity = get_activation(non_linearity)
self.upsample = self.downsample = None
#TODO: Add support for upsample and downsample
assert self.up is False, "Upsampling is not supported currently."
assert self.down is False, "Downsampling is not supported currently."
# if self.up:
# if kernel == "fir":
# fir_kernel = (1, 3, 3, 1)
# self.upsample = lambda x: upsample_2d(x, kernel=fir_kernel)
# elif kernel == "sde_vp":
# self.upsample = partial(F.interpolate, scale_factor=2.0, mode="nearest")
# else:
# self.upsample = Upsample2D(in_channels, use_conv=False)
# elif self.down:
# if kernel == "fir":
# fir_kernel = (1, 3, 3, 1)
# self.downsample = lambda x: downsample_2d(x, kernel=fir_kernel)
# elif kernel == "sde_vp":
# self.downsample = partial(F.avg_pool2d, kernel_size=2, stride=2)
# else:
# self.downsample = Downsample2D(in_channels, use_conv=False, padding=1, name="op")
self.use_in_shortcut = self.in_channels != conv_2d_out_channels if use_in_shortcut is None else use_in_shortcut
self.conv_shortcut = None
if self.use_in_shortcut:
self.conv_shortcut = Conv2dAdapter(
conv_cls(
in_channels,
conv_2d_out_channels,
kernel_size=1,
stride=1,
padding=0,
bias=conv_shortcut_bias,
),
block_size=conv_block_size
)
def forward(self, input_tensor: torch.FloatTensor, temb: torch.FloatTensor, *args, **kwargs) -> torch.FloatTensor:
#TODO: Add support for temb
assert temb is None, "temb is not supported currently."
if len(args) > 0 or kwargs.get("scale", None) is not None:
deprecation_message = "The `scale` argument is deprecated and will be ignored. Please remove it, as passing it will raise an error in the future. `scale` should directly be passed while calling the underlying pipeline component i.e., via `cross_attention_kwargs`."
deprecate("scale", "1.0.0", deprecation_message)
hidden_states = input_tensor
hidden_states = self.norm1(hidden_states)
hidden_states = self.nonlinearity(hidden_states)
if self.upsample is not None:
# upsample_nearest_nhwc fails with large batch sizes. see https://github.com/huggingface/diffusers/issues/984
if hidden_states.shape[0] >= 64:
input_tensor = input_tensor.contiguous()
hidden_states = hidden_states.contiguous()
input_tensor = self.upsample(input_tensor)
hidden_states = self.upsample(hidden_states)
elif self.downsample is not None:
input_tensor = self.downsample(input_tensor)
hidden_states = self.downsample(hidden_states)
hidden_states = self.conv1(hidden_states)
if self.time_emb_proj is not None:
if not self.skip_time_act:
temb = self.nonlinearity(temb)
temb = self.time_emb_proj(temb)[:, :, None, None]
if self.time_embedding_norm == "default":
if temb is not None:
hidden_states = hidden_states + temb
hidden_states = self.norm2(hidden_states)
elif self.time_embedding_norm == "scale_shift":
if temb is None:
raise ValueError(
f" `temb` should not be None when `time_embedding_norm` is {self.time_embedding_norm}"
)
time_scale, time_shift = torch.chunk(temb, 2, dim=1)
hidden_states = self.norm2(hidden_states)
hidden_states = hidden_states * (1 + time_scale) + time_shift
else:
hidden_states = self.norm2(hidden_states)
hidden_states = self.nonlinearity(hidden_states)
hidden_states = self.dropout(hidden_states)
hidden_states = self.conv2(hidden_states)
if self.conv_shortcut is not None:
input_tensor = self.conv_shortcut(input_tensor)
output_tensor = (input_tensor + hidden_states) / self.output_scale_factor
return output_tensor |