unet needs to be conditioned on log(snr) in p_mean_variance for continuous time gaussian diffusion

README.md

@@ -6,8 +6,6 @@ Implementation of <a href="https://arxiv.org/abs/2006.11239">Denoising Diffusion
 
 This implementation was transcribed from the official Tensorflow version <a href="https://github.com/hojonathanho/diffusion">here</a>
 
-<a href="https://huggingface.co/blog/annotated-diffusion">Annotated code</a> by Research Scientists / Engineers from <a href="https://huggingface.co/">🤗 Huggingface</a>
-
 <img src="./sample.png" width="500px"><img>
 
 [![PyPI version](https://badge.fury.io/py/denoising-diffusion-pytorch.svg)](https://badge.fury.io/py/denoising-diffusion-pytorch)

denoising_diffusion_pytorch/continuous_time_gaussian_diffusion.py

@@ -6,7 +6,6 @@ from torch.special import expm1
 
 from tqdm import tqdm
 from einops import rearrange, repeat
-from einops.layers.torch import Rearrange
 
 # helpers
 
@@ -34,24 +33,6 @@ def right_pad_dims_to(x, t):
         return t
     return t.view(*t.shape, *((1,) * padding_dims))
 
-# neural net helpers
-
-class Residual(nn.Module):
-    def __init__(self, fn):
-        super().__init__()
-        self.fn = fn
-
-    def forward(self, x):
-        return x + self.fn(x)
-
-class MonotonicLinear(nn.Module):
-    def __init__(self, *args, **kwargs):
-        super().__init__()
-        self.net = nn.Linear(*args, **kwargs)
-
-    def forward(self, x):
-        return F.linear(x, self.net.weight.abs(), self.net.bias.abs())
-
 # continuous schedules
 
 # equations are taken from https://openreview.net/attachment?id=2LdBqxc1Yv&name=supplementary_material
@@ -59,54 +40,17 @@ class MonotonicLinear(nn.Module):
 
 # log(snr) that approximates the original linear schedule
 
-def log(t, eps = 1e-20):
-    return torch.log(t.clamp(min = eps))
-
 def beta_linear_log_snr(t):
-    return -log(expm1(1e-4 + 10 * (t ** 2)))
+    return -torch.log(expm1(1e-4 + 10 * (t ** 2)))
 
-def alpha_cosine_log_snr(t, s = 0.008):
-    return -log((torch.cos((t + s) / (1 + s) * torch.pi * 0.5) ** -2) - 1)
+def alpha_cosine_log_snr(t):
+    raise NotImplementedError
 
 class learned_noise_schedule(nn.Module):
-    """ described in section H and then I.2 of the supplementary material for variational ddpm paper """
-
-    def __init__(
-        self,
-        *,
-        log_snr_max,
-        log_snr_min,
-        hidden_dim = 1024,
-        frac_gradient = 1.
-    ):
+    def __init__(self):
         super().__init__()
-        self.slope = log_snr_min - log_snr_max
-        self.intercept = log_snr_max
-
-        self.net = nn.Sequential(
-            Rearrange('... -> ... 1'),
-            MonotonicLinear(1, 1),
-            Residual(nn.Sequential(
-                MonotonicLinear(1, hidden_dim),
-                nn.Sigmoid(),
-                MonotonicLinear(hidden_dim, 1)
-            )),
-            Rearrange('... 1 -> ...'),
-        )
-
-        self.frac_gradient = frac_gradient
-
-    def forward(self, x):
-        frac_gradient = self.frac_gradient
-        device = x.device
-
-        out_zero = self.net(torch.zeros_like(x))
-        out_one =  self.net(torch.ones_like(x))
-
-        x = self.net(x)
-
-        normed = self.slope * ((x - out_zero) / (out_one - out_zero)) + self.intercept
-        return normed * frac_gradient + normed.detach() * (1 - frac_gradient)
+        raise NotImplementedError
+        # learned noise schedule, using learned monotonic MLP (weights kept positive) in the paper
 
 class ContinuousTimeGaussianDiffusion(nn.Module):
     def __init__(
@@ -115,12 +59,10 @@ class ContinuousTimeGaussianDiffusion(nn.Module):
         *,
         image_size,
         channels = 3,
+        cond_scale = 500,
         loss_type = 'l1',
         noise_schedule = 'linear',
-        num_sample_steps = 500,
-        clip_sample_denoised = True,
-        learned_schedule_net_hidden_dim = 1024,
-        learned_noise_schedule_frac_gradient = 1.   # between 0 and 1, determines what percentage of gradients go back, so one can update the learned noise schedule more slowly
+        num_sample_steps = 500
     ):
         super().__init__()
         assert not denoise_fn.sinusoidal_cond_mlp
@@ -134,28 +76,17 @@ class ContinuousTimeGaussianDiffusion(nn.Module):
 
         # continuous noise schedule related stuff
 
+        self.cond_scale = cond_scale # the log(snr) will be scaled by this value
         self.loss_type = loss_type
 
         if noise_schedule == 'linear':
             self.log_snr = beta_linear_log_snr
-        elif noise_schedule == 'cosine':
-            self.log_snr = alpha_cosine_log_snr
-        elif noise_schedule == 'learned':
-            log_snr_max, log_snr_min = [beta_linear_log_snr(torch.tensor([time])).item() for time in (0., 1.)]
-
-            self.log_snr = learned_noise_schedule(
-                log_snr_max = log_snr_max,
-                log_snr_min = log_snr_min,
-                hidden_dim = learned_schedule_net_hidden_dim,
-                frac_gradient = learned_noise_schedule_frac_gradient
-            )
         else:
             raise ValueError(f'unknown noise schedule {noise_schedule}')
 
         # sampling
 
         self.num_sample_steps = num_sample_steps
-        self.clip_sample_denoised = clip_sample_denoised
 
     @property
     def device(self):
@@ -174,6 +105,9 @@ class ContinuousTimeGaussianDiffusion(nn.Module):
         # reviewer found an error in the equation in the paper (missing sigma)
         # following - https://openreview.net/forum?id=2LdBqxc1Yv&noteId=rIQgH0zKsRt
 
+        # todo - derive x_start from the posterior mean and do dynamic thresholding
+        # assumed that is what is going on in Imagen
+
         log_snr = self.log_snr(time)
         log_snr_next = self.log_snr(time_next)
         c = -expm1(log_snr - log_snr_next)
@@ -181,21 +115,10 @@ class ContinuousTimeGaussianDiffusion(nn.Module):
         squared_alpha, squared_alpha_next = log_snr.sigmoid(), log_snr_next.sigmoid()
         squared_sigma, squared_sigma_next = (-log_snr).sigmoid(), (-log_snr_next).sigmoid()
 
-        alpha, sigma, alpha_next = map(sqrt, (squared_alpha, squared_sigma, squared_alpha_next))
-
         batch_log_snr = repeat(log_snr, ' -> b', b = x.shape[0])
         pred_noise = self.denoise_fn(x, batch_log_snr)
 
-        if self.clip_sample_denoised:
-            x_start = (x - sigma * pred_noise) / alpha
-
-            # in Imagen, this was changed to dynamic thresholding
-            x_start.clamp_(-1., 1.)
-
-            model_mean = alpha_next * (x * (1 - c) / alpha + c * x_start)
-        else:
-            model_mean = alpha_next / alpha * (x - c * sigma * pred_noise)
-
+        model_mean = sqrt(squared_alpha_next / squared_alpha) * (x - c * sqrt(squared_sigma) * pred_noise)
         posterior_variance = squared_sigma_next * c
 
         return model_mean, posterior_variance
@@ -256,7 +179,7 @@ class ContinuousTimeGaussianDiffusion(nn.Module):
 
         x, log_snr = self.q_sample(x_start = x_start, times = times, noise = noise)
 
-        model_out = self.denoise_fn(x, log_snr)
+        model_out = self.denoise_fn(x, log_snr * self.cond_scale)
         return self.loss_fn(model_out, noise)
 
     def forward(self, img, *args, **kwargs):

setup.py

@@ -3,7 +3,7 @@ from setuptools import setup, find_packages
 setup(
   name = 'denoising-diffusion-pytorch',
   packages = find_packages(),
-  version = '0.17.7',
+  version = '0.16.6',
   license='MIT',
   description = 'Denoising Diffusion Probabilistic Models - Pytorch',
   author = 'Phil Wang',