update with new and improved cosine noise scheduler

.gitignore

@@ -1,6 +1,3 @@
-# Generation results
-results/
-
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]

README.md

@@ -27,9 +27,8 @@ model = Unet(
 
 diffusion = GaussianDiffusion(
     model,
-    image_size = 128,
     timesteps = 1000,   # number of steps
-    loss_type = 'l1'    # L1 or L2
+    loss_type = 'l1'                  # L1 or L2
 )
 
 training_images = torch.randn(8, 3, 128, 128)
@@ -37,7 +36,7 @@ loss = diffusion(training_images)
 loss.backward()
 # after a lot of training
 
-sampled_images = diffusion.sample(batch_size = 4)
+sampled_images = diffusion.sample(128, batch_size = 4)
 sampled_images.shape # (4, 3, 128, 128)
 ```
 
@@ -53,7 +52,6 @@ model = Unet(
 
 diffusion = GaussianDiffusion(
     model,
-    image_size = 128,
     timesteps = 1000,   # number of steps
     loss_type = 'l1'    # L1 or L2
 ).cuda()
@@ -61,9 +59,10 @@ diffusion = GaussianDiffusion(
 trainer = Trainer(
     diffusion,
     'path/to/your/images',
+    image_size = 128,
     train_batch_size = 32,
     train_lr = 2e-5,
-    train_num_steps = 700000,         # total training steps
+    train_num_steps = 100000,         # total training steps
     gradient_accumulate_every = 2,    # gradient accumulation steps
     ema_decay = 0.995,                # exponential moving average decay
     fp16 = True                       # turn on mixed precision training with apex
@@ -72,28 +71,27 @@ trainer = Trainer(
 trainer.train()
 ```
 
-Samples and model checkpoints will be logged to `./results` periodically
-
 ## Citations
 
 ```bibtex
 @misc{ho2020denoising,
-    title   = {Denoising Diffusion Probabilistic Models},
+    title={Denoising Diffusion Probabilistic Models},
-    author  = {Jonathan Ho and Ajay Jain and Pieter Abbeel},
+    author={Jonathan Ho and Ajay Jain and Pieter Abbeel},
-    year    = {2020},
+    year={2020},
-    eprint  = {2006.11239},
+    eprint={2006.11239},
-    archivePrefix = {arXiv},
+    archivePrefix={arXiv},
-    primaryClass = {cs.LG}
+    primaryClass={cs.LG}
 }
 ```
 
 ```bibtex
-@inproceedings{anonymous2021improved,
+@inproceedings{
-    title   = {Improved Denoising Diffusion Probabilistic Models},
+    anonymous2021improved,
-    author  = {Anonymous},
+    title={Improved Denoising Diffusion Probabilistic Models},
-    booktitle = {Submitted to International Conference on Learning Representations},
+    author={Anonymous},
-    year    = {2021},
+    booktitle={Submitted to International Conference on Learning Representations},
-    url     = {https://openreview.net/forum?id=-NEXDKk8gZ},
+    year={2021},
-    note    = {under review}
+    url={https://openreview.net/forum?id=-NEXDKk8gZ},
+    note={under review}
 }
 ```

denoising_diffusion_pytorch/denoising_diffusion_pytorch.py

@@ -28,9 +28,6 @@ SAVE_AND_SAMPLE_EVERY = 1000
 UPDATE_EMA_EVERY = 10
 EXTS = ['jpg', 'jpeg', 'png']
 
-RESULTS_FOLDER = Path('./results')
-RESULTS_FOLDER.mkdir(exist_ok = True)
-
 # helpers functions
 
 def exists(x):
@@ -181,18 +178,9 @@ class LinearAttention(nn.Module):
 # model
 
 class Unet(nn.Module):
-    def __init__(
+    def __init__(self, dim, out_dim = None, dim_mults=(1, 2, 4, 8), groups = 8):
-        self,
-        dim,
-        out_dim = None,
-        dim_mults=(1, 2, 4, 8),
-        groups = 8,
-        channels = 3
-    ):
         super().__init__()
-        self.channels = channels
+        dims = [3, *map(lambda m: dim * m, dim_mults)]
-
-        dims = [channels, *map(lambda m: dim * m, dim_mults)]
         in_out = list(zip(dims[:-1], dims[1:]))
 
         self.time_pos_emb = SinusoidalPosEmb(dim)
@@ -231,7 +219,7 @@ class Unet(nn.Module):
                 Upsample(dim_in) if not is_last else nn.Identity()
             ]))
 
-        out_dim = default(out_dim, channels)
+        out_dim = default(out_dim, 3)
         self.final_conv = nn.Sequential(
             Block(dim, dim),
             nn.Conv2d(dim, out_dim, 1)
@@ -288,19 +276,8 @@ def cosine_beta_schedule(timesteps, s = 0.008):
     return np.clip(betas, a_min = 0, a_max = 0.999)
 
 class GaussianDiffusion(nn.Module):
-    def __init__(
+    def __init__(self, denoise_fn, timesteps=1000, loss_type='l1', betas = None):
-        self,
-        denoise_fn,
-        *,
-        image_size,
-        channels = 3,
-        timesteps = 1000,
-        loss_type = 'l1',
-        betas = None
-    ):
         super().__init__()
-        self.channels = channels
-        self.image_size = image_size
         self.denoise_fn = denoise_fn
 
         if exists(betas):
@@ -391,10 +368,8 @@ class GaussianDiffusion(nn.Module):
         return img
 
     @torch.no_grad()
-    def sample(self, batch_size = 16):
+    def sample(self, image_size, batch_size = 16):
-        image_size = self.image_size
+        return self.p_sample_loop((batch_size, 3, image_size, image_size))
-        channels = self.channels
-        return self.p_sample_loop((batch_size, channels, image_size, image_size))
 
     @torch.no_grad()
     def interpolate(self, x1, x2, t = None, lam = 0.5):
@@ -437,8 +412,7 @@ class GaussianDiffusion(nn.Module):
         return loss
 
     def forward(self, x, *args, **kwargs):
-        b, c, h, w, device, img_size, = *x.shape, x.device, self.image_size
+        b, *_, device = *x.shape, x.device
-        assert h == img_size and w == img_size, f'height and width of image must be {img_size}'
         t = torch.randint(0, self.num_timesteps, (b,), device=device).long()
         return self.p_losses(x, t, *args, **kwargs)
 
@@ -490,7 +464,7 @@ class Trainer(object):
         self.step_start_ema = step_start_ema
 
         self.batch_size = train_batch_size
-        self.image_size = diffusion_model.image_size
+        self.image_size = image_size
         self.gradient_accumulate_every = gradient_accumulate_every
         self.train_num_steps = train_num_steps
 
@@ -523,10 +497,10 @@ class Trainer(object):
             'model': self.model.state_dict(),
             'ema': self.ema_model.state_dict()
         }
-        torch.save(data, str(RESULTS_FOLDER / f'model-{milestone}.pt'))
+        torch.save(data, f'./model-{milestone}.pt')
 
     def load(self, milestone):
-        data = torch.load(str(RESULTS_FOLDER / f'model-{milestone}.pt'))
+        data = torch.load(f'./model-{milestone}.pt')
 
         self.step = data['step']
         self.model.load_state_dict(data['model'])
@@ -551,9 +525,9 @@ class Trainer(object):
             if self.step != 0 and self.step % SAVE_AND_SAMPLE_EVERY == 0:
                 milestone = self.step // SAVE_AND_SAMPLE_EVERY
                 batches = num_to_groups(36, self.batch_size)
-                all_images_list = list(map(lambda n: self.ema_model.sample(batch_size=n), batches))
+                all_images_list = list(map(lambda n: self.ema_model.sample(self.image_size, batch_size=n), batches))
                 all_images = torch.cat(all_images_list, dim=0)
-                utils.save_image(all_images, str(RESULTS_FOLDER / f'sample-{milestone}.png'), nrow=6)
+                utils.save_image(all_images, f'./sample-{milestone}.png', nrow=6)
                 self.save(milestone)
 
             self.step += 1

setup.py

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