first pass at complete DALL-E2 + Latent Diffusion integration, latent diffusion on any layer(s) of the cascading ddpm in the decoder.

README.md

@@ -12,7 +12,7 @@ This model is SOTA for text-to-image for now.
 
 Please join <a href="https://discord.gg/xBPBXfcFHd"><img alt="Join us on Discord" src="https://img.shields.io/discord/823813159592001537?color=5865F2&logo=discord&logoColor=white"></a> if you are interested in helping out with the replication
 
-There was enough interest for a <a href="https://github.com/lucidrains/dalle2-jax">Jax version</a>. I will also eventually extend this to <a href="https://github.com/lucidrains/dalle2-video">text to video</a>, once the repository is in a good place.
+There was enough interest for a Jax version. It will be completed after the Pytorch version shows signs of life on my toy tasks. <a href="https://github.com/lucidrains/dalle2-jax">Placeholder repository</a>. I will also eventually extend this to <a href="https://github.com/lucidrains/dalle2-video">text to video</a>, once the repository is in a good place.
 
 ## Install
 
@@ -246,6 +246,13 @@ loss = decoder(images, unet_number = 2)
 loss.backward()
 
 # do the above for many steps for both unets
+
+# then it will learn to generate images based on the CLIP image embeddings
+
+# chaining the unets from lowest resolution to highest resolution (thus cascading)
+
+mock_image_embed = torch.randn(1, 512).cuda()
+images = decoder.sample(mock_image_embed) # (1, 3, 512, 512)
 ```
 
 Finally, to generate the DALL-E2 images from text. Insert the trained `DiffusionPrior` as well as the `Decoder` (which wraps `CLIP`, the causal transformer, and unet(s))
@@ -348,8 +355,7 @@ decoder = Decoder(
     image_sizes = (128, 256),
     clip = clip,
     timesteps = 100,
-    cond_drop_prob = 0.2,
-    condition_on_text_encodings = False  # set this to True if you wish to condition on text during training and sampling
+    cond_drop_prob = 0.2
 ).cuda()
 
 for unet_number in (1, 2):
@@ -377,224 +383,12 @@ You can also train the decoder on images of greater than the size (say 512x512)
 
 For the layperson, no worries, training will all be automated into a CLI tool, at least for small scale training.
 
-## Training on Preprocessed CLIP Embeddings
+## Experimental - DALL-E2 with Latent Diffusion
 
-It is likely, when scaling up, that you would first preprocess your images and text into corresponding embeddings before training the prior network. You can do so easily by simply passing in `image_embed`, `text_embed`, and optionally `text_encodings` and `text_mask`
-
-Working example below
-
-```python
-import torch
-from dalle2_pytorch import DiffusionPriorNetwork, DiffusionPrior, CLIP
-
-# get trained CLIP from step one
-
-clip = CLIP(
-    dim_text = 512,
-    dim_image = 512,
-    dim_latent = 512,
-    num_text_tokens = 49408,
-    text_enc_depth = 6,
-    text_seq_len = 256,
-    text_heads = 8,
-    visual_enc_depth = 6,
-    visual_image_size = 256,
-    visual_patch_size = 32,
-    visual_heads = 8,
-).cuda()
-
-# setup prior network, which contains an autoregressive transformer
-
-prior_network = DiffusionPriorNetwork(
-    dim = 512,
-    depth = 6,
-    dim_head = 64,
-    heads = 8
-).cuda()
-
-# diffusion prior network, which contains the CLIP and network (with transformer) above
-
-diffusion_prior = DiffusionPrior(
-    net = prior_network,
-    clip = clip,
-    timesteps = 100,
-    cond_drop_prob = 0.2,
-    condition_on_text_encodings = False  # this probably should be true, but just to get Laion started
-).cuda()
-
-# mock data
-
-text = torch.randint(0, 49408, (4, 256)).cuda()
-images = torch.randn(4, 3, 256, 256).cuda()
-
-# precompute the text and image embeddings
-# here using the diffusion prior class, but could be done with CLIP alone
-
-clip_image_embeds = diffusion_prior.clip.embed_image(images).image_embed
-clip_text_embeds = diffusion_prior.clip.embed_text(text).text_embed
-
-# feed text and images into diffusion prior network
-
-loss = diffusion_prior(
-    text_embed = clip_text_embeds,
-    image_embed = clip_image_embeds
-)
-
-loss.backward()
-
-# do the above for many many many steps
-# now the diffusion prior can generate image embeddings from the text embeddings
-```
-
-You can also completely go `CLIP`-less, in which case you will need to pass in the `image_embed_dim` into the `DiffusionPrior` on initialization
-
-```python
-import torch
-from dalle2_pytorch import DiffusionPriorNetwork, DiffusionPrior
-
-# setup prior network, which contains an autoregressive transformer
-
-prior_network = DiffusionPriorNetwork(
-    dim = 512,
-    depth = 6,
-    dim_head = 64,
-    heads = 8
-).cuda()
-
-# diffusion prior network, which contains the CLIP and network (with transformer) above
-
-diffusion_prior = DiffusionPrior(
-    net = prior_network,
-    image_embed_dim = 512,               # this needs to be set
-    timesteps = 100,
-    cond_drop_prob = 0.2,
-    condition_on_text_encodings = False  # this probably should be true, but just to get Laion started
-).cuda()
-
-# mock data
-
-text = torch.randint(0, 49408, (4, 256)).cuda()
-images = torch.randn(4, 3, 256, 256).cuda()
-
-# precompute the text and image embeddings
-# here using the diffusion prior class, but could be done with CLIP alone
-
-clip_image_embeds = torch.randn(4, 512).cuda()
-clip_text_embeds = torch.randn(4, 512).cuda()
-
-# feed text and images into diffusion prior network
-
-loss = diffusion_prior(
-    text_embed = clip_text_embeds,
-    image_embed = clip_image_embeds
-)
-
-loss.backward()
-
-# do the above for many many many steps
-# now the diffusion prior can generate image embeddings from the text embeddings
-```
-
-## OpenAI CLIP
-
-Although there is the possibility they are using an unreleased, more powerful CLIP, you can use one of the released ones, if you do not wish to train your own CLIP from scratch. This will also allow the community to more quickly validate the conclusions of the paper.
-
-First you'll need to install <a href="https://github.com/openai/CLIP#usage">the prerequisites</a>
-
-Then to use a pretrained OpenAI CLIP, simply import `OpenAIClipAdapter` and pass it into the `DiffusionPrior` or `Decoder` like so
-
-```python
-import torch
-from dalle2_pytorch import DALLE2, DiffusionPriorNetwork, DiffusionPrior, Unet, Decoder, OpenAIClipAdapter
-
-# openai pretrained clip - defaults to ViT/B-32
-
-clip = OpenAIClipAdapter()
-
-# mock data
-
-text = torch.randint(0, 49408, (4, 256)).cuda()
-images = torch.randn(4, 3, 256, 256).cuda()
-
-# prior networks (with transformer)
-
-prior_network = DiffusionPriorNetwork(
-    dim = 512,
-    depth = 6,
-    dim_head = 64,
-    heads = 8
-).cuda()
-
-diffusion_prior = DiffusionPrior(
-    net = prior_network,
-    clip = clip,
-    timesteps = 100,
-    cond_drop_prob = 0.2
-).cuda()
-
-loss = diffusion_prior(text, images)
-loss.backward()
-
-# do above for many steps ...
-
-# decoder (with unet)
-
-unet1 = Unet(
-    dim = 128,
-    image_embed_dim = 512,
-    cond_dim = 128,
-    channels = 3,
-    dim_mults=(1, 2, 4, 8)
-).cuda()
-
-unet2 = Unet(
-    dim = 16,
-    image_embed_dim = 512,
-    cond_dim = 128,
-    channels = 3,
-    dim_mults = (1, 2, 4, 8, 16)
-).cuda()
-
-decoder = Decoder(
-    unet = (unet1, unet2),
-    image_sizes = (128, 256),
-    clip = clip,
-    timesteps = 100,
-    cond_drop_prob = 0.2,
-    condition_on_text_encodings = False  # set this to True if you wish to condition on text during training and sampling
-).cuda()
-
-for unet_number in (1, 2):
-    loss = decoder(images, unet_number = unet_number) # this can optionally be decoder(images, text) if you wish to condition on the text encodings as well, though it was hinted in the paper it didn't do much
-    loss.backward()
-
-# do above for many steps
-
-dalle2 = DALLE2(
-    prior = diffusion_prior,
-    decoder = decoder
-)
-
-images = dalle2(
-    ['a butterfly trying to escape a tornado'],
-    cond_scale = 2. # classifier free guidance strength (> 1 would strengthen the condition)
-)
-
-# save your image (in this example, of size 256x256)
-```
-
-Now you'll just have to worry about training the Prior and the Decoder!
-
-## Experimental
-
-### DALL-E2 with Latent Diffusion
-
-This repository decides to take the next step and offer DALL-E v2 combined with <a href="https://huggingface.co/spaces/multimodalart/latentdiffusion">latent diffusion</a>, from Rombach et al.
+This repository decides to take the next step and offer DALL-E2 combined with latent diffusion, from Rombach et al.
 
 You can use it as follows. Latent diffusion can be limited to just the first U-Net in the cascade, or to any number you wish.
 
-The repository also comes equipped with all the necessary settings to recreate `ViT-VQGan` from the <a href="https://arxiv.org/abs/2110.04627">Improved VQGans</a> paper. Furthermore, the <a href="https://github.com/lucidrains/vector-quantize-pytorch">vector quantization</a> library also comes equipped to do <a href="https://arxiv.org/abs/2203.01941">residual or multi-headed quantization</a>, which I believe will give an even further boost in performance to the autoencoder.
-
 ```python
 import torch
 from dalle2_pytorch import Unet, Decoder, CLIP, VQGanVAE
@@ -615,10 +409,9 @@ clip = CLIP(
     visual_heads = 8
 )
 
-# 3 unets for the decoder (a la cascading DDPM)
+# 2 unets for the decoder (a la cascading DDPM)
 
-# first two unets are doing latent diffusion
-# vqgan-vae must be trained before hand
+# 1st unet is doing latent diffusion
 
 vae1 = VQGanVAE(
     dim = 32,
@@ -676,7 +469,7 @@ decoder = Decoder(
 
 # mock images (get a lot of this)
 
-images = torch.randn(1, 3, 1024, 1024).cuda()
+images = torch.randn(1, 3, 512, 512).cuda()
 
 # feed images into decoder, specifying which unet you want to train
 # each unet can be trained separately, which is one of the benefits of the cascading DDPM scheme
@@ -689,10 +482,6 @@ with decoder.one_unet_in_gpu(2):
     loss = decoder(images, unet_number = 2)
     loss.backward()
 
-with decoder.one_unet_in_gpu(3):
-    loss = decoder(images, unet_number = 3)
-    loss.backward()
-
 # do the above for many steps for both unets
 
 # then it will learn to generate images based on the CLIP image embeddings
@@ -703,11 +492,7 @@ mock_image_embed = torch.randn(1, 512).cuda()
 images = decoder.sample(mock_image_embed) # (1, 3, 1024, 1024)
 ```
 
-## Training wrapper (wip)
-
-Offer training wrappers
-
-## CLI (wip)
+## CLI Usage (work in progress)
 
 ```bash
 $ dream 'sharing a sunset at the summit of mount everest with my dog'
@@ -715,7 +500,9 @@ $ dream 'sharing a sunset at the summit of mount everest with my dog'
 
 Once built, images will be saved to the same directory the command is invoked
 
-<a href="https://github.com/lucidrains/big-sleep">template</a>
+## Training wrapper (wip)
+
+Offer training wrappers
 
 ## Training CLI (wip)
 
@@ -733,19 +520,11 @@ Once built, images will be saved to the same directory the command is invoked
 - [x] be able to finely customize what to condition on (text, image embed) for specific unet in the cascade (super resolution ddpms near the end may not need too much conditioning)
 - [x] offload unets not being trained on to CPU for memory efficiency (for training each resolution unets separately)
 - [x] build out latent diffusion architecture, with the vq-reg variant (vqgan-vae), make it completely optional and compatible with cascading ddpms
-- [x] for decoder, allow ability to customize objective (predict epsilon vs x0), in case latent diffusion does better with prediction of x0
-- [x] use attention-based upsampling https://arxiv.org/abs/2112.11435
-- [x] use inheritance just this once for sharing logic between decoder and prior network ddpms
-- [x] bring in vit-vqgan https://arxiv.org/abs/2110.04627 for the latent diffusion
-- [x] abstract interface for CLIP adapter class, so other CLIPs can be brought in
+- [ ] spend one day cleaning up tech debt in decoder
 - [ ] become an expert with unets, cleanup unet code, make it fully configurable, port all learnings over to https://github.com/lucidrains/x-unet
 - [ ] copy the cascading ddpm code to a separate repo (perhaps https://github.com/lucidrains/denoising-diffusion-pytorch) as the main contribution of dalle2 really is just the prior network
-- [ ] transcribe code to Jax, which lowers the activation energy for distributed training, given access to TPUs
-- [ ] just take care of the training for the decoder in a wrapper class, as each unet in the cascade will need its own optimizer
 - [ ] train on a toy task, offer in colab
-- [ ] think about how best to design a declarative training config that handles preencoding for prior and training of multiple networks in decoder
 - [ ] extend diffusion head to use diffusion-gan (potentially using lightweight-gan) to speed up inference
-- [ ] bring in tools to train vqgan-vae
 
 ## Citations
 
@@ -777,12 +556,23 @@ Once built, images will be saved to the same directory the command is invoked
 
 ```bibtex
 @inproceedings{Liu2022ACF,
-    title   = {A ConvNet for the 2020https://arxiv.org/abs/2112.11435s},
+    title   = {A ConvNet for the 2020s},
     author  = {Zhuang Liu and Hanzi Mao and Chaozheng Wu and Christoph Feichtenhofer and Trevor Darrell and Saining Xie},
     year    = {2022}
 }
 ```
 
+```bibtex
+@misc{zhang2019root,
+    title   = {Root Mean Square Layer Normalization},
+    author  = {Biao Zhang and Rico Sennrich},
+    year    = {2019},
+    eprint  = {1910.07467},
+    archivePrefix = {arXiv},
+    primaryClass = {cs.LG}
+}
+```
+
 ```bibtex
 @inproceedings{Tu2022MaxViTMV,
     title   = {MaxViT: Multi-Axis Vision Transformer},
@@ -791,14 +581,4 @@ Once built, images will be saved to the same directory the command is invoked
 }
 ```
 
-```bibtex
-@article{Yu2021VectorquantizedIM,
-    title   = {Vector-quantized Image Modeling with Improved VQGAN},
-    author  = {Jiahui Yu and Xin Li and Jing Yu Koh and Han Zhang and Ruoming Pang and James Qin and Alexander Ku and Yuanzhong Xu and Jason Baldridge and Yonghui Wu},
-    journal = {ArXiv},
-    year    = {2021},
-    volume  = {abs/2110.04627}
-}
-```
-
 *Creating noise from data is easy; creating data from noise is generative modeling.* - Yang Song's <a href="https://arxiv.org/abs/2011.13456">paper</a>

dalle2_pytorch/__init__.py

@@ -1,5 +1,4 @@
 from dalle2_pytorch.dalle2_pytorch import DALLE2, DiffusionPriorNetwork, DiffusionPrior, Unet, Decoder
-from dalle2_pytorch.dalle2_pytorch import OpenAIClipAdapter
 
 from dalle2_pytorch.vqgan_vae import VQGanVAE
 from x_clip import CLIP

dalle2_pytorch/cli.py

@@ -1,51 +1,9 @@
 import click
-import torch
-import torchvision.transforms as T
-from pathlib import Path
-
-from dalle2_pytorch import DALLE2, Decoder, DiffusionPrior
-
-def safeget(dictionary, keys, default = None):
-    return reduce(lambda d, key: d.get(key, default) if isinstance(d, dict) else default, keys.split('.'), dictionary)
-
-def simple_slugify(text, max_length = 255):
-    return text.replace("-", "_").replace(",", "").replace(" ", "_").replace("|", "--").strip('-_')[:max_length]
-
-def get_pkg_version():
-    from pkg_resources import get_distribution
-    return get_distribution('dalle2_pytorch').version
 
 def main():
     pass
 
 @click.command()
-@click.option('--model', default = './dalle2.pt', help = 'path to trained DALL-E2 model')
-@click.option('--cond_scale', default = 2, help = 'conditioning scale (classifier free guidance) in decoder')
 @click.argument('text')
-def dream(
-    model,
-    cond_scale,
-    text
-):
-    model_path = Path(model)
-    full_model_path = str(model_path.resolve())
-    assert model_path.exists(), f'model not found at {full_model_path}'
-    loaded = torch.load(str(model_path))
-
-    version = safeget(loaded, 'version')
-    print(f'loading DALL-E2 from {full_model_path}, saved at version {version} - current package version is {get_pkg_version()}')
-
-    prior_init_params = safeget(loaded, 'init_params.prior')
-    decoder_init_params = safeget(loaded, 'init_params.decoder')
-    model_params = safeget(loaded, 'model_params')
-
-    prior = DiffusionPrior(**prior_init_params)
-    decoder = Decoder(**decoder_init_params)
-
-    dalle2 = DALLE2(prior, decoder)
-    dalle2.load_state_dict(model_params)
-
-    image = dalle2(text, cond_scale = cond_scale)
-
-    pil_image = T.ToPILImage()(image)
-    return pil_image.save(f'./{simple_slugify(text)}.png')
+def dream(text):
+    return 'not ready yet'

dalle2_pytorch/optimizer.py

@@ -1,29 +0,0 @@
-from torch.optim import AdamW, Adam
-
-def separate_weight_decayable_params(params):
-    no_wd_params = set([param for param in params if param.ndim < 2])
-    wd_params = set(params) - no_wd_params
-    return wd_params, no_wd_params
-
-def get_optimizer(
-    params,
-    lr = 3e-4,
-    wd = 1e-2,
-    betas = (0.9, 0.999),
-    filter_by_requires_grad = False
-):
-    if filter_by_requires_grad:
-        params = list(filter(lambda t: t.requires_grad, params))
-
-    if wd == 0:
-        return Adam(params, lr = lr, betas = betas)
-
-    params = set(params)
-    wd_params, no_wd_params = separate_weight_decayable_params(params)
-
-    param_groups = [
-        {'params': list(wd_params)},
-        {'params': list(no_wd_params), 'weight_decay': 0},
-    ]
-
-    return AdamW(param_groups, lr = lr, weight_decay = wd, betas = betas)

dalle2_pytorch/train.py

@@ -1,53 +0,0 @@
-import copy
-import torch
-from torch import nn
-
-# exponential moving average wrapper
-
-class EMA(nn.Module):
-    def __init__(
-        self,
-        model,
-        beta = 0.99,
-        ema_update_after_step = 1000,
-        ema_update_every = 10,
-    ):
-        super().__init__()
-        self.beta = beta
-        self.online_model = model
-        self.ema_model = copy.deepcopy(model)
-
-        self.ema_update_after_step = ema_update_after_step # only start EMA after this step number, starting at 0
-        self.ema_update_every = ema_update_every
-
-        self.register_buffer('initted', torch.Tensor([False]))
-        self.register_buffer('step', torch.tensor([0.]))
-
-    def update(self):
-        self.step += 1
-
-        if self.step <= self.ema_update_after_step or (self.step % self.ema_update_every) != 0:
-            return
-
-        if not self.initted:
-            self.ema_model.state_dict(self.online_model.state_dict())
-            self.initted.data.copy_(torch.Tensor([True]))
-
-        self.update_moving_average(self.ema_model, self.online_model)
-
-    def update_moving_average(self, ma_model, current_model):
-        def calculate_ema(beta, old, new):
-            if not exists(old):
-                return new
-            return old * beta + (1 - beta) * new
-
-        for current_params, ma_params in zip(current_model.parameters(), ma_model.parameters()):
-            old_weight, up_weight = ma_params.data, current_params.data
-            ma_params.data = calculate_ema(self.beta, old_weight, up_weight)
-
-        for current_buffer, ma_buffer in zip(current_model.buffers(), ma_model.buffers()):
-            new_buffer_value = calculate_ema(self.beta, ma_buffer, current_buffer)
-            ma_buffer.copy_(new_buffer_value)
-
-    def __call__(self, *args, **kwargs):
-        return self.ema_model(*args, **kwargs)

dalle2_pytorch/vqgan_vae.py

@@ -12,8 +12,6 @@ from torch.autograd import grad as torch_grad
 import torchvision
 
 from einops import rearrange, reduce, repeat
-from einops_exts import rearrange_many
-from einops.layers.torch import Rearrange
 
 # constants
 
@@ -146,8 +144,6 @@ class LayerNormChan(nn.Module):
         mean = torch.mean(x, dim = 1, keepdim = True)
         return (x - mean) / (var + self.eps).sqrt() * self.gamma
 
-# discriminator
-
 class Discriminator(nn.Module):
     def __init__(
         self,
@@ -181,8 +177,6 @@ class Discriminator(nn.Module):
 
         return self.to_logits(x)
 
-# positional encoding
-
 class ContinuousPositionBias(nn.Module):
     """ from https://arxiv.org/abs/2111.09883 """
 
@@ -217,84 +211,6 @@ class ContinuousPositionBias(nn.Module):
         bias = rearrange(rel_pos, 'i j h -> h i j')
         return x + bias
 
-# resnet encoder / decoder
-
-class ResnetEncDec(nn.Module):
-    def __init__(
-        self,
-        dim,
-        *,
-        channels = 3,
-        layers = 4,
-        layer_mults = None,
-        num_resnet_blocks = 1,
-        resnet_groups = 16,
-        first_conv_kernel_size = 5,
-        use_attn = True,
-        attn_dim_head = 64,
-        attn_heads = 8,
-        attn_dropout = 0.,
-    ):
-        super().__init__()
-        assert dim % resnet_groups == 0, f'dimension {dim} must be divisible by {resnet_groups} (groups for the groupnorm)'
-
-        self.layers = layers
-
-        self.encoders = MList([])
-        self.decoders = MList([])
-
-        layer_mults = default(layer_mults, list(map(lambda t: 2 ** t, range(layers))))
-        assert len(layer_mults) == layers, 'layer multipliers must be equal to designated number of layers'
-
-        layer_dims = [dim * mult for mult in layer_mults]
-        dims = (dim, *layer_dims)
-
-        self.encoded_dim = dims[-1]
-
-        dim_pairs = zip(dims[:-1], dims[1:])
-
-        append = lambda arr, t: arr.append(t)
-        prepend = lambda arr, t: arr.insert(0, t)
-
-        if not isinstance(num_resnet_blocks, tuple):
-            num_resnet_blocks = (*((0,) * (layers - 1)), num_resnet_blocks)
-
-        if not isinstance(use_attn, tuple):
-            use_attn = (*((False,) * (layers - 1)), use_attn)
-
-        assert len(num_resnet_blocks) == layers, 'number of resnet blocks config must be equal to number of layers'
-        assert len(use_attn) == layers
-
-        for layer_index, (dim_in, dim_out), layer_num_resnet_blocks, layer_use_attn in zip(range(layers), dim_pairs, num_resnet_blocks, use_attn):
-            append(self.encoders, nn.Sequential(nn.Conv2d(dim_in, dim_out, 4, stride = 2, padding = 1), leaky_relu()))
-            prepend(self.decoders, nn.Sequential(nn.ConvTranspose2d(dim_out, dim_in, 4, 2, 1), leaky_relu()))
-
-            if layer_use_attn:
-                prepend(self.decoders, VQGanAttention(dim = dim_out, heads = attn_heads, dim_head = attn_dim_head, dropout = attn_dropout))
-
-            for _ in range(layer_num_resnet_blocks):
-                append(self.encoders, ResBlock(dim_out, groups = resnet_groups))
-                prepend(self.decoders, GLUResBlock(dim_out, groups = resnet_groups))
-
-            if layer_use_attn:
-                append(self.encoders, VQGanAttention(dim = dim_out, heads = attn_heads, dim_head = attn_dim_head, dropout = attn_dropout))
-
-        prepend(self.encoders, nn.Conv2d(channels, dim, first_conv_kernel_size, padding = first_conv_kernel_size // 2))
-        append(self.decoders, nn.Conv2d(dim, channels, 1))
-
-    def get_encoded_fmap_size(self, image_size):
-        return image_size // (2 ** self.layers)
-
-    def encode(self, x):
-        for enc in self.encoders:
-            x = enc(x)
-        return x
-
-    def decode(self, x):
-        for dec in self.decoders:
-            x = dec(x)
-        return x
-
 class GLUResBlock(nn.Module):
     def __init__(self, chan, groups = 16):
         super().__init__()
@@ -327,8 +243,6 @@ class ResBlock(nn.Module):
     def forward(self, x):
         return self.net(x) + x
 
-# vqgan attention layer
-
 class VQGanAttention(nn.Module):
     def __init__(
         self,
@@ -373,167 +287,6 @@ class VQGanAttention(nn.Module):
 
         return out + residual
 
-# ViT encoder / decoder
-
-class RearrangeImage(nn.Module):
-    def forward(self, x):
-        n = x.shape[1]
-        w = h = int(sqrt(n))
-        return rearrange(x, 'b (h w) ... -> b h w ...', h = h, w = w)
-
-class Attention(nn.Module):
-    def __init__(
-        self,
-        dim,
-        *,
-        heads = 8,
-        dim_head = 32
-    ):
-        super().__init__()
-        self.norm = nn.LayerNorm(dim)
-        self.heads = heads
-        self.scale = dim_head ** -0.5
-        inner_dim = dim_head * heads
-
-        self.to_qkv = nn.Linear(dim, inner_dim * 3, bias = False)
-        self.to_out = nn.Linear(inner_dim, dim)
-
-    def forward(self, x):
-        h = self.heads
-
-        x = self.norm(x)
-
-        q, k, v = self.to_qkv(x).chunk(3, dim = -1)
-        q, k, v = rearrange_many((q, k, v), 'b n (h d) -> b h n d', h = h)
-
-        q = q * self.scale
-        sim = einsum('b h i d, b h j d -> b h i j', q, k)
-
-        sim = sim - sim.amax(dim = -1, keepdim = True).detach()
-        attn = sim.softmax(dim = -1)
-
-        out = einsum('b h i j, b h j d -> b h i d', attn, v)
-
-        out = rearrange(out, 'b h n d -> b n (h d)')
-        return self.to_out(out)
-
-def FeedForward(dim, mult = 4):
-    return nn.Sequential(
-        nn.LayerNorm(dim),
-        nn.Linear(dim, dim * mult, bias = False),
-        nn.GELU(),
-        nn.Linear(dim * mult, dim, bias = False)
-    )
-
-class Transformer(nn.Module):
-    def __init__(
-        self,
-        dim,
-        *,
-        layers,
-        dim_head = 32,
-        heads = 8,
-        ff_mult = 4
-    ):
-        super().__init__()
-        self.layers = nn.ModuleList([])
-        for _ in range(layers):
-            self.layers.append(nn.ModuleList([
-                Attention(dim = dim, dim_head = dim_head, heads = heads),
-                FeedForward(dim = dim, mult = ff_mult)
-            ]))
-
-        self.norm = nn.LayerNorm(dim)
-
-    def forward(self, x):
-        for attn, ff in self.layers:
-            x = attn(x) + x
-            x = ff(x) + x
-
-        return self.norm(x)
-
-class ViTEncDec(nn.Module):
-    def __init__(
-        self,
-        dim,
-        channels = 3,
-        layers = 4,
-        patch_size = 8,
-        dim_head = 32,
-        heads = 8,
-        ff_mult = 4
-    ):
-        super().__init__()
-        self.encoded_dim = dim
-        self.patch_size = patch_size
-
-        input_dim = channels * (patch_size ** 2)
-
-        self.encoder = nn.Sequential(
-            Rearrange('b c (h p1) (w p2) -> b (h w) (p1 p2 c)', p1 = patch_size, p2 = patch_size),
-            nn.Linear(input_dim, dim),
-            Transformer(
-                dim = dim,
-                dim_head = dim_head,
-                heads = heads,
-                ff_mult = ff_mult,
-                layers = layers
-            ),
-            RearrangeImage(),
-            Rearrange('b h w c -> b c h w')
-        )
-
-        self.decoder = nn.Sequential(
-            Rearrange('b c h w -> b (h w) c'),
-            Transformer(
-                dim = dim,
-                dim_head = dim_head,
-                heads = heads,
-                ff_mult = ff_mult,
-                layers = layers
-            ),
-            nn.Sequential(
-                nn.Linear(dim, dim * 4, bias = False),
-                nn.Tanh(),
-                nn.Linear(dim * 4, input_dim, bias = False),
-            ),
-            RearrangeImage(),
-            Rearrange('b h w (p1 p2 c) -> b c (h p1) (w p2)', p1 = patch_size, p2 = patch_size)
-        )
-
-    def get_encoded_fmap_size(self, image_size):
-        return image_size // self.patch_size
-
-    def encode(self, x):
-        return self.encoder(x)
-
-    def decode(self, x):
-        return self.decoder(x)
-
-# main vqgan-vae classes
-
-class NullVQGanVAE(nn.Module):
-    def __init__(
-        self,
-        *,
-        channels
-    ):
-        super().__init__()
-        self.encoded_dim = channels
-        self.layers = 0
-
-    def get_encoded_fmap_size(self, size):
-        return size
-
-    def copy_for_eval(self):
-        return self
-
-    def encode(self, x):
-        return x
-
-    def decode(self, x):
-        return x
-
 class VQGanVAE(nn.Module):
     def __init__(
         self,
@@ -542,45 +295,81 @@ class VQGanVAE(nn.Module):
         image_size,
         channels = 3,
         layers = 4,
+        layer_mults = None,
         l2_recon_loss = False,
         use_hinge_loss = True,
+        num_resnet_blocks = 1,
         vgg = None,
-        vq_codebook_dim = 256,
         vq_codebook_size = 512,
         vq_decay = 0.8,
         vq_commitment_weight = 1.,
         vq_kmeans_init = True,
         vq_use_cosine_sim = True,
+        use_attn = True,
+        attn_dim_head = 64,
+        attn_heads = 8,
+        resnet_groups = 16,
+        attn_dropout = 0.,
+        first_conv_kernel_size = 5,
         use_vgg_and_gan = True,
-        vae_type = 'resnet',
-        discr_layers = 4,
         **kwargs
     ):
         super().__init__()
+        assert dim % resnet_groups == 0, f'dimension {dim} must be divisible by {resnet_groups} (groups for the groupnorm)'
+
         vq_kwargs, kwargs = groupby_prefix_and_trim('vq_', kwargs)
-        encdec_kwargs, kwargs = groupby_prefix_and_trim('encdec_', kwargs)
 
         self.image_size = image_size
         self.channels = channels
+        self.layers = layers
+        self.fmap_size = image_size // (layers ** 2)
         self.codebook_size = vq_codebook_size
 
-        if vae_type == 'resnet':
-            enc_dec_klass = ResnetEncDec
-        elif vae_type == 'vit':
-            enc_dec_klass = ViTEncDec
-        else:
-            raise ValueError(f'{vae_type} not valid')
+        self.encoders = MList([])
+        self.decoders = MList([])
 
-        self.enc_dec = enc_dec_klass(
-            dim = dim,
-            channels = channels,
-            layers = layers,
-            **encdec_kwargs
-        )
+        layer_mults = default(layer_mults, list(map(lambda t: 2 ** t, range(layers))))
+        assert len(layer_mults) == layers, 'layer multipliers must be equal to designated number of layers'
+
+        layer_dims = [dim * mult for mult in layer_mults]
+        dims = (dim, *layer_dims)
+        codebook_dim = layer_dims[-1]
+
+        self.encoded_dim = dims[-1]
+
+        dim_pairs = zip(dims[:-1], dims[1:])
+
+        append = lambda arr, t: arr.append(t)
+        prepend = lambda arr, t: arr.insert(0, t)
+
+        if not isinstance(num_resnet_blocks, tuple):
+            num_resnet_blocks = (*((0,) * (layers - 1)), num_resnet_blocks)
+
+        if not isinstance(use_attn, tuple):
+            use_attn = (*((False,) * (layers - 1)), use_attn)
+
+        assert len(num_resnet_blocks) == layers, 'number of resnet blocks config must be equal to number of layers'
+        assert len(use_attn) == layers
+
+        for layer_index, (dim_in, dim_out), layer_num_resnet_blocks, layer_use_attn in zip(range(layers), dim_pairs, num_resnet_blocks, use_attn):
+            append(self.encoders, nn.Sequential(nn.Conv2d(dim_in, dim_out, 4, stride = 2, padding = 1), leaky_relu()))
+            prepend(self.decoders, nn.Sequential(nn.Upsample(scale_factor = 2, mode = 'bilinear', align_corners = False), nn.Conv2d(dim_out, dim_in, 3, padding = 1), leaky_relu()))
+
+            if layer_use_attn:
+                prepend(self.decoders, VQGanAttention(dim = dim_out, heads = attn_heads, dim_head = attn_dim_head, dropout = attn_dropout))
+
+            for _ in range(layer_num_resnet_blocks):
+                append(self.encoders, ResBlock(dim_out, groups = resnet_groups))
+                prepend(self.decoders, GLUResBlock(dim_out, groups = resnet_groups))
+
+            if layer_use_attn:
+                append(self.encoders, VQGanAttention(dim = dim_out, heads = attn_heads, dim_head = attn_dim_head, dropout = attn_dropout))
+
+        prepend(self.encoders, nn.Conv2d(channels, dim, first_conv_kernel_size, padding = first_conv_kernel_size // 2))
+        append(self.decoders, nn.Conv2d(dim, channels, 1))
 
         self.vq = VQ(
-            dim = self.enc_dec.encoded_dim,
-            codebook_dim = vq_codebook_dim,
+            dim = codebook_dim,
             codebook_size = vq_codebook_size,
             decay = vq_decay,
             commitment_weight = vq_commitment_weight,
@@ -613,22 +402,11 @@ class VQGanVAE(nn.Module):
 
         # gan related losses
 
-        layer_mults = list(map(lambda t: 2 ** t, range(discr_layers)))
-        layer_dims = [dim * mult for mult in layer_mults]
-        dims = (dim, *layer_dims)
-
         self.discr = Discriminator(dims = dims, channels = channels)
 
         self.discr_loss = hinge_discr_loss if use_hinge_loss else bce_discr_loss
         self.gen_loss = hinge_gen_loss if use_hinge_loss else bce_gen_loss
 
-    @property
-    def encoded_dim(self):
-        return self.enc_dec.encoded_dim
-
-    def get_encoded_fmap_size(self, image_size):
-        return self.enc_dec.get_encoded_fmap_size(image_size)
-
     def copy_for_eval(self):
         device = next(self.parameters()).device
         vae_copy = copy.deepcopy(self.cpu())
@@ -653,13 +431,16 @@ class VQGanVAE(nn.Module):
         return self.vq.codebook
 
     def encode(self, fmap):
-        fmap = self.enc_dec.encode(fmap)
+        for enc in self.encoders:
+            fmap = enc(fmap)
+
         return fmap
 
     def decode(self, fmap, return_indices_and_loss = False):
         fmap, indices, commit_loss = self.vq(fmap)
 
-        fmap = self.enc_dec.decode(fmap)
+        for dec in self.decoders:
+            fmap = dec(fmap)
 
         if not return_indices_and_loss:
             return fmap
@@ -671,8 +452,7 @@ class VQGanVAE(nn.Module):
         img,
         return_loss = False,
         return_discr_loss = False,
-        return_recons = False,
-        add_gradient_penalty = True
+        return_recons = False
     ):
         batch, channels, height, width, device = *img.shape, img.device
         assert height == self.image_size and width == self.image_size, 'height and width of input image must be equal to {self.image_size}'
@@ -697,11 +477,11 @@ class VQGanVAE(nn.Module):
 
             fmap_discr_logits, img_discr_logits = map(self.discr, (fmap, img))
 
+            gp = gradient_penalty(img, img_discr_logits)
+
             discr_loss = self.discr_loss(fmap_discr_logits, img_discr_logits)
 
-            if add_gradient_penalty:
-                gp = gradient_penalty(img, img_discr_logits)
-                loss = discr_loss + gp
+            loss = discr_loss + gp
 
             if return_recons:
                 return loss, fmap

setup.py

@@ -10,7 +10,7 @@ setup(
       'dream = dalle2_pytorch.cli:dream'
     ],
   },
-  version = '0.0.71',
+  version = '0.0.37',
   license='MIT',
   description = 'DALL-E 2',
   author = 'Phil Wang',
@@ -31,7 +31,7 @@ setup(
     'torchvision',
     'tqdm',
     'vector-quantize-pytorch',
-    'x-clip>=0.5.1',
+    'x-clip>=0.4.4',
     'youtokentome'
   ],
   classifiers=[