| | import torch |
| | import math |
| | import torch.nn as nn |
| | import numpy as np |
| | import einops |
| |
|
| |
|
| | def return_time_sigma_embedding_model(embedding_type, time_embed_dim, device): |
| | ''' |
| | Method returns an embedding model given the chosen type |
| | ''' |
| | if embedding_type == 'GaussianFourier': |
| | return GaussianFourierEmbedding(time_embed_dim, device) |
| | elif embedding_type == 'Sinusoidal': |
| | return SinusoidalPosEmbedding(time_embed_dim, device) |
| | elif embedding_type == 'FourierFeatures': |
| | return FourierFeatures(time_embed_dim, device) |
| | else: |
| | raise ValueError('Embedding not avaiable, please chose an existing one!') |
| |
|
| |
|
| | class GaussianFourierProjection(nn.Module): |
| | """Gaussian random features for encoding time steps.""" |
| | def __init__(self, embed_dim, scale=30.): |
| | super().__init__() |
| | |
| | |
| | self.W = nn.Parameter(torch.randn(embed_dim // 2) * scale, requires_grad=False) |
| |
|
| | def forward(self, x): |
| | x_proj = x[:, None] * self.W[None, :] * 2 * np.pi |
| | return torch.cat([torch.sin(x_proj), torch.cos(x_proj)], dim=-1) |
| | |
| |
|
| | class FourierFeatures(nn.Module): |
| | def __init__(self, time_embed_dim, device, in_features=1, std=1.): |
| | super().__init__() |
| | self.device = device |
| | assert time_embed_dim % 2 == 0 |
| | self.register_buffer('weight', torch.randn([time_embed_dim // 2, in_features]) * std |
| | ) |
| |
|
| | def forward(self, input): |
| | if len(input.shape) == 1: |
| | input = einops.rearrange(input, 'b -> b 1') |
| | f = 2 * math.pi * input @ self.weight.T |
| | return torch.cat([f.cos(), f.sin()], dim=-1).to(self.device) |
| |
|
| |
|
| | class GaussianFourierEmbedding(nn.Module): |
| | |
| | def __init__(self, time_embed_dim, device): |
| | super().__init__() |
| | self.t_dim = time_embed_dim |
| | self.embed = nn.Sequential( |
| | GaussianFourierProjection(embed_dim=time_embed_dim), |
| | nn.Linear(time_embed_dim, 2*time_embed_dim), |
| | nn.Mish(), |
| | nn.Linear(2*time_embed_dim, time_embed_dim) |
| | ).to(device) |
| | |
| | def forward(self, t): |
| | return self.embed(t) |
| |
|
| |
|
| | class SinusoidalPosEmbedding(nn.Module): |
| | |
| | def __init__(self, time_embed_dim, device): |
| | super().__init__() |
| | self.device = device |
| | self.embed = nn.Sequential( |
| | SinusoidalPosEmb(time_embed_dim), |
| | nn.Linear(time_embed_dim, time_embed_dim * 2), |
| | nn.Mish(), |
| | nn.Linear(time_embed_dim * 2, time_embed_dim), |
| | ).to(self.device) |
| | |
| | def forward(self, t): |
| | return self.embed(t) |
| | |
| | |
| |
|
| | class PositionalEncoding(nn.Module): |
| | def __init__(self, d_model, dropout=0.1, max_len=5000): |
| | super(PositionalEncoding, self).__init__() |
| | self.dropout = nn.Dropout(p=dropout) |
| |
|
| | pe = torch.zeros(max_len, d_model) |
| | position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1) |
| | div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-np.log(10000.0) / d_model)) |
| | pe[:, 0::2] = torch.sin(position * div_term) |
| | pe[:, 1::2] = torch.cos(position * div_term) |
| | pe = pe.unsqueeze(0).transpose(0, 1) |
| |
|
| | self.register_buffer('pe', pe) |
| |
|
| | def forward(self, x): |
| | |
| | x = x + self.pe[:x.shape[0], :] |
| | return self.dropout(x) |
| | |
| |
|
| | class SinusoidalPosEmb(nn.Module): |
| | def __init__(self, dim): |
| | super().__init__() |
| | self.dim = dim |
| |
|
| | def forward(self, x): |
| | device = x.device |
| | half_dim = self.dim // 2 |
| | emb = math.log(10000) / (half_dim - 1) |
| | emb = torch.exp(torch.arange(half_dim, device=device) * -emb) |
| | emb = x[:, None] * emb[None, :] |
| | emb = torch.cat((emb.sin(), emb.cos()), dim=-1) |
| | return emb |
| |
|
| |
|
| | class InputEncoder(nn.Module): |
| | |
| | def __init__(self, input_dim, latent_dim): |
| | super().__init__() |
| | |
| | self.input_dim = input_dim |
| | self.latent_dim = latent_dim |
| | |
| | self.emb = nn.Linear(self.input_dim, self.latent_dim) |
| | |
| | def forward(self, x): |
| | return self.emb(x) |
| |
|
| |
|
| | class TEncoder(nn.Module): |
| | |
| | def __init__(self, input_dim, latent_dim): |
| | super().__init__() |
| | |
| | self.input_dim = input_dim |
| | self.latent_dim = latent_dim |
| | |
| | self.emb = nn.Linear(self.input_dim, self.latent_dim) |
| | |
| | def forward(self, x): |
| | return self.emb(x) |
| | |
| |
|
| | def append_dims(x, target_dims): |
| | """Appends dimensions to the end of a tensor until it has target_dims dimensions.""" |
| | dims_to_append = target_dims - x.ndim |
| | if dims_to_append < 0: |
| | raise ValueError(f'input has {x.ndim} dims but target_dims is {target_dims}, which is less') |
| | return x[(...,) + (None,) * dims_to_append] |
| |
|
| |
|
| | def rand_log_normal(shape, loc=0., scale=1., device='cpu', dtype=torch.float32): |
| | """Draws samples from a lognormal distribution.""" |
| | return (torch.randn(shape, device=device, dtype=dtype) * scale + loc).exp() |
| |
|
| |
|
| | def rand_log_logistic(shape, loc=0., scale=1., min_value=0., max_value=float('inf'), device='cpu', dtype=torch.float32): |
| | """Draws samples from an optionally truncated log-logistic distribution.""" |
| | min_value = torch.as_tensor(min_value, device=device, dtype=torch.float64) |
| | max_value = torch.as_tensor(max_value, device=device, dtype=torch.float64) |
| | min_cdf = min_value.log().sub(loc).div(scale).sigmoid() |
| | max_cdf = max_value.log().sub(loc).div(scale).sigmoid() |
| | u = torch.rand(shape, device=device, dtype=torch.float64) * (max_cdf - min_cdf) + min_cdf |
| | return u.logit().mul(scale).add(loc).exp().to(dtype) |
| |
|
| |
|
| | def rand_log_uniform(shape, min_value, max_value, device='cpu', dtype=torch.float32): |
| | """Draws samples from an log-uniform distribution.""" |
| | min_value = math.log(min_value) |
| | max_value = math.log(max_value) |
| | return (torch.rand(shape, device=device, dtype=dtype) * (max_value - min_value) + min_value).exp() |
| |
|
| |
|
| | def rand_v_diffusion(shape, sigma_data=1., min_value=0., max_value=float('inf'), device='cpu', dtype=torch.float32): |
| | """Draws samples from a truncated v-diffusion training timestep distribution.""" |
| | min_cdf = math.atan(min_value / sigma_data) * 2 / math.pi |
| | max_cdf = math.atan(max_value / sigma_data) * 2 / math.pi |
| | u = torch.rand(shape, device=device, dtype=dtype) * (max_cdf - min_cdf) + min_cdf |
| | return torch.tan(u * math.pi / 2) * sigma_data |
| |
|
| |
|
| | def rand_split_log_normal(shape, loc, scale_1, scale_2, device='cpu', dtype=torch.float32): |
| | """Draws samples from a split lognormal distribution.""" |
| | n = torch.randn(shape, device=device, dtype=dtype).abs() |
| | u = torch.rand(shape, device=device, dtype=dtype) |
| | n_left = n * -scale_1 + loc |
| | n_right = n * scale_2 + loc |
| | ratio = scale_1 / (scale_1 + scale_2) |
| | return torch.where(u < ratio, n_left, n_right).exp() |
| |
|
| | |
| | def rand_discrete(shape, values, device='cpu', dtype=torch.float32): |
| | """Draws samples from the given discrete values.""" |
| | indices = torch.randint(0, len(values), shape, device=device) |
| | samples = torch.index_select(values, 0, indices).to(dtype) |
| | return samples |
| |
|
| |
|
| | def rand_uniform(shape, min_value, max_value, device='cpu', dtype=torch.float32): |
| | """Draws samples from a uniform distribution.""" |
| | return torch.rand(shape, device=device, dtype=dtype) * (max_value - min_value) + min_value |
| |
|
