diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..5a1981d --- /dev/null +++ b/.gitattributes @@ -0,0 +1,2 @@ +* linguist-vendored +*.py linguist-vendored=false diff --git a/README.md b/README.md index 81f467d..8c9faa8 100644 --- a/README.md +++ b/README.md @@ -1,28 +1,33 @@ # min(DALL·E) -[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/kuprel/min-dalle/blob/main/min_dalle.ipynb) +[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/kuprel/min-dalle/blob/main/min_dalle.ipynb)   +[![Replicate](https://replicate.com/kuprel/min-dalle/badge)](https://replicate.com/kuprel/min-dalle) -This is a minimal implementation of [DALL·E Mini](https://github.com/borisdayma/dalle-mini). It has been stripped to the bare essentials necessary for doing inference, and converted to PyTorch. The only third party dependencies are `numpy` and `torch` for the torch model and `flax` for the flax model. +This is a minimal implementation of Boris Dayma's [DALL·E Mini](https://github.com/borisdayma/dalle-mini). It has been stripped to the bare essentials necessary for doing inference, and converted to PyTorch. To run the torch model, the only third party dependencies are numpy and torch. Flax is used to convert the weights (which are saved with `torch.save` the first time the model is loaded), and wandb is only used to download the models. + +It currently takes **7.4 seconds** to generate an image with DALL·E Mega with PyTorch on a standard GPU runtime in Colab ### Setup -Run `sh setup.sh` to install dependencies and download pretrained models. In the bash script, Git LFS is used to download the VQGan detokenizer from Hugging Face and the Weight & Biases python package is used to download the DALL·E Mini and DALL·E Mega transformer models. These models can also be downloaded manually: +Run `sh setup.sh` to install dependencies and download pretrained models. The models can also be downloaded manually here: [VQGan](https://huggingface.co/dalle-mini/vqgan_imagenet_f16_16384), [DALL·E Mini](https://wandb.ai/dalle-mini/dalle-mini/artifacts/DalleBart_model/mini-1/v0/files), [DALL·E Mega](https://wandb.ai/dalle-mini/dalle-mini/artifacts/DalleBart_model/mega-1-fp16/v14/files) ### Usage -Use the command line python script `image_from_text.py` to generate images. Here are some examples: +Use the python script `image_from_text.py` to generate images from the command line. Note: the command line script loads the models and parameters each time. To load a model once and generate multiple times, initialize either `MinDalleTorch` or `MinDalleFlax`, then call `generate_image` with some text and a seed. See the colab for an example. + +### Examples ``` -python image_from_text.py --text='alien life' --seed=7 +python image_from_text.py --text='artificial intelligence' --torch ``` -![Alien](examples/alien.png) +![Alien](examples/artificial_intelligence.png) ``` -python image_from_text.py --text='a comfy chair that looks like an avocado' --mega --seed=4 +python image_from_text.py --text='a comfy chair that looks like an avocado' --torch --mega --seed=10 ``` ![Avocado Armchair](examples/avocado_armchair.png) diff --git a/cog.yaml b/cog.yaml new file mode 100644 index 0000000..42e8f9b --- /dev/null +++ b/cog.yaml @@ -0,0 +1,12 @@ +build: + cuda: "11.0" + gpu: true + python_version: "3.8" + system_packages: + - "libgl1-mesa-glx" + - "libglib2.0-0" + python_packages: + - "torch==1.10.1" + - "flax==0.5.2" + +predict: "predict.py:Predictor" diff --git a/examples/alien.png b/examples/alien.png deleted file mode 100644 index cd4c59b..0000000 Binary files a/examples/alien.png and /dev/null differ diff --git a/examples/artificial_intelligence.png b/examples/artificial_intelligence.png new file mode 100644 index 0000000..978a6e4 Binary files /dev/null and b/examples/artificial_intelligence.png differ diff --git a/examples/avocado_armchair.png b/examples/avocado_armchair.png index f270df5..1dd2c87 100644 Binary files a/examples/avocado_armchair.png and b/examples/avocado_armchair.png differ diff --git a/image_from_text.py b/image_from_text.py index a56522d..c00d6af 100644 --- a/image_from_text.py +++ b/image_from_text.py @@ -2,8 +2,8 @@ import argparse import os from PIL import Image -from min_dalle.generate_image import generate_image_from_text - +from min_dalle.min_dalle_torch import MinDalleTorch +from min_dalle.min_dalle_flax import MinDalleFlax parser = argparse.ArgumentParser() parser.add_argument('--mega', action='store_true') @@ -12,10 +12,10 @@ parser.set_defaults(mega=False) parser.add_argument('--torch', action='store_true') parser.add_argument('--no-torch', dest='torch', action='store_false') parser.set_defaults(torch=False) -parser.add_argument('--text', type=str) -parser.add_argument('--seed', type=int, default=0) +parser.add_argument('--text', type=str, default='alien life') +parser.add_argument('--seed', type=int, default=7) parser.add_argument('--image_path', type=str, default='generated') -parser.add_argument('--image_token_count', type=int, default=256) # for debugging +parser.add_argument('--token_count', type=int, default=256) # for debugging def ascii_from_image(image: Image.Image, size: int) -> str: @@ -36,19 +36,41 @@ def save_image(image: Image.Image, path: str): return image +def generate_image( + is_torch: bool, + is_mega: bool, + text: str, + seed: int, + image_path: str, + token_count: int +): + is_reusable = False + if is_torch: + image_generator = MinDalleTorch(is_mega, is_reusable, token_count) + + if token_count < image_generator.config['image_length']: + image_tokens = image_generator.generate_image_tokens(text, seed) + print('image tokens', list(image_tokens.to('cpu').detach().numpy())) + return + else: + image = image_generator.generate_image(text, seed) + + else: + image_generator = MinDalleFlax(is_mega, is_reusable) + image = image_generator.generate_image(text, seed) + + save_image(image, image_path) + print(ascii_from_image(image, size=128)) + + if __name__ == '__main__': args = parser.parse_args() - print(args) - - image = generate_image_from_text( - text = args.text, - is_mega = args.mega, - is_torch = args.torch, - seed = args.seed, - image_token_count = args.image_token_count - ) - - if image != None: - save_image(image, args.image_path) - print(ascii_from_image(image, size=128)) \ No newline at end of file + generate_image( + is_torch=args.torch, + is_mega=args.mega, + text=args.text, + seed=args.seed, + image_path=args.image_path, + token_count=args.token_count + ) \ No newline at end of file diff --git a/min_dalle.ipynb b/min_dalle.ipynb index e1fcf82..43e57e0 100644 --- a/min_dalle.ipynb +++ b/min_dalle.ipynb @@ -3,8 +3,8 @@ { "cell_type": "markdown", "metadata": { - "colab_type": "text", - "id": "view-in-github" + "id": "view-in-github", + "colab_type": "text" }, "source": [ "\"Open" @@ -25,28 +25,67 @@ "id": "Zl_ZFisFApeh" }, "source": [ - "### Setup" + "### Download models and install dependencies" ] }, { "cell_type": "code", "execution_count": null, "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "ix_xt4X1_6F4", - "outputId": "59ad2c80-4782-4ce3-ba9e-44b5afaa7e48" + "cellView": "code", + "id": "ix_xt4X1_6F4" }, "outputs": [], "source": [ - "#@title Setup\n", - "! git clone https://github.com/kuprel/min-dalle\n", - "! git lfs install\n", - "! git clone https://huggingface.co/dalle-mini/vqgan_imagenet_f16_16384 /content/min-dalle/pretrained/vqgan\n", - "! pip install torch flax==0.4.2 wandb\n", - "! wandb login --anonymously\n", - "! wandb artifact get --root=/content/min-dalle/pretrained/dalle_bart_mini dalle-mini/dalle-mini/mini-1:v0" + "%%shell\n", + "\n", + "git clone https://github.com/kuprel/min-dalle\n", + "mkdir -p /content/min-dalle/pretrained/vqgan/\n", + "curl https://huggingface.co/dalle-mini/vqgan_imagenet_f16_16384/resolve/main/flax_model.msgpack -L --output /content/min-dalle/pretrained/vqgan/flax_model.msgpack\n", + "pip install torch flax wandb\n", + "wandb login --anonymously\n", + "wandb artifact get --root=/content/min-dalle/pretrained/dalle_bart_mega dalle-mini/dalle-mini/mega-1-fp16:v14\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kViq2dMbGDKt" + }, + "source": [ + "### Load Model" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "8W-L2ICFGFup", + "outputId": "952470ce-4ea3-4245-818e-db10e5b75b2d" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "initializing MinDalleTorch\n", + "reading files from pretrained/dalle_bart_mega\n", + "converting params to torch\n", + "initializing DalleBartEncoderTorch\n", + "initializing DalleBartDecoderTorch\n", + "initializing VQGanDetokenizer\n" + ] + } + ], + "source": [ + "import os\n", + "os.chdir('/content/min-dalle')\n", + "from min_dalle.min_dalle_torch import MinDalleTorch\n", + "\n", + "model = MinDalleTorch(is_mega=True, is_reusable=True)" ] }, { @@ -60,69 +99,72 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 11, "metadata": { "colab": { "base_uri": "https://localhost:8080/", - "height": 480 + "height": 511 }, "id": "nQ0UG05dA4p2", - "outputId": "2da437dc-9e62-448a-8398-73f87a2e313a" + "outputId": "af0aa7a3-a339-4d98-8ec6-e680aa153f8a" }, "outputs": [ { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ - "parsing metadata from ./pretrained/dalle_bart_mini\n", "tokenizing text\n", - "['Ġalien']\n", - "['Ġlife']\n", - "text tokens [0, 8925, 742, 2]\n", - "loading flax encoder\n", + "['Ġcctv']\n", + "['Ġof']\n", + "['Ġyoda']\n", + "['Ġrob', 'bing']\n", + "['Ġa']\n", + "['Ġliquor']\n", + "['Ġstore']\n", + "text tokens [0, 17685, 111, 24509, 976, 11811, 58, 13142, 1110, 2]\n", "encoding text tokens\n", - "loading flax decoder\n", "sampling image tokens\n", - "image tokens [6965, 6172, 1052, 14447, 6172, 12062, 15771, 2193, 10710, 4147, 1052, 6172, 2528, 14447, 5772, 8447, 6965, 14447, 14447, 14447, 11665, 6879, 15798, 9479, 910, 15303, 5605, 7542, 1052, 14447, 14447, 2528, 6965, 1052, 14447, 6078, 3386, 2519, 12838, 16017, 867, 8447, 11993, 12426, 11196, 14447, 14447, 2528, 6965, 14447, 14447, 7491, 16147, 13512, 8269, 271, 10397, 15945, 15945, 4903, 12892, 14447, 14447, 2528, 6965, 14447, 14447, 351, 358, 10362, 6001, 8612, 14037, 7864, 14246, 5201, 2810, 14447, 14447, 2528, 6965, 14447, 14447, 10549, 15618, 11792, 13401, 16223, 1464, 12861, 6992, 572, 601, 14447, 14447, 2528, 6965, 14447, 14447, 14447, 13183, 194, 14633, 1994, 10912, 2778, 5495, 12187, 2528, 14447, 14447, 2528, 6965, 14447, 14447, 14447, 2528, 14068, 4054, 5071, 1948, 5286, 7771, 12062, 12016, 14447, 14447, 2528, 6965, 14447, 14447, 14447, 7504, 15433, 7781, 4816, 12062, 663, 3812, 8447, 8173, 14447, 14447, 2528, 6965, 14447, 14447, 6078, 13401, 6790, 2813, 10121, 4301, 4811, 5984, 3851, 8493, 14447, 14447, 2528, 6965, 14447, 14447, 4465, 12509, 4238, 12290, 10543, 8222, 11348, 13909, 5919, 6965, 14447, 14447, 2528, 11591, 14447, 6172, 11665, 9501, 2810, 9570, 7781, 910, 10549, 4395, 10639, 16147, 8173, 14164, 2528, 11591, 14164, 11993, 11610, 15891, 6242, 1936, 14602, 4903, 3583, 11574, 7516, 12892, 8173, 14447, 2528, 11591, 7467, 5243, 13157, 2810, 6790, 16017, 7236, 4301, 11725, 10689, 11941, 12659, 8173, 1052, 2528, 6965, 6598, 4465, 4816, 2895, 11820, 3132, 15917, 1811, 4904, 6933, 6690, 4811, 7504, 2528, 11605, 7467, 4815, 351, 6948, 10228, 7771, 9479, 9213, 11196, 6628, 9897, 12480, 5885, 14247, 5772, 5772]\n", "detokenizing image\n" ] }, { + "output_type": "display_data", "data": { - "image/png": "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", "text/plain": [ - "" - ] + "" + ], + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "CPU times: user 7.76 s, sys: 12.6 ms, total: 7.77 s\n", + "Wall time: 7.72 s\n" + ] } ], "source": [ - "#@title Default title text\n", - "text = \"alien life\" #@param {type:\"string\"}\n", - "seed = 7#@param {type:\"integer\"}\n", - "torch = True\n", - "mega = False\n", + "%%time\n", "\n", - "import os\n", - "os.chdir('/content/min-dalle')\n", - "from min_dalle.generate_image import generate_image_from_text\n", - "image = generate_image_from_text(text, seed=seed)\n", - "display(image)" + "text = \"cctv of yoda robbing a liquor store\" #@param {type:\"string\"}\n", + "seed = 2 #@param {type:\"integer\"}\n", + "\n", + "display(model.generate_image(text, seed))" ] } ], "metadata": { "accelerator": "GPU", "colab": { - "authorship_tag": "ABX9TyMOl5R0K08QJNx12TxSCM7M", "collapsed_sections": [ "Zl_ZFisFApeh" ], - "include_colab_link": true, "name": "min-dalle", - "provenance": [] + "provenance": [], + "include_colab_link": true }, "gpuClass": "standard", "kernelspec": { @@ -135,4 +177,4 @@ }, "nbformat": 4, "nbformat_minor": 0 -} +} \ No newline at end of file diff --git a/min_dalle/generate_image.py b/min_dalle/generate_image.py deleted file mode 100644 index 401f9e2..0000000 --- a/min_dalle/generate_image.py +++ /dev/null @@ -1,77 +0,0 @@ -import os -import json -import numpy -from PIL import Image -from typing import Tuple, List - -from min_dalle.load_params import load_dalle_bart_flax_params -from min_dalle.text_tokenizer import TextTokenizer -from min_dalle.min_dalle_flax import generate_image_tokens_flax -from min_dalle.min_dalle_torch import ( - generate_image_tokens_torch, - detokenize_torch -) - -def load_dalle_bart_metadata(path: str) -> Tuple[dict, dict, List[str]]: - print("parsing metadata from {}".format(path)) - for f in ['config.json', 'flax_model.msgpack', 'vocab.json', 'merges.txt']: - assert(os.path.exists(os.path.join(path, f))) - with open(path + '/config.json', 'r') as f: - config = json.load(f) - with open(path + '/vocab.json') as f: - vocab = json.load(f) - with open(path + '/merges.txt') as f: - merges = f.read().split("\n")[1:-1] - return config, vocab, merges - - -def tokenize_text( - text: str, - config: dict, - vocab: dict, - merges: List[str] -) -> numpy.ndarray: - print("tokenizing text") - tokens = TextTokenizer(vocab, merges)(text) - print("text tokens", tokens) - text_tokens = numpy.ones((2, config['max_text_length']), dtype=numpy.int32) - text_tokens[0, :len(tokens)] = tokens - text_tokens[1, :2] = [tokens[0], tokens[-1]] - return text_tokens - - -def generate_image_from_text( - text: str, - is_mega: bool = False, - is_torch: bool = False, - seed: int = 0, - image_token_count: int = 256 -) -> Image.Image: - model_name = 'mega' if is_mega else 'mini' - model_path = './pretrained/dalle_bart_{}'.format(model_name) - config, vocab, merges = load_dalle_bart_metadata(model_path) - text_tokens = tokenize_text(text, config, vocab, merges) - params_dalle_bart = load_dalle_bart_flax_params(model_path) - - image_tokens = numpy.zeros(config['image_length']) - if is_torch: - image_tokens[:image_token_count] = generate_image_tokens_torch( - text_tokens = text_tokens, - seed = seed, - config = config, - params = params_dalle_bart, - image_token_count = image_token_count - ) - else: - image_tokens[...] = generate_image_tokens_flax( - text_tokens = text_tokens, - seed = seed, - config = config, - params = params_dalle_bart, - ) - - if image_token_count == config['image_length']: - image = detokenize_torch(image_tokens) - return Image.fromarray(image) - else: - return None \ No newline at end of file diff --git a/min_dalle/load_params.py b/min_dalle/load_params.py index fa66d89..c51a3a9 100644 --- a/min_dalle/load_params.py +++ b/min_dalle/load_params.py @@ -1,17 +1,17 @@ import os import numpy -from copy import deepcopy from typing import Dict -from flax import traverse_util, serialization +from flax.traverse_util import flatten_dict +from flax.serialization import msgpack_restore import torch -torch.no_grad() +torch.set_grad_enabled(False) def load_vqgan_torch_params(path: str) -> Dict[str, torch.Tensor]: with open(os.path.join(path, 'flax_model.msgpack'), "rb") as f: - params: Dict[str, numpy.ndarray] = serialization.msgpack_restore(f.read()) + params: Dict[str, numpy.ndarray] = msgpack_restore(f.read()) - P: Dict[str, numpy.ndarray] = traverse_util.flatten_dict(params, sep='.') + P: Dict[str, numpy.ndarray] = flatten_dict(params, sep='.') for i in list(P.keys()): j = i @@ -30,7 +30,6 @@ def load_vqgan_torch_params(path: str) -> Dict[str, torch.Tensor]: for i in P: P[i] = torch.tensor(P[i]) - if torch.cuda.is_available(): P[i] = P[i].cuda() P['embedding.weight'] = P.pop('quantize.embedding.embedding') @@ -43,7 +42,7 @@ def load_vqgan_torch_params(path: str) -> Dict[str, torch.Tensor]: def load_dalle_bart_flax_params(path: str) -> Dict[str, numpy.ndarray]: with open(os.path.join(path, "flax_model.msgpack"), "rb") as f: - params = serialization.msgpack_restore(f.read()) + params = msgpack_restore(f.read()) for codec in ['encoder', 'decoder']: k = 'FlaxBart{}Layers'.format(codec.title()) @@ -82,12 +81,10 @@ def convert_dalle_bart_torch_from_flax_params( layer_count: int, is_encoder: bool ) -> dict: - P = deepcopy(params) - P: Dict[str, numpy.ndarray] = traverse_util.flatten_dict(P, sep='.') + P: Dict[str, numpy.ndarray] = flatten_dict(params, sep='.') for i in P: - P[i] = torch.tensor(P[i]) - if torch.cuda.is_available(): P[i] = P[i].cuda() + P[i] = torch.tensor(P[i]).to(torch.float16) for i in list(P): if 'kernel' in i: @@ -107,4 +104,29 @@ def convert_dalle_bart_torch_from_flax_params( P['embed_tokens.weight'] = P.pop('embed_tokens.embedding') P['embed_positions.weight'] = P.pop('embed_positions.embedding') - return P \ No newline at end of file + return P + + +def convert_and_save_torch_params(is_mega: bool, model_path: str): + print("converting params to torch") + layer_count = 24 if is_mega else 12 + flax_params = load_dalle_bart_flax_params(model_path) + encoder_params = convert_dalle_bart_torch_from_flax_params( + flax_params['encoder'], + layer_count=layer_count, + is_encoder=True + ) + decoder_params = convert_dalle_bart_torch_from_flax_params( + flax_params['decoder'], + layer_count=layer_count, + is_encoder=False + ) + + for i in decoder_params: + decoder_params[i] = decoder_params[i].to(torch.float16) + + for i in encoder_params: + encoder_params[i] = encoder_params[i].to(torch.float16) + + torch.save(encoder_params, os.path.join(model_path, 'encoder.pt')) + torch.save(decoder_params, os.path.join(model_path, 'decoder.pt')) \ No newline at end of file diff --git a/min_dalle/min_dalle_base.py b/min_dalle/min_dalle_base.py new file mode 100644 index 0000000..1bde741 --- /dev/null +++ b/min_dalle/min_dalle_base.py @@ -0,0 +1,46 @@ +import os +import json +import numpy + +from .text_tokenizer import TextTokenizer +from .load_params import load_vqgan_torch_params, load_dalle_bart_flax_params +from .models.vqgan_detokenizer import VQGanDetokenizer + +class MinDalleBase: + def __init__(self, is_mega: bool): + self.is_mega = is_mega + model_name = 'dalle_bart_{}'.format('mega' if is_mega else 'mini') + self.model_path = os.path.join('pretrained', model_name) + + print("reading files from {}".format(self.model_path)) + config_path = os.path.join(self.model_path, 'config.json') + vocab_path = os.path.join(self.model_path, 'vocab.json') + merges_path = os.path.join(self.model_path, 'merges.txt') + + with open(config_path, 'r', encoding='utf8') as f: + self.config = json.load(f) + with open(vocab_path, 'r', encoding='utf8') as f: + vocab = json.load(f) + with open(merges_path, 'r', encoding='utf8') as f: + merges = f.read().split("\n")[1:-1] + + self.tokenizer = TextTokenizer(vocab, merges) + + + def init_detokenizer(self): + print("initializing VQGanDetokenizer") + params = load_vqgan_torch_params('./pretrained/vqgan') + self.detokenizer = VQGanDetokenizer() + self.detokenizer.load_state_dict(params) + del params + + + def tokenize_text(self, text: str) -> numpy.ndarray: + print("tokenizing text") + tokens = self.tokenizer.tokenize(text) + print("text tokens", tokens) + text_token_count = self.config['max_text_length'] + text_tokens = numpy.ones((2, text_token_count), dtype=numpy.int32) + text_tokens[0, :len(tokens)] = tokens + text_tokens[1, :2] = [tokens[0], tokens[-1]] + return text_tokens \ No newline at end of file diff --git a/min_dalle/min_dalle_flax.py b/min_dalle/min_dalle_flax.py index 884f271..176ce6b 100644 --- a/min_dalle/min_dalle_flax.py +++ b/min_dalle/min_dalle_flax.py @@ -1,79 +1,80 @@ import jax -from jax import numpy as jnp import numpy +from PIL import Image +import torch +from .min_dalle_base import MinDalleBase from .models.dalle_bart_encoder_flax import DalleBartEncoderFlax from .models.dalle_bart_decoder_flax import DalleBartDecoderFlax - -def encode_flax( - text_tokens: numpy.ndarray, - config: dict, - params: dict -) -> jnp.ndarray: - print("loading flax encoder") - encoder: DalleBartEncoderFlax = DalleBartEncoderFlax( - attention_head_count = config['encoder_attention_heads'], - embed_count = config['d_model'], - glu_embed_count = config['encoder_ffn_dim'], - text_token_count = config['max_text_length'], - text_vocab_count = config['encoder_vocab_size'], - layer_count = config['encoder_layers'] - ).bind({'params': params.pop('encoder')}) - - print("encoding text tokens") - encoder_state = encoder(text_tokens) - del encoder - return encoder_state +from .load_params import load_dalle_bart_flax_params -def decode_flax( - text_tokens: jnp.ndarray, - encoder_state: jnp.ndarray, - config: dict, - seed: int, - params: dict -) -> jnp.ndarray: - print("loading flax decoder") - decoder = DalleBartDecoderFlax( - image_token_count = config['image_length'], - text_token_count = config['max_text_length'], - image_vocab_count = config['image_vocab_size'], - attention_head_count = config['decoder_attention_heads'], - embed_count = config['d_model'], - glu_embed_count = config['decoder_ffn_dim'], - layer_count = config['decoder_layers'], - start_token = config['decoder_start_token_id'] - ) - print("sampling image tokens") - image_tokens = decoder.sample_image_tokens( - text_tokens, - encoder_state, - jax.random.PRNGKey(seed), - params.pop('decoder') - ) - del decoder - return image_tokens +class MinDalleFlax(MinDalleBase): + def __init__(self, is_mega: bool, is_reusable: bool = True): + super().__init__(is_mega) + self.is_reusable = is_reusable + print("initializing MinDalleFlax") + self.model_params = load_dalle_bart_flax_params(self.model_path) + if is_reusable: + self.init_encoder() + self.init_decoder() + self.init_detokenizer() -def generate_image_tokens_flax( - text_tokens: numpy.ndarray, - seed: int, - config: dict, - params: dict -) -> numpy.ndarray: - encoder_state = encode_flax( - text_tokens, - config, - params - ) - image_tokens = decode_flax( - text_tokens, - encoder_state, - config, - seed, - params - ) - image_tokens = numpy.array(image_tokens) - print("image tokens", list(image_tokens)) - return image_tokens \ No newline at end of file + def init_encoder(self): + print("initializing DalleBartEncoderFlax") + self.encoder: DalleBartEncoderFlax = DalleBartEncoderFlax( + attention_head_count = self.config['encoder_attention_heads'], + embed_count = self.config['d_model'], + glu_embed_count = self.config['encoder_ffn_dim'], + text_token_count = self.config['max_text_length'], + text_vocab_count = self.config['encoder_vocab_size'], + layer_count = self.config['encoder_layers'] + ).bind({'params': self.model_params.pop('encoder')}) + + + def init_decoder(self): + print("initializing DalleBartDecoderFlax") + self.decoder = DalleBartDecoderFlax( + image_token_count = self.config['image_length'], + text_token_count = self.config['max_text_length'], + image_vocab_count = self.config['image_vocab_size'], + attention_head_count = self.config['decoder_attention_heads'], + embed_count = self.config['d_model'], + glu_embed_count = self.config['decoder_ffn_dim'], + layer_count = self.config['decoder_layers'], + start_token = self.config['decoder_start_token_id'] + ) + + + def generate_image(self, text: str, seed: int) -> Image.Image: + text_tokens = self.tokenize_text(text) + + if not self.is_reusable: self.init_encoder() + print("encoding text tokens") + encoder_state = self.encoder(text_tokens) + if not self.is_reusable: del self.encoder + + if not self.is_reusable: + self.init_decoder() + params = self.model_params.pop('decoder') + else: + params = self.model_params['decoder'] + print("sampling image tokens") + image_tokens = self.decoder.sample_image_tokens( + text_tokens, + encoder_state, + jax.random.PRNGKey(seed), + params + ) + if not self.is_reusable: del self.decoder + + image_tokens = torch.tensor(numpy.array(image_tokens)) + + if not self.is_reusable: self.init_detokenizer() + print("detokenizing image") + image = self.detokenizer.forward(image_tokens).to(torch.uint8) + if not self.is_reusable: del self.detokenizer + image = Image.fromarray(image.to('cpu').detach().numpy()) + return image \ No newline at end of file diff --git a/min_dalle/min_dalle_torch.py b/min_dalle/min_dalle_torch.py index 3940815..e5a0699 100644 --- a/min_dalle/min_dalle_torch.py +++ b/min_dalle/min_dalle_torch.py @@ -1,113 +1,114 @@ -import numpy +import os +from PIL import Image from typing import Dict -from torch import LongTensor, FloatTensor +from torch import LongTensor import torch -torch.no_grad() +torch.set_grad_enabled(False) +torch.set_num_threads(os.cpu_count()) -from .models.vqgan_detokenizer import VQGanDetokenizer +from .load_params import ( + convert_and_save_torch_params, + load_dalle_bart_flax_params +) +from .min_dalle_base import MinDalleBase from .models.dalle_bart_encoder_torch import DalleBartEncoderTorch from .models.dalle_bart_decoder_torch import DalleBartDecoderTorch -from .load_params import ( - load_vqgan_torch_params, - convert_dalle_bart_torch_from_flax_params -) + +class MinDalleTorch(MinDalleBase): + def __init__( + self, + is_mega: bool, + is_reusable: bool = True, + token_count: int = 256 + ): + print("initializing MinDalleTorch") + super().__init__(is_mega) + self.is_reusable = is_reusable + self.token_count = token_count + + if not is_mega: + self.model_params = load_dalle_bart_flax_params(self.model_path) + + self.encoder_params_path = os.path.join(self.model_path, 'encoder.pt') + self.decoder_params_path = os.path.join(self.model_path, 'decoder.pt') + + is_converted = os.path.exists(self.encoder_params_path) + is_converted &= os.path.exists(self.decoder_params_path) + if not is_converted: + convert_and_save_torch_params(is_mega, self.model_path) + + if is_reusable: + self.init_encoder() + self.init_decoder() + self.init_detokenizer() -def encode_torch( - text_tokens: LongTensor, - config: dict, - params: dict -) -> FloatTensor: - print("loading torch encoder") - encoder = DalleBartEncoderTorch( - layer_count = config['encoder_layers'], - embed_count = config['d_model'], - attention_head_count = config['encoder_attention_heads'], - text_vocab_count = config['encoder_vocab_size'], - text_token_count = config['max_text_length'], - glu_embed_count = config['encoder_ffn_dim'] - ) - encoder_params = convert_dalle_bart_torch_from_flax_params( - params.pop('encoder'), - layer_count=config['encoder_layers'], - is_encoder=True - ) - encoder.load_state_dict(encoder_params, strict=False) - del encoder_params - - print("encoding text tokens") - encoder_state = encoder(text_tokens) - del encoder - return encoder_state + def init_encoder(self): + print("initializing DalleBartEncoderTorch") + self.encoder = DalleBartEncoderTorch( + layer_count = self.config['encoder_layers'], + embed_count = self.config['d_model'], + attention_head_count = self.config['encoder_attention_heads'], + text_vocab_count = self.config['encoder_vocab_size'], + text_token_count = self.config['max_text_length'], + glu_embed_count = self.config['encoder_ffn_dim'] + ) + params = torch.load(self.encoder_params_path) + self.encoder.load_state_dict(params, strict=False) + del params + if torch.cuda.is_available(): self.encoder = self.encoder.cuda() -def decode_torch( - text_tokens: LongTensor, - encoder_state: FloatTensor, - config: dict, - seed: int, - params: dict, - image_token_count: int -) -> LongTensor: - print("loading torch decoder") - decoder = DalleBartDecoderTorch( - image_vocab_size = config['image_vocab_size'], - image_token_count = config['image_length'], - sample_token_count = image_token_count, - embed_count = config['d_model'], - attention_head_count = config['decoder_attention_heads'], - glu_embed_count = config['decoder_ffn_dim'], - layer_count = config['decoder_layers'], - batch_count = 2, - start_token = config['decoder_start_token_id'], - is_verbose = True - ) - decoder_params = convert_dalle_bart_torch_from_flax_params( - params.pop('decoder'), - layer_count=config['decoder_layers'], - is_encoder=False - ) - decoder.load_state_dict(decoder_params, strict=False) - del decoder_params + def init_decoder(self): + print("initializing DalleBartDecoderTorch") + self.decoder = DalleBartDecoderTorch( + image_vocab_size = self.config['image_vocab_size'], + image_token_count = self.config['image_length'], + sample_token_count = self.token_count, + embed_count = self.config['d_model'], + attention_head_count = self.config['decoder_attention_heads'], + glu_embed_count = self.config['decoder_ffn_dim'], + layer_count = self.config['decoder_layers'], + batch_count = 2, + start_token = self.config['decoder_start_token_id'], + is_verbose = True + ) + params = torch.load(self.decoder_params_path) + self.decoder.load_state_dict(params, strict=False) + del params + if torch.cuda.is_available(): self.decoder = self.decoder.cuda() - print("sampling image tokens") - torch.manual_seed(seed) - image_tokens = decoder.forward(text_tokens, encoder_state) - return image_tokens + + def init_detokenizer(self): + super().init_detokenizer() + if torch.cuda.is_available(): + self.detokenizer = self.detokenizer.cuda() + + def generate_image_tokens(self, text: str, seed: int) -> LongTensor: + text_tokens = self.tokenize_text(text) + text_tokens = torch.tensor(text_tokens).to(torch.long) + if torch.cuda.is_available(): text_tokens = text_tokens.cuda() -def generate_image_tokens_torch( - text_tokens: numpy.ndarray, - seed: int, - config: dict, - params: dict, - image_token_count: int -) -> LongTensor: - text_tokens = torch.tensor(text_tokens).to(torch.long) - if torch.cuda.is_available(): text_tokens = text_tokens.cuda() - encoder_state = encode_torch( - text_tokens, - config, - params - ) - image_tokens = decode_torch( - text_tokens, - encoder_state, - config, - seed, - params, - image_token_count - ) - return image_tokens + if not self.is_reusable: self.init_encoder() + print("encoding text tokens") + encoder_state = self.encoder.forward(text_tokens) + if not self.is_reusable: del self.encoder + if not self.is_reusable: self.init_decoder() + print("sampling image tokens") + torch.manual_seed(seed) + image_tokens = self.decoder.forward(text_tokens, encoder_state) + if not self.is_reusable: del self.decoder + return image_tokens + -def detokenize_torch(image_tokens: LongTensor) -> numpy.ndarray: - print("detokenizing image") - model_path = './pretrained/vqgan' - params = load_vqgan_torch_params(model_path) - detokenizer = VQGanDetokenizer() - detokenizer.load_state_dict(params) - image = detokenizer.forward(image_tokens).to(torch.uint8) - return image.detach().numpy() - \ No newline at end of file + def generate_image(self, text: str, seed: int) -> Image.Image: + image_tokens = self.generate_image_tokens(text, seed) + if not self.is_reusable: self.init_detokenizer() + print("detokenizing image") + image = self.detokenizer.forward(image_tokens).to(torch.uint8) + if not self.is_reusable: del self.detokenizer + image = Image.fromarray(image.to('cpu').detach().numpy()) + return image \ No newline at end of file diff --git a/min_dalle/models/dalle_bart_decoder_flax.py b/min_dalle/models/dalle_bart_decoder_flax.py index caf28ec..edce6c2 100644 --- a/min_dalle/models/dalle_bart_decoder_flax.py +++ b/min_dalle/models/dalle_bart_decoder_flax.py @@ -13,46 +13,39 @@ class DecoderCrossAttentionFlax(AttentionFlax): encoder_state: jnp.ndarray, attention_mask: jnp.ndarray, ) -> jnp.ndarray: - keys: jnp.ndarray = self.k_proj(encoder_state) - values: jnp.ndarray = self.v_proj(encoder_state) - queries: jnp.ndarray = self.q_proj(decoder_state) - query_shape = queries.shape[:2] + (self.head_count, -1) - key_value_shape = keys.shape[:2] + (self.head_count, -1) - keys = keys.reshape(key_value_shape) - values = values.reshape(key_value_shape) - queries = queries.reshape(query_shape) - queries /= queries.shape[-1] ** 0.5 + keys = self.k_proj(encoder_state) + values = self.v_proj(encoder_state) + queries = self.q_proj(decoder_state) return self.forward(keys, values, queries, attention_mask) class DecoderSelfAttentionFlax(AttentionFlax): - def __call__(self, + def __call__( + self, decoder_state: jnp.ndarray, - keys_state: jnp.ndarray, - values_state: jnp.ndarray, + attention_state: jnp.ndarray, attention_mask: jnp.ndarray, state_index: tuple - ) -> Tuple[jnp.ndarray, Tuple[jnp.ndarray, jnp.ndarray]]: - shape_split = decoder_state.shape[:2] + (self.head_count, -1) - keys_state = lax.dynamic_update_slice( - keys_state, - self.k_proj(decoder_state).reshape(shape_split), + ) -> Tuple[jnp.ndarray, jnp.ndarray]: + keys = self.k_proj(decoder_state) + values = self.v_proj(decoder_state) + queries = self.q_proj(decoder_state) + + attention_state = lax.dynamic_update_slice( + attention_state, + jnp.concatenate([keys, values]), state_index ) - values_state = lax.dynamic_update_slice( - values_state, - self.v_proj(decoder_state).reshape(shape_split), - state_index - ) - queries = self.q_proj(decoder_state).reshape(shape_split) - queries /= queries.shape[-1] ** 0.5 + batch_count = decoder_state.shape[0] + keys, values = attention_state[:batch_count], attention_state[batch_count:] + decoder_state = self.forward( - keys_state, - values_state, + keys, + values, queries, attention_mask ) - return decoder_state, (keys_state, values_state) + return decoder_state, attention_state class DalleBartDecoderLayerFlax(nn.Module): @@ -77,14 +70,14 @@ class DalleBartDecoderLayerFlax(nn.Module): self.glu = GLUFlax(self.embed_count, self.glu_embed_count) @nn.compact - def __call__(self, + def __call__( + self, decoder_state: jnp.ndarray, encoder_state: jnp.ndarray, - keys_state: jnp.ndarray, - values_state: jnp.ndarray, + attention_state: jnp.ndarray, attention_mask: jnp.ndarray, token_index: int - ) -> Tuple[jnp.ndarray, Tuple[jnp.ndarray, jnp.ndarray]]: + ) -> Tuple[jnp.ndarray, jnp.ndarray]: # Self Attention residual = decoder_state decoder_state = self.pre_self_attn_layer_norm(decoder_state) @@ -92,12 +85,11 @@ class DalleBartDecoderLayerFlax(nn.Module): jnp.arange(self.image_token_count) < token_index + 1, (decoder_state.shape[0], 1) ) - decoder_state, keys_values_state = self.self_attn( + decoder_state, attention_state = self.self_attn( decoder_state, - keys_state, - values_state, + attention_state, self_attention_mask, - (0, token_index, 0, 0) + (0, token_index, 0) ) decoder_state = self.self_attn_layer_norm(decoder_state) decoder_state = residual + decoder_state @@ -118,15 +110,14 @@ class DalleBartDecoderLayerFlax(nn.Module): decoder_state = self.glu(decoder_state) decoder_state = residual + decoder_state - return decoder_state, keys_values_state + return decoder_state, attention_state @flax.struct.dataclass class SampleState: prev_token: jnp.ndarray prng_key: jnp.ndarray - keys_state: jnp.ndarray - values_state: jnp.ndarray + attention_state: jnp.ndarray def super_conditioned(logits: jnp.ndarray, a: float) -> jnp.ndarray: return a * logits[0, -1] + (1 - a) * logits[1, -1] @@ -157,10 +148,10 @@ class DalleBartDecoderFlax(nn.Module): ) self.layers = nn.scan( DalleBartDecoderLayerFlax, - variable_axes = { "params": 0, "cache": 0 }, + variable_axes = { "params": 0 }, split_rngs = { "params": True }, - in_axes = (nn.broadcast, 0, 0, nn.broadcast, nn.broadcast), - out_axes = (0, 0), + in_axes = (nn.broadcast, 0, nn.broadcast, nn.broadcast), + out_axes = 0, length=self.layer_count, )( self.image_token_count, @@ -173,32 +164,32 @@ class DalleBartDecoderFlax(nn.Module): self.final_ln = nn.LayerNorm(use_scale=False) self.lm_head = nn.Dense(self.image_vocab_count + 1, use_bias=False) - def __call__(self, + def __call__( + self, encoder_state: jnp.ndarray, - keys_state: jnp.ndarray, - values_state: jnp.ndarray, + attention_state: jnp.ndarray, attention_mask: jnp.ndarray, prev_token: int, token_index: int - ) -> Tuple[jnp.ndarray, jnp.ndarray, jnp.ndarray]: + ) -> Tuple[jnp.ndarray, jnp.ndarray]: batch_count = encoder_state.shape[0] ones = jnp.ones((batch_count, 1), dtype=jnp.int32) decoder_state = self.embed_tokens(prev_token * ones) decoder_state += self.embed_positions(token_index * ones) decoder_state = self.layernorm_embedding(decoder_state) - decoder_state, (keys_state, values_state) = self.layers( + decoder_state, attention_state = self.layers( decoder_state, encoder_state, - keys_state, - values_state, + attention_state, attention_mask, token_index ) decoder_state = self.final_ln(decoder_state) decoder_state = self.lm_head(decoder_state) - return decoder_state, keys_state, values_state + return decoder_state, attention_state - def sample_image_tokens(self, + def sample_image_tokens( + self, text_tokens: jnp.ndarray, encoder_state: jnp.ndarray, prng_key: jax.random.PRNGKey, @@ -209,12 +200,11 @@ class DalleBartDecoderFlax(nn.Module): def sample_next_image_token( state: SampleState, token_index: int - ) -> Tuple[SampleState, None]: - logits, keys_state, values_state = self.apply( + ) -> Tuple[SampleState, jnp.ndarray]: + logits, attention_state = self.apply( { 'params': params }, encoder_state = encoder_state, - keys_state = state.keys_state, - values_state = state.values_state, + attention_state = state.attention_state, attention_mask = attention_mask, prev_token = state.prev_token, token_index = token_index @@ -229,26 +219,23 @@ class DalleBartDecoderFlax(nn.Module): state = SampleState( prev_token = next_token, prng_key = prng_key_next, - keys_state = keys_state, - values_state = values_state + attention_state = attention_state ) return state, next_token batch_count = encoder_state.shape[0] - state_shape = ( + attention_state_shape = ( self.layer_count, - batch_count, + batch_count * 2, self.image_token_count, - self.attention_head_count, - self.embed_count // self.attention_head_count + self.embed_count ) initial_state = SampleState( prev_token = self.start_token, prng_key = prng_key, - keys_state = jnp.zeros(state_shape), - values_state = jnp.zeros(state_shape) + attention_state = jnp.zeros(attention_state_shape) ) _, image_tokens = lax.scan( diff --git a/min_dalle/models/dalle_bart_decoder_torch.py b/min_dalle/models/dalle_bart_decoder_torch.py index 6b4093d..e6376fd 100644 --- a/min_dalle/models/dalle_bart_decoder_torch.py +++ b/min_dalle/models/dalle_bart_decoder_torch.py @@ -1,7 +1,7 @@ from typing import List, Tuple import torch from torch import LongTensor, nn, FloatTensor, BoolTensor -torch.no_grad() +torch.set_grad_enabled(False) from .dalle_bart_encoder_torch import GLUTorch, AttentionTorch @@ -16,42 +16,35 @@ class DecoderCrossAttentionTorch(AttentionTorch): keys = self.k_proj.forward(encoder_state) values = self.v_proj.forward(encoder_state) queries = self.q_proj.forward(decoder_state) - query_shape = queries.shape[:2] + (self.head_count, -1) - key_value_shape = keys.shape[:2] + (self.head_count, -1) - keys = keys.reshape(key_value_shape) - values = values.reshape(key_value_shape) - queries = queries.reshape(query_shape) - queries /= queries.shape[-1] ** 0.5 return super().forward(keys, values, queries, attention_mask) class DecoderSelfAttentionTorch(AttentionTorch): - def forward(self, + def forward( + self, decoder_state: FloatTensor, - keys_values: FloatTensor, + attention_state: FloatTensor, attention_mask: BoolTensor, - token_index: LongTensor + token_mask: BoolTensor ) -> Tuple[FloatTensor, FloatTensor]: - batch_count = decoder_state.shape[0] - token_count = keys_values.shape[1] - shape = (batch_count, 1) + keys_values.shape[2:] - keys = self.k_proj.forward(decoder_state).view(shape) - values = self.v_proj.forward(decoder_state).view(shape) - token_mask = torch.arange(token_count) == token_index - keys_values = torch.where( - token_mask[None, :, None, None], + keys = self.k_proj.forward(decoder_state) + values = self.v_proj.forward(decoder_state) + queries = self.q_proj.forward(decoder_state) + attention_state = torch.where( + token_mask[None, :, None], torch.cat([keys, values]), - keys_values + attention_state ) - queries = self.q_proj.forward(decoder_state).reshape(shape) - queries /= queries.shape[-1] ** 0.5 - keys, values = keys_values[:batch_count], keys_values[batch_count:] + batch_count = decoder_state.shape[0] + keys = attention_state[:batch_count] + values = attention_state[batch_count:] decoder_state = super().forward(keys, values, queries, attention_mask) - return decoder_state, keys_values + return decoder_state, attention_state class DecoderLayerTorch(nn.Module): - def __init__(self, + def __init__( + self, image_token_count: int, head_count: int, embed_count: int, @@ -67,23 +60,29 @@ class DecoderLayerTorch(nn.Module): self.encoder_attn_layer_norm = nn.LayerNorm(embed_count) self.glu = GLUTorch(embed_count, glu_embed_count) - def forward(self, + self.token_indices = torch.arange(self.image_token_count) + if torch.cuda.is_available(): + self.token_indices = self.token_indices.cuda() + + def forward( + self, decoder_state: FloatTensor, encoder_state: FloatTensor, - keys_values_state: FloatTensor, + attention_state: FloatTensor, attention_mask: BoolTensor, token_index: LongTensor ) -> Tuple[FloatTensor, FloatTensor]: # Self Attention residual = decoder_state decoder_state = self.pre_self_attn_layer_norm.forward(decoder_state) - self_attn_mask = torch.arange(self.image_token_count) < token_index + 1 + self_attn_mask = self.token_indices < token_index + 1 + token_mask = self.token_indices == token_index self_attn_mask = torch.stack([self_attn_mask] * decoder_state.shape[0]) - decoder_state, keys_values_state = self.self_attn.forward( + decoder_state, attention_state = self.self_attn.forward( decoder_state, - keys_values_state, + attention_state, self_attn_mask, - token_index + token_mask ) decoder_state = self.self_attn_layer_norm.forward(decoder_state) decoder_state = residual + decoder_state @@ -104,11 +103,12 @@ class DecoderLayerTorch(nn.Module): decoder_state = self.glu.forward(decoder_state) decoder_state = residual + decoder_state - return decoder_state, keys_values_state + return decoder_state, attention_state class DalleBartDecoderTorch(nn.Module): - def __init__(self, + def __init__( + self, image_vocab_size: int, image_token_count: int, sample_token_count: int, @@ -124,13 +124,7 @@ class DalleBartDecoderTorch(nn.Module): self.is_verbose = is_verbose self.layer_count = layer_count self.sample_token_count = sample_token_count - self.start_token = torch.tensor([start_token]).to(torch.long) - self.pad_token = torch.tensor([1]).to(torch.long) - self.condition_factor = torch.tensor([10]).to(torch.float) - if torch.cuda.is_available(): - self.start_token = self.start_token.cuda() - self.pad_token = self.pad_token.cuda() - self.condition_factor = self.condition_factor.cuda() + self.condition_factor = 10.0 self.image_token_count = image_token_count self.embed_tokens = nn.Embedding(image_vocab_size + 1, embed_count) self.embed_positions = nn.Embedding(image_token_count, embed_count) @@ -146,77 +140,82 @@ class DalleBartDecoderTorch(nn.Module): self.layernorm_embedding = nn.LayerNorm(embed_count) self.final_ln = nn.LayerNorm(embed_count) self.lm_head = nn.Linear(embed_count, image_vocab_size + 1, bias=False) - self.keys_values_state_shape = ( - layer_count * 2 * batch_count, + self.attention_state_shape = ( + layer_count, + 2 * batch_count, image_token_count, - attention_head_count, - embed_count // attention_head_count + embed_count ) + self.zero_prob = torch.zeros([1]) + self.token_indices = torch.arange(self.sample_token_count) + self.start_token = torch.tensor([start_token]).to(torch.long) + if torch.cuda.is_available(): + self.zero_prob = self.zero_prob.cuda() + self.token_indices = self.token_indices.cuda() + self.start_token = self.start_token.cuda() - def decode_step(self, + def decode_step( + self, text_tokens: LongTensor, encoder_state: FloatTensor, - keys_values_state: FloatTensor, - prev_token_and_index: LongTensor + attention_state: FloatTensor, + prev_token: LongTensor, + token_index: LongTensor ) -> Tuple[LongTensor, FloatTensor]: - attention_mask = text_tokens.not_equal(self.pad_token) + attention_mask = text_tokens.not_equal(1) batch_count = encoder_state.shape[0] - prev_token = torch.cat([prev_token_and_index[:1]] * batch_count) - token_index = torch.cat([prev_token_and_index[1:]] * batch_count) - decoder_state = self.embed_tokens.forward(prev_token) - decoder_state += self.embed_positions.forward(token_index) + prev_token_batched = torch.cat([prev_token] * batch_count) + token_index_batched = torch.cat([token_index] * batch_count) + decoder_state = self.embed_tokens.forward(prev_token_batched) + decoder_state += self.embed_positions.forward(token_index_batched) decoder_state = self.layernorm_embedding.forward(decoder_state) decoder_state = decoder_state[:, None] - keys_values = [] - for i, layer in enumerate(self.layers): - j1, j2 = i * 2 * batch_count, (i + 1) * 2 * batch_count - decoder_state, keys_values_layer = layer.forward( + attention_states_new = [] + for i in range(self.layer_count): + decoder_state, attention_state_layer = self.layers[i].forward( decoder_state, encoder_state, - keys_values_state[j1:j2], + attention_state[i], attention_mask, - token_index[:1] + token_index ) - keys_values.append(keys_values_layer) - keys_values = torch.cat(keys_values, dim=0) + attention_states_new.append(attention_state_layer) decoder_state = self.final_ln(decoder_state) logits = self.lm_head(decoder_state) a = self.condition_factor logits: FloatTensor = a * logits[0, -1] + (1 - a) * logits[1, -1] - top_logits = logits.sort(descending=True)[0][:50] + top_logits, _ = logits.topk(50, dim=-1) probs = torch.where( logits < top_logits[-1], - torch.zeros([1]), + self.zero_prob, torch.exp(logits - top_logits[0]) ) - return probs, keys_values + return probs, torch.stack(attention_states_new) - def forward(self, + def forward( + self, text_tokens: LongTensor, encoder_state: FloatTensor ) -> LongTensor: image_tokens: List[LongTensor] = [] - keys_values_state = torch.zeros(self.keys_values_state_shape) + attention_state = torch.zeros(self.attention_state_shape) + if torch.cuda.is_available(): + attention_state = attention_state.cuda() image_token = self.start_token for i in range(self.sample_token_count): - token_index = torch.tensor([i]).to(torch.long) - if torch.cuda.is_available(): token_index = token_index.cuda() - probs, keys_values_state = self.decode_step( + probs, attention_state = self.decode_step( text_tokens = text_tokens, encoder_state = encoder_state, - keys_values_state = keys_values_state, - prev_token_and_index = torch.cat([image_token, token_index]) + attention_state = attention_state, + prev_token = image_token, + token_index = self.token_indices[[i]] ) image_token = torch.multinomial(probs, 1) image_tokens += [image_token] - - if self.is_verbose: - token = int(image_token.detach().numpy()) - print("image token {} is {}".format(i, token)) return torch.cat(image_tokens) \ No newline at end of file diff --git a/min_dalle/models/dalle_bart_encoder_flax.py b/min_dalle/models/dalle_bart_encoder_flax.py index 71bbef3..7a1cc1b 100644 --- a/min_dalle/models/dalle_bart_encoder_flax.py +++ b/min_dalle/models/dalle_bart_encoder_flax.py @@ -34,12 +34,17 @@ class AttentionFlax(nn.Module): self.v_proj = nn.Dense(self.embed_count, use_bias=False) self.out_proj = nn.Dense(self.embed_count, use_bias=False) - def forward(self, + def forward( + self, keys: jnp.ndarray, values: jnp.ndarray, queries: jnp.ndarray, attention_mask: jnp.ndarray ) -> jnp.ndarray: + keys = keys.reshape(keys.shape[:2] + (self.head_count, -1)) + values = values.reshape(values.shape[:2] + (self.head_count, -1)) + queries = queries.reshape(queries.shape[:2] + (self.head_count, -1)) + queries /= queries.shape[-1] ** 0.5 attention_bias: jnp.ndarray = lax.select( attention_mask, jnp.full(attention_mask.shape, 0.0), @@ -69,11 +74,9 @@ class EncoderSelfAttentionFlax(AttentionFlax): encoder_state: jnp.ndarray, attention_mask: jnp.ndarray ) -> jnp.ndarray: - shape_split = encoder_state.shape[:2] + (self.head_count, -1) - keys = self.k_proj(encoder_state).reshape(shape_split) - values = self.v_proj(encoder_state).reshape(shape_split) - queries = self.q_proj(encoder_state).reshape(shape_split) - queries /= queries.shape[-1] ** 0.5 + keys = self.k_proj(encoder_state) + values = self.v_proj(encoder_state) + queries = self.q_proj(encoder_state) return self.forward(keys, values, queries, attention_mask) @@ -92,7 +95,8 @@ class DalleBartEncoderLayerFlax(nn.Module): self.glu = GLUFlax(self.embed_count, self.glu_embed_count) @nn.compact - def __call__(self, + def __call__( + self, encoder_state: jnp.ndarray, attention_mask: jnp.ndarray ) -> jnp.ndarray: @@ -120,7 +124,7 @@ class DalleBartEncoderFlax(nn.Module): self.embed_positions = nn.Embed(self.text_token_count, self.embed_count) self.layers = nn.scan( DalleBartEncoderLayerFlax, - variable_axes = { "params": 0, "cache": 0 }, + variable_axes = { "params": 0 }, split_rngs = { "params": True }, in_axes = nn.broadcast, length = self.layer_count diff --git a/min_dalle/models/dalle_bart_encoder_torch.py b/min_dalle/models/dalle_bart_encoder_torch.py index d21c542..296cdec 100644 --- a/min_dalle/models/dalle_bart_encoder_torch.py +++ b/min_dalle/models/dalle_bart_encoder_torch.py @@ -1,7 +1,7 @@ from typing import List import torch from torch import nn, BoolTensor, FloatTensor, LongTensor -torch.no_grad() +torch.set_grad_enabled(False) class GLUTorch(nn.Module): @@ -34,17 +34,25 @@ class AttentionTorch(nn.Module): self.v_proj = nn.Linear(embed_count, embed_count, bias=False) self.q_proj = nn.Linear(embed_count, embed_count, bias=False) self.out_proj = nn.Linear(embed_count, embed_count, bias=False) + self.one = torch.ones((1, 1)) + if torch.cuda.is_available(): self.one = self.one.cuda() - def forward(self, + def forward( + self, keys: FloatTensor, values: FloatTensor, queries: FloatTensor, attention_mask: BoolTensor ) -> FloatTensor: + keys = keys.reshape(keys.shape[:2] + (self.head_count, -1)) + values = values.reshape(values.shape[:2] + (self.head_count, -1)) + queries = queries.reshape(queries.shape[:2] + (self.head_count, -1)) + queries /= queries.shape[-1] ** 0.5 + attention_bias = torch.where( attention_mask, - torch.full(attention_mask.shape, 0.0), - torch.full(attention_mask.shape, -torch.inf), + self.one * 0, + self.one * (-torch.inf), ) attention_weights: FloatTensor = torch.einsum( 'bqhc,bkhc->bhqk', @@ -70,11 +78,9 @@ class EncoderSelfAttentionTorch(AttentionTorch): encoder_state: FloatTensor, attention_mask: BoolTensor ) -> FloatTensor: - shape_split = encoder_state.shape[:2] + (self.head_count, -1) - keys = self.k_proj.forward(encoder_state).reshape(shape_split) - values = self.v_proj.forward(encoder_state).reshape(shape_split) - queries = self.q_proj.forward(encoder_state).reshape(shape_split) - queries /= queries.shape[-1] ** 0.5 + keys = self.k_proj.forward(encoder_state) + values = self.v_proj.forward(encoder_state) + queries = self.q_proj.forward(encoder_state) return super().forward(keys, values, queries, attention_mask) @@ -103,7 +109,8 @@ class EncoderLayerTorch(nn.Module): class DalleBartEncoderTorch(nn.Module): - def __init__(self, + def __init__( + self, layer_count: int, embed_count: int, attention_head_count: int, @@ -124,11 +131,14 @@ class DalleBartEncoderTorch(nn.Module): ]) self.layernorm_embedding = nn.LayerNorm(embed_count) self.final_ln = nn.LayerNorm(embed_count) + self.token_indices = torch.arange(text_token_count).to(torch.long) + if torch.cuda.is_available(): + self.token_indices = self.token_indices.cuda() def forward(self, text_tokens: LongTensor) -> FloatTensor: attention_mask = text_tokens.not_equal(1) - batch_count, token_count = text_tokens.shape - pose_tokens = torch.stack([torch.arange(token_count)] * batch_count) + batch_count = text_tokens.shape[0] + pose_tokens = torch.stack([self.token_indices] * batch_count) encoder_state = ( self.embed_tokens.forward(text_tokens) + self.embed_positions.forward(pose_tokens) diff --git a/min_dalle/models/vqgan_detokenizer.py b/min_dalle/models/vqgan_detokenizer.py index e74416e..1233046 100644 --- a/min_dalle/models/vqgan_detokenizer.py +++ b/min_dalle/models/vqgan_detokenizer.py @@ -1,7 +1,7 @@ import torch from torch import Tensor from torch.nn import Module, ModuleList, GroupNorm, Conv2d, Embedding -torch.no_grad() +torch.set_grad_enabled(False) BATCH_COUNT: int = 1 @@ -61,6 +61,7 @@ class AttentionBlock(Module): h = self.proj_out.forward(h) return x + h + class MiddleLayer(Module): def __init__(self): super().__init__() @@ -74,6 +75,7 @@ class MiddleLayer(Module): h = self.block_2.forward(h) return h + class Upsample(Module): def __init__(self, log2_count): super().__init__() @@ -86,6 +88,7 @@ class Upsample(Module): x = self.conv.forward(x) return x + class UpsampleBlock(Module): def __init__( self, @@ -124,6 +127,7 @@ class UpsampleBlock(Module): h = self.upsample.forward(h) return h + class Decoder(Module): def __init__(self): super().__init__() @@ -154,6 +158,7 @@ class Decoder(Module): z = self.conv_out.forward(z) return z + class VQGanDetokenizer(Module): def __init__(self): super().__init__() diff --git a/min_dalle/text_tokenizer.py b/min_dalle/text_tokenizer.py index 1d601e6..1d06349 100644 --- a/min_dalle/text_tokenizer.py +++ b/min_dalle/text_tokenizer.py @@ -8,7 +8,7 @@ class TextTokenizer: pairs = [tuple(pair.split()) for pair in merges] self.rank_from_pair = dict(zip(pairs, range(len(pairs)))) - def __call__(self, text: str) -> List[int]: + def tokenize(self, text: str) -> List[int]: sep_token = self.token_from_subword[''] cls_token = self.token_from_subword[''] unk_token = self.token_from_subword[''] diff --git a/predict.py b/predict.py new file mode 100644 index 0000000..6c6701f --- /dev/null +++ b/predict.py @@ -0,0 +1,23 @@ +import tempfile +from cog import BasePredictor, Path, Input + +from min_dalle.min_dalle_torch import MinDalleTorch + +class Predictor(BasePredictor): + def setup(self): + self.model = MinDalleTorch(is_mega=True) + + def predict( + self, + text: str = Input( + description="Text for generating images.", + ), + seed: int = Input( + description="Specify the seed.", + ), + ) -> Path: + image = self.model.generate_image(text, seed) + out_path = Path(tempfile.mkdtemp()) / "output.png" + image.save(str(out_path)) + + return out_path \ No newline at end of file diff --git a/requirements.txt b/requirements.txt index 3ff893b..c9d8923 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,2 +1,3 @@ torch flax==0.4.2 +wandb diff --git a/setup.sh b/setup.sh index 4793242..d405671 100644 --- a/setup.sh +++ b/setup.sh @@ -1,15 +1,15 @@ #!/bin/bash +set -e + pip install -r requirements.txt -mkdir -p pretrained +mkdir -p pretrained/vqgan # download vqgan -git lfs install -git clone https://huggingface.co/dalle-mini/vqgan_imagenet_f16_16384 ./pretrained/vqgan +curl https://huggingface.co/dalle-mini/vqgan_imagenet_f16_16384/resolve/main/flax_model.msgpack -L --output ./pretrained/vqgan/flax_model.msgpack # download dalle-mini and dalle mega -pip install wandb -python -m wandb login +python -m wandb login --anonymously python -m wandb artifact get --root=./pretrained/dalle_bart_mini dalle-mini/dalle-mini/mini-1:v0 python -m wandb artifact get --root=./pretrained/dalle_bart_mega dalle-mini/dalle-mini/mega-1-fp16:v14