From ec254fa1488c4b6fac2bb371bc652863b36b2249 Mon Sep 17 00:00:00 2001 From: Keita Watanabe Date: Mon, 26 Feb 2024 12:19:30 +0000 Subject: [PATCH 01/16] initial commit --- 3.test_cases/15.neuron-distributed/LICENSE | 7 + 3.test_cases/15.neuron-distributed/README.md | 171 +++++++++ 3.test_cases/15.neuron-distributed/demo.ipynb | 331 ++++++++++++++++++ .../15.neuron-distributed/docs/README.md | 147 ++++++++ .../15.neuron-distributed/generate.ipynb | 166 +++++++++ 3.test_cases/15.neuron-distributed/mingpt.jpg | Bin 0 -> 118276 bytes .../15.neuron-distributed/mingpt/__init__.py | 0 .../15.neuron-distributed/mingpt/bpe.py | 319 +++++++++++++++++ .../15.neuron-distributed/mingpt/model.py | 310 ++++++++++++++++ .../15.neuron-distributed/mingpt/trainer.py | 109 ++++++ .../15.neuron-distributed/mingpt/utils.py | 103 ++++++ .../projects/adder/adder.py | 207 +++++++++++ .../projects/adder/readme.md | 4 + .../projects/chargpt/chargpt.py | 133 +++++++ .../projects/chargpt/readme.md | 9 + .../15.neuron-distributed/projects/readme.md | 4 + 3.test_cases/15.neuron-distributed/setup.py | 12 + .../tests/test_huggingface_import.py | 57 +++ 18 files changed, 2089 insertions(+) create mode 100644 3.test_cases/15.neuron-distributed/LICENSE create mode 100644 3.test_cases/15.neuron-distributed/README.md create mode 100644 3.test_cases/15.neuron-distributed/demo.ipynb create mode 100644 3.test_cases/15.neuron-distributed/docs/README.md create mode 100644 3.test_cases/15.neuron-distributed/generate.ipynb create mode 100644 3.test_cases/15.neuron-distributed/mingpt.jpg create mode 100644 3.test_cases/15.neuron-distributed/mingpt/__init__.py create mode 100644 3.test_cases/15.neuron-distributed/mingpt/bpe.py create mode 100644 3.test_cases/15.neuron-distributed/mingpt/model.py create mode 100644 3.test_cases/15.neuron-distributed/mingpt/trainer.py create mode 100644 3.test_cases/15.neuron-distributed/mingpt/utils.py create mode 100644 3.test_cases/15.neuron-distributed/projects/adder/adder.py create mode 100644 3.test_cases/15.neuron-distributed/projects/adder/readme.md create mode 100644 3.test_cases/15.neuron-distributed/projects/chargpt/chargpt.py create mode 100644 3.test_cases/15.neuron-distributed/projects/chargpt/readme.md create mode 100644 3.test_cases/15.neuron-distributed/projects/readme.md create mode 100644 3.test_cases/15.neuron-distributed/setup.py create mode 100644 3.test_cases/15.neuron-distributed/tests/test_huggingface_import.py diff --git a/3.test_cases/15.neuron-distributed/LICENSE b/3.test_cases/15.neuron-distributed/LICENSE new file mode 100644 index 00000000..3d899601 --- /dev/null +++ b/3.test_cases/15.neuron-distributed/LICENSE @@ -0,0 +1,7 @@ +The MIT License (MIT) Copyright (c) 2020 Andrej Karpathy + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/3.test_cases/15.neuron-distributed/README.md b/3.test_cases/15.neuron-distributed/README.md new file mode 100644 index 00000000..ae4daa09 --- /dev/null +++ b/3.test_cases/15.neuron-distributed/README.md @@ -0,0 +1,171 @@ +# Mosaic Pretrained Transformers (MPT) Test Case + +MPT are GPT-style models in [llm-foundry](https://github.com/mosaicml/llm-foundry/tree/main) with some special features -- [Flash Attention](https://arxiv.org/abs/2205.14135) for efficiency, [ALiBi](https://arxiv.org/abs/2108.12409) for context length extrapolation, and stability improvements to mitigate loss spikes. + +This project contains: + +* AWS optimized [llm-foundry](https://github.com/mosaicml/llm-foundry/tree/main) container image. +* Slurm scripts for the [c4 dataset](https://huggingface.co/datasets/c4) preparation and multi-node distributed training. + +## 1. Preparation + +This guide assumes that you have the following: + +* A functional Slurm cluster on AWS. +* Docker, [Pyxis](https://github.com/NVIDIA/pyxis) and [Enroot](https://github.com/NVIDIA/enroot) installed. +* An FSx for Lustre filesystem mounted on `/fsx`. + +We recommend that you setup a Slurm cluster using the templates in the architectures [directory](../../1.architectures). Before creating the Slurm cluster, you need to setup the following environment variables: + +```bash +export APPS_PATH=/apps +export ENROOT_IMAGE=$APPS_PATH/llm-foundry.sqsh +export FSX_PATH=/fsx +export DATA_PATH=$FSX_PATH/c4-dataset +export TEST_CASE_PATH=${HOME}/3.MPT # where you copy the test case or set to your test case path +cd $TEST_CASE_PATH +``` + +then follow the detailed instructions [here](../../1.architectures/2.aws-parallelcluster/README.md). + +## 2. Build the container + +Before running training jobs, you need to use an [Enroot](https://github.com/NVIDIA/enroot) container to retrieve and preprocess the input data. Below are the steps you need to follow: + +1. Copy the test case files to your cluster. You will need `0.llm-foundry.Dockerfile`, +2. Build the Docker image with the command below in this directory. + + ```bash + docker build -t llm-foundry -f 0.llm-foundry.Dockerfile . + ``` + +3. Once the Docker image is built, you can check if it is present with `docker images`. You should see an output similar to this one: + + ```bash + REPOSITORY TAG IMAGE ID CREATED SIZE + llm-foundry latest a964fb32cd53 2 weeks ago 23.6GB + ... + ``` + +4. Convert the Docker image to a squash file with the command below. + + ```bash + enroot import -o ${ENROOT_IMAGE} dockerd://llm-foundry:latest + ``` + + The file will be stored in the `/apps` directory (default). The output should look as below. + + ```bash + [INFO] Fetching image + + 36a8c752c28a2db543d2a632a3fc1fcbd5789a6f3d45b9d3a24632420dedcfa8 + + [INFO] Extracting image content... + [INFO] Creating squashfs filesystem... + + Parallel mksquashfs: Using 32 processors + Creating 4.0 filesystem on /apps/llm-foundry.sqsh, block size 131072. + [========================================================================================================================================================================================================================-] 291068/291068 100% + + Exportable Squashfs 4.0 filesystem, gzip compressed, data block size 131072 + uncompressed data, uncompressed metadata, uncompressed fragments, uncompressed xattrs + duplicates are not removed + ... + ``` + +It will take around 5 minutes to convert the container image from Docker to the Enroot format. Once done proceed to the next stage. + +For ease of testing we've included a `Makefile` that automatically builds and imports the latest image. To run this, execute `make` or you can individually specify `make build` to build the Docker image, `make clean` to remove the squash file and `make import` to import the Dockerfile into enroot squash file. + +## 3. Run the processing job + +You need to retrieve input data and preprocess it before running the training job. + +1. Run a preprocessing job by submitting the script `1.c4-preprocess.sbatch` to Slurm. The command will return the Slurm Job ID. You can use `squeue` to consult the status of your jobs. + + ```bash + sbatch 1.c4-preprocess.sbatch + ``` + + It will create the streaming dataset for composer library using C4 dataset in `/fsx/c4-dataset` (default). + +2. You see a new file in your current working directory called `c4-preprocess_XY.out` where `XY` corresponds the Slurm job ID. This is your output file and will capture the `STDOUT` and `STDERR` from your job. You can check how it progresses via the command `tail -f c4-preprocess_XY.out` with the correct job ID instead of `XY`. If running successfully, the job will generate an output similar to the except below. + + ```console + Downloading (…)okenizer_config.json: 100%|██████████| 156/156 [00:00<00:00, 1.09MB/s] + ... + Downloading metadata: 100%|██████████| 2.40M/2.40M [00:01<00:00, 2.05MB/s] + ... + train_small: 32%|███▏ | 31745/100000 [01:51<00:19, 3538.83it/s] + ... + val_small: 100%|██████████| 10000/10000 [00:19<00:00, 514.19it/s] + ``` + + Please be aware that this job downloads the tokenizer on demand (if it's not available under `./EleutherAI/gpt-neox-20b`), after which the tokenizer will be cached under `$HOME/.cache/huggingface`, and the `$HOME` directory is an NFS filesystem shared by the head node. Please consult the [HuggingFace cache management](https://huggingface.co/docs/datasets/cache) document to learn more about fine-grained control of the HuggingFace cache. + +3. After the job completed, check `/fsx/c4-dataset` (default) which will contain a structure similar as below + + ```console + /fsx/c4-dataset/ + ├── train_small + │ ├── index.json + │ ├── shard.00000.mds + │ ├── shard.00001.mds + │ ├── shard.00002.mds + ... + │ ├── shard.00023.mds + │ └── shard.00024.mds + └── val_small + ├── index.json + ├── shard.00000.mds + ├── shard.00001.mds + └── shard.00002.mds + ``` + +Once preprocessing is done, you will run a training job in the next stage. + +## 4. Distributed training of MPT + +Now that the data is preprocessed, we will pretrain a MPT model with [Mosaic Composer](https://github.com/mosaicml/composer). + +1. Run a training job by submitting script `2.train-mpt-manual-distributed.sbatch` to Slurm via `sbatch` as shown below. + + ```bash + sbatch 2.train-mpt-manual-distributed.sbatch + ``` +by default it runs `mpt-7b` model. You can specify model to be trained as: + ```bash + sbatch 2.train-mpt-manual-distributed.sbatch mpt-30b + ``` + +2. When the training job completes successfully, it should produce a log output similar to the below in the `logs/` directory of `$TEST_CASE_PATH`. + +```console +... +0: [batch=1/300000000]: +0: Train time/epoch: 0 +0: Train time/batch: 0 +0: Train time/sample: 0 +0: Train time/batch_in_epoch: 0 +0: Train time/sample_in_epoch: 0 +0: Train time/token: 0 +0: Train time/token_in_epoch: 0 +0: Train memory/allocated_mem: 3.6287 +0: Train memory/active_mem: 3.6287 +0: Train memory/inactive_mem: 2.7844 +0: Train memory/reserved_mem: 20.9650 +0: Train memory/alloc_retries: 0 +0: Train trainer/device_train_microbatch_size: 8 +0: Train loss/train/total: 12.0000 +0: Train metrics/train/LanguageCrossEntropy: 12.0000 +0: Train metrics/train/LanguagePerplexity: 162754.5000 +0: Train time/train: 0.0037 +0: Train time/val: 0.0000 +... +``` + +## 5. Authors / Reviewers + +* [A] Keita Watanabe - mlkeita@ +* [R] Pierre-Yves Aquilanti - pierreya@ +* [R] Verdi March - marcverd@ diff --git a/3.test_cases/15.neuron-distributed/demo.ipynb b/3.test_cases/15.neuron-distributed/demo.ipynb new file mode 100644 index 00000000..4e74622e --- /dev/null +++ b/3.test_cases/15.neuron-distributed/demo.ipynb @@ -0,0 +1,331 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A cute little demo showing the simplest usage of minGPT. Configured to run fine on Macbook Air in like a minute." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "from torch.utils.data import Dataset\n", + "from torch.utils.data.dataloader import DataLoader\n", + "from mingpt.utils import set_seed\n", + "set_seed(3407)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import pickle\n", + "\n", + "class SortDataset(Dataset):\n", + " \"\"\" \n", + " Dataset for the Sort problem. E.g. for problem length 6:\n", + " Input: 0 0 2 1 0 1 -> Output: 0 0 0 1 1 2\n", + " Which will feed into the transformer concatenated as:\n", + " input: 0 0 2 1 0 1 0 0 0 1 1\n", + " output: I I I I I 0 0 0 1 1 2\n", + " where I is \"ignore\", as the transformer is reading the input sequence\n", + " \"\"\"\n", + "\n", + " def __init__(self, split, length=6, num_digits=3):\n", + " assert split in {'train', 'test'}\n", + " self.split = split\n", + " self.length = length\n", + " self.num_digits = num_digits\n", + " \n", + " def __len__(self):\n", + " return 10000 # ...\n", + " \n", + " def get_vocab_size(self):\n", + " return self.num_digits\n", + " \n", + " def get_block_size(self):\n", + " # the length of the sequence that will feed into transformer, \n", + " # containing concatenated input and the output, but -1 because\n", + " # the transformer starts making predictions at the last input element\n", + " return self.length * 2 - 1\n", + "\n", + " def __getitem__(self, idx):\n", + " \n", + " # use rejection sampling to generate an input example from the desired split\n", + " while True:\n", + " # generate some random integers\n", + " inp = torch.randint(self.num_digits, size=(self.length,), dtype=torch.long)\n", + " # half of the time let's try to boost the number of examples that \n", + " # have a large number of repeats, as this is what the model seems to struggle\n", + " # with later in training, and they are kind of rate\n", + " if torch.rand(1).item() < 0.5:\n", + " if inp.unique().nelement() > self.length // 2:\n", + " # too many unqiue digits, re-sample\n", + " continue\n", + " # figure out if this generated example is train or test based on its hash\n", + " h = hash(pickle.dumps(inp.tolist()))\n", + " inp_split = 'test' if h % 4 == 0 else 'train' # designate 25% of examples as test\n", + " if inp_split == self.split:\n", + " break # ok\n", + " \n", + " # solve the task: i.e. sort\n", + " sol = torch.sort(inp)[0]\n", + "\n", + " # concatenate the problem specification and the solution\n", + " cat = torch.cat((inp, sol), dim=0)\n", + "\n", + " # the inputs to the transformer will be the offset sequence\n", + " x = cat[:-1].clone()\n", + " y = cat[1:].clone()\n", + " # we only want to predict at output locations, mask out the loss at the input locations\n", + " y[:self.length-1] = -1\n", + " return x, y\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 -1\n", + "0 -1\n", + "1 -1\n", + "0 -1\n", + "0 -1\n", + "0 0\n", + "0 0\n", + "0 0\n", + "0 0\n", + "0 1\n", + "1 1\n" + ] + } + ], + "source": [ + "# print an example instance of the dataset\n", + "train_dataset = SortDataset('train')\n", + "test_dataset = SortDataset('test')\n", + "x, y = train_dataset[0]\n", + "for a, b in zip(x,y):\n", + " print(int(a),int(b))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "number of parameters: 0.09M\n" + ] + } + ], + "source": [ + "# create a GPT instance\n", + "from mingpt.model import GPT\n", + "\n", + "model_config = GPT.get_default_config()\n", + "model_config.model_type = 'gpt-nano'\n", + "model_config.vocab_size = train_dataset.get_vocab_size()\n", + "model_config.block_size = train_dataset.get_block_size()\n", + "model = GPT(model_config)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "running on device cuda\n" + ] + } + ], + "source": [ + "# create a Trainer object\n", + "from mingpt.trainer import Trainer\n", + "\n", + "train_config = Trainer.get_default_config()\n", + "train_config.learning_rate = 5e-4 # the model we're using is so small that we can go a bit faster\n", + "train_config.max_iters = 2000\n", + "train_config.num_workers = 0\n", + "trainer = Trainer(train_config, model, train_dataset)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iter_dt 0.00ms; iter 0: train loss 1.06407\n", + "iter_dt 18.17ms; iter 100: train loss 0.14712\n", + "iter_dt 18.70ms; iter 200: train loss 0.05315\n", + "iter_dt 19.65ms; iter 300: train loss 0.04404\n", + "iter_dt 31.64ms; iter 400: train loss 0.04724\n", + "iter_dt 18.43ms; iter 500: train loss 0.02521\n", + "iter_dt 19.83ms; iter 600: train loss 0.03352\n", + "iter_dt 19.58ms; iter 700: train loss 0.00539\n", + "iter_dt 18.72ms; iter 800: train loss 0.02057\n", + "iter_dt 18.26ms; iter 900: train loss 0.00360\n", + "iter_dt 18.50ms; iter 1000: train loss 0.00788\n", + "iter_dt 20.64ms; iter 1100: train loss 0.01162\n", + "iter_dt 18.63ms; iter 1200: train loss 0.00963\n", + "iter_dt 18.32ms; iter 1300: train loss 0.02066\n", + "iter_dt 18.40ms; iter 1400: train loss 0.01739\n", + "iter_dt 18.37ms; iter 1500: train loss 0.00376\n", + "iter_dt 18.67ms; iter 1600: train loss 0.00133\n", + "iter_dt 18.38ms; iter 1700: train loss 0.00179\n", + "iter_dt 18.66ms; iter 1800: train loss 0.00079\n", + "iter_dt 18.48ms; iter 1900: train loss 0.00042\n" + ] + } + ], + "source": [ + "def batch_end_callback(trainer):\n", + " if trainer.iter_num % 100 == 0:\n", + " print(f\"iter_dt {trainer.iter_dt * 1000:.2f}ms; iter {trainer.iter_num}: train loss {trainer.loss.item():.5f}\")\n", + "trainer.set_callback('on_batch_end', batch_end_callback)\n", + "\n", + "trainer.run()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# now let's perform some evaluation\n", + "model.eval();" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train final score: 5000/5000 = 100.00% correct\n", + "test final score: 5000/5000 = 100.00% correct\n" + ] + } + ], + "source": [ + "def eval_split(trainer, split, max_batches):\n", + " dataset = {'train':train_dataset, 'test':test_dataset}[split]\n", + " n = train_dataset.length # naugy direct access shrug\n", + " results = []\n", + " mistakes_printed_already = 0\n", + " loader = DataLoader(dataset, batch_size=100, num_workers=0, drop_last=False)\n", + " for b, (x, y) in enumerate(loader):\n", + " x = x.to(trainer.device)\n", + " y = y.to(trainer.device)\n", + " # isolate the input pattern alone\n", + " inp = x[:, :n]\n", + " sol = y[:, -n:]\n", + " # let the model sample the rest of the sequence\n", + " cat = model.generate(inp, n, do_sample=False) # using greedy argmax, not sampling\n", + " sol_candidate = cat[:, n:] # isolate the filled in sequence\n", + " # compare the predicted sequence to the true sequence\n", + " correct = (sol == sol_candidate).all(1).cpu() # Software 1.0 vs. Software 2.0 fight RIGHT on this line haha\n", + " for i in range(x.size(0)):\n", + " results.append(int(correct[i]))\n", + " if not correct[i] and mistakes_printed_already < 3: # only print up to 5 mistakes to get a sense\n", + " mistakes_printed_already += 1\n", + " print(\"GPT claims that %s sorted is %s but gt is %s\" % (inp[i].tolist(), sol_candidate[i].tolist(), sol[i].tolist()))\n", + " if max_batches is not None and b+1 >= max_batches:\n", + " break\n", + " rt = torch.tensor(results, dtype=torch.float)\n", + " print(\"%s final score: %d/%d = %.2f%% correct\" % (split, rt.sum(), len(results), 100*rt.mean()))\n", + " return rt.sum()\n", + "\n", + "# run a lot of examples from both train and test through the model and verify the output correctness\n", + "with torch.no_grad():\n", + " train_score = eval_split(trainer, 'train', max_batches=50)\n", + " test_score = eval_split(trainer, 'test', max_batches=50)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "input sequence : [[0, 0, 2, 1, 0, 1]]\n", + "predicted sorted: [[0, 0, 0, 1, 1, 2]]\n", + "gt sort : [0, 0, 0, 1, 1, 2]\n", + "matches : True\n" + ] + } + ], + "source": [ + "# let's run a random given sequence through the model as well\n", + "n = train_dataset.length # naugy direct access shrug\n", + "inp = torch.tensor([[0, 0, 2, 1, 0, 1]], dtype=torch.long).to(trainer.device)\n", + "assert inp[0].nelement() == n\n", + "with torch.no_grad():\n", + " cat = model.generate(inp, n, do_sample=False)\n", + "sol = torch.sort(inp[0])[0]\n", + "sol_candidate = cat[:, n:]\n", + "print('input sequence :', inp.tolist())\n", + "print('predicted sorted:', sol_candidate.tolist())\n", + "print('gt sort :', sol.tolist())\n", + "print('matches :', bool((sol == sol_candidate).all()))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.4 64-bit", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.4" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "3ad933181bd8a04b432d3370b9dc3b0662ad032c4dfaa4e4f1596c548f763858" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/3.test_cases/15.neuron-distributed/docs/README.md b/3.test_cases/15.neuron-distributed/docs/README.md new file mode 100644 index 00000000..9debd177 --- /dev/null +++ b/3.test_cases/15.neuron-distributed/docs/README.md @@ -0,0 +1,147 @@ + +# minGPT + +![mingpt](mingpt.jpg) + +A PyTorch re-implementation of [GPT](https://github.com/openai/gpt-2), both training and inference. minGPT tries to be small, clean, interpretable and educational, as most of the currently available GPT model implementations can a bit sprawling. GPT is not a complicated model and this implementation is appropriately about 300 lines of code (see [mingpt/model.py](mingpt/model.py)). All that's going on is that a sequence of indices feeds into a [Transformer](https://arxiv.org/abs/1706.03762), and a probability distribution over the next index in the sequence comes out. The majority of the complexity is just being clever with batching (both across examples and over sequence length) for efficiency. + +**note (Jan 2023)**: though I may continue to accept and change some details, minGPT is in a semi-archived state. For more recent developments see my rewrite [nanoGPT](https://github.com/karpathy/nanoGPT). Basically, minGPT became referenced across a wide variety of places (notebooks, blogs, courses, books, etc.) which made me less willing to make the bigger changes I wanted to make to move the code forward. I also wanted to change the direction a bit, from a sole focus on education to something that is still simple and hackable but has teeth (reproduces medium-sized industry benchmarks, accepts some tradeoffs to gain runtime efficiency, etc). + +The minGPT library is three files: [mingpt/model.py](mingpt/model.py) contains the actual Transformer model definition, [mingpt/bpe.py](mingpt/bpe.py) contains a mildly refactored Byte Pair Encoder that translates between text and sequences of integers exactly like OpenAI did in GPT, [mingpt/trainer.py](mingpt/trainer.py) is (GPT-independent) PyTorch boilerplate code that trains the model. Then there are a number of demos and projects that use the library in the `projects` folder: + +- `projects/adder` trains a GPT from scratch to add numbers (inspired by the addition section in the GPT-3 paper) +- `projects/chargpt` trains a GPT to be a character-level language model on some input text file +- `demo.ipynb` shows a minimal usage of the `GPT` and `Trainer` in a notebook format on a simple sorting example +- `generate.ipynb` shows how one can load a pretrained GPT2 and generate text given some prompt + +### Library Installation + +If you want to `import mingpt` into your project: + +``` +git clone https://github.com/karpathy/minGPT.git +cd minGPT +pip install -e . +``` + +### Usage + +Here's how you'd instantiate a GPT-2 (124M param version): + +```python +from mingpt.model import GPT +model_config = GPT.get_default_config() +model_config.model_type = 'gpt2' +model_config.vocab_size = 50257 # openai's model vocabulary +model_config.block_size = 1024 # openai's model block_size (i.e. input context length) +model = GPT(model_config) +``` + +And here's how you'd train it: + +```python +# your subclass of torch.utils.data.Dataset that emits example +# torch LongTensor of lengths up to 1024, with integers from [0,50257) +train_dataset = YourDataset() + +from mingpt.trainer import Trainer +train_config = Trainer.get_default_config() +train_config.learning_rate = 5e-4 # many possible options, see the file +train_config.max_iters = 1000 +train_config.batch_size = 32 +trainer = Trainer(train_config, model, train_dataset) +trainer.run() +``` + +See `demo.ipynb` for a more concrete example. + +### Unit tests + +Coverage is not super amazing just yet but: + +``` +python -m unittest discover tests +``` + +### todos + +- add gpt-2 finetuning demo on arbitrary given text file +- add dialog agent demo +- better docs of outcomes for existing projects (adder, chargpt) +- add mixed precision and related training scaling goodies +- distributed training support +- reproduce some benchmarks in projects/, e.g. text8 or other language modeling +- proper logging instead of print statement amateur hour haha +- i probably should have a requirements.txt file... +- it should be possible to load in many other model weights other than just gpt2-\* + +### References + +Code: + +- [openai/gpt-2](https://github.com/openai/gpt-2) has the model definition in TensorFlow, but not the training code +- [openai/image-gpt](https://github.com/openai/image-gpt) has some more modern gpt-3 like modification in its code, good reference as well +- [huggingface/transformers](https://github.com/huggingface/transformers) has a [language-modeling example](https://github.com/huggingface/transformers/tree/master/examples/pytorch/language-modeling). It is full-featured but as a result also somewhat challenging to trace. E.g. some large functions have as much as 90% unused code behind various branching statements that is unused in the default setting of simple language modeling + +Papers + some implementation notes: + +#### Improving Language Understanding by Generative Pre-Training (GPT-1) + +- Our model largely follows the original transformer work +- We trained a 12-layer decoder-only transformer with masked self-attention heads (768 dimensional states and 12 attention heads). For the position-wise feed-forward networks, we used 3072 dimensional inner states. +- Adam max learning rate of 2.5e-4. (later GPT-3 for this model size uses 6e-4) +- LR decay: increased linearly from zero over the first 2000 updates and annealed to 0 using a cosine schedule +- We train for 100 epochs on minibatches of 64 randomly sampled, contiguous sequences of 512 tokens. +- Since layernorm is used extensively throughout the model, a simple weight initialization of N(0, 0.02) was sufficient +- bytepair encoding (BPE) vocabulary with 40,000 merges +- residual, embedding, and attention dropouts with a rate of 0.1 for regularization. +- modified version of L2 regularization proposed in (37), with w = 0.01 on all non bias or gain weights +- For the activation function, we used the Gaussian Error Linear Unit (GELU). +- We used learned position embeddings instead of the sinusoidal version proposed in the original work +- For finetuning: We add dropout to the classifier with a rate of 0.1. learning rate of 6.25e-5 and a batchsize of 32. 3 epochs. We use a linear learning rate decay schedule with warmup over 0.2% of training. λ was set to 0.5. +- GPT-1 model is 12 layers and d_model 768, ~117M params + +#### Language Models are Unsupervised Multitask Learners (GPT-2) + +- LayerNorm was moved to the input of each sub-block, similar to a pre-activation residual network +- an additional layer normalization was added after the final self-attention block. +- modified initialization which accounts for the accumulation on the residual path with model depth is used. We scale the weights of residual layers at initialization by a factor of 1/√N where N is the number of residual layers. (weird because in their released code i can only find a simple use of the old 0.02... in their release of image-gpt I found it used for c_proj, and even then only for attn, not for mlp. huh. https://github.com/openai/image-gpt/blob/master/src/model.py) +- the vocabulary is expanded to 50,257 +- increase the context size from 512 to 1024 tokens +- larger batchsize of 512 is used +- GPT-2 used 48 layers and d_model 1600 (vs. original 12 layers and d_model 768). ~1.542B params + +#### Language Models are Few-Shot Learners (GPT-3) + +- GPT-3: 96 layers, 96 heads, with d_model of 12,288 (175B parameters). +- GPT-1-like: 12 layers, 12 heads, d_model 768 (125M) +- We use the same model and architecture as GPT-2, including the modified initialization, pre-normalization, and reversible tokenization described therein +- we use alternating dense and locally banded sparse attention patterns in the layers of the transformer, similar to the Sparse Transformer +- we always have the feedforward layer four times the size of the bottleneck layer, dff = 4 ∗ dmodel +- all models use a context window of nctx = 2048 tokens. +- Adam with β1 = 0.9, β2 = 0.95, and eps = 10−8 +- All models use weight decay of 0.1 to provide a small amount of regularization. (NOTE: GPT-1 used 0.01 I believe, see above) +- clip the global norm of the gradient at 1.0 +- Linear LR warmup over the first 375 million tokens. Then use cosine decay for learning rate down to 10% of its value, over 260 billion tokens. +- gradually increase the batch size linearly from a small value (32k tokens) to the full value over the first 4-12 billion tokens of training, depending on the model size. +- full 2048-sized time context window is always used, with a special END OF DOCUMENT token delimiter + +#### Generative Pretraining from Pixels (Image GPT) + +- When working with images, we pick the identity permutation πi = i for 1 ≤ i ≤ n, also known as raster order. +- we create our own 9-bit color palette by clustering (R, G, B) pixel values using k-means with k = 512. +- Our largest model, iGPT-XL, contains L = 60 layers and uses an embedding size of d = 3072 for a total of 6.8B parameters. +- Our next largest model, iGPT-L, is essentially identical to GPT-2 with L = 48 layers, but contains a slightly smaller embedding size of d = 1536 (vs 1600) for a total of 1.4B parameters. +- We use the same model code as GPT-2, except that we initialize weights in the layerdependent fashion as in Sparse Transformer (Child et al., 2019) and zero-initialize all projections producing logits. +- We also train iGPT-M, a 455M parameter model with L = 36 and d = 1024 +- iGPT-S, a 76M parameter model with L = 24 and d = 512 (okay, and how many heads? looks like the Github code claims 8) +- When pre-training iGPT-XL, we use a batch size of 64 and train for 2M iterations, and for all other models we use a batch size of 128 and train for 1M iterations. +- Adam with β1 = 0.9 and β2 = 0.95 +- The learning rate is warmed up for one epoch, and then decays to 0 +- We did not use weight decay because applying a small weight decay of 0.01 did not change representation quality. +- iGPT-S lr 0.003 +- No dropout is used. + +### License + +MIT diff --git a/3.test_cases/15.neuron-distributed/generate.ipynb b/3.test_cases/15.neuron-distributed/generate.ipynb new file mode 100644 index 00000000..9bc9d7f7 --- /dev/null +++ b/3.test_cases/15.neuron-distributed/generate.ipynb @@ -0,0 +1,166 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Shows how one can generate text given a prompt and some hyperparameters, using either minGPT or huggingface/transformers" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "from transformers import GPT2Tokenizer, GPT2LMHeadModel\n", + "from mingpt.model import GPT\n", + "from mingpt.utils import set_seed\n", + "from mingpt.bpe import BPETokenizer\n", + "set_seed(3407)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "use_mingpt = True # use minGPT or huggingface/transformers model?\n", + "model_type = 'gpt2-xl'\n", + "device = 'cuda'" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "number of parameters: 1557.61M\n" + ] + } + ], + "source": [ + "if use_mingpt:\n", + " model = GPT.from_pretrained(model_type)\n", + "else:\n", + " model = GPT2LMHeadModel.from_pretrained(model_type)\n", + " model.config.pad_token_id = model.config.eos_token_id # suppress a warning\n", + "\n", + "# ship model to device and set to eval mode\n", + "model.to(device)\n", + "model.eval();" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "def generate(prompt='', num_samples=10, steps=20, do_sample=True):\n", + " \n", + " # tokenize the input prompt into integer input sequence\n", + " if use_mingpt:\n", + " tokenizer = BPETokenizer()\n", + " if prompt == '':\n", + " # to create unconditional samples...\n", + " # manually create a tensor with only the special <|endoftext|> token\n", + " # similar to what openai's code does here https://github.com/openai/gpt-2/blob/master/src/generate_unconditional_samples.py\n", + " x = torch.tensor([[tokenizer.encoder.encoder['<|endoftext|>']]], dtype=torch.long)\n", + " else:\n", + " x = tokenizer(prompt).to(device)\n", + " else:\n", + " tokenizer = GPT2Tokenizer.from_pretrained(model_type)\n", + " if prompt == '': \n", + " # to create unconditional samples...\n", + " # huggingface/transformers tokenizer special cases these strings\n", + " prompt = '<|endoftext|>'\n", + " encoded_input = tokenizer(prompt, return_tensors='pt').to(device)\n", + " x = encoded_input['input_ids']\n", + " \n", + " # we'll process all desired num_samples in a batch, so expand out the batch dim\n", + " x = x.expand(num_samples, -1)\n", + "\n", + " # forward the model `steps` times to get samples, in a batch\n", + " y = model.generate(x, max_new_tokens=steps, do_sample=do_sample, top_k=40)\n", + " \n", + " for i in range(num_samples):\n", + " out = tokenizer.decode(y[i].cpu().squeeze())\n", + " print('-'*80)\n", + " print(out)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------------------------------------\n", + "Andrej Karpathy, the chief of the criminal investigation department, said during a news conference, \"We still have a lot of\n", + "--------------------------------------------------------------------------------\n", + "Andrej Karpathy, the man whom most of America believes is the architect of the current financial crisis. He runs the National Council\n", + "--------------------------------------------------------------------------------\n", + "Andrej Karpathy, the head of the Department for Regional Reform of Bulgaria and an MP in the centre-right GERB party\n", + "--------------------------------------------------------------------------------\n", + "Andrej Karpathy, the former head of the World Bank's IMF department, who worked closely with the IMF. The IMF had\n", + "--------------------------------------------------------------------------------\n", + "Andrej Karpathy, the vice president for innovation and research at Citi who oversaw the team's work to make sense of the\n", + "--------------------------------------------------------------------------------\n", + "Andrej Karpathy, the CEO of OOAK Research, said that the latest poll indicates that it won't take much to\n", + "--------------------------------------------------------------------------------\n", + "Andrej Karpathy, the former prime minister of Estonia was at the helm of a three-party coalition when parliament met earlier this\n", + "--------------------------------------------------------------------------------\n", + "Andrej Karpathy, the director of the Institute of Economic and Social Research, said if the rate of return is only 5 per\n", + "--------------------------------------------------------------------------------\n", + "Andrej Karpathy, the minister of commerce for Latvia's western neighbour: \"The deal means that our two countries have reached more\n", + "--------------------------------------------------------------------------------\n", + "Andrej Karpathy, the state's environmental protection commissioner. \"That's why we have to keep these systems in place.\"\n", + "\n" + ] + } + ], + "source": [ + "generate(prompt='Andrej Karpathy, the', num_samples=10, steps=20)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.4 64-bit", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.4" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "3ad933181bd8a04b432d3370b9dc3b0662ad032c4dfaa4e4f1596c548f763858" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/3.test_cases/15.neuron-distributed/mingpt.jpg b/3.test_cases/15.neuron-distributed/mingpt.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8070bcb841210296a6c5f29b4ecb51d4a408e51f GIT binary patch literal 118276 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 z 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 literal 0 HcmV?d00001 diff --git a/3.test_cases/15.neuron-distributed/mingpt/__init__.py b/3.test_cases/15.neuron-distributed/mingpt/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/3.test_cases/15.neuron-distributed/mingpt/bpe.py b/3.test_cases/15.neuron-distributed/mingpt/bpe.py new file mode 100644 index 00000000..b8468ef9 --- /dev/null +++ b/3.test_cases/15.neuron-distributed/mingpt/bpe.py @@ -0,0 +1,319 @@ +""" +bpe is short for Byte Pair Encoder. It translates arbitrary utf-8 strings into +sequences of integers, where each integer represents small chunks of commonly +occuring characters. This implementation is based on openai's gpt2 encoder.py: +https://github.com/openai/gpt-2/blob/master/src/encoder.py +but was mildly modified because the original implementation is a bit confusing. +I also tried to add as many comments as possible, my own understanding of what's +going on. +""" + +import os +import json +import regex as re +import requests + +import torch + +# ----------------------------------------------------------------------------- + +def bytes_to_unicode(): + """ + Every possible byte (really an integer 0..255) gets mapped by OpenAI to a unicode + character that represents it visually. Some bytes have their appearance preserved + because they don't cause any trouble. These are defined in list bs. For example: + chr(33) returns "!", so in the returned dictionary we simply have d[33] -> "!". + However, chr(0), for example, is '\x00', which looks ugly. So OpenAI maps these + bytes, into new characters in a range where chr() returns a single nice character. + So in the final dictionary we have d[0] -> 'Ā' instead, which is just chr(0 + 2**8). + In particular, the space character is 32, which we can see by ord(' '). Instead, + this function will shift space (32) by 256 to 288, so d[32] -> 'Ġ'. + So this is just a simple one-to-one mapping of bytes 0..255 into unicode characters + that "look nice", either in their original form, or a funny shifted character + like 'Ā', or 'Ġ', etc. + """ + # the 188 integers that render fine in their original form and need no shifting + bs = list(range(ord("!"), ord("~")+1))+list(range(ord("¡"), ord("¬")+1))+list(range(ord("®"), ord("ÿ")+1)) + cs = bs[:] # all integers b in bs will simply map to chr(b) in the output dict + # now get the representations of the other 68 integers that do need shifting + # each will get mapped chr(256 + n), where n will grow from 0...67 in the loop + n = 0 + for b in range(2**8): + if b not in bs: + # if this byte is "ugly" then map it to the next available "nice" character + bs.append(b) + cs.append(2**8+n) + n += 1 + cs = [chr(n) for n in cs] + d = dict(zip(bs, cs)) + return d + +def get_pairs(word): + """ + Return all bigrams as a set of tuples, of consecutive elements in the iterable word. + """ + pairs = set() + prev_char = word[0] + for char in word[1:]: + pairs.add((prev_char, char)) + prev_char = char + return pairs + +class Encoder: + + def __init__(self, encoder, bpe_merges): + # byte encoder/decoder + self.byte_encoder = bytes_to_unicode() + self.byte_decoder = {v:k for k, v in self.byte_encoder.items()} + # bpe token encoder/decoder + self.encoder = encoder + self.decoder = {v:k for k,v in self.encoder.items()} + # bpe merge list that defines the bpe "tree", of tuples (a,b) that are to merge to token ab + self.bpe_ranks = dict(zip(bpe_merges, range(len(bpe_merges)))) + # the splitting pattern used for pre-tokenization + # Should haved added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions <-- original openai comment + """ + ok so what is this regex looking for, exactly? + python re reference: https://docs.python.org/3/library/re.html + - the vertical bars | is OR, so re.findall will chunkate text as the pieces match, from left to right + - '\'s' would split up things like Andrej's -> (Andrej, 's) + - ' ?\p{L}': optional space followed by 1+ unicode code points in the category "letter" + - ' ?\p{N}': optional space followed by 1+ unicode code points in the category "number" + - ' ?[^\s\p{L}\p{N}]+': optional space, then 1+ things that are NOT a whitespace, letter or number + - '\s+(?!\S)': 1+ whitespace characters (e.g. space or tab or etc) UNLESS they are followed by non-whitespace + so this will consume whitespace characters in a sequence but exclude the last whitespace in + that sequence. that last whitespace has the opportunity to then match the optional ' ?' in + earlier patterns. + - '\s+': 1+ whitespace characters, intended probably to catch a full trailing sequence of whitespaces at end of string + So TLDR: + - we are special casing a few common apostrophe constructs ('s, 't, 're, ...) and making those into separate tokens + - we then separate out strings into consecutive chunks of 1) letters, 2) numbers, 3) non-letter-numbers, 4) whitespaces + """ + self.pat = re.compile(r"""'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+""") + self.cache = {} + + def bpe(self, token): + """ + this function uses self.bpe_ranks to iteratively merge all the possible bpe tokens + up the tree. token is a string of one individual 'word' (after regex tokenization) + and after byte encoding, e.g. 'Ġthere'. + """ + # token is a string of one individual 'word', after byte encoding, e.g. 'Ġthere' + + # memoization, for efficiency + if token in self.cache: + return self.cache[token] + + word = tuple(token) # individual characters that make up the token, in a tuple + pairs = get_pairs(word) # get all bigrams + + if not pairs: + return token + + while True: + + # find the next lowest rank bigram that can be merged + bigram = min(pairs, key = lambda pair: self.bpe_ranks.get(pair, float('inf'))) + if bigram not in self.bpe_ranks: + break # no more bigrams are eligible to be merged + first, second = bigram + + # we will now replace all occurences of (first, second) in the list of current + # words into one merged token first_second, in the output list new_words + new_word = [] + i = 0 + while i < len(word): + + # find the next occurence of first in the sequence of current words + try: + j = word.index(first, i) + new_word.extend(word[i:j]) + i = j + except: + new_word.extend(word[i:]) + break + + # if this occurence is also followed by second, then merge them into one + if word[i] == first and i < len(word)-1 and word[i+1] == second: + new_word.append(first+second) + i += 2 + else: + new_word.append(word[i]) + i += 1 + + # all occurences of (first, second) have been merged to first_second + new_word = tuple(new_word) + word = new_word + if len(word) == 1: + break + else: + pairs = get_pairs(word) + + # concat all words into a string, and use ' ' as the separator. Note that + # by now all characters have been byte encoded, guaranteeing that ' ' is + # not used in the actual data and is a 'special' delimiter character + word = ' '.join(word) + + # cache the result and return + self.cache[token] = word + return word + + def encode(self, text): + """ string goes in, list of integers comes out """ + bpe_idx = [] + # pre-tokenize the input text into string tokens (words, roughly speaking) + tokens = re.findall(self.pat, text) + # process each token into BPE integers + for token in tokens: + # encode the token as a bytes (b'') object + token_bytes = token.encode('utf-8') + # translate all bytes to their unicode string representation and flatten + token_translated = ''.join(self.byte_encoder[b] for b in token_bytes) + # perform all the applicable bpe merges according to self.bpe_ranks + token_merged = self.bpe(token_translated).split(' ') + # translate all bpe tokens to integers + token_ix = [self.encoder[bpe_token] for bpe_token in token_merged] + # extend our running list of all output integers + bpe_idx.extend(token_ix) + return bpe_idx + + def encode_and_show_work(self, text): + """ debugging function, same as encode but returns all intermediate work """ + bpe_idx = [] + parts = [] + tokens = re.findall(self.pat, text) + for token in tokens: + token_bytes = token.encode('utf-8') + token_translated = ''.join(self.byte_encoder[b] for b in token_bytes) + token_merged = self.bpe(token_translated).split(' ') + token_ix = [self.encoder[bpe_token] for bpe_token in token_merged] + bpe_idx.extend(token_ix) + parts.append({ + 'token': token, + 'token_bytes': token_bytes, + 'token_translated': token_translated, + 'token_merged': token_merged, + 'token_ix': token_ix, + }) + out = { + 'bpe_idx': bpe_idx, # the actual output sequence + 'tokens': tokens, # result of pre-tokenization + 'parts': parts, # intermediates for each token part + } + return out + + def decode(self, bpe_idx): + """ list of integers comes in, string comes out """ + # inverse map the integers to get the tokens + tokens_merged = [self.decoder[token] for token in bpe_idx] + # inverse the byte encoder, e.g. recovering 'Ġ' -> ' ', and get the bytes + tokens_flat = ''.join(tokens_merged) + tokens_bytes = bytearray([self.byte_decoder[c] for c in tokens_flat]) + # recover the full utf-8 string + text = tokens_bytes.decode('utf-8', errors='replace') + return text + +def get_file(local_file, remote_file): + """ downloads remote_file to local_file if necessary """ + if not os.path.isfile(local_file): + print(f"downloading {remote_file} to {local_file}") + response = requests.get(remote_file) + open(local_file, "wb").write(response.content) + +def get_encoder(): + """ + Returns an instance of the GPT BPE Encoder/Decoder + and handles caching of "database" files. + """ + home_dir = os.path.expanduser('~') + cache_dir = os.path.join(home_dir, '.cache', 'mingpt') + os.makedirs(cache_dir, exist_ok=True) + + # load encoder.json that has the raw mappings from token -> bpe index + encoder_local_file = os.path.join(cache_dir, 'encoder.json') + encoder_remote_file = 'https://openaipublic.blob.core.windows.net/gpt-2/models/124M/encoder.json' + get_file(encoder_local_file, encoder_remote_file) + with open(encoder_local_file, 'r') as f: + encoder = json.load(f) + assert len(encoder) == 50257 # 256 individual byte tokens, 50,000 merged tokens, and 1 special <|endoftext|> token + + # load vocab.bpe that contains the bpe merges, i.e. the bpe tree structure + # in the form tuples (a, b), that indicate that (a, b) is to be merged to one token ab + vocab_local_file = os.path.join(cache_dir, 'vocab.bpe') + vocab_remote_file = 'https://openaipublic.blob.core.windows.net/gpt-2/models/124M/vocab.bpe' + get_file(vocab_local_file, vocab_remote_file) + with open(vocab_local_file, 'r', encoding="utf-8") as f: + bpe_data = f.read() + # light postprocessing: strip the version on first line and the last line is a blank + bpe_merges = [tuple(merge_str.split()) for merge_str in bpe_data.split('\n')[1:-1]] + assert len(bpe_merges) == 50000 # 50,000 merged tokens + + # construct the Encoder object and return + enc = Encoder(encoder, bpe_merges) + return enc + +# ----------------------------------------------------------------------------- + +class BPETokenizer: + """ PyTorch-aware class that wraps the Encoder above """ + + def __init__(self): + self.encoder = get_encoder() + + def __call__(self, text, return_tensors='pt'): + # PyTorch only; here because we want to match huggingface/transformers interface + assert return_tensors == 'pt' + # single string input for now, in the future potentially a list of strings + assert isinstance(text, str) + # encode and create a "batch dimension" of 1 + idx = [self.encoder.encode(text)] + # wrap into PyTorch tensor + out = torch.tensor(idx, dtype=torch.long) + return out + + def decode(self, idx): + # ensure a simple 1D tensor for now + assert idx.ndim == 1 + # decode indices to text + text = self.encoder.decode(idx.tolist()) + return text + + +if __name__ == '__main__': + + # here is an encoding example + text = "Hello!! I'm Andrej Karpathy. It's 2022. w00t :D 🤗" + e = get_encoder() + r = e.encode_and_show_work(text) + + print("Original text is:") + print(text) + print("First the text gets pre-tokenized, broken up into chunks, the outcome is:") + print(r['tokens']) + # ['Hello', '!!', ' I', "'m", ' Andrej', ' Karpathy', '.', ' It', "'s", ' 2022', '.', ' w', '00', 't', ' :', 'D', ' 🤗'] + print("Then we iterate over each chunk and process them in turn...") + for part in r['parts']: + print(part) + # {'token': 'Hello', 'token_bytes': b'Hello', 'token_translated': 'Hello', 'token_merged': ['Hello'], 'token_ix': [15496]} + # {'token': '!!', 'token_bytes': b'!!', 'token_translated': '!!', 'token_merged': ['!!'], 'token_ix': [3228]} + # {'token': ' I', 'token_bytes': b' I', 'token_translated': 'ĠI', 'token_merged': ['ĠI'], 'token_ix': [314]} + # {'token': "'m", 'token_bytes': b"'m", 'token_translated': "'m", 'token_merged': ["'m"], 'token_ix': [1101]} + # {'token': ' Andrej', 'token_bytes': b' Andrej', 'token_translated': 'ĠAndrej', 'token_merged': ['ĠAndre', 'j'], 'token_ix': [10948, 73]} + # {'token': ' Karpathy', 'token_bytes': b' Karpathy', 'token_translated': 'ĠKarpathy', 'token_merged': ['ĠK', 'arp', 'athy'], 'token_ix': [509, 5117, 10036]} + # {'token': '.', 'token_bytes': b'.', 'token_translated': '.', 'token_merged': ['.'], 'token_ix': [13]} + # {'token': ' It', 'token_bytes': b' It', 'token_translated': 'ĠIt', 'token_merged': ['ĠIt'], 'token_ix': [632]} + # {'token': "'s", 'token_bytes': b"'s", 'token_translated': "'s", 'token_merged': ["'s"], 'token_ix': [338]} + # {'token': ' 2022', 'token_bytes': b' 2022', 'token_translated': 'Ġ2022', 'token_merged': ['Ġ2022'], 'token_ix': [33160]} + # {'token': '.', 'token_bytes': b'.', 'token_translated': '.', 'token_merged': ['.'], 'token_ix': [13]} + # {'token': ' w', 'token_bytes': b' w', 'token_translated': 'Ġw', 'token_merged': ['Ġw'], 'token_ix': [266]} + # {'token': '00', 'token_bytes': b'00', 'token_translated': '00', 'token_merged': ['00'], 'token_ix': [405]} + # {'token': 't', 'token_bytes': b't', 'token_translated': 't', 'token_merged': ['t'], 'token_ix': [83]} + # {'token': ' :', 'token_bytes': b' :', 'token_translated': 'Ġ:', 'token_merged': ['Ġ:'], 'token_ix': [1058]} + # {'token': 'D', 'token_bytes': b'D', 'token_translated': 'D', 'token_merged': ['D'], 'token_ix': [35]} + # {'token': ' 🤗', 'token_bytes': b' \xf0\x9f\xa4\x97', 'token_translated': 'ĠðŁ¤Ĺ', 'token_merged': ['ĠðŁ', '¤', 'Ĺ'], 'token_ix': [12520, 97, 245]} + # (refer to the code inside Encoder.encode for what these intermediates are) + print("and the final outcome is concatenating and flattening all the token_ix:") + print(r['bpe_idx']) + # [15496, 3228, 314, 1101, 10948, 73, 509, 5117, 10036, 13, 632, 338, 33160, 13, 266, 405, 83, 1058, 35, 12520, 97, 245] + # this would then become the integer input sequence to the transformer + print("ready to feed into a Transformer!") diff --git a/3.test_cases/15.neuron-distributed/mingpt/model.py b/3.test_cases/15.neuron-distributed/mingpt/model.py new file mode 100644 index 00000000..83ee22dc --- /dev/null +++ b/3.test_cases/15.neuron-distributed/mingpt/model.py @@ -0,0 +1,310 @@ +""" +Full definition of a GPT Language Model, all of it in this single file. + +References: +1) the official GPT-2 TensorFlow implementation released by OpenAI: +https://github.com/openai/gpt-2/blob/master/src/model.py +2) huggingface/transformers PyTorch implementation: +https://github.com/huggingface/transformers/blob/main/src/transformers/models/gpt2/modeling_gpt2.py +""" + +import math + +import torch +import torch.nn as nn +from torch.nn import functional as F + +from mingpt.utils import CfgNode as CN + +# ----------------------------------------------------------------------------- + +class NewGELU(nn.Module): + """ + Implementation of the GELU activation function currently in Google BERT repo (identical to OpenAI GPT). + Reference: Gaussian Error Linear Units (GELU) paper: https://arxiv.org/abs/1606.08415 + """ + def forward(self, x): + return 0.5 * x * (1.0 + torch.tanh(math.sqrt(2.0 / math.pi) * (x + 0.044715 * torch.pow(x, 3.0)))) + +class CausalSelfAttention(nn.Module): + """ + A vanilla multi-head masked self-attention layer with a projection at the end. + It is possible to use torch.nn.MultiheadAttention here but I am including an + explicit implementation here to show that there is nothing too scary here. + """ + + def __init__(self, config): + super().__init__() + assert config.n_embd % config.n_head == 0 + # key, query, value projections for all heads, but in a batch + self.c_attn = nn.Linear(config.n_embd, 3 * config.n_embd) + # output projection + self.c_proj = nn.Linear(config.n_embd, config.n_embd) + # regularization + self.attn_dropout = nn.Dropout(config.attn_pdrop) + self.resid_dropout = nn.Dropout(config.resid_pdrop) + # causal mask to ensure that attention is only applied to the left in the input sequence + self.register_buffer("bias", torch.tril(torch.ones(config.block_size, config.block_size)) + .view(1, 1, config.block_size, config.block_size)) + self.n_head = config.n_head + self.n_embd = config.n_embd + + def forward(self, x): + B, T, C = x.size() # batch size, sequence length, embedding dimensionality (n_embd) + + # calculate query, key, values for all heads in batch and move head forward to be the batch dim + q, k ,v = self.c_attn(x).split(self.n_embd, dim=2) + k = k.view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs) + q = q.view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs) + v = v.view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs) + + # causal self-attention; Self-attend: (B, nh, T, hs) x (B, nh, hs, T) -> (B, nh, T, T) + att = (q @ k.transpose(-2, -1)) * (1.0 / math.sqrt(k.size(-1))) + att = att.masked_fill(self.bias[:,:,:T,:T] == 0, float('-inf')) + att = F.softmax(att, dim=-1) + att = self.attn_dropout(att) + y = att @ v # (B, nh, T, T) x (B, nh, T, hs) -> (B, nh, T, hs) + y = y.transpose(1, 2).contiguous().view(B, T, C) # re-assemble all head outputs side by side + + # output projection + y = self.resid_dropout(self.c_proj(y)) + return y + +class Block(nn.Module): + """ an unassuming Transformer block """ + + def __init__(self, config): + super().__init__() + self.ln_1 = nn.LayerNorm(config.n_embd) + self.attn = CausalSelfAttention(config) + self.ln_2 = nn.LayerNorm(config.n_embd) + self.mlp = nn.ModuleDict(dict( + c_fc = nn.Linear(config.n_embd, 4 * config.n_embd), + c_proj = nn.Linear(4 * config.n_embd, config.n_embd), + act = NewGELU(), + dropout = nn.Dropout(config.resid_pdrop), + )) + m = self.mlp + self.mlpf = lambda x: m.dropout(m.c_proj(m.act(m.c_fc(x)))) # MLP forward + + def forward(self, x): + x = x + self.attn(self.ln_1(x)) + x = x + self.mlpf(self.ln_2(x)) + return x + +class GPT(nn.Module): + """ GPT Language Model """ + + @staticmethod + def get_default_config(): + C = CN() + # either model_type or (n_layer, n_head, n_embd) must be given in the config + C.model_type = 'gpt' + C.n_layer = None + C.n_head = None + C.n_embd = None + # these options must be filled in externally + C.vocab_size = None + C.block_size = None + # dropout hyperparameters + C.embd_pdrop = 0.1 + C.resid_pdrop = 0.1 + C.attn_pdrop = 0.1 + return C + + def __init__(self, config): + super().__init__() + assert config.vocab_size is not None + assert config.block_size is not None + self.block_size = config.block_size + + type_given = config.model_type is not None + params_given = all([config.n_layer is not None, config.n_head is not None, config.n_embd is not None]) + assert type_given ^ params_given # exactly one of these (XOR) + if type_given: + # translate from model_type to detailed configuration + config.merge_from_dict({ + # names follow the huggingface naming conventions + # GPT-1 + 'openai-gpt': dict(n_layer=12, n_head=12, n_embd=768), # 117M params + # GPT-2 configs + 'gpt2': dict(n_layer=12, n_head=12, n_embd=768), # 124M params + 'gpt2-medium': dict(n_layer=24, n_head=16, n_embd=1024), # 350M params + 'gpt2-large': dict(n_layer=36, n_head=20, n_embd=1280), # 774M params + 'gpt2-xl': dict(n_layer=48, n_head=25, n_embd=1600), # 1558M params + # Gophers + 'gopher-44m': dict(n_layer=8, n_head=16, n_embd=512), + # (there are a number more...) + # I made these tiny models up + 'gpt-mini': dict(n_layer=6, n_head=6, n_embd=192), + 'gpt-micro': dict(n_layer=4, n_head=4, n_embd=128), + 'gpt-nano': dict(n_layer=3, n_head=3, n_embd=48), + }[config.model_type]) + + self.transformer = nn.ModuleDict(dict( + wte = nn.Embedding(config.vocab_size, config.n_embd), + wpe = nn.Embedding(config.block_size, config.n_embd), + drop = nn.Dropout(config.embd_pdrop), + h = nn.ModuleList([Block(config) for _ in range(config.n_layer)]), + ln_f = nn.LayerNorm(config.n_embd), + )) + self.lm_head = nn.Linear(config.n_embd, config.vocab_size, bias=False) + + # init all weights, and apply a special scaled init to the residual projections, per GPT-2 paper + self.apply(self._init_weights) + for pn, p in self.named_parameters(): + if pn.endswith('c_proj.weight'): + torch.nn.init.normal_(p, mean=0.0, std=0.02/math.sqrt(2 * config.n_layer)) + + # report number of parameters (note we don't count the decoder parameters in lm_head) + n_params = sum(p.numel() for p in self.transformer.parameters()) + print("number of parameters: %.2fM" % (n_params/1e6,)) + + def _init_weights(self, module): + if isinstance(module, nn.Linear): + torch.nn.init.normal_(module.weight, mean=0.0, std=0.02) + if module.bias is not None: + torch.nn.init.zeros_(module.bias) + elif isinstance(module, nn.Embedding): + torch.nn.init.normal_(module.weight, mean=0.0, std=0.02) + elif isinstance(module, nn.LayerNorm): + torch.nn.init.zeros_(module.bias) + torch.nn.init.ones_(module.weight) + + @classmethod + def from_pretrained(cls, model_type): + """ + Initialize a pretrained GPT model by copying over the weights + from a huggingface/transformers checkpoint. + """ + assert model_type in {'gpt2', 'gpt2-medium', 'gpt2-large', 'gpt2-xl'} + from transformers import GPT2LMHeadModel + + # create a from-scratch initialized minGPT model + config = cls.get_default_config() + config.model_type = model_type + config.vocab_size = 50257 # openai's model vocabulary + config.block_size = 1024 # openai's model block_size + model = GPT(config) + sd = model.state_dict() + + # init a huggingface/transformers model + model_hf = GPT2LMHeadModel.from_pretrained(model_type) + sd_hf = model_hf.state_dict() + + # copy while ensuring all of the parameters are aligned and match in names and shapes + keys = [k for k in sd_hf if not k.endswith('attn.masked_bias')] # ignore these + transposed = ['attn.c_attn.weight', 'attn.c_proj.weight', 'mlp.c_fc.weight', 'mlp.c_proj.weight'] + # basically the openai checkpoints use a "Conv1D" module, but we only want to use a vanilla nn.Linear. + # this means that we have to transpose these weights when we import them + assert len(keys) == len(sd) + for k in keys: + if any(k.endswith(w) for w in transposed): + # special treatment for the Conv1D weights we need to transpose + assert sd_hf[k].shape[::-1] == sd[k].shape + with torch.no_grad(): + sd[k].copy_(sd_hf[k].t()) + else: + # vanilla copy over the other parameters + assert sd_hf[k].shape == sd[k].shape + with torch.no_grad(): + sd[k].copy_(sd_hf[k]) + + return model + + def configure_optimizers(self, train_config): + """ + This long function is unfortunately doing something very simple and is being very defensive: + We are separating out all parameters of the model into two buckets: those that will experience + weight decay for regularization and those that won't (biases, and layernorm/embedding weights). + We are then returning the PyTorch optimizer object. + """ + + # separate out all parameters to those that will and won't experience regularizing weight decay + decay = set() + no_decay = set() + whitelist_weight_modules = (torch.nn.Linear, ) + blacklist_weight_modules = (torch.nn.LayerNorm, torch.nn.Embedding) + for mn, m in self.named_modules(): + for pn, p in m.named_parameters(): + fpn = '%s.%s' % (mn, pn) if mn else pn # full param name + # random note: because named_modules and named_parameters are recursive + # we will see the same tensors p many many times. but doing it this way + # allows us to know which parent module any tensor p belongs to... + if pn.endswith('bias'): + # all biases will not be decayed + no_decay.add(fpn) + elif pn.endswith('weight') and isinstance(m, whitelist_weight_modules): + # weights of whitelist modules will be weight decayed + decay.add(fpn) + elif pn.endswith('weight') and isinstance(m, blacklist_weight_modules): + # weights of blacklist modules will NOT be weight decayed + no_decay.add(fpn) + + # validate that we considered every parameter + param_dict = {pn: p for pn, p in self.named_parameters()} + inter_params = decay & no_decay + union_params = decay | no_decay + assert len(inter_params) == 0, "parameters %s made it into both decay/no_decay sets!" % (str(inter_params), ) + assert len(param_dict.keys() - union_params) == 0, "parameters %s were not separated into either decay/no_decay set!" \ + % (str(param_dict.keys() - union_params), ) + + # create the pytorch optimizer object + optim_groups = [ + {"params": [param_dict[pn] for pn in sorted(list(decay))], "weight_decay": train_config.weight_decay}, + {"params": [param_dict[pn] for pn in sorted(list(no_decay))], "weight_decay": 0.0}, + ] + optimizer = torch.optim.AdamW(optim_groups, lr=train_config.learning_rate, betas=train_config.betas) + return optimizer + + def forward(self, idx, targets=None): + device = idx.device + b, t = idx.size() + assert t <= self.block_size, f"Cannot forward sequence of length {t}, block size is only {self.block_size}" + pos = torch.arange(0, t, dtype=torch.long, device=device).unsqueeze(0) # shape (1, t) + + # forward the GPT model itself + tok_emb = self.transformer.wte(idx) # token embeddings of shape (b, t, n_embd) + pos_emb = self.transformer.wpe(pos) # position embeddings of shape (1, t, n_embd) + x = self.transformer.drop(tok_emb + pos_emb) + for block in self.transformer.h: + x = block(x) + x = self.transformer.ln_f(x) + logits = self.lm_head(x) + + # if we are given some desired targets also calculate the loss + loss = None + if targets is not None: + loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1), ignore_index=-1) + + return logits, loss + + @torch.no_grad() + def generate(self, idx, max_new_tokens, temperature=1.0, do_sample=False, top_k=None): + """ + Take a conditioning sequence of indices idx (LongTensor of shape (b,t)) and complete + the sequence max_new_tokens times, feeding the predictions back into the model each time. + Most likely you'll want to make sure to be in model.eval() mode of operation for this. + """ + for _ in range(max_new_tokens): + # if the sequence context is growing too long we must crop it at block_size + idx_cond = idx if idx.size(1) <= self.block_size else idx[:, -self.block_size:] + # forward the model to get the logits for the index in the sequence + logits, _ = self(idx_cond) + # pluck the logits at the final step and scale by desired temperature + logits = logits[:, -1, :] / temperature + # optionally crop the logits to only the top k options + if top_k is not None: + v, _ = torch.topk(logits, top_k) + logits[logits < v[:, [-1]]] = -float('Inf') + # apply softmax to convert logits to (normalized) probabilities + probs = F.softmax(logits, dim=-1) + # either sample from the distribution or take the most likely element + if do_sample: + idx_next = torch.multinomial(probs, num_samples=1) + else: + _, idx_next = torch.topk(probs, k=1, dim=-1) + # append sampled index to the running sequence and continue + idx = torch.cat((idx, idx_next), dim=1) + + return idx diff --git a/3.test_cases/15.neuron-distributed/mingpt/trainer.py b/3.test_cases/15.neuron-distributed/mingpt/trainer.py new file mode 100644 index 00000000..c0d08521 --- /dev/null +++ b/3.test_cases/15.neuron-distributed/mingpt/trainer.py @@ -0,0 +1,109 @@ +""" +Simple training loop; Boilerplate that could apply to any arbitrary neural network, +so nothing in this file really has anything to do with GPT specifically. +""" + +import time +from collections import defaultdict + +import torch +from torch.utils.data.dataloader import DataLoader +from mingpt.utils import CfgNode as CN + +class Trainer: + + @staticmethod + def get_default_config(): + C = CN() + # device to train on + C.device = 'auto' + # dataloder parameters + C.num_workers = 4 + # optimizer parameters + C.max_iters = None + C.batch_size = 64 + C.learning_rate = 3e-4 + C.betas = (0.9, 0.95) + C.weight_decay = 0.1 # only applied on matmul weights + C.grad_norm_clip = 1.0 + return C + + def __init__(self, config, model, train_dataset): + self.config = config + self.model = model + self.optimizer = None + self.train_dataset = train_dataset + self.callbacks = defaultdict(list) + + # determine the device we'll train on + if config.device == 'auto': + self.device = 'cuda' if torch.cuda.is_available() else 'cpu' + else: + self.device = config.device + self.model = self.model.to(self.device) + print("running on device", self.device) + + # variables that will be assigned to trainer class later for logging and etc + self.iter_num = 0 + self.iter_time = 0.0 + self.iter_dt = 0.0 + + def add_callback(self, onevent: str, callback): + self.callbacks[onevent].append(callback) + + def set_callback(self, onevent: str, callback): + self.callbacks[onevent] = [callback] + + def trigger_callbacks(self, onevent: str): + for callback in self.callbacks.get(onevent, []): + callback(self) + + def run(self): + model, config = self.model, self.config + + # setup the optimizer + self.optimizer = model.configure_optimizers(config) + + # setup the dataloader + train_loader = DataLoader( + self.train_dataset, + sampler=torch.utils.data.RandomSampler(self.train_dataset, replacement=True, num_samples=int(1e10)), + shuffle=False, + pin_memory=True, + batch_size=config.batch_size, + num_workers=config.num_workers, + ) + + model.train() + self.iter_num = 0 + self.iter_time = time.time() + data_iter = iter(train_loader) + while True: + + # fetch the next batch (x, y) and re-init iterator if needed + try: + batch = next(data_iter) + except StopIteration: + data_iter = iter(train_loader) + batch = next(data_iter) + batch = [t.to(self.device) for t in batch] + x, y = batch + + # forward the model + logits, self.loss = model(x, y) + + # backprop and update the parameters + model.zero_grad(set_to_none=True) + self.loss.backward() + torch.nn.utils.clip_grad_norm_(model.parameters(), config.grad_norm_clip) + self.optimizer.step() + + self.trigger_callbacks('on_batch_end') + self.iter_num += 1 + tnow = time.time() + self.iter_dt = tnow - self.iter_time + self.iter_time = tnow + + # termination conditions + if config.max_iters is not None and self.iter_num >= config.max_iters: + break diff --git a/3.test_cases/15.neuron-distributed/mingpt/utils.py b/3.test_cases/15.neuron-distributed/mingpt/utils.py new file mode 100644 index 00000000..af864ecb --- /dev/null +++ b/3.test_cases/15.neuron-distributed/mingpt/utils.py @@ -0,0 +1,103 @@ + +import os +import sys +import json +import random +from ast import literal_eval + +import numpy as np +import torch + +# ----------------------------------------------------------------------------- + +def set_seed(seed): + random.seed(seed) + np.random.seed(seed) + torch.manual_seed(seed) + torch.cuda.manual_seed_all(seed) + +def setup_logging(config): + """ monotonous bookkeeping """ + work_dir = config.system.work_dir + # create the work directory if it doesn't already exist + os.makedirs(work_dir, exist_ok=True) + # log the args (if any) + with open(os.path.join(work_dir, 'args.txt'), 'w') as f: + f.write(' '.join(sys.argv)) + # log the config itself + with open(os.path.join(work_dir, 'config.json'), 'w') as f: + f.write(json.dumps(config.to_dict(), indent=4)) + +class CfgNode: + """ a lightweight configuration class inspired by yacs """ + # TODO: convert to subclass from a dict like in yacs? + # TODO: implement freezing to prevent shooting of own foot + # TODO: additional existence/override checks when reading/writing params? + + def __init__(self, **kwargs): + self.__dict__.update(kwargs) + + def __str__(self): + return self._str_helper(0) + + def _str_helper(self, indent): + """ need to have a helper to support nested indentation for pretty printing """ + parts = [] + for k, v in self.__dict__.items(): + if isinstance(v, CfgNode): + parts.append("%s:\n" % k) + parts.append(v._str_helper(indent + 1)) + else: + parts.append("%s: %s\n" % (k, v)) + parts = [' ' * (indent * 4) + p for p in parts] + return "".join(parts) + + def to_dict(self): + """ return a dict representation of the config """ + return { k: v.to_dict() if isinstance(v, CfgNode) else v for k, v in self.__dict__.items() } + + def merge_from_dict(self, d): + self.__dict__.update(d) + + def merge_from_args(self, args): + """ + update the configuration from a list of strings that is expected + to come from the command line, i.e. sys.argv[1:]. + + The arguments are expected to be in the form of `--arg=value`, and + the arg can use . to denote nested sub-attributes. Example: + + --model.n_layer=10 --trainer.batch_size=32 + """ + for arg in args: + + keyval = arg.split('=') + assert len(keyval) == 2, "expecting each override arg to be of form --arg=value, got %s" % arg + key, val = keyval # unpack + + # first translate val into a python object + try: + val = literal_eval(val) + """ + need some explanation here. + - if val is simply a string, literal_eval will throw a ValueError + - if val represents a thing (like an 3, 3.14, [1,2,3], False, None, etc.) it will get created + """ + except ValueError: + pass + + # find the appropriate object to insert the attribute into + assert key[:2] == '--' + key = key[2:] # strip the '--' + keys = key.split('.') + obj = self + for k in keys[:-1]: + obj = getattr(obj, k) + leaf_key = keys[-1] + + # ensure that this attribute exists + assert hasattr(obj, leaf_key), f"{key} is not an attribute that exists in the config" + + # overwrite the attribute + print("command line overwriting config attribute %s with %s" % (key, val)) + setattr(obj, leaf_key, val) diff --git a/3.test_cases/15.neuron-distributed/projects/adder/adder.py b/3.test_cases/15.neuron-distributed/projects/adder/adder.py new file mode 100644 index 00000000..55f03ee1 --- /dev/null +++ b/3.test_cases/15.neuron-distributed/projects/adder/adder.py @@ -0,0 +1,207 @@ +""" +Trains a GPT to add n-digit numbers. +""" + +import os +import sys +import json + +import torch +from torch.utils.data import Dataset +from torch.utils.data.dataloader import DataLoader + +from mingpt.model import GPT +from mingpt.trainer import Trainer +from mingpt.utils import set_seed, setup_logging, CfgNode as CN + +# ----------------------------------------------------------------------------- + +def get_config(): + + C = CN() + + # system + C.system = CN() + C.system.seed = 3407 + C.system.work_dir = './out/adder' + + # data + C.data = AdditionDataset.get_default_config() + + # model + C.model = GPT.get_default_config() + C.model.model_type = 'gpt-nano' + + # trainer + C.trainer = Trainer.get_default_config() + C.trainer.learning_rate = 5e-4 # the model we're using is so small that we can go a bit faster + + return C + +# ----------------------------------------------------------------------------- + +class AdditionDataset(Dataset): + """ + Creates n-digit addition problems. For example, if n=2, then an example + addition problem would be to add 85 + 50 = 135. This problem would be + represented as the following string for the GPT: + + "8550531" + + This is because: + - we are discarding the + and =, which are not necessary. We just encode the digits + of the input numbers concatenated together. + - the result 135 is encoded backwards to make the addition easier to learn for the + GPT model, because of how the addition algorithm works. + + As one more example, the problem 6 + 39 = 45 would be encoded as: + + "0639054" + + where you will notice that we are padding with zeros to make sure that we always + produce strings of the exact same size: n + n + (n + 1). When n=2, this is 7. + At test time, we will feed in an addition problem by giving the first 2n digits, + and hoping that the GPT model completes the sequence with the next (n+1) digits + correctly. + """ + + @staticmethod + def get_default_config(): + C = CN() + C.ndigit = 2 + return C + + def __init__(self, config, split): + self.config = config + self.split = split # train/test + + # split up all addition problems into either training data or test data + ndigit = self.config.ndigit + assert ndigit <= 3, "the lines below would be very memory inefficient, in future maybe refactor to support" + num = (10**ndigit)**2 # total number of possible addition problems with ndigit numbers + rng = torch.Generator() + rng.manual_seed(1337) + perm = torch.randperm(num, generator=rng) + num_test = min(int(num*0.2), 500) # 20% of the whole dataset, or only up to 500 + self.ixes = perm[:num_test] if split == 'test' else perm[num_test:] + + def get_vocab_size(self): + return 10 # digits 0..9 + + def get_block_size(self): + # a,b,a+b, and +1 due to potential carry overflow, + # but then also -1 because very last digit doesn't ever plug back + # as there is no explicit token to predict, it is implied + return 3*self.config.ndigit + 1 - 1 + + def __len__(self): + return self.ixes.nelement() + + def __getitem__(self, idx): + ndigit = self.config.ndigit + # given a problem index idx, first recover the associated a + b + idx = self.ixes[idx].item() + nd = 10**ndigit + a = idx // nd + b = idx % nd + # calculate the "label" of the addition problem a + b + c = a + b + # encode the digits of a, b, c into strings + astr = f'%0{ndigit}d' % a + bstr = f'%0{ndigit}d' % b + cstr = (f'%0{ndigit+1}d' % c)[::-1] # reverse c to make addition easier + render = astr + bstr + cstr + dix = [int(s) for s in render] # convert each character to its token index + # x will be input to GPT and y will be the associated expected outputs + x = torch.tensor(dix[:-1], dtype=torch.long) + y = torch.tensor(dix[1:], dtype=torch.long) # predict the next token in the sequence + y[:ndigit*2-1] = -1 # we will only train in the output locations. -1 will mask loss to zero + return x, y + +# ----------------------------------------------------------------------------- + +if __name__ == '__main__': + + # get default config and overrides from the command line, if any + config = get_config() + config.merge_from_args(sys.argv[1:]) + print(config) + setup_logging(config) + set_seed(config.system.seed) + + # construct train and test datasets + train_dataset = AdditionDataset(config.data, split='train') + test_dataset = AdditionDataset(config.data, split='test') + + # construct the model + config.model.vocab_size = train_dataset.get_vocab_size() + config.model.block_size = train_dataset.get_block_size() + model = GPT(config.model) + + # construct the trainer object + trainer = Trainer(config.trainer, model, train_dataset) + + # helper function for the evaluation of a model + def eval_split(trainer, split, max_batches=None): + dataset = {'train':train_dataset, 'test':test_dataset}[split] + ndigit = config.data.ndigit + results = [] + mistakes_printed_already = 0 + factors = torch.tensor([[10**i for i in range(ndigit+1)][::-1]]).to(trainer.device) + loader = DataLoader(dataset, batch_size=100, num_workers=0, drop_last=False) + for b, (x, y) in enumerate(loader): + x = x.to(trainer.device) + # isolate the first two digits of the input sequence alone + d1d2 = x[:, :ndigit*2] + # let the model sample the rest of the sequence + d1d2d3 = model.generate(d1d2, ndigit+1, do_sample=False) # using greedy argmax, not sampling + # isolate the last digit of the sampled sequence + d3 = d1d2d3[:, -(ndigit+1):] + d3 = d3.flip(1) # reverse the digits to their "normal" order + # decode the integers from individual digits + d1i = (d1d2[:,:ndigit] * factors[:,1:]).sum(1) + d2i = (d1d2[:,ndigit:ndigit*2] * factors[:,1:]).sum(1) + d3i_pred = (d3 * factors).sum(1) + d3i_gt = d1i + d2i # manually calculate the ground truth + # evaluate the correctness of the results in this batch + correct = (d3i_pred == d3i_gt).cpu() # Software 1.0 vs. Software 2.0 fight RIGHT on this line haha + for i in range(x.size(0)): + results.append(int(correct[i])) + if not correct[i] and mistakes_printed_already < 5: # only print up to 5 mistakes to get a sense + mistakes_printed_already += 1 + print("GPT claims that %d + %d = %d but gt is %d" % (d1i[i], d2i[i], d3i_pred[i], d3i_gt[i])) + if max_batches is not None and b+1 >= max_batches: + break + rt = torch.tensor(results, dtype=torch.float) + print("%s final score: %d/%d = %.2f%% correct" % (split, rt.sum(), len(results), 100*rt.mean())) + return rt.sum() + + # iteration callback + top_score = 0 + def batch_end_callback(trainer): + global top_score + + if trainer.iter_num % 10 == 0: + print(f"iter_dt {trainer.iter_dt * 1000:.2f}ms; iter {trainer.iter_num}: train loss {trainer.loss.item():.5f}") + + if trainer.iter_num % 500 == 0: + # evaluate both the train and test score + train_max_batches = {1: None, 2: None, 3: 5}[config.data.ndigit] # if ndigit=2 we can afford the whole train set, ow no + model.eval() + with torch.no_grad(): + train_score = eval_split(trainer, 'train', max_batches=train_max_batches) + test_score = eval_split(trainer, 'test', max_batches=None) + score = train_score + test_score + # save the model if this is the best score we've seen so far + if score > top_score: + top_score = score + print(f"saving model with new top score of {score}") + ckpt_path = os.path.join(config.system.work_dir, "model.pt") + torch.save(model.state_dict(), ckpt_path) + # revert model to training mode + model.train() + + trainer.set_callback('on_batch_end', batch_end_callback) + + # run the optimization + trainer.run() diff --git a/3.test_cases/15.neuron-distributed/projects/adder/readme.md b/3.test_cases/15.neuron-distributed/projects/adder/readme.md new file mode 100644 index 00000000..ad168f43 --- /dev/null +++ b/3.test_cases/15.neuron-distributed/projects/adder/readme.md @@ -0,0 +1,4 @@ + +### adder + +Train a GPT model to add n-digit numbers diff --git a/3.test_cases/15.neuron-distributed/projects/chargpt/chargpt.py b/3.test_cases/15.neuron-distributed/projects/chargpt/chargpt.py new file mode 100644 index 00000000..5de925b0 --- /dev/null +++ b/3.test_cases/15.neuron-distributed/projects/chargpt/chargpt.py @@ -0,0 +1,133 @@ +""" +Trains a character-level language model. +""" + +import os +import sys + +import torch +from torch.utils.data import Dataset +from torch.utils.data.dataloader import DataLoader + +from mingpt.model import GPT +from mingpt.trainer import Trainer +from mingpt.utils import set_seed, setup_logging, CfgNode as CN + +# ----------------------------------------------------------------------------- + +def get_config(): + + C = CN() + + # system + C.system = CN() + C.system.seed = 3407 + C.system.work_dir = './out/chargpt' + + # data + C.data = CharDataset.get_default_config() + + # model + C.model = GPT.get_default_config() + C.model.model_type = 'gpt-mini' + + # trainer + C.trainer = Trainer.get_default_config() + C.trainer.learning_rate = 5e-4 # the model we're using is so small that we can go a bit faster + + return C + +# ----------------------------------------------------------------------------- + +class CharDataset(Dataset): + """ + Emits batches of characters + """ + + @staticmethod + def get_default_config(): + C = CN() + C.block_size = 128 + return C + + def __init__(self, config, data): + self.config = config + + chars = sorted(list(set(data))) + data_size, vocab_size = len(data), len(chars) + print('data has %d characters, %d unique.' % (data_size, vocab_size)) + + self.stoi = { ch:i for i,ch in enumerate(chars) } + self.itos = { i:ch for i,ch in enumerate(chars) } + self.vocab_size = vocab_size + self.data = data + + def get_vocab_size(self): + return self.vocab_size + + def get_block_size(self): + return self.config.block_size + + def __len__(self): + return len(self.data) - self.config.block_size + + def __getitem__(self, idx): + # grab a chunk of (block_size + 1) characters from the data + chunk = self.data[idx:idx + self.config.block_size + 1] + # encode every character to an integer + dix = [self.stoi[s] for s in chunk] + # return as tensors + x = torch.tensor(dix[:-1], dtype=torch.long) + y = torch.tensor(dix[1:], dtype=torch.long) + return x, y + +# ----------------------------------------------------------------------------- + +if __name__ == '__main__': + + # get default config and overrides from the command line, if any + config = get_config() + config.merge_from_args(sys.argv[1:]) + print(config) + setup_logging(config) + set_seed(config.system.seed) + + # construct the training dataset + text = open('input.txt', 'r').read() # don't worry we won't run out of file handles + train_dataset = CharDataset(config.data, text) + + # construct the model + config.model.vocab_size = train_dataset.get_vocab_size() + config.model.block_size = train_dataset.get_block_size() + model = GPT(config.model) + + # construct the trainer object + trainer = Trainer(config.trainer, model, train_dataset) + + # iteration callback + def batch_end_callback(trainer): + + if trainer.iter_num % 10 == 0: + print(f"iter_dt {trainer.iter_dt * 1000:.2f}ms; iter {trainer.iter_num}: train loss {trainer.loss.item():.5f}") + + if trainer.iter_num % 500 == 0: + # evaluate both the train and test score + model.eval() + with torch.no_grad(): + # sample from the model... + context = "O God, O God!" + x = torch.tensor([train_dataset.stoi[s] for s in context], dtype=torch.long)[None,...].to(trainer.device) + y = model.generate(x, 500, temperature=1.0, do_sample=True, top_k=10)[0] + completion = ''.join([train_dataset.itos[int(i)] for i in y]) + print(completion) + # save the latest model + print("saving model") + ckpt_path = os.path.join(config.system.work_dir, "model.pt") + torch.save(model.state_dict(), ckpt_path) + # revert model to training mode + model.train() + + trainer.set_callback('on_batch_end', batch_end_callback) + + # run the optimization + trainer.run() diff --git a/3.test_cases/15.neuron-distributed/projects/chargpt/readme.md b/3.test_cases/15.neuron-distributed/projects/chargpt/readme.md new file mode 100644 index 00000000..00d8def3 --- /dev/null +++ b/3.test_cases/15.neuron-distributed/projects/chargpt/readme.md @@ -0,0 +1,9 @@ +# chargpt + +chargpt trains a character-level language model. + +We support three settings: 1 convenience setting and 2 "benchmark" settings that have acedemic literature results: + +- a user specified `input.txt` file that we train an LM on (e.g. get tiny-shakespear (1.1MB of data) [here](https://raw.githubusercontent.com/karpathy/char-rnn/master/data/tinyshakespeare/input.txt)) +- TODO [text8](http://mattmahoney.net/dc/textdata.html): also derived from Wikipedia text but all XML is removed and is lowercased to only 26 characters of +- TODO [enwik8](http://prize.hutter1.net) benchmark ("Hutter Prize"), first 100M bytes of a Wikipedia XML dump, with 205 unique tokensEnglish plus spaces diff --git a/3.test_cases/15.neuron-distributed/projects/readme.md b/3.test_cases/15.neuron-distributed/projects/readme.md new file mode 100644 index 00000000..432505d2 --- /dev/null +++ b/3.test_cases/15.neuron-distributed/projects/readme.md @@ -0,0 +1,4 @@ + +### minGPT projects + +Various projects that use the minGPT library to achieve great things. diff --git a/3.test_cases/15.neuron-distributed/setup.py b/3.test_cases/15.neuron-distributed/setup.py new file mode 100644 index 00000000..9a2d64f6 --- /dev/null +++ b/3.test_cases/15.neuron-distributed/setup.py @@ -0,0 +1,12 @@ +from setuptools import setup + +setup(name='minGPT', + version='0.0.1', + author='Andrej Karpathy', + packages=['mingpt'], + description='A PyTorch re-implementation of GPT', + license='MIT', + install_requires=[ + 'torch', + ], +) diff --git a/3.test_cases/15.neuron-distributed/tests/test_huggingface_import.py b/3.test_cases/15.neuron-distributed/tests/test_huggingface_import.py new file mode 100644 index 00000000..dab52a82 --- /dev/null +++ b/3.test_cases/15.neuron-distributed/tests/test_huggingface_import.py @@ -0,0 +1,57 @@ +""" +Ensure that we can load huggingface/transformer GPTs into minGPT +""" + +import unittest +import torch +from transformers import GPT2Tokenizer, GPT2LMHeadModel +from mingpt.model import GPT +from mingpt.bpe import BPETokenizer +# ----------------------------------------------------------------------------- + +class TestHuggingFaceImport(unittest.TestCase): + + def test_gpt2(self): + model_type = 'gpt2' + device = 'cuda' if torch.cuda.is_available() else 'cpu' + prompt = "Hello!!!!!!!!!? 🤗, my dog is a little" + + # create a minGPT and a huggingface/transformers model + model = GPT.from_pretrained(model_type) + model_hf = GPT2LMHeadModel.from_pretrained(model_type) # init a HF model too + + # ship both to device + model.to(device) + model_hf.to(device) + + # set both to eval mode + model.eval() + model_hf.eval() + + # tokenize input prompt + # ... with mingpt + tokenizer = BPETokenizer() + x1 = tokenizer(prompt).to(device) + # ... with huggingface/transformers + tokenizer_hf = GPT2Tokenizer.from_pretrained(model_type) + model_hf.config.pad_token_id = model_hf.config.eos_token_id # suppress a warning + encoded_input = tokenizer_hf(prompt, return_tensors='pt').to(device) + x2 = encoded_input['input_ids'] + + # ensure the logits match exactly + logits1, loss = model(x1) + logits2 = model_hf(x2).logits + self.assertTrue(torch.allclose(logits1, logits2)) + + # now draw the argmax samples from each + y1 = model.generate(x1, max_new_tokens=20, do_sample=False)[0] + y2 = model_hf.generate(x2, max_new_tokens=20, do_sample=False)[0] + self.assertTrue(torch.equal(y1, y2)) # compare the raw sampled indices + + # convert indices to strings + out1 = tokenizer.decode(y1.cpu().squeeze()) + out2 = tokenizer_hf.decode(y2.cpu().squeeze()) + self.assertTrue(out1 == out2) # compare the exact output strings too + +if __name__ == '__main__': + unittest.main() From c6448308be8edee96c641c3fc286b869d8d98015 Mon Sep 17 00:00:00 2001 From: Keita Watanabe Date: Tue, 12 Mar 2024 01:43:54 +0000 Subject: [PATCH 02/16] reorder --- .../LICENSE | 0 .../README.md | 0 .../demo.ipynb | 0 .../docs/README.md | 0 .../generate.ipynb | 0 .../mingpt.jpg | Bin .../mingpt/__init__.py | 0 .../mingpt/bpe.py | 0 .../mingpt/model.py | 0 .../mingpt/trainer.py | 0 .../mingpt/utils.py | 0 .../projects/adder/adder.py | 0 .../projects/adder/readme.md | 0 .../projects/chargpt/chargpt.py | 0 .../projects/chargpt/readme.md | 0 .../projects/readme.md | 0 .../setup.py | 0 .../tests/test_huggingface_import.py | 0 18 files changed, 0 insertions(+), 0 deletions(-) rename 3.test_cases/{15.neuron-distributed => 16.neuron-distributed}/LICENSE (100%) rename 3.test_cases/{15.neuron-distributed => 16.neuron-distributed}/README.md (100%) rename 3.test_cases/{15.neuron-distributed => 16.neuron-distributed}/demo.ipynb (100%) rename 3.test_cases/{15.neuron-distributed => 16.neuron-distributed}/docs/README.md (100%) rename 3.test_cases/{15.neuron-distributed => 16.neuron-distributed}/generate.ipynb (100%) rename 3.test_cases/{15.neuron-distributed => 16.neuron-distributed}/mingpt.jpg (100%) rename 3.test_cases/{15.neuron-distributed => 16.neuron-distributed}/mingpt/__init__.py (100%) rename 3.test_cases/{15.neuron-distributed => 16.neuron-distributed}/mingpt/bpe.py (100%) rename 3.test_cases/{15.neuron-distributed => 16.neuron-distributed}/mingpt/model.py (100%) rename 3.test_cases/{15.neuron-distributed => 16.neuron-distributed}/mingpt/trainer.py (100%) rename 3.test_cases/{15.neuron-distributed => 16.neuron-distributed}/mingpt/utils.py (100%) rename 3.test_cases/{15.neuron-distributed => 16.neuron-distributed}/projects/adder/adder.py (100%) rename 3.test_cases/{15.neuron-distributed => 16.neuron-distributed}/projects/adder/readme.md (100%) rename 3.test_cases/{15.neuron-distributed => 16.neuron-distributed}/projects/chargpt/chargpt.py (100%) rename 3.test_cases/{15.neuron-distributed => 16.neuron-distributed}/projects/chargpt/readme.md (100%) rename 3.test_cases/{15.neuron-distributed => 16.neuron-distributed}/projects/readme.md (100%) rename 3.test_cases/{15.neuron-distributed => 16.neuron-distributed}/setup.py (100%) rename 3.test_cases/{15.neuron-distributed => 16.neuron-distributed}/tests/test_huggingface_import.py (100%) diff --git a/3.test_cases/15.neuron-distributed/LICENSE b/3.test_cases/16.neuron-distributed/LICENSE similarity index 100% rename from 3.test_cases/15.neuron-distributed/LICENSE rename to 3.test_cases/16.neuron-distributed/LICENSE diff --git a/3.test_cases/15.neuron-distributed/README.md b/3.test_cases/16.neuron-distributed/README.md similarity index 100% rename from 3.test_cases/15.neuron-distributed/README.md rename to 3.test_cases/16.neuron-distributed/README.md diff --git a/3.test_cases/15.neuron-distributed/demo.ipynb b/3.test_cases/16.neuron-distributed/demo.ipynb similarity index 100% rename from 3.test_cases/15.neuron-distributed/demo.ipynb rename to 3.test_cases/16.neuron-distributed/demo.ipynb diff --git a/3.test_cases/15.neuron-distributed/docs/README.md b/3.test_cases/16.neuron-distributed/docs/README.md similarity index 100% rename from 3.test_cases/15.neuron-distributed/docs/README.md rename to 3.test_cases/16.neuron-distributed/docs/README.md diff --git a/3.test_cases/15.neuron-distributed/generate.ipynb b/3.test_cases/16.neuron-distributed/generate.ipynb similarity index 100% rename from 3.test_cases/15.neuron-distributed/generate.ipynb rename to 3.test_cases/16.neuron-distributed/generate.ipynb diff --git a/3.test_cases/15.neuron-distributed/mingpt.jpg b/3.test_cases/16.neuron-distributed/mingpt.jpg similarity index 100% rename from 3.test_cases/15.neuron-distributed/mingpt.jpg rename to 3.test_cases/16.neuron-distributed/mingpt.jpg diff --git a/3.test_cases/15.neuron-distributed/mingpt/__init__.py b/3.test_cases/16.neuron-distributed/mingpt/__init__.py similarity index 100% rename from 3.test_cases/15.neuron-distributed/mingpt/__init__.py rename to 3.test_cases/16.neuron-distributed/mingpt/__init__.py diff --git a/3.test_cases/15.neuron-distributed/mingpt/bpe.py b/3.test_cases/16.neuron-distributed/mingpt/bpe.py similarity index 100% rename from 3.test_cases/15.neuron-distributed/mingpt/bpe.py rename to 3.test_cases/16.neuron-distributed/mingpt/bpe.py diff --git a/3.test_cases/15.neuron-distributed/mingpt/model.py b/3.test_cases/16.neuron-distributed/mingpt/model.py similarity index 100% rename from 3.test_cases/15.neuron-distributed/mingpt/model.py rename to 3.test_cases/16.neuron-distributed/mingpt/model.py diff --git a/3.test_cases/15.neuron-distributed/mingpt/trainer.py b/3.test_cases/16.neuron-distributed/mingpt/trainer.py similarity index 100% rename from 3.test_cases/15.neuron-distributed/mingpt/trainer.py rename to 3.test_cases/16.neuron-distributed/mingpt/trainer.py diff --git a/3.test_cases/15.neuron-distributed/mingpt/utils.py b/3.test_cases/16.neuron-distributed/mingpt/utils.py similarity index 100% rename from 3.test_cases/15.neuron-distributed/mingpt/utils.py rename to 3.test_cases/16.neuron-distributed/mingpt/utils.py diff --git a/3.test_cases/15.neuron-distributed/projects/adder/adder.py b/3.test_cases/16.neuron-distributed/projects/adder/adder.py similarity index 100% rename from 3.test_cases/15.neuron-distributed/projects/adder/adder.py rename to 3.test_cases/16.neuron-distributed/projects/adder/adder.py diff --git a/3.test_cases/15.neuron-distributed/projects/adder/readme.md b/3.test_cases/16.neuron-distributed/projects/adder/readme.md similarity index 100% rename from 3.test_cases/15.neuron-distributed/projects/adder/readme.md rename to 3.test_cases/16.neuron-distributed/projects/adder/readme.md diff --git a/3.test_cases/15.neuron-distributed/projects/chargpt/chargpt.py b/3.test_cases/16.neuron-distributed/projects/chargpt/chargpt.py similarity index 100% rename from 3.test_cases/15.neuron-distributed/projects/chargpt/chargpt.py rename to 3.test_cases/16.neuron-distributed/projects/chargpt/chargpt.py diff --git a/3.test_cases/15.neuron-distributed/projects/chargpt/readme.md b/3.test_cases/16.neuron-distributed/projects/chargpt/readme.md similarity index 100% rename from 3.test_cases/15.neuron-distributed/projects/chargpt/readme.md rename to 3.test_cases/16.neuron-distributed/projects/chargpt/readme.md diff --git a/3.test_cases/15.neuron-distributed/projects/readme.md b/3.test_cases/16.neuron-distributed/projects/readme.md similarity index 100% rename from 3.test_cases/15.neuron-distributed/projects/readme.md rename to 3.test_cases/16.neuron-distributed/projects/readme.md diff --git a/3.test_cases/15.neuron-distributed/setup.py b/3.test_cases/16.neuron-distributed/setup.py similarity index 100% rename from 3.test_cases/15.neuron-distributed/setup.py rename to 3.test_cases/16.neuron-distributed/setup.py diff --git a/3.test_cases/15.neuron-distributed/tests/test_huggingface_import.py b/3.test_cases/16.neuron-distributed/tests/test_huggingface_import.py similarity index 100% rename from 3.test_cases/15.neuron-distributed/tests/test_huggingface_import.py rename to 3.test_cases/16.neuron-distributed/tests/test_huggingface_import.py From 52e8c3374e35594c3c770715355517d9c16d32c1 Mon Sep 17 00:00:00 2001 From: AWS ParallelCluster user Date: Sat, 8 Jun 2024 00:49:47 +0000 Subject: [PATCH 03/16] update --- .../LICENSE | 0 .../README.md | 4 +++- .../demo.ipynb | 0 .../docs/README.md | 0 .../generate.ipynb | 0 .../mingpt.jpg | Bin .../mingpt/__init__.py | 0 .../mingpt/bpe.py | 0 .../mingpt/model.py | 0 .../mingpt/trainer.py | 0 .../mingpt/utils.py | 0 .../projects/adder/adder.py | 0 .../projects/adder/readme.md | 0 .../projects/chargpt/chargpt.py | 0 .../projects/chargpt/readme.md | 0 .../projects/readme.md | 0 .../setup.py | 0 .../tests/test_huggingface_import.py | 0 18 files changed, 3 insertions(+), 1 deletion(-) rename 3.test_cases/{16.neuron-distributed => neuronx-distributed}/LICENSE (100%) rename 3.test_cases/{16.neuron-distributed => neuronx-distributed}/README.md (99%) rename 3.test_cases/{16.neuron-distributed => neuronx-distributed}/demo.ipynb (100%) rename 3.test_cases/{16.neuron-distributed => neuronx-distributed}/docs/README.md (100%) rename 3.test_cases/{16.neuron-distributed => neuronx-distributed}/generate.ipynb (100%) rename 3.test_cases/{16.neuron-distributed => neuronx-distributed}/mingpt.jpg (100%) rename 3.test_cases/{16.neuron-distributed => neuronx-distributed}/mingpt/__init__.py (100%) rename 3.test_cases/{16.neuron-distributed => neuronx-distributed}/mingpt/bpe.py (100%) rename 3.test_cases/{16.neuron-distributed => neuronx-distributed}/mingpt/model.py (100%) rename 3.test_cases/{16.neuron-distributed => neuronx-distributed}/mingpt/trainer.py (100%) rename 3.test_cases/{16.neuron-distributed => neuronx-distributed}/mingpt/utils.py (100%) rename 3.test_cases/{16.neuron-distributed => neuronx-distributed}/projects/adder/adder.py (100%) rename 3.test_cases/{16.neuron-distributed => neuronx-distributed}/projects/adder/readme.md (100%) rename 3.test_cases/{16.neuron-distributed => neuronx-distributed}/projects/chargpt/chargpt.py (100%) rename 3.test_cases/{16.neuron-distributed => neuronx-distributed}/projects/chargpt/readme.md (100%) rename 3.test_cases/{16.neuron-distributed => neuronx-distributed}/projects/readme.md (100%) rename 3.test_cases/{16.neuron-distributed => neuronx-distributed}/setup.py (100%) rename 3.test_cases/{16.neuron-distributed => neuronx-distributed}/tests/test_huggingface_import.py (100%) diff --git a/3.test_cases/16.neuron-distributed/LICENSE b/3.test_cases/neuronx-distributed/LICENSE similarity index 100% rename from 3.test_cases/16.neuron-distributed/LICENSE rename to 3.test_cases/neuronx-distributed/LICENSE diff --git a/3.test_cases/16.neuron-distributed/README.md b/3.test_cases/neuronx-distributed/README.md similarity index 99% rename from 3.test_cases/16.neuron-distributed/README.md rename to 3.test_cases/neuronx-distributed/README.md index ae4daa09..ff717d82 100644 --- a/3.test_cases/16.neuron-distributed/README.md +++ b/3.test_cases/neuronx-distributed/README.md @@ -1,4 +1,6 @@ -# Mosaic Pretrained Transformers (MPT) Test Case +# NeuronX distributed test cases + + MPT are GPT-style models in [llm-foundry](https://github.com/mosaicml/llm-foundry/tree/main) with some special features -- [Flash Attention](https://arxiv.org/abs/2205.14135) for efficiency, [ALiBi](https://arxiv.org/abs/2108.12409) for context length extrapolation, and stability improvements to mitigate loss spikes. diff --git a/3.test_cases/16.neuron-distributed/demo.ipynb b/3.test_cases/neuronx-distributed/demo.ipynb similarity index 100% rename from 3.test_cases/16.neuron-distributed/demo.ipynb rename to 3.test_cases/neuronx-distributed/demo.ipynb diff --git a/3.test_cases/16.neuron-distributed/docs/README.md b/3.test_cases/neuronx-distributed/docs/README.md similarity index 100% rename from 3.test_cases/16.neuron-distributed/docs/README.md rename to 3.test_cases/neuronx-distributed/docs/README.md diff --git a/3.test_cases/16.neuron-distributed/generate.ipynb b/3.test_cases/neuronx-distributed/generate.ipynb similarity index 100% rename from 3.test_cases/16.neuron-distributed/generate.ipynb rename to 3.test_cases/neuronx-distributed/generate.ipynb diff --git a/3.test_cases/16.neuron-distributed/mingpt.jpg b/3.test_cases/neuronx-distributed/mingpt.jpg similarity index 100% rename from 3.test_cases/16.neuron-distributed/mingpt.jpg rename to 3.test_cases/neuronx-distributed/mingpt.jpg diff --git a/3.test_cases/16.neuron-distributed/mingpt/__init__.py b/3.test_cases/neuronx-distributed/mingpt/__init__.py similarity index 100% rename from 3.test_cases/16.neuron-distributed/mingpt/__init__.py rename to 3.test_cases/neuronx-distributed/mingpt/__init__.py diff --git a/3.test_cases/16.neuron-distributed/mingpt/bpe.py b/3.test_cases/neuronx-distributed/mingpt/bpe.py similarity index 100% rename from 3.test_cases/16.neuron-distributed/mingpt/bpe.py rename to 3.test_cases/neuronx-distributed/mingpt/bpe.py diff --git a/3.test_cases/16.neuron-distributed/mingpt/model.py b/3.test_cases/neuronx-distributed/mingpt/model.py similarity index 100% rename from 3.test_cases/16.neuron-distributed/mingpt/model.py rename to 3.test_cases/neuronx-distributed/mingpt/model.py diff --git a/3.test_cases/16.neuron-distributed/mingpt/trainer.py b/3.test_cases/neuronx-distributed/mingpt/trainer.py similarity index 100% rename from 3.test_cases/16.neuron-distributed/mingpt/trainer.py rename to 3.test_cases/neuronx-distributed/mingpt/trainer.py diff --git a/3.test_cases/16.neuron-distributed/mingpt/utils.py b/3.test_cases/neuronx-distributed/mingpt/utils.py similarity index 100% rename from 3.test_cases/16.neuron-distributed/mingpt/utils.py rename to 3.test_cases/neuronx-distributed/mingpt/utils.py diff --git a/3.test_cases/16.neuron-distributed/projects/adder/adder.py b/3.test_cases/neuronx-distributed/projects/adder/adder.py similarity index 100% rename from 3.test_cases/16.neuron-distributed/projects/adder/adder.py rename to 3.test_cases/neuronx-distributed/projects/adder/adder.py diff --git a/3.test_cases/16.neuron-distributed/projects/adder/readme.md b/3.test_cases/neuronx-distributed/projects/adder/readme.md similarity index 100% rename from 3.test_cases/16.neuron-distributed/projects/adder/readme.md rename to 3.test_cases/neuronx-distributed/projects/adder/readme.md diff --git a/3.test_cases/16.neuron-distributed/projects/chargpt/chargpt.py b/3.test_cases/neuronx-distributed/projects/chargpt/chargpt.py similarity index 100% rename from 3.test_cases/16.neuron-distributed/projects/chargpt/chargpt.py rename to 3.test_cases/neuronx-distributed/projects/chargpt/chargpt.py diff --git a/3.test_cases/16.neuron-distributed/projects/chargpt/readme.md b/3.test_cases/neuronx-distributed/projects/chargpt/readme.md similarity index 100% rename from 3.test_cases/16.neuron-distributed/projects/chargpt/readme.md rename to 3.test_cases/neuronx-distributed/projects/chargpt/readme.md diff --git a/3.test_cases/16.neuron-distributed/projects/readme.md b/3.test_cases/neuronx-distributed/projects/readme.md similarity index 100% rename from 3.test_cases/16.neuron-distributed/projects/readme.md rename to 3.test_cases/neuronx-distributed/projects/readme.md diff --git a/3.test_cases/16.neuron-distributed/setup.py b/3.test_cases/neuronx-distributed/setup.py similarity index 100% rename from 3.test_cases/16.neuron-distributed/setup.py rename to 3.test_cases/neuronx-distributed/setup.py diff --git a/3.test_cases/16.neuron-distributed/tests/test_huggingface_import.py b/3.test_cases/neuronx-distributed/tests/test_huggingface_import.py similarity index 100% rename from 3.test_cases/16.neuron-distributed/tests/test_huggingface_import.py rename to 3.test_cases/neuronx-distributed/tests/test_huggingface_import.py From 5e312426b215f8105df1a0d7d7f93dc7fedc2a61 Mon Sep 17 00:00:00 2001 From: Keita Watanabe Date: Sat, 8 Jun 2024 22:25:50 +0000 Subject: [PATCH 04/16] update --- .../neuronx-distributed/mingpt/0.cpu.py | 37 ++++ .../neuronx-distributed/{ => mingpt}/LICENSE | 0 .../neuronx-distributed/mingpt/README.md | 5 + .../{ => mingpt}/demo.ipynb | 0 .../{ => mingpt}/docs/README.md | 0 .../{ => mingpt}/generate.ipynb | 0 .../{ => mingpt}/mingpt.jpg | Bin .../mingpt/{ => mingpt}/__init__.py | 0 .../mingpt/{ => mingpt}/bpe.py | 0 .../mingpt/mingpt/configs.py | 18 ++ .../mingpt/mingpt/datasets.py | 135 ++++++++++++ .../mingpt/{ => mingpt}/model.py | 0 .../mingpt/{ => mingpt}/trainer.py | 3 +- .../mingpt/{ => mingpt}/utils.py | 3 - .../neuronx-distributed/{ => mingpt}/setup.py | 0 .../tests/test_huggingface_import.py | 0 .../mingpt/tutorials/ddp_neuron.py | 104 +++++++++ .../mingpt/tutorials/main.py | 5 + .../mingpt/tutorials/model_paralell_neuron.py | 0 .../projects/adder/adder.py | 207 ------------------ .../projects/adder/readme.md | 4 - .../projects/chargpt/chargpt.py | 133 ----------- .../projects/chargpt/readme.md | 9 - .../neuronx-distributed/projects/readme.md | 4 - 24 files changed, 306 insertions(+), 361 deletions(-) create mode 100644 3.test_cases/neuronx-distributed/mingpt/0.cpu.py rename 3.test_cases/neuronx-distributed/{ => mingpt}/LICENSE (100%) create mode 100644 3.test_cases/neuronx-distributed/mingpt/README.md rename 3.test_cases/neuronx-distributed/{ => mingpt}/demo.ipynb (100%) rename 3.test_cases/neuronx-distributed/{ => mingpt}/docs/README.md (100%) rename 3.test_cases/neuronx-distributed/{ => mingpt}/generate.ipynb (100%) rename 3.test_cases/neuronx-distributed/{ => mingpt}/mingpt.jpg (100%) rename 3.test_cases/neuronx-distributed/mingpt/{ => mingpt}/__init__.py (100%) rename 3.test_cases/neuronx-distributed/mingpt/{ => mingpt}/bpe.py (100%) create mode 100644 3.test_cases/neuronx-distributed/mingpt/mingpt/configs.py create mode 100644 3.test_cases/neuronx-distributed/mingpt/mingpt/datasets.py rename 3.test_cases/neuronx-distributed/mingpt/{ => mingpt}/model.py (100%) rename 3.test_cases/neuronx-distributed/mingpt/{ => mingpt}/trainer.py (98%) rename 3.test_cases/neuronx-distributed/mingpt/{ => mingpt}/utils.py (94%) rename 3.test_cases/neuronx-distributed/{ => mingpt}/setup.py (100%) rename 3.test_cases/neuronx-distributed/{ => mingpt}/tests/test_huggingface_import.py (100%) create mode 100644 3.test_cases/neuronx-distributed/mingpt/tutorials/ddp_neuron.py create mode 100644 3.test_cases/neuronx-distributed/mingpt/tutorials/main.py create mode 100644 3.test_cases/neuronx-distributed/mingpt/tutorials/model_paralell_neuron.py delete mode 100644 3.test_cases/neuronx-distributed/projects/adder/adder.py delete mode 100644 3.test_cases/neuronx-distributed/projects/adder/readme.md delete mode 100644 3.test_cases/neuronx-distributed/projects/chargpt/chargpt.py delete mode 100644 3.test_cases/neuronx-distributed/projects/chargpt/readme.md delete mode 100644 3.test_cases/neuronx-distributed/projects/readme.md diff --git a/3.test_cases/neuronx-distributed/mingpt/0.cpu.py b/3.test_cases/neuronx-distributed/mingpt/0.cpu.py new file mode 100644 index 00000000..ecc2a714 --- /dev/null +++ b/3.test_cases/neuronx-distributed/mingpt/0.cpu.py @@ -0,0 +1,37 @@ +import torch +from torch.utils.data import DataLoader +from tqdm import tqdm + +from mingpt.model import GPT +from mingpt.datasets import SortDataset +from mingpt.trainer import Trainer +from mingpt.configs import TrainConfig + +# create train and test dataset +train_dataset = SortDataset('train') +test_dataset = SortDataset('test') +train_config = TrainConfig.get_default_config() +train_loader = DataLoader( + train_dataset, + batch_size=train_config.batch_size, + ) + +# create a GPT instance +model_config = GPT.get_default_config() +model_config.model_type = 'gpt-nano' +model_config.vocab_size = train_dataset.get_vocab_size() +model_config.block_size = train_dataset.get_block_size() +model = GPT(model_config) +optimizer = model.configure_optimizers(train_config) + +model.train() +pbar = tqdm(enumerate(train_loader)) +for idx, (x, y) in pbar: + # forward the model + logits, loss = model(x, y) + # backprop and update the parameters + model.zero_grad(set_to_none=True) + loss.backward() + torch.nn.utils.clip_grad_norm_(model.parameters(), train_config.grad_norm_clip) + optimizer.step() + pbar.set_description(f"Iteration: {idx}, train loss: {loss.item():.5f}") \ No newline at end of file diff --git a/3.test_cases/neuronx-distributed/LICENSE b/3.test_cases/neuronx-distributed/mingpt/LICENSE similarity index 100% rename from 3.test_cases/neuronx-distributed/LICENSE rename to 3.test_cases/neuronx-distributed/mingpt/LICENSE diff --git a/3.test_cases/neuronx-distributed/mingpt/README.md b/3.test_cases/neuronx-distributed/mingpt/README.md new file mode 100644 index 00000000..8fa3ea54 --- /dev/null +++ b/3.test_cases/neuronx-distributed/mingpt/README.md @@ -0,0 +1,5 @@ +# minGPT test case + +This test case is an educational sample that guide you through how to construct distributed training codes using NeuronX distributed. + + diff --git a/3.test_cases/neuronx-distributed/demo.ipynb b/3.test_cases/neuronx-distributed/mingpt/demo.ipynb similarity index 100% rename from 3.test_cases/neuronx-distributed/demo.ipynb rename to 3.test_cases/neuronx-distributed/mingpt/demo.ipynb diff --git a/3.test_cases/neuronx-distributed/docs/README.md b/3.test_cases/neuronx-distributed/mingpt/docs/README.md similarity index 100% rename from 3.test_cases/neuronx-distributed/docs/README.md rename to 3.test_cases/neuronx-distributed/mingpt/docs/README.md diff --git a/3.test_cases/neuronx-distributed/generate.ipynb b/3.test_cases/neuronx-distributed/mingpt/generate.ipynb similarity index 100% rename from 3.test_cases/neuronx-distributed/generate.ipynb rename to 3.test_cases/neuronx-distributed/mingpt/generate.ipynb diff --git a/3.test_cases/neuronx-distributed/mingpt.jpg b/3.test_cases/neuronx-distributed/mingpt/mingpt.jpg similarity index 100% rename from 3.test_cases/neuronx-distributed/mingpt.jpg rename to 3.test_cases/neuronx-distributed/mingpt/mingpt.jpg diff --git a/3.test_cases/neuronx-distributed/mingpt/__init__.py b/3.test_cases/neuronx-distributed/mingpt/mingpt/__init__.py similarity index 100% rename from 3.test_cases/neuronx-distributed/mingpt/__init__.py rename to 3.test_cases/neuronx-distributed/mingpt/mingpt/__init__.py diff --git a/3.test_cases/neuronx-distributed/mingpt/bpe.py b/3.test_cases/neuronx-distributed/mingpt/mingpt/bpe.py similarity index 100% rename from 3.test_cases/neuronx-distributed/mingpt/bpe.py rename to 3.test_cases/neuronx-distributed/mingpt/mingpt/bpe.py diff --git a/3.test_cases/neuronx-distributed/mingpt/mingpt/configs.py b/3.test_cases/neuronx-distributed/mingpt/mingpt/configs.py new file mode 100644 index 00000000..8c1fab66 --- /dev/null +++ b/3.test_cases/neuronx-distributed/mingpt/mingpt/configs.py @@ -0,0 +1,18 @@ +from mingpt.utils import CfgNode as CN + +class TrainConfig: + @staticmethod + def get_default_config(): + C = CN() + # device to train on + C.device = 'auto' + # dataloder parameters + C.num_workers = 0 + # optimizer parameters + C.batch_size = 32 + C.learning_rate = 3e-4 + C.betas = (0.9, 0.95) + C.max_iters = 8000 + C.weight_decay = 0.1 # only applied on matmul weights + C.grad_norm_clip = 1.0 + return C diff --git a/3.test_cases/neuronx-distributed/mingpt/mingpt/datasets.py b/3.test_cases/neuronx-distributed/mingpt/mingpt/datasets.py new file mode 100644 index 00000000..95d1f28c --- /dev/null +++ b/3.test_cases/neuronx-distributed/mingpt/mingpt/datasets.py @@ -0,0 +1,135 @@ +import pickle + +import torch +from torch.utils.data import Dataset + +class AdditionDataset(Dataset): + """ + Creates n-digit addition problems. For example, if n=2, then an example + addition problem would be to add 85 + 50 = 135. This problem would be + represented as the following string for the GPT: + + "8550531" + + This is because: + - we are discarding the + and =, which are not necessary. We just encode the digits + of the input numbers concatenated together. + - the result 135 is encoded backwards to make the addition easier to learn for the + GPT model, because of how the addition algorithm works. + + As one more example, the problem 6 + 39 = 45 would be encoded as: + + "0639054" + + where you will notice that we are padding with zeros to make sure that we always + produce strings of the exact same size: n + n + (n + 1). When n=2, this is 7. + At test time, we will feed in an addition problem by giving the first 2n digits, + and hoping that the GPT model completes the sequence with the next (n+1) digits + correctly. + """ + + def __init__(self, split, ndigit=2): + self.split = split # train/test + + # split up all addition problems into either training data or test data + self.ndigit = ndigit + assert ndigit <= 3, "the lines below would be very memory inefficient, in future maybe refactor to support" + num = (10**ndigit)**2 # total number of possible addition problems with ndigit numbers + rng = torch.Generator() + rng.manual_seed(1337) + perm = torch.randperm(num, generator=rng) + num_test = min(int(num*0.2), 500) # 20% of the whole dataset, or only up to 500 + self.ixes = perm[:num_test] if split == 'test' else perm[num_test:] + + def get_vocab_size(self): + return 10 # digits 0..9 + + def get_block_size(self): + # a,b,a+b, and +1 due to potential carry overflow, + # but then also -1 because very last digit doesn't ever plug back + # as there is no explicit token to predict, it is implied + return 3*self.ndigit + 1 - 1 + + def __len__(self): + return self.ixes.nelement() + + def __getitem__(self, idx): + ndigit = self.ndigit + # given a problem index idx, first recover the associated a + b + idx = self.ixes[idx].item() + nd = 10**ndigit + a = idx // nd + b = idx % nd + # calculate the "label" of the addition problem a + b + c = a + b + # encode the digits of a, b, c into strings + astr = f'%0{ndigit}d' % a + bstr = f'%0{ndigit}d' % b + cstr = (f'%0{ndigit+1}d' % c)[::-1] # reverse c to make addition easier + render = astr + bstr + cstr + dix = [int(s) for s in render] # convert each character to its token index + # x will be input to GPT and y will be the associated expected outputs + x = torch.tensor(dix[:-1], dtype=torch.long) + y = torch.tensor(dix[1:], dtype=torch.long) # predict the next token in the sequence + y[:ndigit*2-1] = -1 # we will only train in the output locations. -1 will mask loss to zero + return x, y + +class SortDataset(Dataset): + """ + Dataset for the Sort problem. E.g. for problem length 6: + Input: 0 0 2 1 0 1 -> Output: 0 0 0 1 1 2 + Which will feed into the transformer concatenated as: + input: 0 0 2 1 0 1 0 0 0 1 1 + output: I I I I I 0 0 0 1 1 2 + where I is "ignore", as the transformer is reading the input sequence + """ + + def __init__(self, split, length=6, num_digits=3): + assert split in {'train', 'test'} + self.split = split + self.length = length + self.num_digits = num_digits + + def __len__(self): + return 10000 # ... + + def get_vocab_size(self): + return self.num_digits + + def get_block_size(self): + # the length of the sequence that will feed into transformer, + # containing concatenated input and the output, but -1 because + # the transformer starts making predictions at the last input element + return self.length * 2 - 1 + + def __getitem__(self, idx): + + # use rejection sampling to generate an input example from the desired split + while True: + # generate some random integers + inp = torch.randint(self.num_digits, size=(self.length,), dtype=torch.long) + # half of the time let's try to boost the number of examples that + # have a large number of repeats, as this is what the model seems to struggle + # with later in training, and they are kind of rate + if torch.rand(1).item() < 0.5: + if inp.unique().nelement() > self.length // 2: + # too many unqiue digits, re-sample + continue + # figure out if this generated example is train or test based on its hash + h = hash(pickle.dumps(inp.tolist())) + inp_split = 'test' if h % 4 == 0 else 'train' # designate 25% of examples as test + if inp_split == self.split: + break # ok + + # solve the task: i.e. sort + sol = torch.sort(inp)[0] + + # concatenate the problem specification and the solution + cat = torch.cat((inp, sol), dim=0) + + # the inputs to the transformer will be the offset sequence + x = cat[:-1].clone() + y = cat[1:].clone() + # we only want to predict at output locations, mask out the loss at the input locations + y[:self.length-1] = -1 + return x, y diff --git a/3.test_cases/neuronx-distributed/mingpt/model.py b/3.test_cases/neuronx-distributed/mingpt/mingpt/model.py similarity index 100% rename from 3.test_cases/neuronx-distributed/mingpt/model.py rename to 3.test_cases/neuronx-distributed/mingpt/mingpt/model.py diff --git a/3.test_cases/neuronx-distributed/mingpt/trainer.py b/3.test_cases/neuronx-distributed/mingpt/mingpt/trainer.py similarity index 98% rename from 3.test_cases/neuronx-distributed/mingpt/trainer.py rename to 3.test_cases/neuronx-distributed/mingpt/mingpt/trainer.py index c0d08521..4ac6d266 100644 --- a/3.test_cases/neuronx-distributed/mingpt/trainer.py +++ b/3.test_cases/neuronx-distributed/mingpt/mingpt/trainer.py @@ -18,12 +18,13 @@ def get_default_config(): # device to train on C.device = 'auto' # dataloder parameters - C.num_workers = 4 + C.num_workers = 0 # optimizer parameters C.max_iters = None C.batch_size = 64 C.learning_rate = 3e-4 C.betas = (0.9, 0.95) + C.max_iters = 2000 C.weight_decay = 0.1 # only applied on matmul weights C.grad_norm_clip = 1.0 return C diff --git a/3.test_cases/neuronx-distributed/mingpt/utils.py b/3.test_cases/neuronx-distributed/mingpt/mingpt/utils.py similarity index 94% rename from 3.test_cases/neuronx-distributed/mingpt/utils.py rename to 3.test_cases/neuronx-distributed/mingpt/mingpt/utils.py index af864ecb..9b7ea6b7 100644 --- a/3.test_cases/neuronx-distributed/mingpt/utils.py +++ b/3.test_cases/neuronx-distributed/mingpt/mingpt/utils.py @@ -30,9 +30,6 @@ def setup_logging(config): class CfgNode: """ a lightweight configuration class inspired by yacs """ - # TODO: convert to subclass from a dict like in yacs? - # TODO: implement freezing to prevent shooting of own foot - # TODO: additional existence/override checks when reading/writing params? def __init__(self, **kwargs): self.__dict__.update(kwargs) diff --git a/3.test_cases/neuronx-distributed/setup.py b/3.test_cases/neuronx-distributed/mingpt/setup.py similarity index 100% rename from 3.test_cases/neuronx-distributed/setup.py rename to 3.test_cases/neuronx-distributed/mingpt/setup.py diff --git a/3.test_cases/neuronx-distributed/tests/test_huggingface_import.py b/3.test_cases/neuronx-distributed/mingpt/tests/test_huggingface_import.py similarity index 100% rename from 3.test_cases/neuronx-distributed/tests/test_huggingface_import.py rename to 3.test_cases/neuronx-distributed/mingpt/tests/test_huggingface_import.py diff --git a/3.test_cases/neuronx-distributed/mingpt/tutorials/ddp_neuron.py b/3.test_cases/neuronx-distributed/mingpt/tutorials/ddp_neuron.py new file mode 100644 index 00000000..19a28c80 --- /dev/null +++ b/3.test_cases/neuronx-distributed/mingpt/tutorials/ddp_neuron.py @@ -0,0 +1,104 @@ +import os +import time +import torch + +from torchvision.datasets import mnist +from torch.utils.data import DataLoader +from torchvision.transforms import ToTensor + +# XLA imports +import torch_xla.core.xla_model as xm + +# XLA imports for parallel loader and multi-processing +import torch_xla.distributed.parallel_loader as pl +from torch.utils.data.distributed import DistributedSampler + +# Initialize XLA process group for torchrun +import torch_xla.distributed.xla_backend +torch.distributed.init_process_group('xla') + +# Global constants +EPOCHS = 4 +WARMUP_STEPS = 2 +BATCH_SIZE = 32 + +import torch.nn as nn +import torch.nn.functional as F + +# Declare 3-layer MLP for MNIST dataset +class MLP(nn.Module): + def __init__(self, input_size = 28 * 28, output_size = 10, layers = [120, 84]): + super(MLP, self).__init__() + self.fc1 = nn.Linear(input_size, layers[0]) + self.fc2 = nn.Linear(layers[0], layers[1]) + self.fc3 = nn.Linear(layers[1], output_size) + + def forward(self, x): + x = F.relu(self.fc1(x)) + x = F.relu(self.fc2(x)) + x = self.fc3(x) + return F.log_softmax(x, dim=1) + +# Load MNIST train dataset +if not xm.is_master_ordinal(): xm.rendezvous('dataset_download') +train_dataset = mnist.MNIST(root='/tmp/MNIST_DATA_train', + train=True, download=True, transform=ToTensor()) +if xm.is_master_ordinal(): xm.rendezvous('dataset_download') + +def main(): + # XLA MP: get world size + world_size = xm.xrt_world_size() + # multi-processing: ensure each worker has same initial weights + torch.manual_seed(0) + + # Move model to device and declare optimizer and loss function + device = 'xla' + model = MLP().to(device) + # For multiprocessing, scale up learning rate + optimizer = torch.optim.SGD(model.parameters(), lr=0.01 * world_size) + loss_fn = torch.nn.NLLLoss() + + # Prepare data loader + train_sampler = None + if world_size > 1: + train_sampler = DistributedSampler(train_dataset, + num_replicas=world_size, + rank=xm.get_ordinal(), + shuffle=True) + train_loader = DataLoader(train_dataset, + batch_size=BATCH_SIZE, + sampler=train_sampler, + shuffle=False if train_sampler else True) + # XLA MP: use MpDeviceLoader from torch_xla.distributed + train_device_loader = pl.MpDeviceLoader(train_loader, device) + + # Run the training loop + print('----------Training ---------------') + model.train() + for epoch in range(EPOCHS): + start = time.time() + for idx, (train_x, train_label) in enumerate(train_device_loader): + optimizer.zero_grad() + train_x = train_x.view(train_x.size(0), -1) + output = model(train_x) + loss = loss_fn(output, train_label) + loss.backward() + xm.optimizer_step(optimizer) # XLA MP: performs grad allreduce and optimizer step + if idx < WARMUP_STEPS: # skip warmup iterations + start = time.time() + + # Compute statistics for the last epoch + interval = idx - WARMUP_STEPS # skip warmup iterations + throughput = interval / (time.time() - start) + print("Train throughput (iter/sec): {}".format(throughput)) + print("Final loss is {:0.4f}".format(loss.detach().to('cpu'))) + + # Save checkpoint for evaluation (xm.save ensures only one process save) + os.makedirs("checkpoints", exist_ok=True) + checkpoint = {'state_dict': model.state_dict()} + xm.save(checkpoint,'checkpoints/checkpoint.pt') + + print('----------End Training ---------------') + +if __name__ == '__main__': + main() diff --git a/3.test_cases/neuronx-distributed/mingpt/tutorials/main.py b/3.test_cases/neuronx-distributed/mingpt/tutorials/main.py new file mode 100644 index 00000000..f125d515 --- /dev/null +++ b/3.test_cases/neuronx-distributed/mingpt/tutorials/main.py @@ -0,0 +1,5 @@ +import math + +import torch +import torch.nn as nn +from torch.nn import functional as F diff --git a/3.test_cases/neuronx-distributed/mingpt/tutorials/model_paralell_neuron.py b/3.test_cases/neuronx-distributed/mingpt/tutorials/model_paralell_neuron.py new file mode 100644 index 00000000..e69de29b diff --git a/3.test_cases/neuronx-distributed/projects/adder/adder.py b/3.test_cases/neuronx-distributed/projects/adder/adder.py deleted file mode 100644 index 55f03ee1..00000000 --- a/3.test_cases/neuronx-distributed/projects/adder/adder.py +++ /dev/null @@ -1,207 +0,0 @@ -""" -Trains a GPT to add n-digit numbers. -""" - -import os -import sys -import json - -import torch -from torch.utils.data import Dataset -from torch.utils.data.dataloader import DataLoader - -from mingpt.model import GPT -from mingpt.trainer import Trainer -from mingpt.utils import set_seed, setup_logging, CfgNode as CN - -# ----------------------------------------------------------------------------- - -def get_config(): - - C = CN() - - # system - C.system = CN() - C.system.seed = 3407 - C.system.work_dir = './out/adder' - - # data - C.data = AdditionDataset.get_default_config() - - # model - C.model = GPT.get_default_config() - C.model.model_type = 'gpt-nano' - - # trainer - C.trainer = Trainer.get_default_config() - C.trainer.learning_rate = 5e-4 # the model we're using is so small that we can go a bit faster - - return C - -# ----------------------------------------------------------------------------- - -class AdditionDataset(Dataset): - """ - Creates n-digit addition problems. For example, if n=2, then an example - addition problem would be to add 85 + 50 = 135. This problem would be - represented as the following string for the GPT: - - "8550531" - - This is because: - - we are discarding the + and =, which are not necessary. We just encode the digits - of the input numbers concatenated together. - - the result 135 is encoded backwards to make the addition easier to learn for the - GPT model, because of how the addition algorithm works. - - As one more example, the problem 6 + 39 = 45 would be encoded as: - - "0639054" - - where you will notice that we are padding with zeros to make sure that we always - produce strings of the exact same size: n + n + (n + 1). When n=2, this is 7. - At test time, we will feed in an addition problem by giving the first 2n digits, - and hoping that the GPT model completes the sequence with the next (n+1) digits - correctly. - """ - - @staticmethod - def get_default_config(): - C = CN() - C.ndigit = 2 - return C - - def __init__(self, config, split): - self.config = config - self.split = split # train/test - - # split up all addition problems into either training data or test data - ndigit = self.config.ndigit - assert ndigit <= 3, "the lines below would be very memory inefficient, in future maybe refactor to support" - num = (10**ndigit)**2 # total number of possible addition problems with ndigit numbers - rng = torch.Generator() - rng.manual_seed(1337) - perm = torch.randperm(num, generator=rng) - num_test = min(int(num*0.2), 500) # 20% of the whole dataset, or only up to 500 - self.ixes = perm[:num_test] if split == 'test' else perm[num_test:] - - def get_vocab_size(self): - return 10 # digits 0..9 - - def get_block_size(self): - # a,b,a+b, and +1 due to potential carry overflow, - # but then also -1 because very last digit doesn't ever plug back - # as there is no explicit token to predict, it is implied - return 3*self.config.ndigit + 1 - 1 - - def __len__(self): - return self.ixes.nelement() - - def __getitem__(self, idx): - ndigit = self.config.ndigit - # given a problem index idx, first recover the associated a + b - idx = self.ixes[idx].item() - nd = 10**ndigit - a = idx // nd - b = idx % nd - # calculate the "label" of the addition problem a + b - c = a + b - # encode the digits of a, b, c into strings - astr = f'%0{ndigit}d' % a - bstr = f'%0{ndigit}d' % b - cstr = (f'%0{ndigit+1}d' % c)[::-1] # reverse c to make addition easier - render = astr + bstr + cstr - dix = [int(s) for s in render] # convert each character to its token index - # x will be input to GPT and y will be the associated expected outputs - x = torch.tensor(dix[:-1], dtype=torch.long) - y = torch.tensor(dix[1:], dtype=torch.long) # predict the next token in the sequence - y[:ndigit*2-1] = -1 # we will only train in the output locations. -1 will mask loss to zero - return x, y - -# ----------------------------------------------------------------------------- - -if __name__ == '__main__': - - # get default config and overrides from the command line, if any - config = get_config() - config.merge_from_args(sys.argv[1:]) - print(config) - setup_logging(config) - set_seed(config.system.seed) - - # construct train and test datasets - train_dataset = AdditionDataset(config.data, split='train') - test_dataset = AdditionDataset(config.data, split='test') - - # construct the model - config.model.vocab_size = train_dataset.get_vocab_size() - config.model.block_size = train_dataset.get_block_size() - model = GPT(config.model) - - # construct the trainer object - trainer = Trainer(config.trainer, model, train_dataset) - - # helper function for the evaluation of a model - def eval_split(trainer, split, max_batches=None): - dataset = {'train':train_dataset, 'test':test_dataset}[split] - ndigit = config.data.ndigit - results = [] - mistakes_printed_already = 0 - factors = torch.tensor([[10**i for i in range(ndigit+1)][::-1]]).to(trainer.device) - loader = DataLoader(dataset, batch_size=100, num_workers=0, drop_last=False) - for b, (x, y) in enumerate(loader): - x = x.to(trainer.device) - # isolate the first two digits of the input sequence alone - d1d2 = x[:, :ndigit*2] - # let the model sample the rest of the sequence - d1d2d3 = model.generate(d1d2, ndigit+1, do_sample=False) # using greedy argmax, not sampling - # isolate the last digit of the sampled sequence - d3 = d1d2d3[:, -(ndigit+1):] - d3 = d3.flip(1) # reverse the digits to their "normal" order - # decode the integers from individual digits - d1i = (d1d2[:,:ndigit] * factors[:,1:]).sum(1) - d2i = (d1d2[:,ndigit:ndigit*2] * factors[:,1:]).sum(1) - d3i_pred = (d3 * factors).sum(1) - d3i_gt = d1i + d2i # manually calculate the ground truth - # evaluate the correctness of the results in this batch - correct = (d3i_pred == d3i_gt).cpu() # Software 1.0 vs. Software 2.0 fight RIGHT on this line haha - for i in range(x.size(0)): - results.append(int(correct[i])) - if not correct[i] and mistakes_printed_already < 5: # only print up to 5 mistakes to get a sense - mistakes_printed_already += 1 - print("GPT claims that %d + %d = %d but gt is %d" % (d1i[i], d2i[i], d3i_pred[i], d3i_gt[i])) - if max_batches is not None and b+1 >= max_batches: - break - rt = torch.tensor(results, dtype=torch.float) - print("%s final score: %d/%d = %.2f%% correct" % (split, rt.sum(), len(results), 100*rt.mean())) - return rt.sum() - - # iteration callback - top_score = 0 - def batch_end_callback(trainer): - global top_score - - if trainer.iter_num % 10 == 0: - print(f"iter_dt {trainer.iter_dt * 1000:.2f}ms; iter {trainer.iter_num}: train loss {trainer.loss.item():.5f}") - - if trainer.iter_num % 500 == 0: - # evaluate both the train and test score - train_max_batches = {1: None, 2: None, 3: 5}[config.data.ndigit] # if ndigit=2 we can afford the whole train set, ow no - model.eval() - with torch.no_grad(): - train_score = eval_split(trainer, 'train', max_batches=train_max_batches) - test_score = eval_split(trainer, 'test', max_batches=None) - score = train_score + test_score - # save the model if this is the best score we've seen so far - if score > top_score: - top_score = score - print(f"saving model with new top score of {score}") - ckpt_path = os.path.join(config.system.work_dir, "model.pt") - torch.save(model.state_dict(), ckpt_path) - # revert model to training mode - model.train() - - trainer.set_callback('on_batch_end', batch_end_callback) - - # run the optimization - trainer.run() diff --git a/3.test_cases/neuronx-distributed/projects/adder/readme.md b/3.test_cases/neuronx-distributed/projects/adder/readme.md deleted file mode 100644 index ad168f43..00000000 --- a/3.test_cases/neuronx-distributed/projects/adder/readme.md +++ /dev/null @@ -1,4 +0,0 @@ - -### adder - -Train a GPT model to add n-digit numbers diff --git a/3.test_cases/neuronx-distributed/projects/chargpt/chargpt.py b/3.test_cases/neuronx-distributed/projects/chargpt/chargpt.py deleted file mode 100644 index 5de925b0..00000000 --- a/3.test_cases/neuronx-distributed/projects/chargpt/chargpt.py +++ /dev/null @@ -1,133 +0,0 @@ -""" -Trains a character-level language model. -""" - -import os -import sys - -import torch -from torch.utils.data import Dataset -from torch.utils.data.dataloader import DataLoader - -from mingpt.model import GPT -from mingpt.trainer import Trainer -from mingpt.utils import set_seed, setup_logging, CfgNode as CN - -# ----------------------------------------------------------------------------- - -def get_config(): - - C = CN() - - # system - C.system = CN() - C.system.seed = 3407 - C.system.work_dir = './out/chargpt' - - # data - C.data = CharDataset.get_default_config() - - # model - C.model = GPT.get_default_config() - C.model.model_type = 'gpt-mini' - - # trainer - C.trainer = Trainer.get_default_config() - C.trainer.learning_rate = 5e-4 # the model we're using is so small that we can go a bit faster - - return C - -# ----------------------------------------------------------------------------- - -class CharDataset(Dataset): - """ - Emits batches of characters - """ - - @staticmethod - def get_default_config(): - C = CN() - C.block_size = 128 - return C - - def __init__(self, config, data): - self.config = config - - chars = sorted(list(set(data))) - data_size, vocab_size = len(data), len(chars) - print('data has %d characters, %d unique.' % (data_size, vocab_size)) - - self.stoi = { ch:i for i,ch in enumerate(chars) } - self.itos = { i:ch for i,ch in enumerate(chars) } - self.vocab_size = vocab_size - self.data = data - - def get_vocab_size(self): - return self.vocab_size - - def get_block_size(self): - return self.config.block_size - - def __len__(self): - return len(self.data) - self.config.block_size - - def __getitem__(self, idx): - # grab a chunk of (block_size + 1) characters from the data - chunk = self.data[idx:idx + self.config.block_size + 1] - # encode every character to an integer - dix = [self.stoi[s] for s in chunk] - # return as tensors - x = torch.tensor(dix[:-1], dtype=torch.long) - y = torch.tensor(dix[1:], dtype=torch.long) - return x, y - -# ----------------------------------------------------------------------------- - -if __name__ == '__main__': - - # get default config and overrides from the command line, if any - config = get_config() - config.merge_from_args(sys.argv[1:]) - print(config) - setup_logging(config) - set_seed(config.system.seed) - - # construct the training dataset - text = open('input.txt', 'r').read() # don't worry we won't run out of file handles - train_dataset = CharDataset(config.data, text) - - # construct the model - config.model.vocab_size = train_dataset.get_vocab_size() - config.model.block_size = train_dataset.get_block_size() - model = GPT(config.model) - - # construct the trainer object - trainer = Trainer(config.trainer, model, train_dataset) - - # iteration callback - def batch_end_callback(trainer): - - if trainer.iter_num % 10 == 0: - print(f"iter_dt {trainer.iter_dt * 1000:.2f}ms; iter {trainer.iter_num}: train loss {trainer.loss.item():.5f}") - - if trainer.iter_num % 500 == 0: - # evaluate both the train and test score - model.eval() - with torch.no_grad(): - # sample from the model... - context = "O God, O God!" - x = torch.tensor([train_dataset.stoi[s] for s in context], dtype=torch.long)[None,...].to(trainer.device) - y = model.generate(x, 500, temperature=1.0, do_sample=True, top_k=10)[0] - completion = ''.join([train_dataset.itos[int(i)] for i in y]) - print(completion) - # save the latest model - print("saving model") - ckpt_path = os.path.join(config.system.work_dir, "model.pt") - torch.save(model.state_dict(), ckpt_path) - # revert model to training mode - model.train() - - trainer.set_callback('on_batch_end', batch_end_callback) - - # run the optimization - trainer.run() diff --git a/3.test_cases/neuronx-distributed/projects/chargpt/readme.md b/3.test_cases/neuronx-distributed/projects/chargpt/readme.md deleted file mode 100644 index 00d8def3..00000000 --- a/3.test_cases/neuronx-distributed/projects/chargpt/readme.md +++ /dev/null @@ -1,9 +0,0 @@ -# chargpt - -chargpt trains a character-level language model. - -We support three settings: 1 convenience setting and 2 "benchmark" settings that have acedemic literature results: - -- a user specified `input.txt` file that we train an LM on (e.g. get tiny-shakespear (1.1MB of data) [here](https://raw.githubusercontent.com/karpathy/char-rnn/master/data/tinyshakespeare/input.txt)) -- TODO [text8](http://mattmahoney.net/dc/textdata.html): also derived from Wikipedia text but all XML is removed and is lowercased to only 26 characters of -- TODO [enwik8](http://prize.hutter1.net) benchmark ("Hutter Prize"), first 100M bytes of a Wikipedia XML dump, with 205 unique tokensEnglish plus spaces diff --git a/3.test_cases/neuronx-distributed/projects/readme.md b/3.test_cases/neuronx-distributed/projects/readme.md deleted file mode 100644 index 432505d2..00000000 --- a/3.test_cases/neuronx-distributed/projects/readme.md +++ /dev/null @@ -1,4 +0,0 @@ - -### minGPT projects - -Various projects that use the minGPT library to achieve great things. From c1e1841139669d360bf406eff6fd5ea6ba6f34af Mon Sep 17 00:00:00 2001 From: Keita Watanabe Date: Mon, 10 Jun 2024 04:47:55 +0000 Subject: [PATCH 05/16] current status --- .../neuronx-distributed/mingpt/1.neuron.py | 65 ++++++++++++++++++ ...aph.2847_6388737439810603635.hlo_module.pb | Bin 0 -> 107605 bytes ...TensorsGraph.2847_6388737439810603635.neff | Bin 0 -> 369664 bytes 3.test_cases/neuronx-distributed/mingpt/lock | 0 .../mingpt/mingpt/datasets.py | 45 ++++++++++++ .../mingpt/mingpt/model.py | 7 +- .../mingpt/tmp_cross_entropy_test.py | 41 +++++++++++ .../mingpt/tutorials/main.py | 54 +++++++++++++++ 8 files changed, 206 insertions(+), 6 deletions(-) create mode 100644 3.test_cases/neuronx-distributed/mingpt/1.neuron.py create mode 100644 3.test_cases/neuronx-distributed/mingpt/MODULE_SyncTensorsGraph.2847_6388737439810603635.hlo_module.pb create mode 100644 3.test_cases/neuronx-distributed/mingpt/MODULE_SyncTensorsGraph.2847_6388737439810603635.neff create mode 100644 3.test_cases/neuronx-distributed/mingpt/lock create mode 100644 3.test_cases/neuronx-distributed/mingpt/tmp_cross_entropy_test.py diff --git a/3.test_cases/neuronx-distributed/mingpt/1.neuron.py b/3.test_cases/neuronx-distributed/mingpt/1.neuron.py new file mode 100644 index 00000000..6a5dd695 --- /dev/null +++ b/3.test_cases/neuronx-distributed/mingpt/1.neuron.py @@ -0,0 +1,65 @@ +import torch +from torch.utils.data import DataLoader +from tqdm import tqdm +from torch.nn import functional as F +import torch_xla.core.xla_model as xm +# XLA imports for parallel loader and multi-processing +import torch_xla.distributed.parallel_loader as pl + +from mingpt.model import GPT +from mingpt.datasets import SortDataset +from mingpt.trainer import Trainer +from mingpt.configs import TrainConfig + +import os +#os.environ['NEURON_CC_FLAGS'] = "--log_level=INFO" +#os.environ["NEURON_USE_EAGER_DEBUG_MODE"] = "1" +#os.environ["NEURON_FRAMEWORK_DEBUG"] = "1" +#os.environ["NEURON_RT_LOG_LEVEL"]="DEBUG" +#os.environ["NEURON_RT_LOG_LEVEL_NRT"]="DEBUG" +#os.environ["NEURON_DUMP_HLO_SNAPSHOT"] = "1" + + +device = 'xla' +# create train and test dataset +train_dataset = SortDataset('train') +test_dataset = SortDataset('test') +train_config = TrainConfig.get_default_config() +train_loader = DataLoader( + train_dataset, + batch_size=train_config.batch_size, + ) +# We wrap the dataloader with MpDeviceLoader. This dataloader should take +# care of copying the tensors to device +train_loader = pl.MpDeviceLoader(train_loader, device) + +# create a GPT instance +model_config = GPT.get_default_config() +model_config.model_type = 'gpt-nano' +model_config.vocab_size = train_dataset.get_vocab_size() +model_config.block_size = train_dataset.get_block_size() +model = GPT(model_config) +model = model.to(device) +optimizer = model.configure_optimizers(train_config) + + +model.train() +pbar = tqdm(enumerate(train_loader)) +for idx, (x, y) in pbar: + optimizer.zero_grad() + # forward the model + logits = model(x) + loss = F.cross_entropy( + logits.view(-1, logits.size(-1)), + y.view(-1), + ignore_index=-1 + ) + # backprop and update the parameters + #model.zero_grad(set_to_none=True) + loss.backward() + xm.optimizer_step(optimizer) # XLA MP: performs grad allreduce and optimizer step + #torch.nn.utils.clip_grad_norm_(model.parameters(), train_config.grad_norm_clip) + #pbar.set_description(f"Iteration: {idx}, train loss: {loss.item():.5f}") + pbar.set_description(f"Iteration: {idx}") #, train loss: {loss.item():.5f}") + if idx == 500: + break diff --git a/3.test_cases/neuronx-distributed/mingpt/MODULE_SyncTensorsGraph.2847_6388737439810603635.hlo_module.pb b/3.test_cases/neuronx-distributed/mingpt/MODULE_SyncTensorsGraph.2847_6388737439810603635.hlo_module.pb new file mode 100644 index 0000000000000000000000000000000000000000..ab0f625508601c16d10d5f626748e76cb769bd93 GIT binary patch literal 107605 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 JTGBS^{{tQ6l_~%L literal 0 HcmV?d00001 diff --git a/3.test_cases/neuronx-distributed/mingpt/MODULE_SyncTensorsGraph.2847_6388737439810603635.neff b/3.test_cases/neuronx-distributed/mingpt/MODULE_SyncTensorsGraph.2847_6388737439810603635.neff new file mode 100644 index 0000000000000000000000000000000000000000..cc8da81d8d38947878b5e300ce238b33fc1c1cae GIT binary patch literal 369664 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℘qP#GY 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

1e-5wQo%B^ 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 L_=f`j!xZ>mFvEL} literal 0 HcmV?d00001 diff --git a/3.test_cases/neuronx-distributed/mingpt/lock b/3.test_cases/neuronx-distributed/mingpt/lock new file mode 100644 index 00000000..e69de29b diff --git a/3.test_cases/neuronx-distributed/mingpt/mingpt/datasets.py b/3.test_cases/neuronx-distributed/mingpt/mingpt/datasets.py index 95d1f28c..ba1dfebb 100644 --- a/3.test_cases/neuronx-distributed/mingpt/mingpt/datasets.py +++ b/3.test_cases/neuronx-distributed/mingpt/mingpt/datasets.py @@ -3,6 +3,51 @@ import torch from torch.utils.data import Dataset + +class IdentityDataset(Dataset): + def __init__(self, split, ndim=4): + """ + Args: + split (str): The dataset split, e.g., 'train', 'val', 'test'. + ndim (int): The number of dimensions for the one-hot encoded tensor. + """ + self.split = split + self.ndim = ndim + + def __len__(self): + # You can define the length of the dataset based on the split + # For simplicity, let's assume a fixed length for each split + if self.split == 'train': + return 1000 + elif self.split == 'val': + return 200 + elif self.split == 'test': + return 200 + else: + raise ValueError("Invalid split name") + + def get_vocab_size(self): + return self.ndim + + def __getitem__(self, idx): + """ + Args: + idx (int): Index of the data point. + + Returns: + tuple: (x, y) where x and y are one-hot encoded tensors. + """ + # Generate a random index for the one-hot encoding + random_index = torch.randint(0, self.ndim, (1,)).item() + + # Create a one-hot encoded tensor for x and y + x = torch.zeros(self.ndim) + y = torch.zeros(self.ndim) + x[random_index] = 1 + y[random_index] = 1 + return x, y + + class AdditionDataset(Dataset): """ Creates n-digit addition problems. For example, if n=2, then an example diff --git a/3.test_cases/neuronx-distributed/mingpt/mingpt/model.py b/3.test_cases/neuronx-distributed/mingpt/mingpt/model.py index 83ee22dc..4b1f7cdc 100644 --- a/3.test_cases/neuronx-distributed/mingpt/mingpt/model.py +++ b/3.test_cases/neuronx-distributed/mingpt/mingpt/model.py @@ -272,12 +272,7 @@ def forward(self, idx, targets=None): x = self.transformer.ln_f(x) logits = self.lm_head(x) - # if we are given some desired targets also calculate the loss - loss = None - if targets is not None: - loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1), ignore_index=-1) - - return logits, loss + return logits @torch.no_grad() def generate(self, idx, max_new_tokens, temperature=1.0, do_sample=False, top_k=None): diff --git a/3.test_cases/neuronx-distributed/mingpt/tmp_cross_entropy_test.py b/3.test_cases/neuronx-distributed/mingpt/tmp_cross_entropy_test.py new file mode 100644 index 00000000..8980c905 --- /dev/null +++ b/3.test_cases/neuronx-distributed/mingpt/tmp_cross_entropy_test.py @@ -0,0 +1,41 @@ +import torch +from torch.utils.data import DataLoader +from tqdm import tqdm +from torch.nn import functional as F +import torch_xla.core.xla_model as xm +# XLA imports for parallel loader and multi-processing +device = 'xla' + +# Given tensors +x = torch.Tensor([ + [ + [0.0, 1.0, 0.0], + [1.0, 0.0, 0.0] + ], + [ + [0.0, 0.0, 1.0], + [0.0, 0.0, 1.0] + ] +]) +# Set requires_grad=True to enable gradient computation +x.requires_grad_(True) +y = torch.Tensor([[-1, 0], [-1, 0]]).long() +x, y = x.to(device), y.to(device) +loss = F.cross_entropy(x.view(-1, x.size(-1)), y.view(-1), ignore_index=-1) +print(loss) +loss.backward() +# # Mask out the elements where y is -1 +# mask = (y != -1) +# +# # Apply the mask to x and y +# x_masked = x[mask] +# y_masked = y[mask] +# +# # Reshape x_masked to the appropriate dimensions for cross_entropy +# # x_masked should be of shape (N, C) where N is the number of samples and C is the number of classes +# x_masked = x_masked.view(-1, x.size(-1)) +# # Ensure y_masked is 1D +# y_masked = y_masked.view(-1) +# +# # Compute the cross-entropy loss +# loss = F.cross_entropy(x_masked, y_masked) diff --git a/3.test_cases/neuronx-distributed/mingpt/tutorials/main.py b/3.test_cases/neuronx-distributed/mingpt/tutorials/main.py index f125d515..ae15cc64 100644 --- a/3.test_cases/neuronx-distributed/mingpt/tutorials/main.py +++ b/3.test_cases/neuronx-distributed/mingpt/tutorials/main.py @@ -3,3 +3,57 @@ import torch import torch.nn as nn from torch.nn import functional as F + +class NewGELU(nn.Module): + """ + Implementation of the GELU activation function currently in Google BERT repo (identical to OpenAI GPT). + Reference: Gaussian Error Linear Units (GELU) paper: https://arxiv.org/abs/1606.08415 + """ + def forward(self, x): + return 0.5 * x * (1.0 + torch.tanh(math.sqrt(2.0 / math.pi) * (x + 0.044715 * torch.pow(x, 3.0)))) + + +class CausalSelfAttention(nn.Module): + """ + A vanilla multi-head masked self-attention layer with a projection at the end. + It is possible to use torch.nn.MultiheadAttention here but I am including an + explicit implementation here to show that there is nothing too scary here. + """ + + def __init__(self, config): + super().__init__() + assert config.n_embd % config.n_head == 0 + # key, query, value projections for all heads, but in a batch + self.c_attn = nn.Linear(config.n_embd, 3 * config.n_embd) + # output projection + self.c_proj = nn.Linear(config.n_embd, config.n_embd) + # regularization + self.attn_dropout = nn.Dropout(config.attn_pdrop) + self.resid_dropout = nn.Dropout(config.resid_pdrop) + # causal mask to ensure that attention is only applied to the left in the input sequence + self.register_buffer("bias", torch.tril(torch.ones(config.block_size, config.block_size)) + .view(1, 1, config.block_size, config.block_size)) + self.n_head = config.n_head + self.n_embd = config.n_embd + + def forward(self, x): + B, T, C = x.size() # batch size, sequence length, embedding dimensionality (n_embd) + + # calculate query, key, values for all heads in batch and move head forward to be the batch dim + q, k ,v = self.c_attn(x).split(self.n_embd, dim=2) + k = k.view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs) + q = q.view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs) + v = v.view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs) + + # causal self-attention; Self-attend: (B, nh, T, hs) x (B, nh, hs, T) -> (B, nh, T, T) + att = (q @ k.transpose(-2, -1)) * (1.0 / math.sqrt(k.size(-1))) + att = att.masked_fill(self.bias[:,:,:T,:T] == 0, float('-inf')) + att = F.softmax(att, dim=-1) + att = self.attn_dropout(att) + y = att @ v # (B, nh, T, T) x (B, nh, T, hs) -> (B, nh, T, hs) + y = y.transpose(1, 2).contiguous().view(B, T, C) # re-assemble all head outputs side by side + + # output projection + y = self.resid_dropout(self.c_proj(y)) + return y + From d2da958d63cc5ddc3726f00c13b01f6e9638abd2 Mon Sep 17 00:00:00 2001 From: Keita Watanabe Date: Mon, 10 Jun 2024 04:48:16 +0000 Subject: [PATCH 06/16] update --- ...raph.2847_6388737439810603635.hlo_module.pb | Bin 107605 -> 0 bytes ...cTensorsGraph.2847_6388737439810603635.neff | Bin 369664 -> 0 bytes 2 files changed, 0 insertions(+), 0 deletions(-) delete mode 100644 3.test_cases/neuronx-distributed/mingpt/MODULE_SyncTensorsGraph.2847_6388737439810603635.hlo_module.pb delete mode 100644 3.test_cases/neuronx-distributed/mingpt/MODULE_SyncTensorsGraph.2847_6388737439810603635.neff diff --git a/3.test_cases/neuronx-distributed/mingpt/MODULE_SyncTensorsGraph.2847_6388737439810603635.hlo_module.pb b/3.test_cases/neuronx-distributed/mingpt/MODULE_SyncTensorsGraph.2847_6388737439810603635.hlo_module.pb deleted file mode 100644 index ab0f625508601c16d10d5f626748e76cb769bd93..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 107605 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 JTGBS^{{tQ6l_~%L diff --git a/3.test_cases/neuronx-distributed/mingpt/MODULE_SyncTensorsGraph.2847_6388737439810603635.neff b/3.test_cases/neuronx-distributed/mingpt/MODULE_SyncTensorsGraph.2847_6388737439810603635.neff deleted file mode 100644 index cc8da81d8d38947878b5e300ce238b33fc1c1cae..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 369664 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℘qP#GY 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

1e-5wQo%B^ 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 L_=f`j!xZ>mFvEL} From 80185627930221ca9727adaf5de57c40911da487 Mon Sep 17 00:00:00 2001 From: Keita Watanabe Date: Tue, 11 Jun 2024 01:02:18 +0000 Subject: [PATCH 07/16] clean up --- .../neuronx-distributed/mingpt/0.cpu.py | 15 ++++--- .../neuronx-distributed/mingpt/1.neuron.py | 18 ++------ 3.test_cases/neuronx-distributed/mingpt/lock | 0 .../mingpt/tmp_cross_entropy_test.py | 41 ------------------- 4 files changed, 13 insertions(+), 61 deletions(-) delete mode 100644 3.test_cases/neuronx-distributed/mingpt/lock delete mode 100644 3.test_cases/neuronx-distributed/mingpt/tmp_cross_entropy_test.py diff --git a/3.test_cases/neuronx-distributed/mingpt/0.cpu.py b/3.test_cases/neuronx-distributed/mingpt/0.cpu.py index ecc2a714..b79083ef 100644 --- a/3.test_cases/neuronx-distributed/mingpt/0.cpu.py +++ b/3.test_cases/neuronx-distributed/mingpt/0.cpu.py @@ -2,6 +2,7 @@ from torch.utils.data import DataLoader from tqdm import tqdm +from torch.nn import functional as F from mingpt.model import GPT from mingpt.datasets import SortDataset from mingpt.trainer import Trainer @@ -25,13 +26,17 @@ optimizer = model.configure_optimizers(train_config) model.train() -pbar = tqdm(enumerate(train_loader)) -for idx, (x, y) in pbar: +pbar = tqdm(train_loader) +for idx, (x, y) in enumerate(pbar): + optimizer.zero_grad() # forward the model - logits, loss = model(x, y) + logits = model(x) + loss = F.cross_entropy( + logits.view(-1, logits.size(-1)), + y.view(-1), + ignore_index=-1 + ) # backprop and update the parameters - model.zero_grad(set_to_none=True) loss.backward() - torch.nn.utils.clip_grad_norm_(model.parameters(), train_config.grad_norm_clip) optimizer.step() pbar.set_description(f"Iteration: {idx}, train loss: {loss.item():.5f}") \ No newline at end of file diff --git a/3.test_cases/neuronx-distributed/mingpt/1.neuron.py b/3.test_cases/neuronx-distributed/mingpt/1.neuron.py index 6a5dd695..c5863dd8 100644 --- a/3.test_cases/neuronx-distributed/mingpt/1.neuron.py +++ b/3.test_cases/neuronx-distributed/mingpt/1.neuron.py @@ -11,13 +11,6 @@ from mingpt.trainer import Trainer from mingpt.configs import TrainConfig -import os -#os.environ['NEURON_CC_FLAGS'] = "--log_level=INFO" -#os.environ["NEURON_USE_EAGER_DEBUG_MODE"] = "1" -#os.environ["NEURON_FRAMEWORK_DEBUG"] = "1" -#os.environ["NEURON_RT_LOG_LEVEL"]="DEBUG" -#os.environ["NEURON_RT_LOG_LEVEL_NRT"]="DEBUG" -#os.environ["NEURON_DUMP_HLO_SNAPSHOT"] = "1" device = 'xla' @@ -44,8 +37,8 @@ model.train() -pbar = tqdm(enumerate(train_loader)) -for idx, (x, y) in pbar: +pbar = tqdm(train_loader) +for idx, (x, y) in enumerate(pbar): optimizer.zero_grad() # forward the model logits = model(x) @@ -55,11 +48,6 @@ ignore_index=-1 ) # backprop and update the parameters - #model.zero_grad(set_to_none=True) loss.backward() xm.optimizer_step(optimizer) # XLA MP: performs grad allreduce and optimizer step - #torch.nn.utils.clip_grad_norm_(model.parameters(), train_config.grad_norm_clip) - #pbar.set_description(f"Iteration: {idx}, train loss: {loss.item():.5f}") - pbar.set_description(f"Iteration: {idx}") #, train loss: {loss.item():.5f}") - if idx == 500: - break + pbar.set_description(f"Iteration: {idx}, train loss: {loss.item():.5f}") diff --git a/3.test_cases/neuronx-distributed/mingpt/lock b/3.test_cases/neuronx-distributed/mingpt/lock deleted file mode 100644 index e69de29b..00000000 diff --git a/3.test_cases/neuronx-distributed/mingpt/tmp_cross_entropy_test.py b/3.test_cases/neuronx-distributed/mingpt/tmp_cross_entropy_test.py deleted file mode 100644 index 8980c905..00000000 --- a/3.test_cases/neuronx-distributed/mingpt/tmp_cross_entropy_test.py +++ /dev/null @@ -1,41 +0,0 @@ -import torch -from torch.utils.data import DataLoader -from tqdm import tqdm -from torch.nn import functional as F -import torch_xla.core.xla_model as xm -# XLA imports for parallel loader and multi-processing -device = 'xla' - -# Given tensors -x = torch.Tensor([ - [ - [0.0, 1.0, 0.0], - [1.0, 0.0, 0.0] - ], - [ - [0.0, 0.0, 1.0], - [0.0, 0.0, 1.0] - ] -]) -# Set requires_grad=True to enable gradient computation -x.requires_grad_(True) -y = torch.Tensor([[-1, 0], [-1, 0]]).long() -x, y = x.to(device), y.to(device) -loss = F.cross_entropy(x.view(-1, x.size(-1)), y.view(-1), ignore_index=-1) -print(loss) -loss.backward() -# # Mask out the elements where y is -1 -# mask = (y != -1) -# -# # Apply the mask to x and y -# x_masked = x[mask] -# y_masked = y[mask] -# -# # Reshape x_masked to the appropriate dimensions for cross_entropy -# # x_masked should be of shape (N, C) where N is the number of samples and C is the number of classes -# x_masked = x_masked.view(-1, x.size(-1)) -# # Ensure y_masked is 1D -# y_masked = y_masked.view(-1) -# -# # Compute the cross-entropy loss -# loss = F.cross_entropy(x_masked, y_masked) From 0a93c7136c3396ab8ab6b07871062ccec2cd3eb4 Mon Sep 17 00:00:00 2001 From: Keita Watanabe Date: Tue, 11 Jun 2024 01:04:19 +0000 Subject: [PATCH 08/16] update --- .../mingpt/mingpt/configs.py | 2 +- .../mingpt/mingpt/datasets.py | 45 ------------------- 2 files changed, 1 insertion(+), 46 deletions(-) diff --git a/3.test_cases/neuronx-distributed/mingpt/mingpt/configs.py b/3.test_cases/neuronx-distributed/mingpt/mingpt/configs.py index 8c1fab66..75114dde 100644 --- a/3.test_cases/neuronx-distributed/mingpt/mingpt/configs.py +++ b/3.test_cases/neuronx-distributed/mingpt/mingpt/configs.py @@ -9,7 +9,7 @@ def get_default_config(): # dataloder parameters C.num_workers = 0 # optimizer parameters - C.batch_size = 32 + C.batch_size = 8 C.learning_rate = 3e-4 C.betas = (0.9, 0.95) C.max_iters = 8000 diff --git a/3.test_cases/neuronx-distributed/mingpt/mingpt/datasets.py b/3.test_cases/neuronx-distributed/mingpt/mingpt/datasets.py index ba1dfebb..95d1f28c 100644 --- a/3.test_cases/neuronx-distributed/mingpt/mingpt/datasets.py +++ b/3.test_cases/neuronx-distributed/mingpt/mingpt/datasets.py @@ -3,51 +3,6 @@ import torch from torch.utils.data import Dataset - -class IdentityDataset(Dataset): - def __init__(self, split, ndim=4): - """ - Args: - split (str): The dataset split, e.g., 'train', 'val', 'test'. - ndim (int): The number of dimensions for the one-hot encoded tensor. - """ - self.split = split - self.ndim = ndim - - def __len__(self): - # You can define the length of the dataset based on the split - # For simplicity, let's assume a fixed length for each split - if self.split == 'train': - return 1000 - elif self.split == 'val': - return 200 - elif self.split == 'test': - return 200 - else: - raise ValueError("Invalid split name") - - def get_vocab_size(self): - return self.ndim - - def __getitem__(self, idx): - """ - Args: - idx (int): Index of the data point. - - Returns: - tuple: (x, y) where x and y are one-hot encoded tensors. - """ - # Generate a random index for the one-hot encoding - random_index = torch.randint(0, self.ndim, (1,)).item() - - # Create a one-hot encoded tensor for x and y - x = torch.zeros(self.ndim) - y = torch.zeros(self.ndim) - x[random_index] = 1 - y[random_index] = 1 - return x, y - - class AdditionDataset(Dataset): """ Creates n-digit addition problems. For example, if n=2, then an example From 9ac12452ad8c9d9b2c28ac90940b1c73020443c8 Mon Sep 17 00:00:00 2001 From: Keita Watanabe Date: Thu, 13 Jun 2024 04:02:30 +0000 Subject: [PATCH 09/16] add olma --- .../olmo/configs/OLMo-1B.yaml | 446 +++++ .../neuronx-distributed/olmo/olmo/aliases.py | 7 + .../olmo/olmo/beam_search.py | 1078 +++++++++++ .../neuronx-distributed/olmo/olmo/config.py | 1144 +++++++++++ .../neuronx-distributed/olmo/olmo/datasets.py | 135 ++ .../olmo/olmo/exceptions.py | 50 + .../olmo/olmo/initialization.py | 22 + .../neuronx-distributed/olmo/olmo/model.py | 1689 +++++++++++++++++ .../olmo/olmo/tokenizer.py | 180 ++ .../olmo/olmo/torch_util.py | 142 ++ .../neuronx-distributed/olmo/olmo/util.py | 761 ++++++++ .../neuronx-distributed/olmo/scratch_pad.py | 64 + .../olmo/tokenizers/.gitignore | 1 + 13 files changed, 5719 insertions(+) create mode 100644 3.test_cases/neuronx-distributed/olmo/configs/OLMo-1B.yaml create mode 100644 3.test_cases/neuronx-distributed/olmo/olmo/aliases.py create mode 100644 3.test_cases/neuronx-distributed/olmo/olmo/beam_search.py create mode 100644 3.test_cases/neuronx-distributed/olmo/olmo/config.py create mode 100644 3.test_cases/neuronx-distributed/olmo/olmo/datasets.py create mode 100644 3.test_cases/neuronx-distributed/olmo/olmo/exceptions.py create mode 100644 3.test_cases/neuronx-distributed/olmo/olmo/initialization.py create mode 100644 3.test_cases/neuronx-distributed/olmo/olmo/model.py create mode 100644 3.test_cases/neuronx-distributed/olmo/olmo/tokenizer.py create mode 100644 3.test_cases/neuronx-distributed/olmo/olmo/torch_util.py create mode 100644 3.test_cases/neuronx-distributed/olmo/olmo/util.py create mode 100644 3.test_cases/neuronx-distributed/olmo/scratch_pad.py create mode 100644 3.test_cases/neuronx-distributed/olmo/tokenizers/.gitignore diff --git a/3.test_cases/neuronx-distributed/olmo/configs/OLMo-1B.yaml b/3.test_cases/neuronx-distributed/olmo/configs/OLMo-1B.yaml new file mode 100644 index 00000000..c04f0a7f --- /dev/null +++ b/3.test_cases/neuronx-distributed/olmo/configs/OLMo-1B.yaml @@ -0,0 +1,446 @@ +run_name: OLMo-1B +seed: 6198 +dry_run: false + +wandb: + name: ${run_name} + project: olmo-small + +model: + d_model: 2048 + n_heads: 16 + n_layers: 16 + mlp_ratio: 8 + weight_tying: true + alibi: true + rope: false + flash_attention: false # not available on AMD + attention_dropout: 0.0 + attention_layer_norm: false + multi_query_attention: false + include_bias: false + block_type: sequential + layer_norm_type: default + layer_norm_with_affine: false + bias_for_layer_norm: false + attention_layer_norm_with_affine: false + activation_type: swiglu + residual_dropout: 0.0 + embedding_dropout: 0.0 + max_sequence_length: 2048 + vocab_size: 50280 + embedding_size: 50304 + eos_token_id: 50279 + pad_token_id: 1 + init_device: meta + init_fn: mitchell + +compile: null # causes instability on AMD GPUs + +optimizer: + name: adamw + learning_rate: 4.0e-4 + weight_decay: 0.1 + betas: + - 0.9 + - 0.95 + metrics_log_interval: 10 + +scheduler: + name: cosine_with_warmup + t_warmup: 2000 + alpha_f: 0.1 + +tokenizer: + identifier: tokenizers/allenai_eleuther-ai-gpt-neox-20b-pii-special.json + truncate_direction: right +# +# save_folder: ${path.choose:${oc.env:SCRATCH_DIR,no_exist}/checkpoints,/results}/${oc.env:SLURM_JOB_ID,${run_name}} +# save_overwrite: false +# # Sharded checkpoints (best for restarts) +# save_interval: 1000 +# save_num_checkpoints_to_keep: 9 +# # Unsharded checkpoints (for final storage) +# save_interval_unsharded: 10000 +# save_num_unsharded_checkpoints_to_keep: -1 +# +# load_path: null +# +# max_duration: 739_328 # 3.1T tokens +# global_train_batch_size: 2048 +# device_train_microbatch_size: 8 +# +# precision: amp_bf16 +# +# fsdp: +# wrapping_strategy: null +# precision: mixed +# +# max_grad_norm: 1.0 +# max_grad_norm_ratio: null +# +# speed_monitor: +# window_size: 20 +# +# eval_interval: ${save_interval} +# eval_subset_num_batches: -1 +# device_eval_batch_size: ${device_train_microbatch_size} +# evaluators: +# # lump all the small datasets together (we still get separate metrics). +# - label: v3-small-ppl-validation +# data: +# num_workers: 0 +# drop_last: true +# datasets: +# v3-small-c4_en-validation: +# - https://olmo-data.org/eval-data/perplexity/v3_small_gptneox20b/c4_en/val/part-0-00000.npy +# v3-small-dolma_books-validation: +# - https://olmo-data.org/eval-data/perplexity/v3_small_gptneox20b/dolma_books/val/part-0-00000.npy +# v3-small-dolma_common-crawl-validation: +# - https://olmo-data.org/eval-data/perplexity/v3_small_gptneox20b/dolma_common-crawl/val/part-0-00000.npy +# v3-small-dolma_pes2o-validation: +# - https://olmo-data.org/eval-data/perplexity/v3_small_gptneox20b/dolma_pes2o/val/part-0-00000.npy +# v3-small-dolma_reddit-validation: +# - https://olmo-data.org/eval-data/perplexity/v3_small_gptneox20b/dolma_reddit/val/part-0-00000.npy +# v3-small-dolma_stack-validation: +# - https://olmo-data.org/eval-data/perplexity/v3_small_gptneox20b/dolma_stack/val/part-0-00000.npy +# v3-small-dolma_wiki-validation: +# - https://olmo-data.org/eval-data/perplexity/v3_small_gptneox20b/dolma_wiki/val/part-0-00000.npy +# v3-small-ice-validation: +# - https://olmo-data.org/eval-data/perplexity/v3_small_gptneox20b/ice/val/part-0-00000.npy +# v3-small-m2d2_s2orc-validation: +# - https://olmo-data.org/eval-data/perplexity/v3_small_gptneox20b/m2d2_s2orc/val/part-0-00000.npy +# v3-small-pile-validation: +# - https://olmo-data.org/eval-data/perplexity/v3_small_gptneox20b/pile/val/part-0-00000.npy +# v3-small-wikitext_103-validation: +# - https://olmo-data.org/eval-data/perplexity/v3_small_gptneox20b/wikitext_103/val/part-0-00000.npy +# +# - label: v2-small-ppl-validation +# data: +# num_workers: 0 +# drop_last: true +# datasets: +# v2-small-4chan-validation: +# - https://olmo-data.org/eval-data/perplexity/v2_small_gptneox20b/4chan/val.npy +# v2-small-c4_100_domains-validation: +# - https://olmo-data.org/eval-data/perplexity/v2_small_gptneox20b/c4_100_domains/val.npy +# v2-small-c4_en-validation: +# - https://olmo-data.org/eval-data/perplexity/v2_small_gptneox20b/c4_en/val.npy +# v2-small-gab-validation: +# - https://olmo-data.org/eval-data/perplexity/v2_small_gptneox20b/gab/val.npy +# v2-small-ice-validation: +# - https://olmo-data.org/eval-data/perplexity/v2_small_gptneox20b/ice/val.npy +# v2-small-m2d2_s2orc-validation: +# - https://olmo-data.org/eval-data/perplexity/v2_small_gptneox20b/m2d2_s2orc/val.npy +# v2-small-m2d2_wiki-validation: +# - https://olmo-data.org/eval-data/perplexity/v2_small_gptneox20b/m2d2_wiki/val.npy +# v2-small-manosphere-validation: +# - https://olmo-data.org/eval-data/perplexity/v2_small_gptneox20b/manosphere/val.npy +# v2-small-mc4_en-validation: +# - https://olmo-data.org/eval-data/perplexity/v2_small_gptneox20b/mc4_en/val.npy +# v2-small-pile-validation: +# - https://olmo-data.org/eval-data/perplexity/v2_small_gptneox20b/pile/val.npy +# v2-small-ptb-validation: +# - https://olmo-data.org/eval-data/perplexity/v2_small_gptneox20b/ptb/val.npy +# v2-small-twitterAEE-validation: +# - https://olmo-data.org/eval-data/perplexity/v2_small_gptneox20b/twitterAEE/val.npy +# v2-small-wikitext_103-validation: +# - https://olmo-data.org/eval-data/perplexity/v2_small_gptneox20b/wikitext_103/val.npy +# +# - label: piqa +# type: downstream +# +# - label: hellaswag +# type: downstream +# +# - label: winogrande +# type: downstream +# +# - label: openbook_qa +# type: downstream +# +# # - label: boolq # requires implemention of the pmi_dc matrix +# # type: downstream +# +# - label: sciq +# type: downstream +# +# - label: arc_easy +# type: downstream +# +# # - label: arc_challenge # requires implemention of the pmi_dc matrix +# # type: downstream +# +# - label: copa +# type: downstream +# +# - label: rte +# type: downstream +# +# - label: commitment_bank +# type: downstream +# +# - label: mrpc +# type: downstream +# +# - label: sst2 +# type: downstream +# +# data: +# pad_direction: right +# num_workers: 0 +# drop_last: true +# pin_memory: true +# prefetch_factor: 16 +# persistent_workers: true +# timeout: 0 +# paths: +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-000-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-000-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-001-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-002-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-003-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-004-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-004-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-005-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-005-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-006-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-006-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-007-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-008-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-008-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-009-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-009-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-010-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-010-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-011-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-012-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-013-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-014-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-015-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-016-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-017-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-017-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-018-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-018-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-019-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-020-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-020-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-021-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-022-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-023-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-024-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-025-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-025-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-026-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-026-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-027-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-027-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-028-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-029-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-030-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-031-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-032-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-033-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-033-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-034-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-034-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-035-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-035-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-036-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-036-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-037-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-038-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-039-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-039-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-040-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-041-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-042-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-043-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-044-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-045-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-045-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-046-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-047-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-047-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-048-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-049-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-050-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-051-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-052-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-053-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-054-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-055-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-056-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-057-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-058-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-059-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-060-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-061-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-062-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-063-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-064-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-064-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-065-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-065-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-066-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-066-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-067-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-067-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-068-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-068-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-069-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-069-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-070-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-071-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-072-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-073-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-074-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-074-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-075-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-075-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-076-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-076-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-077-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-078-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-078-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-079-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-079-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-080-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-081-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-082-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-083-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-083-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-084-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-085-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-086-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-087-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-088-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-088-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-089-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-089-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-090-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-090-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-091-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-092-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-093-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-094-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-095-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-096-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-096-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-097-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-098-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-099-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-100-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-101-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-102-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-102-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-103-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-104-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-105-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-105-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-106-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-107-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-108-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-109-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-110-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-111-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-112-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-112-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-113-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-114-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-115-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-116-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-117-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-118-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-118-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-119-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-120-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-120-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-121-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-122-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-123-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-124-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-125-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-126-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-126-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-127-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-128-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-129-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-130-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-131-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-132-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-133-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-134-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-135-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-136-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-137-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-138-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-139-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-139-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-140-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-141-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-142-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-143-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-143-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-144-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-145-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-145-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-146-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-147-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-147-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-148-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-149-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-149-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-150-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-151-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-151-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-152-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-152-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-153-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-153-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-154-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-155-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-156-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-156-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-157-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-158-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-158-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-159-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-160-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-160-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-161-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-161-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-162-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-163-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-163-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-164-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-165-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-165-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-166-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-166-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-167-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-167-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-168-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-169-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-170-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-171-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-172-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-173-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-174-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-174-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-175-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-176-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-177-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-178-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-179-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-179-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-180-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-181-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-182-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-183-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-184-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-185-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-185-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-186-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5/gpt-neox-20b-pii-special/part-187-00000.npy \ No newline at end of file diff --git a/3.test_cases/neuronx-distributed/olmo/olmo/aliases.py b/3.test_cases/neuronx-distributed/olmo/olmo/aliases.py new file mode 100644 index 00000000..f9f9b1a3 --- /dev/null +++ b/3.test_cases/neuronx-distributed/olmo/olmo/aliases.py @@ -0,0 +1,7 @@ +from os import PathLike +from typing import Union + +__all__ = ["PathOrStr"] + + +PathOrStr = Union[str, PathLike] \ No newline at end of file diff --git a/3.test_cases/neuronx-distributed/olmo/olmo/beam_search.py b/3.test_cases/neuronx-distributed/olmo/olmo/beam_search.py new file mode 100644 index 00000000..fdcaee31 --- /dev/null +++ b/3.test_cases/neuronx-distributed/olmo/olmo/beam_search.py @@ -0,0 +1,1078 @@ +""" +This is a self-contained and flexible beam search implementation adapted from +AllenNLP's beam search: https://github.com/allenai/allennlp/blob/main/allennlp/nn/beam_search.py +""" + +import copy +import warnings +from abc import abstractmethod +from inspect import signature +from typing import Any, Callable, Dict, List, Optional, Tuple, TypeVar, cast + +import torch + +__all__ = [ + "Sampler", + "DeterministicSampler", + "MultinomialSampler", + "TopKSampler", + "TopPSampler", + "GumbelSampler", + "FinalSequenceScorer", + "SequenceLogProbabilityScorer", + "LengthNormalizedSequenceLogProbabilityScorer", + "Constraint", + "RepeatedNGramBlockingConstraint", + "BeamSearch", +] + +StateType = Dict[str, torch.Tensor] +StepFunctionTypeWithTimestep = Callable[[torch.Tensor, StateType, int], Tuple[torch.Tensor, StateType]] +StepFunctionTypeNoTimestep = Callable[[torch.Tensor, StateType], Tuple[torch.Tensor, StateType]] + +StepFunctionType = TypeVar("StepFunctionType", StepFunctionTypeWithTimestep, StepFunctionTypeNoTimestep) +""" +The type of step function that can be passed to [`BeamSearch.search`](#search). + +This can either be [`StepFunctionTypeWithTimestep`](#stepfunctiontypewithtimestep) +or [`StepFunctionTypeNoTimestep`](#stepfunctiontypenotimestep). +""" + +ConstraintStateType = List[List[Dict[str, Any]]] + + +class Sampler: + """ + An abstract class that can be used to sample candidates (either nodes or beams) + within `BeamSearch`. + + A `Sampler` just has three methods, `init_state()`, `sample_nodes()` and `sample_beams()`. + + `init_state()` takes three arguments: + + - a tensor of starting log probs with shape `(batch_size,, num_classes)`, + - the batch size, an int, + - and the number of classes, also an int. + + It returns a state dictionary with any state tensors needed for subsequent + calls to `sample_nodes()` and `sample_beams()`. + + By default this method just returns an empty dictionary. + + Both `sample_nodes()` and `sample_beams()` should take three arguments: + + - tensor of normalized log probabilities with shape `(batch_size, num_examples)`, + - an integer representing the number of samples to take for each example in the batch, + - and a state dictionary which could contain any tensors needed for the `Sampler` to keep + track of state. + + For `sample_nodes()`, `num_examples = num_classes`, but for `sample_beams`, + `num_examples = beam_size * per_node_beam_size`. + + The return value should be a tuple containing: + + - a tensor of log probabilities of the sampled examples with shape `(batch_size, num_samples)`, + - a tensor of indices of the sampled examples with shape `(batch_size, num_samples)`, + - and the updated state dictionary. + + A default implementation of `sample_beams` is provided, which just deterministically + picks the `k` examples with highest log probability. + """ + + def init_state( + self, start_class_log_probabilities: torch.Tensor, batch_size: int, num_classes: int + ) -> StateType: + del start_class_log_probabilities, batch_size, num_classes + return {} + + @abstractmethod + def sample_nodes( + self, log_probs: torch.Tensor, per_node_beam_size: int, state: StateType + ) -> Tuple[torch.Tensor, torch.Tensor, StateType]: + raise NotImplementedError + + def sample_beams( + self, log_probs: torch.Tensor, beam_size: int, state: StateType + ) -> Tuple[torch.Tensor, torch.Tensor, StateType]: + del state + selected_log_probs, selected_indices = torch.topk(log_probs, beam_size, dim=-1) + return selected_log_probs, selected_indices, {} + + +class DeterministicSampler(Sampler): + """ + A `Sampler` that just deterministically returns the `k` nodes or beams with highest + log probability. + """ + + def sample_nodes( + self, log_probs: torch.Tensor, per_node_beam_size: int, state: StateType + ) -> Tuple[torch.Tensor, torch.Tensor, StateType]: + del state + selected_log_probs, selected_indices = torch.topk(log_probs, per_node_beam_size, dim=-1) + return selected_log_probs, selected_indices, {} + + +class MultinomialSampler(Sampler): + """ + A `Sampler` which samples nodes from the given multinomial distribution. Beams are sampled + in the default, non-deterministic way. + + :param temperature: A `temperature` below 1.0 produces a sharper probability distribution and a `temperature` + above 1.0 produces a flatter probability distribution. + :param with_replacement: Whether to sample with replacement. + + """ + + def __init__( + self, + temperature: float = 1.0, + with_replacement: bool = False, + ) -> None: + self.temperature = temperature + self.with_replacement = with_replacement + + def sample_nodes( + self, log_probs: torch.Tensor, per_node_beam_size: int, state: StateType + ) -> Tuple[torch.Tensor, torch.Tensor, StateType]: + if self.temperature != 1.0: + _probabilities = torch.nn.functional.softmax(log_probs / self.temperature, dim=-1) + else: + _probabilities = log_probs.exp() + + selected_indices = torch.multinomial(_probabilities, per_node_beam_size, replacement=self.with_replacement) + + return torch.gather(log_probs, 1, selected_indices), selected_indices, state + + +class TopKSampler(Sampler): + """ + A `Sampler` which redistributes the probability mass function for nodes among the + top `k` choices, then samples from that subset after re-normalizing the probabilities. + + Beams are sampled in the default, deterministic way. + + :param k: The number of top choices to be selected from. + :param temperature: A `temperature` below 1.0 produces a sharper probability distribution and a `temperature` + above 1.0 produces a flatter probability distribution. + :param with_replacement: If set to `True`, samples will be selected with replacement from the top k choices. + """ + + def __init__( + self, + k: int = 1, + temperature: float = 1.0, + with_replacement: bool = False, + ): + self.k = k + self.temperature = temperature or 1.0 + self.with_replacement = with_replacement + + def sample_nodes( + self, log_probs: torch.Tensor, per_node_beam_size: int, state: StateType + ) -> Tuple[torch.Tensor, torch.Tensor, StateType]: + if not per_node_beam_size <= self.k <= log_probs.size()[1]: + raise ValueError( + "k must be a postive integer no less than per_node_beam_size and no greater than vocabulary size" + ) + + # shape (both): (batch_size, k) + top_k_log_probs, top_k_indices = log_probs.topk(self.k, dim=-1) + + # Apply temperature if necessary. + # shape: (batch_size, k) + if self.temperature != 1.0: + top_k_log_probs = top_k_log_probs / self.temperature + + # Re-normalize the subset. + # shape: (batch_size, k) + normalized_top_k_probs = torch.nn.functional.softmax(top_k_log_probs, dim=-1) + + # Sample from the re-normalized subset. + # NOTE: These indices are not indices into `log_probs`, they are indices into `top_k_log_probs`. + # shape: (batch_size, per_node_beam_size) + sampled_indices = torch.multinomial( + normalized_top_k_probs, per_node_beam_size, replacement=self.with_replacement + ) + + # Convert `sampled_indices` back to indices in the original `log_probs` tensor. + # shape: (batch_size, per_node_beam_size) + indices = top_k_indices.gather(-1, sampled_indices) + + return log_probs.gather(1, indices), indices, state + + +class TopPSampler(Sampler): + """ + A `Sampler` which redistributes the probability mass function for nodes among + the top choices with a cumulative probability of at least `p`, then samples from that subset + after re-normalizing the probabilities. + + Beams are sampled in the default, deterministic way. + + :param p: + The cumulative probability cutoff threshold. A higher value of `p` will result in more possible + examples to sample from. If `with_replacement` is `False` and the number of possible samples is + insufficient to sample without replacement from when calling `sample_nodes`, then the top + `per_node_beam_size` examples will be chosen. + :param temperature: + A `temperature` below 1.0 produces a sharper probability distribution and a `temperature` + above 1.0 produces a flatter probability distribution. + :param with_replacement: + If set to `True`, samples will be selected with replacement from the top choices. + + """ + + def __init__( + self, + p: float = 0.9, + temperature: float = 1.0, + with_replacement: bool = False, + ): + if p < 0.0 or p > 1.0: + raise ValueError("p must be a positive float no greater than 1.0") + self.p = p + self.temperature = temperature or 1.0 + self.with_replacement = with_replacement + + def sample_nodes( + self, log_probs: torch.Tensor, per_node_beam_size: int, state: StateType + ) -> Tuple[torch.Tensor, torch.Tensor, StateType]: + if not per_node_beam_size <= log_probs.size()[1]: + raise ValueError("per_node_beam_size cannot be greater than vocabulary size") + + # First apply temperature coefficient: + if self.temperature != 1.0: + _log_probs = torch.nn.functional.log_softmax(log_probs / self.temperature, dim=-1) + else: + _log_probs = log_probs + + # Sort the probabilities in descending order to then find cumulative sum + log_probs_descending, sorting_indices = torch.sort(_log_probs, descending=True) + + # shape: (batch_size, num_classes) + probabilities_descending = log_probs_descending.exp() + probabilities_summed = torch.cumsum(probabilities_descending, dim=-1) + + # Create a mask for filtering out probabilities that don't make the top `p`. + # shape: (batch_size, num_classes) + exclusion_mask = probabilities_summed >= self.p + + # We want to include the first index where probabilities_summed >= p, so we shift over one. + exclusion_mask[..., 1:] = exclusion_mask[..., :-1].clone() + exclusion_mask[..., 0] = False + + # Make sure there's at least `per_node_beam_size` options to be selected. + if not self.with_replacement: + exclusion_mask[..., :per_node_beam_size] = False + + log_probs_descending[exclusion_mask] = torch.finfo(log_probs.dtype).min + + # Now re-normalized the included log probs. + # shape: (batch_size, num_classes) + filtered_probabilities = torch.nn.functional.softmax(log_probs_descending, dim=-1) + + # Sample from the re-normalized subset. + # NOTE: These indices are not indices into `log_probs`, they are indices into `log_probs_descending`. + # shape: (batch_size, per_node_beam_size) + sampled_indices = torch.multinomial( + filtered_probabilities, per_node_beam_size, replacement=self.with_replacement + ) + + # Convert `sampled_indices` back to indices in the original `log_probs` tensor. + # shape: (batch_size, per_node_beam_size) + selected_indices = sorting_indices.gather(-1, sampled_indices) + + # Return (selected log probabilities, selected classes) + # shape: (len(log_probs),1) , (len(log_probs), 1) + return torch.gather(log_probs, 1, selected_indices), selected_indices, state + + +class GumbelSampler(Sampler): + """ + A `Sampler` which uses the Gumbel-Top-K trick to sample without replacement. See + [*Stochastic Beams and Where to Find Them: The Gumbel-Top-k Trick for Sampling + Sequences Without Replacement*, W Kool, H Van Hoof and M Welling, 2010] + (https://api.semanticscholar.org/CorpusID:76662039). + + :param temperature: A `temperature` below 1.0 produces a sharper probability distribution and a `temperature` + above 1.0 produces a flatter probability distribution. + """ + + def __init__(self, temperature: float = 1.0): + self.temperature = temperature + + def init_state( + self, start_class_log_probabilities: torch.Tensor, batch_size: int, num_classes: int + ) -> StateType: + # shape: (batch_size, num_classes) + zeros = start_class_log_probabilities.new_zeros((batch_size, num_classes)) + + # shape: (batch_size, num_classes) + G_phi_S = self.gumbel_with_max(start_class_log_probabilities, zeros) + + return {"G_phi_S": G_phi_S} + + def sample_nodes( + self, + log_probs: torch.Tensor, + per_node_beam_size: int, + state: StateType, + ) -> Tuple[torch.Tensor, torch.Tensor, StateType]: + # First apply temperature coefficient: + # shape: (batch_size * beam_size, num_classes) + if self.temperature != 1.0: + _log_probs = torch.nn.functional.log_softmax(log_probs / self.temperature, dim=-1) + else: + _log_probs = log_probs + + # shape: (group_size,) + phi_S = state["phi_S"] + + # shape: (group_size, num_classes) + phi_S = phi_S.unsqueeze(-1).expand_as(_log_probs) + + # shape: (group_size, num_classes) + phi_S_new = phi_S + _log_probs + + # shape: (group_size, 1) + G_phi_S = state["G_phi_S"].unsqueeze(-1) + + # shape: (group_size, num_classes) + G_phi_S_new = self.gumbel_with_max(phi_S_new, G_phi_S) + + # Replace NaNs with very negative number. + # shape: (group_size, num_classes) + # G_phi_S_new[G_phi_S_new.isnan()] = torch.finfo(G_phi_S_new.dtype).min + + # shape (both): (group_size, per_node_beam_size) + top_G_phi_S_new, top_indices = torch.topk(G_phi_S_new, per_node_beam_size, dim=-1) + + # shape: (group_size, per_node_beam_size) + top_log_probs = log_probs.gather(1, top_indices) + + return top_log_probs, top_indices, {"G_phi_S": top_G_phi_S_new} + + def sample_beams( + self, + log_probs: torch.Tensor, + beam_size: int, + state: StateType, + ) -> Tuple[torch.Tensor, torch.Tensor, StateType]: + """ + Returns the beams with the highest perturbed log probabilities. + """ + # shape (log_probs): (batch_size, beam_size * per_node_beam_size) + + batch_size = log_probs.size()[0] + + # shape: (batch_size * beam_size, per_node_beam_size) + G_phi_S = state["G_phi_S"] + + # shape: (batch_size, beam_size * per_node_beam_size) + G_phi_S = G_phi_S.reshape_as(log_probs) + + # shape (both): (batch_size, beam_size) + G_phi_S_new, selected_indices = torch.topk(G_phi_S, beam_size, dim=-1) + + # shape: (batch_size, beam_size) + selected_log_probs = log_probs.gather(1, selected_indices) + + # Now sort the selected beams by their true log prob. + # shape (all): (batch_size, beam_size) + selected_log_probs, sort_indices = selected_log_probs.sort(dim=-1, descending=True) + selected_indices = selected_indices.gather(1, sort_indices) + G_phi_S_new = G_phi_S_new.gather(1, sort_indices) + + # shape: (batch_size * beam_size,) + G_phi_S_new = G_phi_S_new.reshape(batch_size * beam_size) + + # shape: (batch_size * beam_size,) + phi_S = selected_log_probs.reshape(batch_size * beam_size) + + return selected_log_probs, selected_indices, {"G_phi_S": G_phi_S_new, "phi_S": phi_S} + + def gumbel(self, phi) -> torch.Tensor: + """ + Sample `Gumbel(phi)`. + + `phi` should have shape `(batch_size, num_classes)`. + """ + return -torch.log(-torch.log(torch.rand_like(phi))) + phi + + def gumbel_with_max(self, phi, T) -> torch.Tensor: + """ + Sample `Gumbel(phi)` conditioned on the maximum value being equal to `T`. + + `phi` should have shape `(batch_size, num_classes)` and `T` should have + shape `(batch_size, 1)`. + """ + # Shape: (batch_size, num_classes) + G_phi = self.gumbel(phi) + + # Now we find the maximum from these samples. + # Shape: (batch_size, ) + Z, _ = G_phi.max(dim=-1) + + # Shape: (batch_size, num_classes) + v = T - G_phi + torch.log1p(-torch.exp(G_phi - Z.unsqueeze(-1))) + + # Shape: (batch_size, num_classes) + return T - torch.nn.functional.relu(v) - torch.log1p(torch.exp(-v.abs())) + + +class FinalSequenceScorer: + """ + An abstract class that can be used to score the final generated sequences found + by beam search. Given the predicted sequences and the corresponding log probabilities of + those sequences, the class calculates and returns the final score of the sequences. + + The default implementation scores the sequences using the sum of the log probabilities of + the sequence, which is passed as input. + """ + + @abstractmethod + def score(self, predictions: torch.Tensor, log_probabilities: torch.Tensor, end_index: int) -> torch.Tensor: + """ + Score the final predictions found by beam search. + Returns a tensor of the final sequence scores of shape `(batch_size, beam_size)`. + + :param predictions: A tensor containing the initial predictions with shape `(batch_size, beam_size, max_steps)`. + :param log_probabilities: A tensor containing the log probabilities of the sequence, defined as the sum + of the log probabilities per token, with shape `(batch_size, beam_size)`. + :param end_index: The index of the end symbol. + + """ + raise NotImplementedError + + +class SequenceLogProbabilityScorer(FinalSequenceScorer): + """ + A :class:`FinalSequenceScorer` which scores the sequences by the sum of the log probabilities + across the sequence's tokens. + """ + + def score(self, predictions: torch.Tensor, log_probabilities: torch.Tensor, end_index: int) -> torch.Tensor: + del predictions, end_index + # The sum of the sequence log probabilities is the input parameter, so just + # return it. + return log_probabilities + + +class LengthNormalizedSequenceLogProbabilityScorer(FinalSequenceScorer): + """ + A :class:`FinalSequenceScorer` which scores the sequences by the average log probability of the + tokens in the sequence. It optionally includes a length penalty which promotes + or demotes sequences based on their lengths. The final score for a sequence will + be `(sequence_log_probability) / (sequence_length ** length_penalty)`. The sequence length + here includes the end token. + + :param length_penalty: The length penalty to use. A value of 1.0 means no length penalty is used. + A value > 1.0 favors longer sequences, and < 1.0 favors shorter sequences. + """ + + def __init__(self, length_penalty: float = 1.0): + super().__init__() + self.length_penalty = length_penalty + + def score(self, predictions: torch.Tensor, log_probabilities: torch.Tensor, end_index: int) -> torch.Tensor: + # shape: (batch_size, beam_size) + lengths = (predictions != end_index).long().sum(dim=2) + + # If the sequence ended during beam search, the `log_probabilities` will include + # the transition to the end token. Therefore, in such situations, `lengths` is + # actually off by 1. This corrects for that. + # shape: (batch_size, beam_size) + is_end_token = predictions[:, :, -1] == end_index + lengths += is_end_token.long() + + # shape: (batch_size, beam_size) + average_log_probs = log_probabilities / (lengths**self.length_penalty) + return average_log_probs + + +class Constraint: + """ + An abstract class that can be used to enforce constraints on the output predictions + by manipulating the class log probabilities during beam search. + + A `Constraint` just has three methods that need to be implemented by subclasses: + `init_state()`, `apply()` and `_update_state()`. + + `init_state()` takes one argument: + + - the batch size, an int + + It returns a constraint state, which is a nested list of dictionaries, with any state needed for subsequent + calls to `apply()` and `update_state()`. The length of the outer list should be equal to `batch_size`. + Each inner list should be of length 1. + + `apply()` takes two arguments: + + - the constraint state, which is a nested list of dictionaries. The length of the outer list is `batch_size` + and the length of each inner list is `beam_size` except on the first time `apply()` is called when it is 1. + - `class_log_probabilities`, a tensor of shape `(batch_size, beam_size, num_classes)` that contains the + log probabilities for the classes during search. The first time `apply()` is called, `beam_size = 1`. + + The `apply()` method should return new `class_log_probabilities` that enforce the constraint + for this step of beam search. For instance, it may prevent a specific class from being selected by setting + the corresponding log probability to a negligible value such as `float("-inf")` or + `torch.finfo(class_log_probabilities.dtype).min`. + + `_update_state()` takes two arguments: + + - the copied parent constraint state, which is a nested list of dictionaries. `state[i][j]` contains the + copied state for the parent of `last_prediction[i, j]`. It is unique to that batch and beam, so it can be + directly edited in-place without affecting the others. + - last_prediction, a tensor of shape `(batch_size, beam_size)` containing the predictions from the last + step of beam search. + + The `_update_state()` function should return a new constraint state, a nested list of dictionaries of + length `batch_size` and inner list of length `beam_size`, one for each of the predictions in `last_prediction`. + + """ + + @abstractmethod + def init_state( + self, + batch_size: int, + ) -> ConstraintStateType: + raise NotImplementedError + + @abstractmethod + def apply( + self, + state: ConstraintStateType, + class_log_probabilities: torch.Tensor, + ) -> torch.Tensor: + raise NotImplementedError + + @staticmethod + def _copy_state( + state: ConstraintStateType, + batch_size: int, + beam_size: int, + last_backpointer: Optional[torch.Tensor] = None, + ) -> ConstraintStateType: + """ + Copies the `state` . This method copies the data in `state` using `copy.deepcopy()`. If this + is not appropriate for your constraint, you will need to implement the copying yourself. + """ + new_state = [] + for i in range(batch_size): + batch_state = [] + for j in range(beam_size): + if last_backpointer is None: + # This is the first prediction, so the backpointer is 0 + backpointer = 0 + else: + backpointer = last_backpointer[i, j].item() + batch_state.append(copy.deepcopy(state[i][backpointer])) # type: ignore + new_state.append(batch_state) + return new_state + + def update_state( + self, + state: ConstraintStateType, + last_prediction: torch.Tensor, + last_backpointer: Optional[torch.Tensor] = None, + ) -> ConstraintStateType: + batch_size, beam_size = last_prediction.size() + new_state = self._copy_state(state, batch_size, beam_size, last_backpointer) + return self._update_state(new_state, last_prediction) + + @abstractmethod + def _update_state( + self, + state: ConstraintStateType, + last_prediction: torch.Tensor, + ) -> ConstraintStateType: + raise NotImplementedError + + +class RepeatedNGramBlockingConstraint(Constraint): + def __init__(self, ngram_size: int, **kwargs) -> None: + super().__init__(**kwargs) + self.ngram_size = ngram_size + + def init_state( + self, + batch_size: int, + ) -> ConstraintStateType: + return [[{"seen_ngrams": {}, "current_prefix": []}] for _ in range(batch_size)] + + def apply( + self, + state: ConstraintStateType, + class_log_probabilities: torch.Tensor, + ) -> torch.Tensor: + for i, batch in enumerate(state): + for j, beam in enumerate(batch): + current_prefix = tuple(beam["current_prefix"]) + seen_ngrams = beam["seen_ngrams"] + try: + disallowed_indices = seen_ngrams[current_prefix] + class_log_probabilities[i, j, disallowed_indices] = torch.finfo( + class_log_probabilities.dtype + ).min + except KeyError: + # We have not seen this prefix before, so there is no index + # that needs to be blocked + pass + return class_log_probabilities + + def _update_state( + self, + state: ConstraintStateType, + last_prediction: torch.Tensor, + ) -> ConstraintStateType: + for i, batch in enumerate(state): + for j, beam in enumerate(batch): + prediction = last_prediction[i, j].item() + prefix = beam["current_prefix"] + seen_ngrams = beam["seen_ngrams"] + + if len(prefix) == self.ngram_size - 1: + # This is a new ngram that we have to remember + if tuple(prefix) not in seen_ngrams: + seen_ngrams[tuple(prefix)] = [] + seen_ngrams[tuple(prefix)].append(prediction) + + # Create the new prefix, removing the oldest index if the prefix + # is too long + prefix.append(prediction) + if len(prefix) == self.ngram_size: + prefix.pop(0) + return state + + +class BeamSearch: + """ + Implements the beam search algorithm for decoding the most likely sequences. + + :param end_index: The index of the "stop" or "end" token in the vocabulary. Usually the EOS token ID. + + :param max_steps: The maximum number of decoding steps to take, i.e. the maximum length + of the predicted sequences. + + :param beam_size: The width of the beam used. + + :param per_node_beam_size: The maximum number of candidates to consider per node, at each step in the search. + If not given, this just defaults to `beam_size`. Setting this parameter + to a number smaller than `beam_size` may give better results, as it can introduce + more diversity into the search. See + [*Beam Search Strategies for Neural Machine Translation*, Freitag and Al-Onaizan, 2017] + (https://api.semanticscholar.org/CorpusID:2229477). + + :param sampler: An optional `Sampler` which is used to pick next candidate nodes and beams. + If not specified, `DeterministicSampler` will be used, which just takes the + `per_node_beam_size` most likely nodes and the `beam_size` most likely beams. + + Using the [`GumbelSampler`](#gumbelsampler), on the other hand, will give you + [Stochastic Beam Search](https://api.semanticscholar.org/CorpusID:76662039). + + :param min_steps: The minimum number of decoding steps to take, i.e. the minimum length of + the predicted sequences. This does not include the start or end tokens. If `None`, + no minimum is enforced. + + :param final_sequence_scorer: An optional `FinalSequenceScorer` which is used to score the final generated sequences. + The output from this module is what is returned by the `search` method. If not + specified, `SequenceLogProbabilityScorer` will be used, which scores the sequences + by the sum of the token log probabilities. + + :param constraints: An optional list of `Constraint`s which should be applied during beam search. If not + provided, no constraints will be enforced. + + """ + + def __init__( + self, + end_index: int, + *, + max_steps: int = 50, + beam_size: int = 10, + per_node_beam_size: Optional[int] = None, + sampler: Optional[Sampler] = None, + min_steps: Optional[int] = None, + final_sequence_scorer: Optional[FinalSequenceScorer] = None, + constraints: Optional[List[Constraint]] = None, + ) -> None: + if not max_steps > 0: + raise ValueError("max_steps must be positive") + if not beam_size > 0: + raise ValueError("beam_size must be positive") + if per_node_beam_size is not None and not per_node_beam_size > 0: + raise ValueError("per_node_beam_size must be positive") + if min_steps is not None: + if not min_steps >= 0: + raise ValueError("min_steps must be non-negative") + if not min_steps <= max_steps: + raise ValueError("min_steps must be less than or equal to max_steps") + + self._end_index = end_index + self.max_steps = max_steps + self.beam_size = beam_size + self.per_node_beam_size = per_node_beam_size or beam_size + self.sampler = sampler or DeterministicSampler() + self.min_steps = min_steps or 0 + self.final_sequence_scorer = final_sequence_scorer or SequenceLogProbabilityScorer() + self.constraints = constraints or [] + + @staticmethod + def _reconstruct_sequences(predictions, backpointers): + # Reconstruct the sequences. + # shape: [(batch_size, beam_size, 1)] + reconstructed_predictions = [predictions[-1].unsqueeze(2)] + + if not backpointers: + return reconstructed_predictions + + # shape: (batch_size, beam_size) + cur_backpointers = backpointers[-1] + + for timestep in range(len(predictions) - 2, 0, -1): + # shape: (batch_size, beam_size, 1) + cur_preds = predictions[timestep].gather(1, cur_backpointers).unsqueeze(2) + + reconstructed_predictions.append(cur_preds) + + # shape: (batch_size, beam_size) + cur_backpointers = backpointers[timestep - 1].gather(1, cur_backpointers) + + # shape: (batch_size, beam_size, 1) + final_preds = predictions[0].gather(1, cur_backpointers).unsqueeze(2) + + reconstructed_predictions.append(final_preds) + + return reconstructed_predictions + + def search( + self, + start_predictions: torch.Tensor, + start_state: StateType, + step: StepFunctionType, + ) -> Tuple[torch.Tensor, torch.Tensor]: + """ + Given a starting state and a step function, apply beam search to find the + most likely target sequences. + + Returns a tuple of `(predictions, final_scores)`, where `predictions` + has shape `(batch_size, beam_size, max_steps)` and `final_scores` + has shape `(batch_size, beam_size)`. + + .. note:: + If your step function returns `-inf` for some log probabilities + (like if you're using a masked log-softmax) then some of the "best" + sequences returned may also have `-inf` log probability. Specifically + this happens when the beam size is smaller than the number of actions + with finite log probability (non-zero probability) returned by the step function. + Therefore if you're using a mask you may want to check the results from `search` + and potentially discard sequences with non-finite log probability. + + :param start_predictions: A tensor containing the initial predictions with shape `(batch_size,)`. + Usually the initial predictions are just the index of the "start" token + in the target vocabulary. + + :param start_state: The initial state passed to the `step` function. Each value of the state dict + should be a tensor of shape `(batch_size, *)`, where `*` means any other + number of dimensions. + + :param step: A function that is responsible for computing the next most likely tokens, + given the current state and the predictions from the last time step. + The function should accept two or three arguments: + + - a tensor of shape `(group_size,)` or representing the index of the predicted + tokens from the last time step, + - the current state, a `StateType`, and + - optionally, the timestep, an `int`. + + The `group_size` will be `batch_size * beam_size`, except in the initial + step, for which it will just be `batch_size`. + + The function is expected to return a tuple, where the first element + is a tensor of shape `(group_size, vocab_size)` containing + the log probabilities of the tokens for the next step, and the second + element is the updated state. The tensor in the state should have shape + `(group_size, *)`, where `*` means any other number of dimensions. + + """ + step_signature = signature(step) + if len(step_signature.parameters) < 3: + # If the step function we're given does not take the time step argument, wrap it + # in one that does. + old_step = cast(StepFunctionTypeNoTimestep, step) + + def new_step(last_predictions: torch.Tensor, state: Dict[str, torch.Tensor], time_step: int): + del time_step + return old_step(last_predictions, state) + + return self._search(start_predictions, start_state, new_step) + else: + return self._search(start_predictions, start_state, cast(StepFunctionTypeWithTimestep, step)) + + def _search( + self, + start_predictions: torch.Tensor, + start_state: StateType, + step: StepFunctionTypeWithTimestep, + ) -> Tuple[torch.Tensor, torch.Tensor]: + batch_size = start_predictions.size()[0] + + # List of (batch_size, beam_size) tensors. One for each time step. Does not + # include the start symbols, which are implicit. + predictions: List[torch.Tensor] = [] + + # List of (batch_size, beam_size) tensors. One for each time step. None for + # the first. Stores the index n for the parent prediction, i.e. + # predictions[t-1][i][n], that it came from. + backpointers: List[torch.Tensor] = [] + + constraint_states = [constraint.init_state(batch_size) for constraint in self.constraints] + + # Calculate the first timestep. This is done outside the main loop + # because we are going from a single decoder input (the output from the + # encoder) to the top `beam_size` decoder outputs. On the other hand, + # within the main loop we are going from the `beam_size` elements of the + # beam to `beam_size`^2 candidates from which we will select the top + # `beam_size` elements for the next iteration. + # shape: (batch_size, num_classes) + start_class_log_probabilities, state = step(start_predictions, start_state, 0) + + num_classes = start_class_log_probabilities.size()[1] + + # Make sure `per_node_beam_size` is not larger than `num_classes`. + if self.per_node_beam_size > num_classes: + raise ValueError( + f"Vocab size ({num_classes:d}) too small " + f"relative to per_node_beam_size ({self.per_node_beam_size:d}).\n" + f"Please decrease beam_size or per_node_beam_size." + ) + + sampler_state = self.sampler.init_state(start_class_log_probabilities, batch_size, num_classes) + + # Apply all constraints. + if self.constraints: + # shape: (batch_size, 1, num_classes) + expanded_start_class_log_probabilities = start_class_log_probabilities.unsqueeze(1) + for constraint, constraint_state in zip(self.constraints, constraint_states): + expanded_start_class_log_probabilities = constraint.apply( + constraint_state, expanded_start_class_log_probabilities + ) + start_class_log_probabilities = expanded_start_class_log_probabilities.squeeze(1) + + # Prevent selecting the end symbol if there is any min_steps constraint + if self.min_steps >= 1: + start_class_log_probabilities[:, self._end_index] = torch.finfo( + start_class_log_probabilities.dtype + ).min + + # Get the initial predicted classed and their log probabilities. + # shape: (batch_size, beam_size), (batch_size, beam_size) + ( + start_top_log_probabilities, + start_predicted_classes, + sampler_state, + ) = self.sampler.sample_beams(start_class_log_probabilities, self.beam_size, sampler_state) + + if self.beam_size == 1 and (start_predicted_classes == self._end_index).all(): + warnings.warn( + "Empty sequences predicted. You may want to increase the beam size or ensure " + "your step function is working properly.", + RuntimeWarning, + ) + return start_predicted_classes.unsqueeze(-1), start_top_log_probabilities + + # The log probabilities for the last time step. + # shape: (batch_size, beam_size) + last_log_probabilities = start_top_log_probabilities + + # shape: [(batch_size, beam_size)] + predictions.append(start_predicted_classes) + + # Log probability tensor that mandates that the end token is selected. + # shape: (batch_size * beam_size, num_classes) + log_probs_after_end = start_class_log_probabilities.new_full( + (batch_size * self.beam_size, num_classes), + torch.finfo(start_class_log_probabilities.dtype).min, + ) + log_probs_after_end[:, self._end_index] = 0.0 + + # Set the same state for each element in the beam. + self._update_initial_state(state, batch_size) + + for i, constraint in enumerate(self.constraints): + constraint_states[i] = constraint.update_state(constraint_states[i], start_predicted_classes) + + for timestep in range(self.max_steps - 1): + # shape: (batch_size * beam_size,) + last_predictions = predictions[-1].reshape(batch_size * self.beam_size) + + # If every predicted token from the last step is `self._end_index`, + # then we can stop early. + if (last_predictions == self._end_index).all(): + break + # Take a step. This get the predicted log probs of the next classes + # and updates the state. + # shape: (batch_size * beam_size, num_classes) + class_log_probabilities, state = step(last_predictions, state, timestep + 1) + + # Apply all constraints. + if self.constraints: + # shape: (batch_size, beam_size, num_classes) + reshaped_class_log_probabilities = class_log_probabilities.view(batch_size, self.beam_size, -1) + for constraint, constraint_state in zip(self.constraints, constraint_states): + reshaped_class_log_probabilities = constraint.apply( + constraint_state, reshaped_class_log_probabilities + ) + # shape: (batch_size * beam_size, num_classes) + class_log_probabilities = reshaped_class_log_probabilities.view(batch_size * self.beam_size, -1) + + # The `timestep`-th iteration of the for loop is generating the `timestep + 2`-th token + # of the sequence (because `timestep` is 0-indexed and we generated the first token + # before the for loop). Here we block the end index if the search is not allowed to + # terminate on this iteration. + if timestep + 2 <= self.min_steps: + class_log_probabilities[:, self._end_index] = torch.finfo(class_log_probabilities.dtype).min + + # shape: (batch_size * beam_size, num_classes) + last_predictions_expanded = last_predictions.unsqueeze(-1).expand( + batch_size * self.beam_size, num_classes + ) + + # Here we are finding any beams where we predicted the end token in + # the previous timestep and replacing the distribution with a + # one-hot distribution, forcing the beam to predict the end token + # this timestep as well. + # shape: (batch_size * beam_size, num_classes) + cleaned_log_probabilities = torch.where( + last_predictions_expanded == self._end_index, + log_probs_after_end, + class_log_probabilities, + ) + + # shape (both): (batch_size * beam_size, per_node_beam_size) + top_log_probabilities, predicted_classes, sampler_state = self.sampler.sample_nodes( + cleaned_log_probabilities, self.per_node_beam_size, sampler_state + ) + + # Here we expand the last log probabilities to (batch_size * beam_size, per_node_beam_size) + # so that we can add them to the current log probs for this timestep. + # This lets us maintain the log probability of each element on the beam. + # shape: (batch_size * beam_size, per_node_beam_size) + expanded_last_log_probabilities = ( + last_log_probabilities.unsqueeze(2) + .expand(batch_size, self.beam_size, self.per_node_beam_size) + .reshape(batch_size * self.beam_size, self.per_node_beam_size) + ) + + # shape: (batch_size * beam_size, per_node_beam_size) + summed_top_log_probabilities = top_log_probabilities + expanded_last_log_probabilities + + # shape: (batch_size, beam_size * per_node_beam_size) + reshaped_summed = summed_top_log_probabilities.reshape( + batch_size, self.beam_size * self.per_node_beam_size + ) + + # shape: (batch_size, beam_size * per_node_beam_size) + reshaped_predicted_classes = predicted_classes.reshape( + batch_size, self.beam_size * self.per_node_beam_size + ) + + # Keep only the top `beam_size` beam indices. + # shape (both): (batch_size, beam_size) + ( + restricted_beam_log_probs, + restricted_beam_indices, + sampler_state, + ) = self.sampler.sample_beams(reshaped_summed, self.beam_size, sampler_state) + + # Use the beam indices to extract the corresponding classes. + # shape: (batch_size, beam_size) + restricted_predicted_classes = reshaped_predicted_classes.gather(1, restricted_beam_indices) + + predictions.append(restricted_predicted_classes) + + # shape: (batch_size, beam_size) + last_log_probabilities = restricted_beam_log_probs + + # The beam indices come from a `beam_size * per_node_beam_size` dimension where the + # indices with a common ancestor are grouped together. Hence + # dividing by per_node_beam_size gives the ancestor. (Note that this is integer + # division as the tensor is a LongTensor.) + # shape: (batch_size, beam_size) + backpointer = torch.divide(restricted_beam_indices, self.per_node_beam_size, rounding_mode="trunc") + backpointers.append(backpointer) + + # Keep only the pieces of the state tensors corresponding to the + # ancestors created this iteration. + self._update_state(state, backpointer) + + for i, constraint in enumerate(self.constraints): + constraint_states[i] = constraint.update_state( + constraint_states[i], restricted_predicted_classes, last_backpointer=backpointer + ) + + # Warn about "-inf" log probabilities if not using any constraints (negligible + # log probabilities are expected when using constraints). + if not self.constraints and ( + not torch.isfinite(last_log_probabilities).all() + or (last_log_probabilities == torch.finfo(last_log_probabilities.dtype).min).any() + ): + warnings.warn( + "Negligible log probabilities encountered ('-inf' or equivalent). " + "Some final sequences may not make sense. " + "This can happen when the beam size is larger than the number of valid (non-zero " + "probability) transitions that the step function produces.", + RuntimeWarning, + ) + + reconstructed_predictions = self._reconstruct_sequences(predictions, backpointers) + + # shape: (batch_size, beam_size, max_steps) + all_predictions = torch.cat(list(reversed(reconstructed_predictions)), 2) + + # Calculate the final sequence scores + # shape: (batch_size, beam_size) + final_scores = self.final_sequence_scorer.score(all_predictions, last_log_probabilities, self._end_index) + + # Sort the sequences based on the final scores so the best scoring + # sequence is at index 0 + sorted_final_scores, sorted_indices = torch.sort(final_scores, dim=1, descending=True) + sorted_all_predictions = torch.gather( + all_predictions, 1, sorted_indices.unsqueeze(-1).expand_as(all_predictions) + ) + + return sorted_all_predictions, sorted_final_scores + + def _update_initial_state(self, state: StateType, batch_size: int): + """ + Expand tensors in a state dictionary from `(batch_size, *)` to `(batch_size * beam_size, *)`. + """ + for key, state_tensor in state.items(): + if state_tensor is None: + continue + # shape: (batch_size * beam_size, *) + _, *last_dims = state_tensor.size() + state[key] = ( + state_tensor.unsqueeze(1) + .expand(batch_size, self.beam_size, *last_dims) + .reshape(batch_size * self.beam_size, *last_dims) + ) + + def _update_state(self, state: StateType, backpointer: torch.Tensor): + batch_size = backpointer.size()[0] + + for key, state_tensor in state.items(): + if state_tensor is None: + continue + _, *last_dims = state_tensor.size() + # shape: (batch_size, beam_size, *) + expanded_backpointer = backpointer.view(batch_size, self.beam_size, *([1] * len(last_dims))).expand( + batch_size, self.beam_size, *last_dims + ) + # shape: (batch_size * beam_size, *) + state[key] = ( + state_tensor.reshape(batch_size, self.beam_size, *last_dims) + .gather(1, expanded_backpointer) + .reshape(batch_size * self.beam_size, *last_dims) + ) \ No newline at end of file diff --git a/3.test_cases/neuronx-distributed/olmo/olmo/config.py b/3.test_cases/neuronx-distributed/olmo/olmo/config.py new file mode 100644 index 00000000..9acabee6 --- /dev/null +++ b/3.test_cases/neuronx-distributed/olmo/olmo/config.py @@ -0,0 +1,1144 @@ +from __future__ import annotations + +from dataclasses import asdict, dataclass, field +from glob import glob +from pathlib import Path +from typing import ( + Any, + Dict, + Iterable, + List, + Optional, + Tuple, + Type, + TypeVar, + Union, + cast, +) + +import numpy as np +import torch +from omegaconf import DictConfig, ListConfig +from omegaconf import OmegaConf as om +from omegaconf.errors import OmegaConfBaseException +from torch.distributed.fsdp import MixedPrecision, ShardingStrategy + +from .aliases import PathOrStr +from .exceptions import OLMoConfigurationError +from .util import StrEnum + +__all__ = [ + "ActivationType", + "ActivationCheckpointingStrategy", + "BlockType", + "LayerNormType", + "InitFnType", + "ModelConfig", + "OptimizerType", + "OptimizerConfig", + "SchedulerType", + "SchedulerConfig", + "DataConfig", + "InstanceFilterConfig", + "EvaluatorConfig", + "TokenizerConfig", + "TrainConfig", + "PaddingDirection", + "TruncationDirection", + "SpeedMonitorConfig", + "WandbConfig", + "CompilerConfig", + "WandbConfig", + "FSDPPrecision", + "FSDPWrapStrategy", + "FSDPConfig", + "CheckpointType", +] + +C = TypeVar("C", bound="BaseConfig") +D = TypeVar("D", bound="DictConfig|ListConfig") + + +class BaseConfig: + @classmethod + def _register_resolvers(cls, validate_paths: bool = True): + # Expands path globs into a list. + def path_glob(*paths) -> List[str]: + out = [] + for path in paths: + matches = sorted(glob(path)) + if not matches and validate_paths: + raise FileNotFoundError(f"{path} does not match any files or dirs") + out.extend(matches) + return out + + # Chooses the first path in the arguments that exists. + def path_choose(*paths) -> str: + from .util import is_url + + for path in paths: + if is_url(path) or Path(path).exists(): + return path + if validate_paths: + raise FileNotFoundError(", ".join(paths)) + else: + return "" + + # Finds the latest checkpoint in a folder. + def path_last_checkpoint(path) -> str: + from .util import find_latest_checkpoint + + latest_checkpoint = find_latest_checkpoint(path) + if latest_checkpoint is None: + if validate_paths: + raise FileNotFoundError(f"Could not find a latest checkpoint at {path}") + else: + return "" + else: + return str(latest_checkpoint) + + om.register_new_resolver("path.glob", path_glob, replace=True) + om.register_new_resolver("path.choose", path_choose, replace=True) + om.register_new_resolver("path.last_checkpoint", path_last_checkpoint, replace=True) + + @classmethod + def update_legacy_settings(cls, config: D) -> D: + """ + Update the legacy config settings whose schemas have undergone backwards-incompatible changes. + """ + return config + + @classmethod + def new(cls: Type[C], **kwargs) -> C: + cls._register_resolvers() + conf = om.structured(cls) + try: + if kwargs: + conf = om.merge(conf, kwargs) + return cast(C, om.to_object(conf)) + except OmegaConfBaseException as e: + raise OLMoConfigurationError(str(e)) + + @classmethod + def load( + cls: Type[C], + path: PathOrStr, + overrides: Optional[List[str]] = None, + key: Optional[str] = None, + validate_paths: bool = True, + ) -> C: + """Load from a YAML file.""" + cls._register_resolvers(validate_paths=validate_paths) + schema = om.structured(cls) + try: + raw = om.load(str(path)) + if key is not None: + raw = raw[key] # type: ignore + raw = cls.update_legacy_settings(raw) + conf = om.merge(schema, raw) + if overrides: + conf = om.merge(conf, om.from_dotlist(overrides)) + return cast(C, om.to_object(conf)) + except OmegaConfBaseException as e: + raise OLMoConfigurationError(str(e)) + + def save(self, path: PathOrStr) -> None: + """Save to a YAML file.""" + om.save(config=self, f=str(path)) + + def asdict(self, exclude: Optional[Iterable[str]] = None) -> Dict[str, Any]: + out = asdict(self) # type: ignore + if exclude is not None: + for name in exclude: + if name in out: + del out[name] + return out + + +class LayerNormType(StrEnum): + default = "default" + """ + The default LayerNorm implementation, equivalent to PyTorch's built-in version. + """ + + low_precision = "low_precision" + """ + A low-precision version of the default LayerNorm. + """ + + rms = "rms" + """ + An RMSNorm implementation. When using ``torch.compile`` this is + probably the fastest implementation. + """ + + +class ActivationType(StrEnum): + gelu = "gelu" + relu = "relu" + swiglu = "swiglu" + + +class BlockType(StrEnum): + sequential = "sequential" + + llama = "llama" + """ + A block similar to the sequential block with slightly different + implementations of operations like attention to imitate the behavior of Llama. + """ + + +class InitFnType(StrEnum): + mitchell = "mitchell" + """ + The strategy suggested to us by Mitchell Wortsman from UW. + This uses a truncated normal distribution with an adaptive standard deviation that depends + on the size of the weights as well as the depth of the layer. + """ + + normal = "normal" + """ + All weights are initialized from the same normal distribution. + """ + + kaiming_normal = "kaiming_normal" + """ + All weights are initialized with the Kaiming method from a normal distribution. + Note this currently won't work with FSDP. + """ + + fan_in = "fan_in" + """ + "Fan-in variance scaling", i.e. normal with a standard deviation of ``1/sqrt(d_in)`` where ``d_in`` + is the input dimensionality of the kernel. + """ + + full_megatron = "full_megatron" + """ + This is what metaseq calls "full megatron init". It is the init used for Llama 2. + """ + + +@dataclass +class ModelConfig(BaseConfig): + """ + OLMo (model) configuration. + """ + + # Note that the defaults for these attributes are equivalent to the base GPT2 model. + + d_model: int = 768 + """ + The hidden size of the model. + """ + + n_heads: int = 12 + """ + The number of self-attention heads. + """ + + n_kv_heads: Optional[int] = None + """ + The number of heads to use for keys and values. Defaults to `n_heads`. + Set this to ``None`` or ``n_heads`` for normal multi-head attention. + Set this to 1 for multi-query attention. + Set it to some in-between value for Llama2-style grouped query attention. + """ + + clip_qkv: Optional[float] = None + """ + Clip QKV to this value when set. + """ + + n_layers: int = 12 + """ + The number of layers/blocks. + """ + + mlp_ratio: int = 4 + """ + The ratio of the inner MLP dimensionality to ``d_model``. + This is only used when ``mlp_hidden_size`` is not set. + """ + + mlp_hidden_size: Optional[int] = None + """ + Set the exact hidden size for the MLP. Otherwise the inner MLP hidden size will be set to `mlp_ratio * d_model`. + """ + + activation_type: ActivationType = ActivationType.swiglu + """ + The activation function to use within the MLP layers. + """ + + block_type: BlockType = BlockType.sequential + """ + The transformer block implementation. + """ + + block_group_size: int = 1 + """ + The number of blocks to group together into a single parent block. + This has no affect on the number of parameters in the model and is only used to wrap groups + of blocks together with a single FSDP wrapper during training. + """ + + alibi: bool = False + """ + If ``True``, use ALiBi embeddings. Mutually exclusive with ``rope``. + """ + + alibi_bias_max: float = 8.0 + """ + Maximum absolute value of ALiBi bias. + """ + + rope: bool = False + """ + Use rotary positional embeddings (RoPE). Mutually exclusive with ``alibi``. + """ + + rope_full_precision: bool = True + """ + If ``True``, apply RoPE embeddings at full precision regardless of the input type. Otherwise, + apply RoPE at the precision of the input. + """ + + flash_attention: bool = False + """ + If ``True``, use ``FlashAttention``. + """ + + attention_dropout: float = 0.1 + """ + The dropout probability within the attention modules. + """ + + multi_query_attention: Optional[bool] = None + """ + Deprecated. Use n_kv_heads instead. + """ + + attention_layer_norm: bool = False + """ + Apply layer norm to the keys and queries within the attention mechanism. + This can help stabilize training. + """ + + residual_dropout: float = 0.1 + """ + The dropout probability for the MLP and attention output within each block. + """ + + embedding_dropout: float = 0.1 + """ + The dropout probability for embeddings. + """ + + layer_norm_type: LayerNormType = LayerNormType.default + """ + The layernorm implementation to use. + """ + + layer_norm_with_affine: bool = True + """ + Whether to include bias and weight parameters for the layer norms. + This only affects layer norms that are immediately followed by a linear layer in the forward pass, + so everything except QK-norms. To turn off affines for QK norms as well, set :attr:`attention_layer_norm_with_affine` + to ``False``. + """ + + attention_layer_norm_with_affine: bool = True + """ + Toggle affine transform for the QK norms. + """ + + max_sequence_length: int = 1024 + """ + The maximum input sequence length supported by the model. + """ + + include_bias: bool = True + """ + Whether or not to include bias parameters in linear layers. + In PaLM, they got rid of all bias terms because they found that large + models tend to have near 0 bias terms anyway. + """ + + bias_for_layer_norm: Optional[bool] = None + """ + Whether or not to include bias parameters in layer norm. + This is separate from the include_bias parameter, because of a ROCm crash when biases are disabled in + layer norm. + When this is None (the default), it inherits the setting from include_bias. + """ + + scale_logits: bool = False + """ + If ``True``, scale the output logits by ``1 / sqrt(d_model)``. + """ + + vocab_size: int = 50257 + """ + Vocabulary size of the model. + """ + + embedding_size: Optional[int] = 50304 + """ + The number of embeddings, i.e. the number of tokens. If set to ``None`` it will default + to ``vocab_size``. If ``vocab_size`` is not a multiple of 128, setting this to the + next multiple of 128 that's greater than ``vocab_size`` can improve throughput + substantially. + """ + + weight_tying: bool = True + """ + Whether to tie output linear weights to the input embedding. + """ + + eos_token_id: int = 50256 + """ + The ID of the end-of-sentence special token. + """ + + pad_token_id: int = 50256 + """ + The ID of the token to use for padding. Defaults to the ID of the EOS token. + """ + + init_device: Optional[str] = None + """ + The torch device to use when initializing the model parameters, e.g. "cpu", "cuda:0", "meta". + """ + + init_fn: InitFnType = InitFnType.normal + """ + The weight initialization strategy. + """ + + init_std: float = 0.02 + """ + The standard deviation to use when initializing weights with a "fixed distribution" ``init_fn``, such + as "normal". + """ + + init_cutoff_factor: Optional[float] = None + """ + A positive factor used to scale the cutoff values when initializing weights with a "fixed distribution" ``init_fn``, such + as "normal". Setting this to None means values are not cutoff. + """ + + precision: Optional[str] = None + """ + Precision used to train/evaluate with. You shouldn't set this directly. + See :data:`TrainConfig.precision` instead. + """ + + @property + def effective_n_kv_heads(self) -> int: + if self.n_kv_heads is None: + if self.multi_query_attention is True: + return 1 + else: + return self.n_heads + else: + if self.multi_query_attention is None: + return self.n_kv_heads + if self.multi_query_attention: + n_kv_heads_should_be = 1 + else: + n_kv_heads_should_be = self.n_heads + if self.n_kv_heads == n_kv_heads_should_be: + return n_kv_heads_should_be + else: + raise OLMoConfigurationError( + "You can't set `multi_query_attention` and `n_kv_heads` at the same time." + ) + + +class OptimizerType(StrEnum): + lionw = "lionw" + adamw = "adamw" + + +@dataclass +class OptimizerConfig(BaseConfig): + name: OptimizerType = OptimizerType.lionw + learning_rate: float = 1.0e-4 + weight_decay: float = 0.01 + betas: Tuple[float, float] = (0.9, 0.95) + eps: float = 1e-5 + + no_decay_norm_and_bias: Optional[bool] = None + """ + Deprecated. Use ``decay_norm_and_bias`` and ``decay_embeddings`` instead. + """ + + decay_norm_and_bias: bool = False + decay_embeddings: bool = False + metrics_log_interval: Optional[int] = None + """ + The interval with which to collect and log detailed parameter-specific metrics. + This only applies when logging to W&B, since these metrics won't be logged to the console. + If not set, defaults to the wandb `log_interval`. + """ + + def __post_init__(self): + self.betas = tuple(self.betas) # type: ignore[assignment] + + @classmethod + def update_legacy_settings(cls, config: D) -> D: + new_config = config.copy() + if om.is_dict(new_config): + assert isinstance(new_config, DictConfig) + + if hasattr(new_config, "name") and new_config.name == "decoupled_lionw": + new_config.name = "lionw" + if hasattr(new_config, "eps"): + del new_config.eps + + return new_config + + +class SchedulerType(StrEnum): + cosine_with_warmup = "cosine_with_warmup" + linear_with_warmup = "linear_with_warmup" + inverse_sqrt_with_warmup = "inverse_sqrt_with_warmup" + max_scheduler = "max_scheduler" + constant = "constant" + + +class SchedulerUnits(StrEnum): + steps = "steps" + tokens = "tokens" + + +@dataclass +class SchedulerConfig(BaseConfig): + name: SchedulerType = SchedulerType.cosine_with_warmup + units: SchedulerUnits = SchedulerUnits.steps + t_warmup: Union[int, float] = 100 + t_max: Optional[Union[int, float]] = None + alpha_f: float = 0.1 + + grad_clip_warmup_steps: Optional[Union[int, float]] = None + """ + The warmup period for which the max grad norm (or norm ratio) will be set to its + warmup value of `max_grad_norm * grad_clip_warmup_factor`. + """ + + grad_clip_warmup_factor: Optional[float] = None + """ + The ratio of the max allowed gradient norm (or norm ratio) for clipping during the warmup period + vs after the warmup period. + """ + + warmup_min_lr: Optional[float] = None + """ + The starting LR during the warmup period. If not set this defaults to 10% of + the target LR. + """ + + +class PaddingDirection(StrEnum): + right = "right" + left = "left" + + +@dataclass +class InstanceFilterConfig(BaseConfig): + repetition_max_period: int = 13 + repetition_min_period: int = 1 + repetition_max_count: int = 32 + + +@dataclass +class DataConfig(BaseConfig): + paths: Optional[List[str]] = None + memmap_dtype: str = "uint16" + datasets: Optional[Dict[str, List[str]]] = None + label_mask_paths: Optional[List[str]] = None + pad_direction: PaddingDirection = PaddingDirection.right + generate_attention_mask: bool = False + num_workers: int = 0 + drop_last: bool = False + pin_memory: bool = False + prefetch_factor: Optional[int] = None + persistent_workers: bool = False + timeout: int = 0 + seed: Optional[int] = None + instance_filter: Optional[InstanceFilterConfig] = None + + @property + def effective_memmap_dtype(self): + if self.memmap_dtype == "uint8": + return np.uint8 + if self.memmap_dtype == "uint16": + return np.uint16 + elif self.memmap_dtype == "uint32": + return np.uint32 + elif self.memmap_dtype == "uint64": + return np.uint64 + # default to uint16 if not set + return np.uint16 + + +class EvaluatorType(StrEnum): + downstream = "downstream" + lm = "lm" + + +@dataclass +class EvaluatorConfig(BaseConfig): + label: str + type: EvaluatorType = EvaluatorType.lm + data: DataConfig = field(default_factory=DataConfig) + device_eval_batch_size: Optional[int] = None + subset_num_batches: Optional[int] = None + + +class TruncationDirection(StrEnum): + right = "right" + left = "left" + + +@dataclass +class TokenizerConfig(BaseConfig): + identifier: str = "gpt2" + truncate_direction: TruncationDirection = TruncationDirection.right + + +@dataclass +class WandbConfig(BaseConfig): + project: Optional[str] = None + entity: Optional[str] = "ai2-llm" + group: Optional[str] = None + name: Optional[str] = None + tags: Optional[List[str]] = field(default_factory=lambda: ["watching"]) + log_artifacts: bool = False + rank_zero_only: bool = True + log_interval: int = 1 + + +@dataclass +class SpeedMonitorConfig(BaseConfig): + window_size: int = 100 + gpu_flops_available: Optional[Union[float, int]] = None + + +@dataclass +class CompilerConfig(BaseConfig): + mode: Optional[str] = None + """ + The mode to compile the model in. At the moment this can be "default", + "reduce-overhead" (useful for smaller models/batches), or "max-autotune" + (the fastest for larger models, but takes a long time to compile). + """ + + fullgraph: bool = False + """ + Whether it is OK to break model into several subgraphs when compiling. + Note that this is not compatible with FSDP. + """ + + backend: str = "inductor" + """ + The backend to use. + """ + + +class FSDPWrapStrategy(StrEnum): + by_block = "by_block" + """ + Wrap each OLMo block with its own FSDP instance. + """ + + by_block_and_size = "by_block_and_size" + """ + Like 'by_block' but `wte` and `ff_out` will be wrapped separately as well. + """ + + by_block_group = "by_block_group" + """ + Wrap each block group together into its own FSDP instance. + This requires :attr:`~ModelConfig.block_group_size` to be bigger than 1. + """ + + by_block_group_and_size = "by_block_group_and_size" + """ + Like 'by_block_group' but `wte` and `ff_out` will be wrapped separately as well. + """ + + size_based = "size_based" + """ + Used PyTorch's default size-based auto wrap policy. + """ + + one_in_two = "one_in_two" + one_in_three = "one_in_three" + one_in_four = "one_in_four" + one_in_five = "one_in_five" + + +class FSDPPrecision(StrEnum): + pure = "pure" + """ + Equivalent to :class:`torch.distributed.fsdp.MixedPrecision` with ``param_dtype``, ``reduce_dtype``, + and ``buffer_dtype`` all set to the autocast precision data type. + """ + + mixed = "mixed" + """ + Equivalent to :class:`torch.distributed.fsdp.MixedPrecision` with ``param_dtype``, and ``buffer_dtype`` + set to the autocast precision data type, while ``reduce_dtype`` is set to fp32. + """ + + +@dataclass +class FSDPConfig(BaseConfig): + use_orig_params: bool = True + """ + This must be ``True`` if using ``compile`` or you want to track the parameter norm during training. + """ + + sharding_strategy: ShardingStrategy = ShardingStrategy.FULL_SHARD + + wrapping_strategy: Optional[FSDPWrapStrategy] = None + """ + The wrapping strategy to use. If ``None``, the default, the model is wrapped with a single top-level + FSDP instance. + """ + + precision: FSDPPrecision = FSDPPrecision.pure + + hybrid_sharding_num_model_replicas: Optional[int] = None + """ + The number of model instances, when using a hybrid sharding strategy. + If not ``None``, this must divide the total number of nodes. If ``None``, the default, + a model instance is used per node (as determined by ``get_world_size() // get_local_world_size()``). + PyTorch's default HSDP behavior matches this default behavior. + """ + + +class CheckpointType(StrEnum): + sharded = "sharded" + unsharded = "unsharded" + sharded_ephemeral = "sharded_ephemeral" + + +class ShardedCheckpointerType(StrEnum): + torch_new = "torch_new" + torch_legacy = "torch_legacy" + local = "local" + olmo_core = "olmo_core" + + +class ActivationCheckpointingStrategy(StrEnum): + whole_layer = "whole_layer" + """ + Checkpoint every transformer layer. + """ + + one_in_two = "one_in_two" + """ + Checkpoint one in two transformer layers. + """ + + one_in_three = "one_in_three" + """ + Checkpoint one in three transformer layers. + """ + + one_in_four = "one_in_four" + """ + Checkpoint one in four transformer layers. + """ + + two_in_three = "two_in_three" + """ + Checkpoint two out of every three transformer layers. + """ + + three_in_four = "three_in_four" + """ + Checkpoint three out of four of every transformer layers. + """ + + fine_grained = "fine_grained" + """ + Focus checkpointing on where it is cheap to recompute and saves most memory. + """ + + +@dataclass +class TrainConfig(BaseConfig): + """ + OLMo training configuration. + """ + + run_name: Optional[str] = None + """ + The name of the run. + """ + + seed: int = 6198 + """ + Used to seed all initial RNG states. + """ + + epoch: Optional[int] = None + """ + Increment this when starting a new epoch. + """ + + dry_run: bool = False + """ + If ``True``, don't actually train. + """ + + model: ModelConfig = field(default_factory=ModelConfig) + """ + OLMo Model configuration. + """ + + optimizer: OptimizerConfig = field(default_factory=OptimizerConfig) + """ + Optimizer configuration. + """ + + scheduler: SchedulerConfig = field(default_factory=SchedulerConfig) + """ + Learning rate scheduler configuration. + """ + + data: DataConfig = field(default_factory=DataConfig) + """ + Training data configuration. + """ + + restore_dataloader: bool = True + """ + When restarting, restore the data loader to where it left off. + If you restarting in order to train on a different dataset, set this to ``False``. + """ + + fast_forward_batches: Optional[int] = None + """ + When restarting, use this to fast-forward the dataloader beyond the last checkpoint. + This can be useful when restarting due to a loss spike in order to skip the data that + corresponded to the spike. + """ + + evaluators: List[EvaluatorConfig] = field(default_factory=list) + """ + Evaluation configurations. + """ + + eval_interval: int = 1000 + """ + How often (in terms of batches) to run evaluations. + """ + + tokenizer: TokenizerConfig = field(default_factory=TokenizerConfig) + """ + Tokenizer configuration. + """ + + save_folder: str = "./" + """ + The directory to save checkpoints to. + """ + + remote_save_folder: Optional[str] = None + """ + A folder in a cloud bucket to upload saved checkpoints to. + """ + + canceled_check_interval: int = 50 + """ + How often (in batches) to check if the run has been canceled or reached its time limit. + """ + + save_interval: int = 1000 + """ + How often (in terms of steps) to save sharded training state checkpoints. + """ + + save_interval_unsharded: Optional[int] = None + """ + How often (if at all) to save unsharded training state checkpoint. + For large models it can be costly to save these, so it usually makes sense to save + these less often than regular (sharded) training checkpoints. + """ + + save_interval_ephemeral: Optional[int] = None + """ + How often (if at all) to save ephemeral sharded checkpoints. These checkpoints are the same + as those saved every `save_interval` except that at most only the most recent one of these is kept. + This is useful when you want to checkpoint often for restarts in case of failures, but don't + want to keep the majority of these checkpoints. + + For example, suppose you want to keep your checkpoints at every 1000 steps, but you also want to save + a temporary checkpoint every 100 steps in case your job fails. In that case you would + set `save_interval=1000` and `save_interval_ephemeral=100`. + """ + + save_num_checkpoints_to_keep: int = -1 + """ + How many sharded checkpoints to keep. + """ + + save_num_unsharded_checkpoints_to_keep: int = -1 + """ + How many unsharded checkpoints to keep. + """ + + save_overwrite: bool = False + """ + If ``True``, overwrite any conflicting checkpoint files. + """ + + force_save_unsharded: bool = False + """ + Save an unsharded checkpoint before training (even during a dry run). + Use this option with `--load-path={PATH}` and `--dry_run` to convert a sharded + checkpoint into an unsharded checkpoint. + """ + + no_pre_train_checkpoint: bool = False + """ + Skip saving pre-train checkpoint. + """ + + load_path: Optional[str] = None + """ + The path to a training checkpoint to restore/resume from. + + Note that you can make use of the "path.last_checkpoint" Omegaconfig YAML resolver here, which takes + a local or remote directory and resolves to the latest checkpoint (sharded or unsharded) in that directory. + For example, + + ```bash + --load_path='${path.last_checkpoint:s3://ai2-llm/checkpoints/7b/v1_5-mix-run-001}' + ``` + """ + + load_path_sharded_checkpointer: Optional[ShardedCheckpointerType] = None + """ + The sharded checkpointer type to use to load the initial checkpoint from ``load_path``. + """ + + reset_optimizer_state: bool = False + """ + When this is set, we restore the model from a checkpoint (if given), but we leave the optimizer uninitialized. + We also set a new learning rate schedule that does a new warmup, such that it intercepts the original learning + curve (according to the current learning rate schedule settings), and continues from there. + """ + + reset_trainer_state: bool = False + """ + When this is set we don't restore the trainer state from a checkpoint. + """ + + sharded_checkpointer: ShardedCheckpointerType = ShardedCheckpointerType.torch_legacy + """ + The name of the sharded checkpointer to use to save (sharded) checkpoints throughout training. + """ + + new_style_checkpoints: Optional[bool] = None + """ + Deprecated. Use ``sharded_checkpointer`` instead. + """ + + max_duration: Union[int, str] = 10000 + """ + How long to train for. + + If specified without a unit (the default), the units are assumed to be steps. + You can also specify this in terms of tokens, for example: `max_duration="2e12T"` means train until + 2 trillion tokens. + """ + + global_train_batch_size: int = 512 + """ + The effective global batch size. + """ + + device_train_batch_size: Optional[int] = None # calculated automatically + """ + Don't set this manually. This will be set to ``global_train_batch_size // world_size``. + """ + + device_train_microbatch_size: int = 16 + """ + The number of instances passed to the model in a single forward-backward pass. You should set + this as large as you can based on available GPU memory. + """ + + device_eval_batch_size: int = 16 + """ + The number of evaluation instances passed to the model in a single forward pass on each device. + """ + + eval_subset_num_batches: int = -1 + """ + The number of batches to use for downstream evaluation from each dataset. + """ + + eval_on_load: bool = False + """ + When resuming from a checkpoint, run the evaluation loop right away. + """ + + device_train_grad_accum: Optional[int] = None # calculated automatically + """ + Don't set this manually. This will be set to ``device_train_batch_size // device_train_microbatch_size``. + """ + + max_grad_norm: Optional[float] = None + """ + Clip gradient norms to this value if set. + """ + + max_grad_norm_ratio: Optional[float] = None + """ + If set, gradient norms will be clipped to `max_grad_norm_ratio * exp_avg(norm(grad))`. + This takes priority over `max_grad_norm` when set. + """ + + precision: Optional[str] = None + """ + Precision to train with (e.g. "amp_bf16", "amp_fp16", or "fp32"). + """ + + wandb: Optional[WandbConfig] = None + """ + Weights & Biases configuration. + """ + + speed_monitor: SpeedMonitorConfig = field(default_factory=SpeedMonitorConfig) + """ + Speed monitor configuration. + """ + + console_log_interval: int = 1 + """ + How often to log to the console. + """ + + gen1_gc_interval: Optional[int] = 1 + """ + How often (in steps) to run generation 1 garbage collection. + Set to ``None`` to use automatic garbage collection (i.e. we don't mess with it). + """ + + compile: Optional[CompilerConfig] = None + """ + Settings for compiling the model with ``torch.compile()``. + """ + + fsdp: FSDPConfig = field(default_factory=FSDPConfig) + """ + Fully sharded data parallel settings. + """ + + softmax_auxiliary_loss: bool = False + """ + If ``True``, we add the auxiliary loss function from PaLM that encourages the softmax + normalizing term to be close to 0. + """ + + time_limit: Optional[float] = None + """ + The maximum amount of time to train for before saving a checkpoint and ending early. + """ + + extra_steps_after_cancel: int = 10 + """ + Under certain conditions when a run is canceled we train for a few extra steps after saving + the final checkpoint so that when the run is restarted from the latest checkpoint we have some + overlap in metrics. + """ + + early_stopping_factor: Optional[float] = None + + save_data_indices: bool = True + """ + Save training data indices from each batch for each worker. + """ + + python_profiling: bool = False + """ + Whether to run the Python profiler on batches 6, 7, and 8. + """ + + torch_profiling: bool = False + """ + Whether to run the PyTorch profiler on batches 6, 7, and 8. + """ + + stop_at: Optional[int] = None + """ + Stop at a specific step. + """ + + stop_after: Optional[int] = None + """ + Stop after a specific number of steps. + """ + + activation_checkpointing: Optional[ActivationCheckpointingStrategy] = None + """ + The activation checkpointing strategy to use. + """ + + fused_loss: Optional[bool] = None + """ + Whether to use the fused CE loss function from `flash-attn`. + """ + + @property + def autocast_precision(self) -> torch.dtype: + if self.precision == "amp_bf16": + return torch.bfloat16 + elif self.precision == "amp_fp16": + return torch.float16 + elif self.precision == "fp32": + return torch.float32 + else: + raise ValueError(f"Unexpected precision type '{self.precision}'") + + @property + def fsdp_precision(self) -> MixedPrecision: + if self.fsdp.precision == FSDPPrecision.pure: + return MixedPrecision( + param_dtype=self.autocast_precision, + reduce_dtype=self.autocast_precision, + buffer_dtype=self.autocast_precision, + ) + elif self.fsdp.precision == FSDPPrecision.mixed: + return MixedPrecision( + param_dtype=self.autocast_precision, + reduce_dtype=torch.float32, + buffer_dtype=self.autocast_precision, + ) + else: + raise NotImplementedError(f"{self.fsdp.precision}") + + @classmethod + def update_legacy_settings(cls, config: D) -> D: + new_config = config.copy() + if om.is_dict(new_config): + assert isinstance(new_config, DictConfig) + + if hasattr(new_config, "activation_checkpointing"): + if new_config.activation_checkpointing is False: + new_config.activation_checkpointing = None + if new_config.activation_checkpointing is True: + new_config.activation_checkpointing = ActivationCheckpointingStrategy.whole_layer + + if hasattr(new_config, "optimizer"): + new_config.optimizer = OptimizerConfig.update_legacy_settings(new_config.optimizer) + + return new_config \ No newline at end of file diff --git a/3.test_cases/neuronx-distributed/olmo/olmo/datasets.py b/3.test_cases/neuronx-distributed/olmo/olmo/datasets.py new file mode 100644 index 00000000..95d1f28c --- /dev/null +++ b/3.test_cases/neuronx-distributed/olmo/olmo/datasets.py @@ -0,0 +1,135 @@ +import pickle + +import torch +from torch.utils.data import Dataset + +class AdditionDataset(Dataset): + """ + Creates n-digit addition problems. For example, if n=2, then an example + addition problem would be to add 85 + 50 = 135. This problem would be + represented as the following string for the GPT: + + "8550531" + + This is because: + - we are discarding the + and =, which are not necessary. We just encode the digits + of the input numbers concatenated together. + - the result 135 is encoded backwards to make the addition easier to learn for the + GPT model, because of how the addition algorithm works. + + As one more example, the problem 6 + 39 = 45 would be encoded as: + + "0639054" + + where you will notice that we are padding with zeros to make sure that we always + produce strings of the exact same size: n + n + (n + 1). When n=2, this is 7. + At test time, we will feed in an addition problem by giving the first 2n digits, + and hoping that the GPT model completes the sequence with the next (n+1) digits + correctly. + """ + + def __init__(self, split, ndigit=2): + self.split = split # train/test + + # split up all addition problems into either training data or test data + self.ndigit = ndigit + assert ndigit <= 3, "the lines below would be very memory inefficient, in future maybe refactor to support" + num = (10**ndigit)**2 # total number of possible addition problems with ndigit numbers + rng = torch.Generator() + rng.manual_seed(1337) + perm = torch.randperm(num, generator=rng) + num_test = min(int(num*0.2), 500) # 20% of the whole dataset, or only up to 500 + self.ixes = perm[:num_test] if split == 'test' else perm[num_test:] + + def get_vocab_size(self): + return 10 # digits 0..9 + + def get_block_size(self): + # a,b,a+b, and +1 due to potential carry overflow, + # but then also -1 because very last digit doesn't ever plug back + # as there is no explicit token to predict, it is implied + return 3*self.ndigit + 1 - 1 + + def __len__(self): + return self.ixes.nelement() + + def __getitem__(self, idx): + ndigit = self.ndigit + # given a problem index idx, first recover the associated a + b + idx = self.ixes[idx].item() + nd = 10**ndigit + a = idx // nd + b = idx % nd + # calculate the "label" of the addition problem a + b + c = a + b + # encode the digits of a, b, c into strings + astr = f'%0{ndigit}d' % a + bstr = f'%0{ndigit}d' % b + cstr = (f'%0{ndigit+1}d' % c)[::-1] # reverse c to make addition easier + render = astr + bstr + cstr + dix = [int(s) for s in render] # convert each character to its token index + # x will be input to GPT and y will be the associated expected outputs + x = torch.tensor(dix[:-1], dtype=torch.long) + y = torch.tensor(dix[1:], dtype=torch.long) # predict the next token in the sequence + y[:ndigit*2-1] = -1 # we will only train in the output locations. -1 will mask loss to zero + return x, y + +class SortDataset(Dataset): + """ + Dataset for the Sort problem. E.g. for problem length 6: + Input: 0 0 2 1 0 1 -> Output: 0 0 0 1 1 2 + Which will feed into the transformer concatenated as: + input: 0 0 2 1 0 1 0 0 0 1 1 + output: I I I I I 0 0 0 1 1 2 + where I is "ignore", as the transformer is reading the input sequence + """ + + def __init__(self, split, length=6, num_digits=3): + assert split in {'train', 'test'} + self.split = split + self.length = length + self.num_digits = num_digits + + def __len__(self): + return 10000 # ... + + def get_vocab_size(self): + return self.num_digits + + def get_block_size(self): + # the length of the sequence that will feed into transformer, + # containing concatenated input and the output, but -1 because + # the transformer starts making predictions at the last input element + return self.length * 2 - 1 + + def __getitem__(self, idx): + + # use rejection sampling to generate an input example from the desired split + while True: + # generate some random integers + inp = torch.randint(self.num_digits, size=(self.length,), dtype=torch.long) + # half of the time let's try to boost the number of examples that + # have a large number of repeats, as this is what the model seems to struggle + # with later in training, and they are kind of rate + if torch.rand(1).item() < 0.5: + if inp.unique().nelement() > self.length // 2: + # too many unqiue digits, re-sample + continue + # figure out if this generated example is train or test based on its hash + h = hash(pickle.dumps(inp.tolist())) + inp_split = 'test' if h % 4 == 0 else 'train' # designate 25% of examples as test + if inp_split == self.split: + break # ok + + # solve the task: i.e. sort + sol = torch.sort(inp)[0] + + # concatenate the problem specification and the solution + cat = torch.cat((inp, sol), dim=0) + + # the inputs to the transformer will be the offset sequence + x = cat[:-1].clone() + y = cat[1:].clone() + # we only want to predict at output locations, mask out the loss at the input locations + y[:self.length-1] = -1 + return x, y diff --git a/3.test_cases/neuronx-distributed/olmo/olmo/exceptions.py b/3.test_cases/neuronx-distributed/olmo/olmo/exceptions.py new file mode 100644 index 00000000..9670b4b2 --- /dev/null +++ b/3.test_cases/neuronx-distributed/olmo/olmo/exceptions.py @@ -0,0 +1,50 @@ +__all__ = [ + "OLMoError", + "OLMoConfigurationError", + "OLMoCliError", + "OLMoEnvironmentError", + "OLMoNetworkError", + "OLMoCheckpointError", +] + + +class OLMoError(Exception): + """ + Base class for all custom OLMo exceptions. + """ + + +class OLMoConfigurationError(OLMoError): + """ + An error with a configuration file. + """ + + +class OLMoCliError(OLMoError): + """ + An error from incorrect CLI usage. + """ + + +class OLMoEnvironmentError(OLMoError): + """ + An error from incorrect environment variables. + """ + + +class OLMoNetworkError(OLMoError): + """ + An error with a network request. + """ + + +class OLMoCheckpointError(OLMoError): + """ + An error occurred reading or writing from a checkpoint. + """ + + +class OLMoThreadError(Exception): + """ + Raised when a thread fails. + """ \ No newline at end of file diff --git a/3.test_cases/neuronx-distributed/olmo/olmo/initialization.py b/3.test_cases/neuronx-distributed/olmo/olmo/initialization.py new file mode 100644 index 00000000..9e4d9543 --- /dev/null +++ b/3.test_cases/neuronx-distributed/olmo/olmo/initialization.py @@ -0,0 +1,22 @@ +from typing import Optional, Union + +import torch.nn as nn + +__all__ = ["init_normal"] + + +def init_normal( + module: Union[nn.Linear, nn.Embedding], + std: float, + init_cutoff_factor: Optional[float] = None, +): + # weights + if init_cutoff_factor is not None: + cutoff_value = init_cutoff_factor * std + nn.init.trunc_normal_(module.weight, mean=0.0, std=std, a=-cutoff_value, b=cutoff_value) + else: + nn.init.normal_(module.weight, mean=0.0, std=std) + + # biases + if isinstance(module, nn.Linear) and module.bias is not None: + nn.init.zeros_(module.bias) \ No newline at end of file diff --git a/3.test_cases/neuronx-distributed/olmo/olmo/model.py b/3.test_cases/neuronx-distributed/olmo/olmo/model.py new file mode 100644 index 00000000..f9e3c011 --- /dev/null +++ b/3.test_cases/neuronx-distributed/olmo/olmo/model.py @@ -0,0 +1,1689 @@ +""" +Adapted from +[MosaiclML](https://github.com/mosaicml/examples.git) and +[minGPT](https://github.com/karpathy/minGPT.git) +""" + +from __future__ import annotations + +import logging +import math +import sys +from abc import abstractmethod +from collections import defaultdict +from functools import partial +from typing import ( + Callable, + Dict, + Iterable, + List, + NamedTuple, + Optional, + Sequence, + Set, + Tuple, + cast, +) + +import torch +import torch.backends.cuda +import torch.nn as nn +import torch.nn.functional as F +from torch import einsum + +from .aliases import PathOrStr +from .beam_search import BeamSearch, Constraint, FinalSequenceScorer, Sampler +from .config import ( + ActivationCheckpointingStrategy, + ActivationType, + BlockType, + CheckpointType, + FSDPWrapStrategy, + InitFnType, + LayerNormType, + ModelConfig, +) +from .exceptions import OLMoConfigurationError +from .initialization import init_normal +from .torch_util import ensure_finite_ + +if sys.version_info.minor > 8: + from collections.abc import MutableMapping +elif sys.version_info.minor == 8: + from typing import MutableMapping +else: + raise SystemExit("This script supports Python 3.8 or higher") + +__all__ = [ + "LayerNormBase", + "LayerNorm", + "RMSLayerNorm", + "RotaryEmbedding", + "Activation", + "GELU", + "ReLU", + "SwiGLU", + "OLMoBlock", + "OLMoSequentialBlock", + "OLMo", + "OLMoOutput", + "OLMoGenerateOutput", +] + + +log = logging.getLogger(__name__) + + +def activation_checkpoint_function(cfg: ModelConfig): + preserve_rng_state = ( + (cfg.attention_dropout == 0.0) and (cfg.embedding_dropout == 0.0) and (cfg.residual_dropout == 0.0) + ) + from torch.utils.checkpoint import checkpoint + + return partial( + checkpoint, + preserve_rng_state=preserve_rng_state, + use_reentrant=False, + ) + + +def should_checkpoint_block(strategy: Optional[ActivationCheckpointingStrategy], block_idx: int) -> bool: + if strategy is None: + return False + elif ( + (strategy == ActivationCheckpointingStrategy.whole_layer) + or (strategy == ActivationCheckpointingStrategy.one_in_two and block_idx % 2 == 0) + or (strategy == ActivationCheckpointingStrategy.one_in_three and block_idx % 3 == 0) + or (strategy == ActivationCheckpointingStrategy.one_in_four and block_idx % 4 == 0) + or (strategy == ActivationCheckpointingStrategy.two_in_three and block_idx % 3 != 0) + or (strategy == ActivationCheckpointingStrategy.three_in_four and block_idx % 4 != 0) + ): + return True + else: + return False + + +class BufferCache(dict, MutableMapping[str, torch.Tensor]): + """ + Cache for attention biases and other things that would normally be stored as buffers. + We avoid using buffers because we've run into various issues doing so with FSDP. + In general it appears the way FSDP handles buffers is not well-defined. + It doesn't shard them but apparently it does synchronize them across processes, which we want to avoid + since (A) it isn't necessary, and (B) we sometimes have `-inf` in these biases which might get turned into + NaNs when they're synchronized due to casting or some other issue. + """ + + +def _non_meta_init_device(config: ModelConfig) -> torch.device: + if config.init_device is not None and config.init_device != "meta": + return torch.device(config.init_device) + else: + return torch.device("cuda" if torch.cuda.is_available() else "cpu") + + +class Dropout(nn.Dropout): + def forward(self, input: torch.Tensor) -> torch.Tensor: + if self.p == 0.0: + return input + else: + return F.dropout(input, self.p, self.training, self.inplace) + + +class LayerNormBase(nn.Module): + def __init__( + self, + config: ModelConfig, + *, + size: Optional[int] = None, + elementwise_affine: Optional[bool] = True, + eps: float = 1e-05, + ): + super().__init__() + self.config = config + self.eps = eps + self.normalized_shape = (size or config.d_model,) + if elementwise_affine or (elementwise_affine is None and self.config.layer_norm_with_affine): + self.weight = nn.Parameter(torch.ones(self.normalized_shape, device=config.init_device)) + use_bias = self.config.bias_for_layer_norm + if use_bias is None: + use_bias = self.config.include_bias + if use_bias: + self.bias = nn.Parameter(torch.zeros(self.normalized_shape, device=config.init_device)) + else: + self.register_parameter("bias", None) + else: + self.register_parameter("bias", None) + self.register_parameter("weight", None) + + @abstractmethod + def forward(self, x: torch.Tensor) -> torch.Tensor: + raise NotImplementedError + + @classmethod + def build(cls, config: ModelConfig, size: Optional[int] = None, **kwargs) -> LayerNormBase: + if config.layer_norm_type == LayerNormType.default: + return LayerNorm(config, size=size, low_precision=False, **kwargs) + elif config.layer_norm_type == LayerNormType.low_precision: + return LayerNorm(config, size=size, low_precision=True, **kwargs) + elif config.layer_norm_type == LayerNormType.rms: + return RMSLayerNorm(config, size=size, **kwargs) + else: + raise NotImplementedError(f"Unknown LayerNorm type: '{config.layer_norm_type}'") + + def _cast_if_autocast_enabled(self, tensor: torch.Tensor, dtype: Optional[torch.dtype] = None) -> torch.Tensor: + # NOTE: `is_autocast_enabled()` only checks for CUDA autocast, so we use the separate function + # `is_autocast_cpu_enabled()` for CPU autocast. + # See https://github.com/pytorch/pytorch/issues/110966. + if tensor.device.type == "cuda" and torch.is_autocast_enabled(): + return tensor.to(dtype=dtype if dtype is not None else torch.get_autocast_gpu_dtype()) + elif tensor.device.type == "cpu" and torch.is_autocast_cpu_enabled(): + return tensor.to(dtype=dtype if dtype is not None else torch.get_autocast_cpu_dtype()) + else: + return tensor + + def reset_parameters(self): + if self.weight is not None: + torch.nn.init.ones_(self.weight) # type: ignore + if self.bias is not None: + torch.nn.init.zeros_(self.bias) # type: ignore + + +class LayerNorm(LayerNormBase): + """ + The default :class:`LayerNorm` implementation which can optionally run in low precision. + """ + + def __init__( + self, + config: ModelConfig, + size: Optional[int] = None, + low_precision: bool = False, + elementwise_affine: Optional[bool] = None, + eps: float = 1e-05, + ): + super().__init__(config, size=size, elementwise_affine=elementwise_affine, eps=eps) + self.low_precision = low_precision + + def forward(self, x: torch.Tensor) -> torch.Tensor: + if self.low_precision: + module_device = x.device + downcast_x = self._cast_if_autocast_enabled(x) + downcast_weight = ( + self._cast_if_autocast_enabled(self.weight) if self.weight is not None else self.weight + ) + downcast_bias = self._cast_if_autocast_enabled(self.bias) if self.bias is not None else self.bias + with torch.autocast(enabled=False, device_type=module_device.type): + return F.layer_norm( + downcast_x, self.normalized_shape, weight=downcast_weight, bias=downcast_bias, eps=self.eps + ) + else: + return F.layer_norm(x, self.normalized_shape, weight=self.weight, bias=self.bias, eps=self.eps) + + +class RMSLayerNorm(LayerNormBase): + """ + RMS layer norm, a simplified :class:`LayerNorm` implementation + """ + + def __init__( + self, + config: ModelConfig, + size: Optional[int] = None, + elementwise_affine: Optional[bool] = None, + eps: float = 1e-5, + ): + super().__init__(config, size=size, elementwise_affine=elementwise_affine, eps=eps) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + with torch.autocast(enabled=False, device_type=x.device.type): + og_dtype = x.dtype + x = x.to(torch.float32) + variance = x.pow(2).mean(-1, keepdim=True) + x = x * torch.rsqrt(variance + self.eps) + x = x.to(og_dtype) + + if self.weight is not None: + if self.bias is not None: + return self.weight * x + self.bias + else: + return self.weight * x + else: + return x + + +class RotaryEmbedding(nn.Module): + """ + [Rotary positional embeddings (RoPE)](https://arxiv.org/abs/2104.09864). + """ + + def __init__(self, config: ModelConfig, cache: BufferCache): + super().__init__() + self.config = config + self.__cache = cache + # Warm up cache. + self.get_rotary_embedding(config.max_sequence_length, _non_meta_init_device(config)) + + def get_rotary_embedding(self, seq_len: int, device: torch.device) -> Tuple[torch.Tensor, torch.Tensor]: + if ( + (pos_sin := self.__cache.get("rope_pos_sin")) is not None + and (pos_cos := self.__cache.get("rope_pos_cos")) is not None + and pos_sin.shape[-2] >= seq_len + and pos_cos.shape[-2] >= seq_len + ): + if pos_sin.device != device: + pos_sin = pos_sin.to(device) + self.__cache["rope_pos_sin"] = pos_sin + if pos_cos.device != device: + pos_cos = pos_cos.to(device) + self.__cache["rope_pos_cos"] = pos_cos + return pos_sin[:, :, :seq_len, :], pos_cos[:, :, :seq_len, :] + + with torch.autocast(device.type, enabled=False): + dim = self.config.d_model // self.config.n_heads + inv_freq = 1.0 / (10000 ** (torch.arange(0, dim, 2, device=device, dtype=torch.float) / dim)) + seq = torch.arange(seq_len, device=device, dtype=torch.float) + freqs = einsum("i , j -> i j", seq, inv_freq) + positions = torch.cat((freqs, freqs), dim=-1) + pos_sin, pos_cos = positions.sin()[None, None, :, :], positions.cos()[None, None, :, :] + self.__cache["rope_pos_sin"] = pos_sin + self.__cache["rope_pos_cos"] = pos_cos + return pos_sin, pos_cos + + def rotate_half(self, x: torch.Tensor) -> torch.Tensor: + B, nh, T, hs = x.size() + x = x.view(B, nh, T, 2, hs // 2) + x1, x2 = x.unbind(dim=-2) + return torch.cat((-x2, x1), dim=-1) + + def apply_rotary_pos_emb(self, pos_sin: torch.Tensor, pos_cos: torch.Tensor, t: torch.Tensor) -> torch.Tensor: + return ((t * pos_cos) + (self.rotate_half(t) * pos_sin)).to(t.dtype) + + def forward(self, q: torch.Tensor, k: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]: + if self.config.rope_full_precision: + q_, k_ = q.float(), k.float() + else: + q_, k_ = q, k + + with torch.autocast(q.device.type, enabled=False): + query_len, key_len = q_.shape[-2], k_.shape[-2] # could be different if layer_past not None + pos_sin, pos_cos = self.get_rotary_embedding(key_len, q_.device) + pos_sin = pos_sin.type_as(q_) + pos_cos = pos_cos.type_as(q_) + q_ = self.apply_rotary_pos_emb( + pos_sin[:, :, key_len - query_len : key_len, :], + pos_cos[:, :, key_len - query_len : key_len, :], + q_, + ) + k_ = self.apply_rotary_pos_emb(pos_sin, pos_cos, k_) + return q_.type_as(q), k_.type_as(k) + + +class Activation(nn.Module): + def __init__(self, config: ModelConfig): + super().__init__() + self.config = config + + @abstractmethod + def forward(self, x: torch.Tensor) -> torch.Tensor: + raise NotImplementedError + + @property + @abstractmethod + def output_multiplier(self) -> float: + raise NotImplementedError + + @classmethod + def build(cls, config: ModelConfig) -> Activation: + if config.activation_type == ActivationType.gelu: + return cast(Activation, GELU(approximate="none")) + elif config.activation_type == ActivationType.relu: + return cast(Activation, ReLU(inplace=False)) + elif config.activation_type == ActivationType.swiglu: + return SwiGLU(config) + else: + raise NotImplementedError(f"Unknown activation: '{config.activation_type}'") + + +class GELU(nn.GELU): + @property + def output_multiplier(self) -> float: + return 1.0 + + +class ReLU(nn.ReLU): + @property + def output_multiplier(self) -> float: + return 1.0 + + +class SwiGLU(Activation): + def forward(self, x: torch.Tensor) -> torch.Tensor: + x, gate = x.chunk(2, dim=-1) + return F.silu(gate) * x + + @property + def output_multiplier(self) -> float: + return 0.5 + + +def causal_attention_bias(seq_len: int, device: torch.device) -> torch.FloatTensor: + att_bias = torch.triu( + torch.ones(seq_len, seq_len, device=device, dtype=torch.float), + diagonal=1, + ) + att_bias.masked_fill_(att_bias == 1, torch.finfo(att_bias.dtype).min) + return att_bias.view(1, 1, seq_len, seq_len) # type: ignore + + +def get_causal_attention_bias(cache: BufferCache, seq_len: int, device: torch.device) -> torch.Tensor: + if (causal_bias := cache.get("causal_attention_bias")) is not None and causal_bias.shape[-1] >= seq_len: + if causal_bias.device != device: + causal_bias = causal_bias.to(device) + cache["causal_attention_bias"] = causal_bias + return causal_bias + with torch.autocast(device.type, enabled=False): + causal_bias = causal_attention_bias(seq_len, device) + cache["causal_attention_bias"] = causal_bias + return causal_bias + + +def alibi_attention_bias(seq_len: int, config: ModelConfig, device: torch.device) -> torch.FloatTensor: + alibi_bias = torch.arange(1 - seq_len, 1, dtype=torch.float, device=device).view(1, 1, 1, seq_len) + + # shape: (1, 1, seq_len, seq_len) + alibi_bias = alibi_bias - torch.arange(1 - seq_len, 1, dtype=torch.float, device=device).view(1, 1, seq_len, 1) + alibi_bias.abs_().mul_(-1) + + # shape: (n_heads,) + m = torch.arange(1, config.n_heads + 1, dtype=torch.float, device=device) + m.mul_(config.alibi_bias_max / config.n_heads) + + # shape: (1, n_heads, seq_len, seq_len) + return alibi_bias * (1.0 / (2 ** m.view(1, config.n_heads, 1, 1))) # type: ignore + + +class OLMoBlock(nn.Module): + """ + A base class for transformer block implementations. + """ + + def __init__(self, layer_id: int, config: ModelConfig, cache: BufferCache): + super().__init__() + self.layer_id = layer_id + self.config = config + self.hidden_size = ( + config.mlp_hidden_size if config.mlp_hidden_size is not None else config.mlp_ratio * config.d_model + ) + self.__cache = cache + assert config.d_model % config.n_heads == 0 + + self._activation_checkpoint_fn = None + + # Dropout. + self.dropout = Dropout(config.residual_dropout) + + # Layer norms. + self.k_norm: Optional[LayerNormBase] = None + self.q_norm: Optional[LayerNormBase] = None + if config.attention_layer_norm: + assert config.effective_n_kv_heads is not None + self.k_norm = LayerNormBase.build( + config, + size=(config.d_model // config.n_heads) * config.effective_n_kv_heads, + elementwise_affine=config.attention_layer_norm_with_affine, + ) + self.q_norm = LayerNormBase.build(config, elementwise_affine=config.attention_layer_norm_with_affine) + + # Make sure QKV clip coefficient is positive, otherwise it's not well-defined. + if config.clip_qkv is not None: + assert config.clip_qkv > 0 + + # Activation function. + self.act = Activation.build(config) + assert (self.act.output_multiplier * self.hidden_size) % 1 == 0 + + # Attention output projection. + self.attn_out = nn.Linear( + config.d_model, config.d_model, bias=config.include_bias, device=config.init_device + ) + + # Feed-forward output projection. + self.ff_out = nn.Linear( + int(self.act.output_multiplier * self.hidden_size), + config.d_model, + bias=config.include_bias, + device=config.init_device, + ) + self.ff_out._is_residual = True # type: ignore + + # Rotary embeddings. + if self.config.rope: + self.rotary_emb = RotaryEmbedding(config, self.__cache) + + self.flash_attn_func = None + if config.flash_attention: + try: + from flash_attn import flash_attn_func # type: ignore + + self.flash_attn_func = flash_attn_func + except ModuleNotFoundError: + pass + + def reset_parameters(self): + if self.k_norm is not None: + self.k_norm.reset_parameters() + if self.q_norm is not None: + self.q_norm.reset_parameters() + + if self.config.init_fn == InitFnType.normal: + attn_out_std = ff_out_std = self.config.init_std + cutoff_factor = self.config.init_cutoff_factor + + elif self.config.init_fn == InitFnType.mitchell: + attn_out_std = 1 / (math.sqrt(2 * self.config.d_model * (self.layer_id + 1))) + ff_out_std = 1 / (math.sqrt(2 * self.ff_out.in_features * (self.layer_id + 1))) + cutoff_factor = self.config.init_cutoff_factor or 3.0 + + elif self.config.init_fn == InitFnType.full_megatron: + attn_out_std = ff_out_std = self.config.init_std / math.sqrt(2.0 * self.config.n_layers) + cutoff_factor = self.config.init_cutoff_factor or 3.0 + + else: + raise NotImplementedError(self.config.init_fn) + + init_normal(self.attn_out, std=attn_out_std, init_cutoff_factor=cutoff_factor) + init_normal(self.ff_out, std=ff_out_std, init_cutoff_factor=cutoff_factor) + + def set_activation_checkpointing(self, strategy: Optional[ActivationCheckpointingStrategy]): + if strategy == ActivationCheckpointingStrategy.fine_grained: + self._activation_checkpoint_fn = activation_checkpoint_function(self.config) + else: + self._activation_checkpoint_fn = None + + @classmethod + def _cast_attn_bias(cls, bias: torch.Tensor, input_dtype: torch.dtype) -> torch.Tensor: + target_dtype = input_dtype + # NOTE: `is_autocast_enabled()` only checks for CUDA autocast, so we use the separate function + # `is_autocast_cpu_enabled()` for CPU autocast. + # See https://github.com/pytorch/pytorch/issues/110966. + if bias.device.type == "cuda" and torch.is_autocast_enabled(): + target_dtype = torch.get_autocast_gpu_dtype() + elif bias.device.type == "cpu" and torch.is_autocast_cpu_enabled(): + target_dtype = torch.get_autocast_cpu_dtype() + if bias.dtype != target_dtype: + bias = bias.to(target_dtype) + ensure_finite_(bias, check_neg_inf=True, check_pos_inf=False) + return bias + + def _scaled_dot_product_attention( + self, + q: torch.Tensor, + k: torch.Tensor, + v: torch.Tensor, + attn_mask: Optional[torch.Tensor] = None, + dropout_p: float = 0.0, + is_causal: bool = False, + ) -> torch.Tensor: + """ + Computes scaled dot product attention on query, key and value tensors, using an optional + attention mask if passed, and applying dropout if a probability greater than 0.0 is specified. + """ + if self.flash_attn_func is not None and attn_mask is None: + r = self.flash_attn_func( + q.transpose(1, 2), k.transpose(1, 2), v.transpose(1, 2), dropout_p=dropout_p, causal=is_causal + ) + return r.transpose(1, 2) + else: + # torch's sdpa doesn't support GQA, so we're doing this + assert k.size(1) == v.size(1) + num_kv_heads = k.size(1) + num_q_heads = q.size(1) + if num_q_heads != num_kv_heads: + assert num_q_heads % num_kv_heads == 0 + k = k.repeat_interleave(num_q_heads // num_kv_heads, dim=1, output_size=num_q_heads) + v = v.repeat_interleave(num_q_heads // num_kv_heads, dim=1, output_size=num_q_heads) + + return F.scaled_dot_product_attention( + q, + k, + v, + attn_mask=attn_mask, + dropout_p=dropout_p, + is_causal=is_causal, + ) + + def attention( + self, + q: torch.Tensor, + k: torch.Tensor, + v: torch.Tensor, + attention_bias: Optional[torch.Tensor] = None, + layer_past: Optional[Tuple[torch.Tensor, torch.Tensor]] = None, + use_cache: bool = False, + ) -> Tuple[torch.Tensor, Optional[Tuple[torch.Tensor, torch.Tensor]]]: + B, T, C = q.size() # batch size, sequence length, d_model + dtype = k.dtype + + # Optionally apply layer norm to keys and queries. + if self.q_norm is not None and self.k_norm is not None: + q = self.q_norm(q).to(dtype=dtype) + k = self.k_norm(k).to(dtype=dtype) + + # Move head forward to be next to the batch dim. + # shape: (B, nh, T, hs) + q = q.view(B, T, self.config.n_heads, C // self.config.n_heads).transpose(1, 2) + # shape: (B, n_kv_h, T, hs) + k = k.view(B, T, self.config.effective_n_kv_heads, C // self.config.n_heads).transpose(1, 2) + # shape: (B, n_kv_h, T, hs) + v = v.view(B, T, self.config.effective_n_kv_heads, C // self.config.n_heads).transpose(1, 2) + + if layer_past is not None: + past_key, past_value = layer_past + k = torch.cat((past_key, k), dim=-2) + v = torch.cat((past_value, v), dim=-2) + + present = (k, v) if use_cache else None + query_len, key_len = q.shape[-2], k.shape[-2] # could be different if layer_past not None + + if self.config.rope: + # Apply rotary embeddings. + q, k = self.rotary_emb(q, k) + + if attention_bias is not None: + # Resize and cast attention bias. + # The current dtype of the attention bias might not match the dtype that the SDP attn function will + # run in if AMP is enabled, and this can be a problem if some tokens are masked out due to padding + # as down-casting the attention bias to the autocast precision will result in -infs, which will + # cause the SDP attn function to produce NaNs. + attention_bias = self._cast_attn_bias( + attention_bias[:, :, key_len - query_len : key_len, :key_len], dtype + ) + + # Get the attention scores. + # shape: (B, nh, T, hs) + att = self._scaled_dot_product_attention( + q, + k, + v, + attn_mask=attention_bias, + dropout_p=0.0 if not self.training else self.config.attention_dropout, + is_causal=attention_bias is None, + ) + + # Re-assemble all head outputs side-by-side. + att = att.transpose(1, 2).contiguous().view(B, T, C) + + # Apply output projection. + return self.attn_out(att), present + + @abstractmethod + def forward( + self, + x: torch.Tensor, + attention_bias: Optional[torch.FloatTensor] = None, + layer_past: Optional[Tuple[torch.Tensor, torch.Tensor]] = None, + use_cache: bool = False, + ) -> Tuple[torch.Tensor, Optional[Tuple[torch.Tensor, torch.Tensor]]]: + raise NotImplementedError + + @classmethod + def build(cls, layer_id: int, config: ModelConfig, cache: BufferCache) -> OLMoBlock: + if config.block_type == BlockType.sequential: + return OLMoSequentialBlock(layer_id, config, cache) + elif config.block_type == BlockType.llama: + return OLMoLlamaBlock(layer_id, config, cache) + else: + raise NotImplementedError(f"Unknown block type: '{config.block_type}'") + + +class OLMoSequentialBlock(OLMoBlock): + """ + This is a typical transformer block where the output is computed as ``MLP(LN(x + Attention(LN(x))))`` + (plus another skip connection). + """ + + def __init__(self, layer_id: int, config: ModelConfig, cache: BufferCache): + super().__init__(layer_id, config, cache) + # Layer norms. + self.attn_norm = LayerNorm.build(config) + self.ff_norm = LayerNorm.build(config) + # Attention input projection. Projects x -> (q, k, v) + + head_dim = config.d_model // config.n_heads + self.fused_dims = ( + config.d_model, + config.effective_n_kv_heads * head_dim, + config.effective_n_kv_heads * head_dim, + ) + self.att_proj = nn.Linear( + config.d_model, sum(self.fused_dims), bias=config.include_bias, device=config.init_device + ) + # Feed-forward input projection. + self.ff_proj = nn.Linear( + config.d_model, self.hidden_size, bias=config.include_bias, device=config.init_device + ) + + def reset_parameters(self): + super().reset_parameters() + self.attn_norm.reset_parameters() + self.ff_norm.reset_parameters() + # NOTE: the standard deviation for these weights does not depend on the layer. + + if self.config.init_fn == InitFnType.normal: + std = self.config.init_std + cutoff_factor = self.config.init_cutoff_factor + elif self.config.init_fn == InitFnType.mitchell: + std = 1 / math.sqrt(self.config.d_model) + cutoff_factor = self.config.init_cutoff_factor or 3.0 + elif self.config.init_fn == InitFnType.full_megatron: + std = self.config.init_std + cutoff_factor = self.config.init_cutoff_factor or 3.0 + else: + raise NotImplementedError(self.config.init_fn) + + init_normal(self.att_proj, std, cutoff_factor) + init_normal(self.ff_proj, std, cutoff_factor) + + def forward( + self, + x: torch.Tensor, + attention_bias: Optional[torch.Tensor] = None, + layer_past: Optional[Tuple[torch.Tensor, torch.Tensor]] = None, + use_cache: bool = False, + ) -> Tuple[torch.Tensor, Optional[Tuple[torch.Tensor, torch.Tensor]]]: + # Get query, key, value projections. + # shape: + # - for regular attn q, k, v: (batch_size, seq_len, d_model) + # - for multi-query attn q: (batch_size, seq_len, d_model) + # k, v: (batch_size, seq_len, d_model // n_heads) + # - for group query attn q: (batch_size, seq_len, d_model) + # k, v: (batch_size, seq_len, d_model // n_kv_heads) + if self._activation_checkpoint_fn is not None: + qkv = self.att_proj(self._activation_checkpoint_fn(self.attn_norm, x)) + else: + qkv = self.att_proj(self.attn_norm(x)) + + if self.config.clip_qkv is not None: + qkv.clamp_(min=-self.config.clip_qkv, max=self.config.clip_qkv) + + q, k, v = qkv.split(self.fused_dims, dim=-1) + + # Get attention scores. + if self._activation_checkpoint_fn is not None: + att, cache = self._activation_checkpoint_fn( # type: ignore + self.attention, q, k, v, attention_bias, layer_past=layer_past, use_cache=use_cache + ) + else: + att, cache = self.attention(q, k, v, attention_bias, layer_past=layer_past, use_cache=use_cache) + + # Add attention scores. + # shape: (B, T, C) + x = x + self.dropout(att) + + # Add feed-forward projection. + # shape: (batch_size, seq_len, d_model) + og_x = x + if self._activation_checkpoint_fn is not None: + x = self._activation_checkpoint_fn(self.ff_norm, x) # type: ignore + else: + x = self.ff_norm(x) + x = self.ff_proj(x) + if self._activation_checkpoint_fn is not None: + x = self._activation_checkpoint_fn(self.act, x) # type: ignore + else: + x = self.act(x) + x = self.ff_out(x) + x = self.dropout(x) + x = og_x + x + + return x, cache + + +class OLMoLlamaBlock(OLMoBlock): + """ + This is a transformer block where the output is computed as ``MLP(LN(x + Attention(LN(x))))`` + (plus another skip connection). This block is similar to `OLMoSequentialBlock` + but some operations have slightly different implementations to imitate the + behavior of Llama. + """ + + def __init__(self, layer_id: int, config: ModelConfig, cache: BufferCache): + super().__init__(layer_id, config, cache) + # Layer norms. + self.attn_norm = LayerNorm.build(config) + self.ff_norm = LayerNorm.build(config) + self.__cache = cache + + # Attention input projection. Projects x -> (q, k, v) + if config.multi_query_attention: + q_proj_out_dim = config.d_model + k_proj_out_dim = config.d_model // config.n_heads + v_proj_out_dim = config.d_model // config.n_heads + else: + q_proj_out_dim = config.d_model + k_proj_out_dim = config.d_model + v_proj_out_dim = config.d_model + self.q_proj = nn.Linear( + config.d_model, q_proj_out_dim, bias=config.include_bias, device=config.init_device + ) + self.k_proj = nn.Linear( + config.d_model, k_proj_out_dim, bias=config.include_bias, device=config.init_device + ) + self.v_proj = nn.Linear( + config.d_model, v_proj_out_dim, bias=config.include_bias, device=config.init_device + ) + + # Feed-forward input projection. + self.ff_proj = nn.Linear( + config.d_model, self.hidden_size, bias=config.include_bias, device=config.init_device + ) + + def reset_parameters(self): + super().reset_parameters() + self.attn_norm.reset_parameters() + self.ff_norm.reset_parameters() + # NOTE: the standard deviation for these weights does not depend on the layer. + + if self.config.init_fn == InitFnType.normal: + std = self.config.init_std + cutoff_factor = self.config.init_cutoff_factor + elif self.config.init_fn == InitFnType.mitchell: + std = 1 / math.sqrt(self.config.d_model) + cutoff_factor = self.config.init_cutoff_factor or 3.0 + elif self.config.init_fn == InitFnType.full_megatron: + std = self.config.init_std + cutoff_factor = self.config.init_cutoff_factor or 3.0 + else: + raise NotImplementedError(self.config.init_fn) + + init_normal(self.q_proj, std, cutoff_factor) + init_normal(self.k_proj, std, cutoff_factor) + init_normal(self.v_proj, std, cutoff_factor) + init_normal(self.ff_proj, std, cutoff_factor) + + def _scaled_dot_product_attention( + self, + q: torch.Tensor, + k: torch.Tensor, + v: torch.Tensor, + attn_mask: Optional[torch.Tensor] = None, + dropout_p: float = 0.0, + is_causal: bool = False, + ) -> torch.Tensor: + attn_weights = torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(q.size(-1)) + + if is_causal: + assert attn_mask is None + + query_len, key_len = q.shape[-2], k.shape[-2] # could be different if layer_past not None + attn_bias = get_causal_attention_bias(self.__cache, key_len, q.device)[:, :, :query_len, :key_len] + elif attn_mask is not None: + attn_bias = attn_mask.to(q.dtype) + else: + attn_bias = torch.zeros_like(attn_weights) + + attn_weights += attn_bias + attn_weights = nn.functional.softmax(attn_weights, dim=-1).to(q.dtype) + attn_weights = nn.functional.dropout(attn_weights, p=dropout_p) + return torch.matmul(attn_weights, v) + + def forward( + self, + x: torch.Tensor, + attention_bias: Optional[torch.Tensor] = None, + layer_past: Optional[Tuple[torch.Tensor, torch.Tensor]] = None, + use_cache: bool = False, + ) -> Tuple[torch.Tensor, Optional[Tuple[torch.Tensor, torch.Tensor]]]: + # Get query, key, value projections. + # shape: + # - for regular attn q, k, v: (batch_size, seq_len, d_model) + # - for multi-query attn q: (batch_size, seq_len, d_model) + # k, v: (batch_size, seq_len, d_model // n_heads) + x_normed = self.attn_norm(x) + q = self.q_proj(x_normed) + k = self.k_proj(x_normed) + v = self.v_proj(x_normed) + + if self.config.clip_qkv is not None: + q.clamp_(min=-self.config.clip_qkv, max=self.config.clip_qkv) + k.clamp_(min=-self.config.clip_qkv, max=self.config.clip_qkv) + v.clamp_(min=-self.config.clip_qkv, max=self.config.clip_qkv) + + # Get attention scores. + att, cache = self.attention(q, k, v, attention_bias, layer_past=layer_past, use_cache=use_cache) + + # Add attention scores. + # shape: (B, T, C) + x = x + self.dropout(att) + + # Add feed-forward projection. + # shape: (batch_size, seq_len, d_model) + og_x = x + if self._activation_checkpoint_fn is not None: + x = self._activation_checkpoint_fn(self.ff_norm, x) # type: ignore + else: + x = self.ff_norm(x) + x = self.ff_proj(x) + if self._activation_checkpoint_fn is not None: + x = self._activation_checkpoint_fn(self.act, x) # type: ignore + else: + x = self.act(x) + x = self.ff_out(x) + x = self.dropout(x) + x = og_x + x + + return x, cache + + +class OLMoOutput(NamedTuple): + logits: torch.FloatTensor + """ + A tensor of shape `(batch_size, seq_len, vocab_size)` representing the log probabilities + for the next token *before* normalization via (log) softmax. + """ + + attn_key_values: Optional[List[Tuple[torch.Tensor, torch.Tensor]]] + """ + Attention keys and values from each block. + """ + + hidden_states: Optional[Tuple[torch.Tensor]] + """ + Hidden states from each block. + """ + + +class OLMoGenerateOutput(NamedTuple): + token_ids: torch.LongTensor + """ + The generated token IDs, a tensor of shape `(batch_size, beam_size, max_steps)`. + These do *not* include the original input IDs. + """ + + scores: torch.FloatTensor + """ + The scores of the generated sequences, a tensor of shape `(batch_size, beam_size)`. + """ + + +class OLMoBlockGroup(nn.ModuleList): + def __init__(self, config: ModelConfig, layer_offset: int, modules: Optional[Iterable[nn.Module]] = None): + super().__init__(modules) + self.config = config + self.layer_offset = layer_offset + self.activation_checkpointing_strategy: Optional[ActivationCheckpointingStrategy] = None + self._activation_checkpoint_fn = activation_checkpoint_function(self.config) + + def forward( + self, + x: torch.Tensor, + attention_bias: Optional[torch.FloatTensor] = None, + layers_past: Optional[List[Tuple[torch.Tensor, torch.Tensor]]] = None, + use_cache: bool = False, + ) -> Tuple[torch.Tensor, Optional[List[Tuple[torch.Tensor, torch.Tensor]]]]: + attn_key_values: Optional[List[Tuple[torch.Tensor, torch.Tensor]]] = [] if use_cache else None + for block_idx, block in enumerate(self): + layer_past = None if layers_past is None else layers_past[block_idx] + block_idx += self.layer_offset + if should_checkpoint_block(self.activation_checkpointing_strategy, block_idx): + # shape: (batch_size, seq_len, d_model) + x, cache = self._activation_checkpoint_fn( # type: ignore + block, x, attention_bias=attention_bias, layer_past=layer_past, use_cache=use_cache + ) + else: + # shape: (batch_size, seq_len, d_model) + x, cache = block(x, attention_bias=attention_bias, layer_past=layer_past, use_cache=use_cache) + if attn_key_values is not None: + assert cache is not None + attn_key_values.append(cache) + return x, attn_key_values + + def reset_parameters(self): + for block in self: + block.reset_parameters() + + def set_activation_checkpointing(self, strategy: Optional[ActivationCheckpointingStrategy]): + self.activation_checkpointing_strategy = strategy + for block in self: + block.set_activation_checkpointing(strategy) + + +class OLMo(nn.Module): + def __init__(self, config: ModelConfig, init_params: bool = True): + super().__init__() + self.config = config + self.__cache = BufferCache() + + # Validate config. + if self.config.alibi and self.config.flash_attention: + raise OLMoConfigurationError("ALiBi is currently not supported with FlashAttention") + + if self.config.alibi and self.config.rope: + raise OLMoConfigurationError("ALiBi and RoPE are mutually exclusive") + + if self.config.embedding_size is not None and self.config.embedding_size != self.config.vocab_size: + if self.config.embedding_size < self.config.vocab_size: + raise OLMoConfigurationError("embedding size should be at least as big as vocab size") + elif self.config.embedding_size % 128 != 0: + import warnings + + warnings.warn( + "Embedding size is not a multiple of 128! This could hurt throughput performance.", UserWarning + ) + + self.activation_checkpointing_strategy: Optional[ActivationCheckpointingStrategy] = None + self._activation_checkpoint_fn: Callable = activation_checkpoint_function(self.config) + + if not ( + 0 < self.config.block_group_size <= self.config.n_layers + and self.config.n_layers % self.config.block_group_size == 0 + ): + raise OLMoConfigurationError("n layers must be divisible by block group size") + + torch.backends.cuda.enable_flash_sdp(True) + torch.backends.cuda.enable_mem_efficient_sdp(False) # this is super slow so make sure torch won't use it + + self.transformer = nn.ModuleDict( + dict( + wte=nn.Embedding( + config.embedding_size or config.vocab_size, config.d_model, device=config.init_device + ), + emb_drop=Dropout(config.embedding_dropout), + ln_f=LayerNorm.build(config), + ) + ) + + blocks = [OLMoBlock.build(i, config, self.__cache) for i in range(config.n_layers)] + if self.config.block_group_size > 1: + block_groups = [ + OLMoBlockGroup(config, i, blocks[i : i + config.block_group_size]) + for i in range(0, config.n_layers, config.block_group_size) + ] + self.transformer.update({"block_groups": nn.ModuleList(block_groups)}) + else: + self.transformer.update({"blocks": nn.ModuleList(blocks)}) + + if not (self.config.alibi or self.config.rope): + self.transformer.update( + {"wpe": nn.Embedding(config.max_sequence_length, config.d_model, device=config.init_device)} + ) + if not config.weight_tying: + self.transformer.update( + { + "ff_out": nn.Linear( + config.d_model, + config.embedding_size or config.vocab_size, + bias=config.include_bias, + device=config.init_device, + ) + } + ) + # When `init_device="meta"` FSDP will call `reset_parameters()` to initialize weights. + if init_params and self.config.init_device != "meta": + self.reset_parameters() + self.__num_fwd_flops: Optional[int] = None + + # Warm up cache. + if self.config.alibi: + get_causal_attention_bias(self.__cache, config.max_sequence_length, _non_meta_init_device(config)) + self.get_alibi_attention_bias(config.max_sequence_length, _non_meta_init_device(config)) + + def set_activation_checkpointing(self, strategy: Optional[ActivationCheckpointingStrategy]): + self.activation_checkpointing_strategy = strategy + if self.config.block_group_size != 1: + for block_group in self.transformer.block_groups: + block_group.set_activation_checkpointing(strategy) + else: + for block in self.transformer.blocks: + block.set_activation_checkpointing(strategy) + + @property + def device(self) -> torch.device: + device: torch.device = self.transformer.wte.weight.device # type: ignore + if device.type == "meta": + return _non_meta_init_device(self.config) + else: + return device + + def reset_parameters(self): + log.info("Initializing model parameters...") + # Top-level embeddings / linear layers. + + if self.config.init_fn == InitFnType.normal: + # Note: We may potentially want to multiply the std by a factor of sqrt(d) in case of `scale_logits` + # and `weight_tying`. However, we are currently not using either, and may need to rethink the init logic + # if/when we do want it. + wte_std = self.config.init_std + wte_cutoff_factor = self.config.init_cutoff_factor + elif self.config.init_fn == InitFnType.mitchell: + wte_std = 1.0 / math.sqrt(self.config.d_model) + wte_cutoff_factor = self.config.init_cutoff_factor or 3.0 + elif self.config.init_fn == InitFnType.full_megatron: + wte_std = self.config.init_std + wte_cutoff_factor = self.config.init_cutoff_factor or 3.0 + else: + raise NotImplementedError(self.config.init_fn) + + init_normal(self.transformer.wte, std=wte_std, init_cutoff_factor=wte_cutoff_factor) + + if hasattr(self.transformer, "wpe"): + if self.config.init_fn == InitFnType.normal: + wpe_std = self.config.init_std + wpe_cutoff_factor = self.config.init_cutoff_factor + elif self.config.init_fn == InitFnType.mitchell: + wpe_std = 1 / math.sqrt(self.config.d_model) + wpe_cutoff_factor = self.config.init_cutoff_factor or 3.0 + elif self.config.init_fn == InitFnType.full_megatron: + wpe_std = self.config.init_std + wpe_cutoff_factor = self.config.init_cutoff_factor or 3.0 + else: + raise NotImplementedError(self.config.init_fn) + + init_normal(self.transformer.wpe, std=wpe_std, init_cutoff_factor=wpe_cutoff_factor) + + # Top-level layer norm. + self.transformer.ln_f.reset_parameters() # type: ignore + + # Output weights. + if hasattr(self.transformer, "ff_out"): + if self.config.init_fn == InitFnType.normal: + ff_out_std = self.config.init_std + ff_out_cutoff_factor = self.config.init_cutoff_factor + elif self.config.init_fn == InitFnType.mitchell: + ff_out_std = 1 / math.sqrt(self.config.d_model) + ff_out_cutoff_factor = self.config.init_cutoff_factor or 3.0 + elif self.config.init_fn == InitFnType.full_megatron: + ff_out_std = 1 / math.sqrt(self.config.d_model) + ff_out_cutoff_factor = self.config.init_cutoff_factor or 3.0 + else: + raise NotImplementedError(self.config.init_fn) + + init_normal(self.transformer.ff_out, ff_out_std, ff_out_cutoff_factor) + + # Let the blocks handle themselves. + if self.config.block_group_size == 1: + for block in self.transformer.blocks: + block.reset_parameters() + else: + for block_group in self.transformer.block_groups: + block_group.reset_parameters() + + def get_alibi_attention_bias(self, seq_len: int, device: torch.device) -> torch.Tensor: + if (alibi_bias := self.__cache.get("alibi_attention_bias")) is not None and alibi_bias.shape[ + -1 + ] >= seq_len: + if alibi_bias.device != device: + alibi_bias = alibi_bias.to(device) + self.__cache["alibi_attention_bias"] = alibi_bias + return alibi_bias + with torch.autocast(device.type, enabled=False): + alibi_bias = alibi_attention_bias(seq_len, self.config, device) + self.__cache["alibi_attention_bias"] = alibi_bias + return alibi_bias + + def forward( + self, + input_ids: torch.LongTensor, + input_embeddings: Optional[torch.FloatTensor] = None, + attention_mask: Optional[torch.Tensor] = None, + attention_bias: Optional[torch.Tensor] = None, + past_key_values: Optional[Sequence[Tuple[torch.Tensor, torch.Tensor]]] = None, + use_cache: bool = False, + last_logits_only: bool = False, + output_hidden_states: Optional[bool] = None, + ) -> OLMoOutput: + """ + :param input_ids: A tensor of shape `(batch_size, seq_len)`. + :param input_embeddings: A tensor of shape `(batch_size, seq_len, d_model)` with input + embeddings. When provided, it is treated as the output of the input embedding layer. + :param attention_mask: A tensor of shape `(batch_size, seq_len)` that indicates + which input IDs are masked. A `1` value in the mask means that + the corresponding input ID should *not* be ignored. A `0` means + that the corresponding input ID is masked. + + This has the same meaning as the `attention_mask` in HuggingFace's `transformers` + library. + :param attention_bias: A tensor of shape `(batch_size, 1, seq_len, seq_len)`, + `(1, 1, seq_len, seq_len)`, or `(seq_len, seq_len)`. This is used + to introduce causal or other biases. + + If the tensor is a bool or byte tensor, a `True` or `1` at `attention_bias[:, :, i, j]` + indicates that the i-th element in the sequence is allowed to attend to the j-th + element in the sequence. + + If the tensor is a float tensor, it will just be added to the attention + scores before the softmax. + + The default is causal, which corresponds to a lower-diagonal byte matrix of ones. + :param past_key_values: Pre-computed keys and values for each attention block. + Can be used to speed up sequential decoding. The `input_ids` which have + their past given to this model should not be passed as `input_ids` as they have already been computed. + :param use_cache: If `True`, return key and value tensors for each block. + :param last_logits_only: If `True`, only compute the logits for the last token of each sequence. + This can speed up decoding when you only care about the next token. + """ + output_hidden_states = output_hidden_states if output_hidden_states is not None else False + + if past_key_values: + assert len(past_key_values) == self.config.n_layers + + batch_size, seq_len = input_ids.size() if input_embeddings is None else input_embeddings.size()[:2] + if past_key_values is None: + past_length = 0 + else: + past_length = past_key_values[0][0].size(-2) + + # Get embeddings of input. + # shape: (batch_size, seq_len, d_model) + x = self.transformer.wte(input_ids) if input_embeddings is None else input_embeddings # type: ignore + + if not (self.config.alibi or self.config.rope): + # Get positional embeddings. + # shape: (1, seq_len) + pos = torch.arange(past_length, past_length + seq_len, dtype=torch.long, device=x.device).unsqueeze(0) + # shape: (1, seq_len, d_model) + pos_emb = self.transformer.wpe(pos) # type: ignore + x = pos_emb + x + + # Add input + positional embeddings and apply dropout. + # shape: (batch_size, seq_len, d_model) + x = self.transformer.emb_drop(x) # type: ignore + + # Transform the attention mask into what the blocks expect. + if attention_mask is not None: + # shape: (batch_size, 1, 1, seq_len) + attention_mask = attention_mask.to(dtype=torch.float).view(batch_size, -1)[:, None, None, :] + attention_mask = (1.0 - attention_mask) * torch.finfo(attention_mask.dtype).min + + # Merge attention mask with attention bias. + if ( + attention_bias is not None + or attention_mask is not None + or self.config.alibi + # NOTE (epwalsh): we need to initialize the attn bias in order for attn to work properly + # with key+value cache. Otherwise `F.scaled_dot_product_attention()` doesn't seem to compute + # scores correctly. + or past_key_values is not None + ): + if attention_bias is None and self.config.alibi: + attention_bias = get_causal_attention_bias( + self.__cache, past_length + seq_len, x.device + ) + self.get_alibi_attention_bias(past_length + seq_len, x.device) + elif attention_bias is None: + attention_bias = get_causal_attention_bias(self.__cache, past_length + seq_len, x.device) + elif attention_bias.dtype in (torch.int8, torch.bool): + attention_bias = attention_bias.to(dtype=torch.float) + attention_bias.masked_fill_(attention_bias == 0.0, torch.finfo(attention_bias.dtype).min) + + # Transform to the right shape and data type. + mask_len = seq_len + if attention_mask is not None: + mask_len = attention_mask.shape[-1] + elif past_key_values is not None: + mask_len = past_key_values[0][0].shape[-2] + seq_len + attention_bias = attention_bias[:, :, :mask_len, :mask_len].to(dtype=torch.float) + + # Add in the masking bias. + if attention_mask is not None: + attention_bias = attention_bias + attention_mask + # Might get -infs after adding attention mask, since dtype.min + dtype.min = -inf. + # `F.scaled_dot_product_attention()` doesn't handle -inf like you'd expect, instead + # it can produce NaNs. + ensure_finite_(attention_bias, check_neg_inf=True, check_pos_inf=False) + + attn_key_values: Optional[List[Tuple[torch.Tensor, torch.Tensor]]] = [] if use_cache else None + + # decoder layers + all_hidden_states = [] + + # Apply blocks one-by-one. + if self.config.block_group_size == 1: + for block_idx, block in enumerate(self.transformer.blocks): + if output_hidden_states: + # add hidden states + all_hidden_states.append(x) + + layer_past = None if past_key_values is None else past_key_values[block_idx] + if should_checkpoint_block(self.activation_checkpointing_strategy, block_idx): + # shape: (batch_size, seq_len, d_model) + x, cache = self._activation_checkpoint_fn( + block, x, attention_bias=attention_bias, layer_past=layer_past, use_cache=use_cache + ) + else: + # shape: (batch_size, seq_len, d_model) + x, cache = block(x, attention_bias=attention_bias, layer_past=layer_past, use_cache=use_cache) + + if attn_key_values is not None: + assert cache is not None + attn_key_values.append(cache) + else: + for group_idx, block_group in enumerate(self.transformer.block_groups): + if output_hidden_states: + # add hidden states + all_hidden_states.append(x) + + layers_past = ( + None + if past_key_values is None + else past_key_values[ + group_idx * self.config.block_group_size : (group_idx + 1) * self.config.block_group_size + ] + ) + x, cache = block_group( + x, attention_bias=attention_bias, layers_past=layers_past, use_cache=use_cache + ) + if attn_key_values is not None: + assert cache is not None + attn_key_values.extend(cache) + + if last_logits_only: + # shape: (batch_size, 1, d_model) + x = x[:, -1, :].unsqueeze(1) + + # Apply final layer norm. + # shape: (batch_size, seq_len or 1, d_model) + x = self.transformer.ln_f(x) # type: ignore + if output_hidden_states: + # add final hidden state post-final-layernorm, following HuggingFace's convention + all_hidden_states.append(x) + + # Get logits. + # shape: (batch_size, seq_len or 1, vocab_size) + if self.config.weight_tying: + logits = F.linear(x, self.transformer.wte.weight, None) # type: ignore + else: + logits = self.transformer.ff_out(x) # type: ignore + if self.config.scale_logits: + logits.mul_(1 / math.sqrt(self.config.d_model)) + return logits + #return OLMoOutput(logits=logits, attn_key_values=attn_key_values, hidden_states=tuple(all_hidden_states) if output_hidden_states else None) # type: ignore[arg-type] + + def get_fsdp_wrap_policy(self, wrap_strategy: Optional[FSDPWrapStrategy] = None): + if wrap_strategy is None: + return None + + # The 'recurse' mode for the wrap function does not behave like you'd expect. + # Even if we return False, it may still recurse because PyTorch does what it wants, + # not what you want. This causes issues when, for example, we want to wrap 'ff_out' (a linear layer) + # but not other linear layers within a block. + # So we have to explicitly tell PyTorch which linear layers to wrap, and we also just + # return True in 'recurse' mode for simplicity. + size_based_module_to_wrap = {self.transformer.wte} + if hasattr(self.transformer, "ff_out"): + size_based_module_to_wrap.add(self.transformer.ff_out) + + if wrap_strategy == FSDPWrapStrategy.by_block: + + def fsdp_wrap_fn(module, recurse: bool = True, nonwrapped_numel: int = 0): + del nonwrapped_numel + wrap = isinstance(module, OLMoBlock) + if recurse: + return True + else: + return wrap + + return fsdp_wrap_fn + elif wrap_strategy == FSDPWrapStrategy.by_block_and_size: + + def fsdp_wrap_fn(module, recurse: bool = True, nonwrapped_numel: int = 0): + del nonwrapped_numel + wrap = isinstance(module, (OLMoBlock,)) or module in size_based_module_to_wrap + if recurse: + return True + else: + return wrap + + return fsdp_wrap_fn + elif wrap_strategy == FSDPWrapStrategy.by_block_group: + if self.config.block_group_size <= 1: + raise OLMoConfigurationError( + "'by_block_group' FSDP wrapping strategy requires block group size greater than 1" + ) + + def fsdp_wrap_fn(module, recurse: bool = True, nonwrapped_numel: int = 0): + del nonwrapped_numel + wrap = isinstance(module, OLMoBlockGroup) + if recurse: + return True + else: + return wrap + + return fsdp_wrap_fn + elif wrap_strategy == FSDPWrapStrategy.by_block_group_and_size: + if self.config.block_group_size <= 1: + raise OLMoConfigurationError( + "'by_block_group_and_size' FSDP wrapping strategy requires block group size greater than 1" + ) + + def fsdp_wrap_fn(module, recurse: bool = True, nonwrapped_numel: int = 0): + del nonwrapped_numel + wrap = isinstance(module, (OLMoBlockGroup,)) or module in size_based_module_to_wrap + if recurse: + return True + else: + return wrap + + return fsdp_wrap_fn + elif wrap_strategy == FSDPWrapStrategy.size_based: + from torch.distributed.fsdp.wrap import size_based_auto_wrap_policy + + return size_based_auto_wrap_policy + elif wrap_strategy in { + FSDPWrapStrategy.one_in_two, + FSDPWrapStrategy.one_in_three, + FSDPWrapStrategy.one_in_four, + FSDPWrapStrategy.one_in_five, + }: + c = { + FSDPWrapStrategy.one_in_two: 2, + FSDPWrapStrategy.one_in_three: 3, + FSDPWrapStrategy.one_in_four: 4, + FSDPWrapStrategy.one_in_five: 5, + }[wrap_strategy] + + def fsdp_wrap_fn(module, recurse: bool = True, nonwrapped_numel: int = 0): + del nonwrapped_numel + wrap = isinstance(module, OLMoBlock) and module.layer_id % c == 0 + if recurse: + return True + else: + return wrap + + return fsdp_wrap_fn + else: + raise NotImplementedError(wrap_strategy) + + def num_params(self, include_embedding: bool = True) -> int: + """ + Get the total number of parameters. + """ + params = (np for np in self.named_parameters()) + if not include_embedding: + params = filter( # type: ignore + lambda np: ".wte." not in np[0] and ".wpe." not in np[0], + params, + ) + return sum(p.numel() for _, p in params) + + @property + def num_fwd_flops(self): + if self.__num_fwd_flops: + return self.__num_fwd_flops + n_params = self.num_params() + # the number of parameters is approximately the number of multiply-accumulates (MAC) in the network + # each MAC has 2 FLOPs - we multiply by 2 ie 2 * n_param + # this gets us FLOPs / token + params_flops_per_token = 2 * n_params + params_flops_per_seq = params_flops_per_token * self.config.max_sequence_length + # there are 2 FLOPS per mac; there is A=Q*K^T and out=A*V ops (ie mult by 2) + attn_flops_per_seq = ( + self.config.n_layers * 2 * 2 * (self.config.d_model * (self.config.max_sequence_length**2)) + ) + self.__num_fwd_flops = params_flops_per_seq + attn_flops_per_seq + return self.__num_fwd_flops + + def generate( + self, + input_ids: torch.LongTensor, + attention_mask: Optional[torch.Tensor] = None, + attention_bias: Optional[torch.Tensor] = None, + max_steps: int = 10, + beam_size: int = 1, + per_node_beam_size: Optional[int] = None, + sampler: Optional[Sampler] = None, + min_steps: Optional[int] = None, + final_sequence_scorer: Optional[FinalSequenceScorer] = None, + constraints: Optional[List[Constraint]] = None, + ) -> OLMoGenerateOutput: + """ + Generate token IDs using beam search. + + Note that by default ``beam_size`` is set to 1, which is greedy decoding. + + :param input_ids: A tensor of shape `(batch_size, seq_len)`. + :param attention_mask: A optional tensor of shape `(batch_size, seq_len)`, the same + as for the forward method. + :param attention_bias: A tensor of shape + `(batch_size, 1, seq_len + tokens_to_generate, seq_len + tokens_to_generate)`, + the same as for the forward method except only one shape is excepted here. + + For an explanation of the other arguments, see :class:`BeamSearch`. + """ + beam_search = BeamSearch( + self.config.eos_token_id, + max_steps=max_steps, + beam_size=beam_size, + per_node_beam_size=per_node_beam_size, + sampler=sampler, + min_steps=min_steps, + final_sequence_scorer=final_sequence_scorer, + constraints=constraints, + ) + + # Validate inputs. + batch_size, seq_len = input_ids.shape + if attention_mask is not None: + assert attention_mask.shape == (batch_size, seq_len) + if attention_bias is not None: + assert len(attention_bias.shape) == 4 + assert attention_bias.shape[:2] == (batch_size, 1) + assert ( + seq_len + beam_search.max_steps + <= attention_bias.shape[2] + == attention_bias.shape[3] + <= self.config.max_sequence_length + ) + + tokens_generated = 0 + + def flatten_past_key_values( + past_key_values: List[Tuple[torch.Tensor, torch.Tensor]], + ) -> Dict[str, torch.Tensor]: + out = {} + for i, (key, value) in enumerate(past_key_values): + out[f"past_key_{i}"] = key + out[f"past_value_{i}"] = value + return out + + def unflatten_past_key_values( + past_key_values: Dict[str, torch.Tensor], + ) -> List[Tuple[torch.Tensor, torch.Tensor]]: + out = [] + for i in range(self.config.n_layers): + past_key = past_key_values[f"past_key_{i}"] + past_value = past_key_values[f"past_value_{i}"] + out.append((past_key, past_value)) + return out + + def step( + last_predictions: torch.Tensor, state: dict[str, torch.Tensor] + ) -> tuple[torch.Tensor, dict[str, torch.Tensor]]: + nonlocal tokens_generated + + attention_mask = state.get("attention_mask") + attention_bias = state.get("attention_bias") + + if tokens_generated > 0: + past_key_values = unflatten_past_key_values(state) + input_ids = last_predictions.unsqueeze(1) + if attention_mask is not None: + group_size = input_ids.shape[0] + attention_mask = torch.cat((attention_mask, attention_mask.new_ones((group_size, 1))), dim=-1) + else: + past_key_values = None + input_ids = state["input_ids"] + + tokens_generated += 1 + + # Run forward pass of model to get logits, then normalize to get log probs. + output = self( + input_ids, + attention_mask=attention_mask, + attention_bias=attention_bias, + past_key_values=past_key_values, + use_cache=True, + last_logits_only=True, + ) + log_probs = F.log_softmax(output.logits[:, -1, :], dim=-1) + + # Create new state. + state = flatten_past_key_values(output.attn_key_values) + if attention_mask is not None: + state["attention_mask"] = attention_mask + if attention_bias is not None: + state["attention_bias"] = attention_bias + + return log_probs, state + + initial_preds = input_ids.new_zeros((batch_size,)) # This is arbitrary, we won't use this. + state: dict[str, torch.Tensor] = {"input_ids": input_ids} + if attention_mask is not None: + state["attention_mask"] = attention_mask + if attention_bias is not None: + state["attention_bias"] = attention_bias + with torch.no_grad(): + token_ids, scores = beam_search.search(initial_preds, state, step) + + return OLMoGenerateOutput( + token_ids=token_ids, # type: ignore[arg-type] + scores=scores, # type: ignore[arg-type] + ) + + @classmethod + def from_checkpoint( + cls, checkpoint_dir: PathOrStr, device: str = "cpu", checkpoint_type: Optional[CheckpointType] = None + ) -> OLMo: + """ + Load an OLMo model from a checkpoint. + """ + from .util import resource_path + + # Guess checkpoint type. + if checkpoint_type is None: + try: + if resource_path(checkpoint_dir, "model.pt").is_file(): + checkpoint_type = CheckpointType.unsharded + else: + checkpoint_type = CheckpointType.sharded + except FileNotFoundError: + checkpoint_type = CheckpointType.sharded + + # Load config. + config_path = resource_path(checkpoint_dir, "config.yaml") + model_config = ModelConfig.load(config_path, key="model", validate_paths=False) + + if checkpoint_type == CheckpointType.unsharded: + # Initialize model (always on CPU to start with so we don't run out of GPU memory). + model_config.init_device = "cpu" + model = OLMo(model_config) + + # Load state dict directly to target device. + state_dict_path = resource_path(checkpoint_dir, "model.pt") + state_dict = torch.load(state_dict_path, map_location="cpu") + model.load_state_dict(model._make_state_dict_compatible(state_dict)[0]) + model = model.to(torch.device(device)) + else: + from .checkpoint import load_model_state + + # Initialize model on target device. In this case the state dict is loaded in-place + # so it's not necessary to start on CPU if the target device is a GPU. + model_config.init_device = device + model = OLMo(model_config) + + # Load state dict in place. + load_model_state(checkpoint_dir, model) + + return model.eval() + + def _make_state_dict_compatible( + self, state_dict: Dict[str, torch.Tensor] + ) -> Tuple[Dict[str, torch.Tensor], Dict[str, Set[str]]]: + """ + Handles some cases where the state dict is valid yet may need to be transformed in order to + be loaded. + + This modifies the state dict in-place and also returns it, along with a mapping of original key + names to new key names in cases where the keys were simply renamed. That mapping can be used + to make a corresponding optimizer state dict compatible as well. + """ + import re + from fnmatch import fnmatch + + new_keys_to_og_keys: Dict[str, str] = {} + + # Remove "_fsdp_wrapped_module." prefix from all keys. We don't want this prefix when the model is + # not wrapped in FSDP. And when the model is wrapped in FSDP, loading this state dict will still work + # fine without the prefixes. This also simplifies the other steps below. + for key in list(state_dict.keys()): + state_dict[(new_key := key.replace("_fsdp_wrapped_module.", ""))] = state_dict.pop(key) + new_keys_to_og_keys[new_key] = key + + # For backwards compatibility prior to fixing https://github.com/allenai/LLM/issues/222 + if self.config.block_type == BlockType.sequential: + for key in list(state_dict.keys()): + if fnmatch(key, "transformer.*.norm.weight"): + tensor = state_dict.pop(key) + state_dict[(new_key := key.replace("norm.weight", "attn_norm.weight"))] = tensor + new_keys_to_og_keys[new_key] = new_keys_to_og_keys[key] + state_dict[(new_key := key.replace("norm.weight", "ff_norm.weight"))] = tensor.clone() + new_keys_to_og_keys[new_key] = new_keys_to_og_keys[key] + del new_keys_to_og_keys[key] + elif fnmatch(key, "transformer.*.norm.bias"): + tensor = state_dict.pop(key) + state_dict[(new_key := key.replace("norm.bias", "attn_norm.bias"))] = tensor + new_keys_to_og_keys[new_key] = new_keys_to_og_keys[key] + state_dict[(new_key := key.replace("norm.bias", "ff_norm.bias"))] = tensor.clone() + new_keys_to_og_keys[new_key] = new_keys_to_og_keys[key] + del new_keys_to_og_keys[key] + + # For loading a state dict that was saved with a different `block_group_size`. + if "transformer.block_groups.0.0.attn_out.weight" in state_dict.keys(): + state_dict_block_group_size = len( + [k for k in state_dict.keys() if fnmatch(k, "transformer.block_groups.0.*.attn_out.weight")] + ) + else: + state_dict_block_group_size = 1 + if self.config.block_group_size != state_dict_block_group_size: + log.info( + f"Regrouping state dict blocks from group size {state_dict_block_group_size} to " + f"group size {self.config.block_group_size}" + ) + # For simplicity we're first going to flatten out the block groups in the state dict (if necessary) + # and then (re-)group them into the right block sizes. + if state_dict_block_group_size > 1: + for key in list(state_dict.keys()): + if (m := re.match(r"transformer.block_groups\.(\d+)\.(\d+)\..*", key)) is not None: + group_idx, group_block_idx = int(m.group(1)), int(m.group(2)) + block_idx = (group_idx * state_dict_block_group_size) + group_block_idx + state_dict[ + ( + new_key := key.replace( + f"block_groups.{group_idx}.{group_block_idx}.", f"blocks.{block_idx}." + ) + ) + ] = state_dict.pop(key) + new_keys_to_og_keys[new_key] = new_keys_to_og_keys.pop(key) + + if self.config.block_group_size > 1: + # Group the state dict blocks into the right block size. + for key in list(state_dict.keys()): + if (m := re.match(r"transformer.blocks\.(\d+)\..*", key)) is not None: + block_idx = int(m.group(1)) + group_idx, group_block_idx = ( + block_idx // self.config.block_group_size, + block_idx % self.config.block_group_size, + ) + state_dict[ + ( + new_key := key.replace( + f"blocks.{block_idx}.", f"block_groups.{group_idx}.{group_block_idx}." + ) + ) + ] = state_dict.pop(key) + new_keys_to_og_keys[new_key] = new_keys_to_og_keys.pop(key) + + og_keys_to_new: Dict[str, Set[str]] = defaultdict(set) + for new_key, og_key in new_keys_to_og_keys.items(): + og_keys_to_new[og_key].add(new_key) + + return state_dict, og_keys_to_new \ No newline at end of file diff --git a/3.test_cases/neuronx-distributed/olmo/olmo/tokenizer.py b/3.test_cases/neuronx-distributed/olmo/olmo/tokenizer.py new file mode 100644 index 00000000..25a94be5 --- /dev/null +++ b/3.test_cases/neuronx-distributed/olmo/olmo/tokenizer.py @@ -0,0 +1,180 @@ +from __future__ import annotations + +import os +from pathlib import Path +from typing import List, Optional, Union + +from tokenizers import Tokenizer as BaseTokenizer + +from .aliases import PathOrStr +from .config import ModelConfig, TokenizerConfig, TrainConfig, TruncationDirection +from .exceptions import OLMoConfigurationError + +__all__ = ["Tokenizer"] + + +class Tokenizer: + """ + A :class:`Tokenizer` is a light-weight wrapper around a HuggingFace :class:`tokenizers.Tokenizer`. + + :param base_tokenizer: The :class:`tokenizers.Tokenizer` to use. + :param eos_token_id: The token ID corresponding to the "end-of-sentence" token. + :param truncate_to: Truncate when tokenizing to this number of token IDs. + :param truncate_direction: The direction to truncate in. "right" means truncate the tokens + on the right. "left" means truncate the tokens on the left. If ``truncate_to`` is null, + this setting has no effect. + """ + + def __init__( + self, + base_tokenizer: BaseTokenizer, + eos_token_id: int, + pad_token_id: Optional[int] = None, + truncate_to: Optional[int] = None, + truncate_direction: Union[str, TruncationDirection] = TruncationDirection.right, + ): + self.base_tokenizer = base_tokenizer + self.base_tokenizer.no_truncation() + self.eos_token_id = eos_token_id + self.pad_token_id = pad_token_id if pad_token_id is not None else eos_token_id + self.truncate_to = truncate_to + self.truncate_direction = TruncationDirection(truncate_direction) + + @property + def vocab_size(self) -> int: + return self.base_tokenizer.get_vocab_size() + + @property + def eos_token(self) -> str: + return self.decode([self.eos_token_id], skip_special_tokens=False) + + @property + def pad_token(self) -> str: + return self.decode([self.pad_token_id], skip_special_tokens=False) + + @classmethod + def from_train_config(cls, config: TrainConfig) -> Tokenizer: + tokenizer_identifier = config.tokenizer.identifier + if Path(tokenizer_identifier).is_file(): + tokenizer = cls.from_file( + tokenizer_identifier, + eos_token_id=config.model.eos_token_id, + pad_token_id=config.model.pad_token_id, + ) + else: + tokenizer = cls.from_pretrained( + tokenizer_identifier, + eos_token_id=config.model.eos_token_id, + pad_token_id=config.model.pad_token_id, + ) + if config.model.vocab_size != tokenizer.vocab_size: + raise OLMoConfigurationError("vocab size mismatch between config and tokenizer") + return tokenizer + + @classmethod + def from_pretrained(cls, identifier: str, **kwargs) -> Tokenizer: + """ + Initialize a tokenizer from a pretrained tokenizer on the HuggingFace Hub. + + :param identifier: The identifier of a model on the Hub that contains a + ``tokenizer.json`` file. + :param kwargs: Other key word arguments passed to :class:`Tokenizer`. + """ + base_tokenizer = BaseTokenizer.from_pretrained(identifier) + eos_token_id = kwargs.pop("eos_token_id", base_tokenizer.get_vocab_size() - 1) + return cls(base_tokenizer, eos_token_id, **kwargs) + + @classmethod + def from_file(cls, filename: PathOrStr, **kwargs) -> Tokenizer: + """ + Initialize a tokenizer from a file. + + You can create those files with ``BaseTokenizer.save()``. + + :param filename: The name of a file containing a tokenizer specification. + :param kwargs: Other key word arguments passed to :class:`Tokenizer`. + """ + base_tokenizer = BaseTokenizer.from_file(filename) + eos_token_id = kwargs.pop("eos_token_id", base_tokenizer.get_vocab_size() - 1) + return cls(base_tokenizer, eos_token_id, **kwargs) + + @classmethod + def from_checkpoint(cls, checkpoint_dir: PathOrStr) -> Tokenizer: + """ + Load a tokenizer from a checkpoint. + """ + from cached_path import cached_path + + # Load configs. + config_path = cached_path(os.path.join(checkpoint_dir, "config.yaml")) + tokenizer_config = TokenizerConfig.load(config_path, key="tokenizer") + model_config = ModelConfig.load(config_path, key="model") + + # Initialize tokenizer and validate vocab size. + if Path(tokenizer_config.identifier).is_file(): + tokenizer = cls.from_file( + tokenizer_config.identifier, + eos_token_id=model_config.eos_token_id, + pad_token_id=model_config.pad_token_id, + ) + else: + tokenizer = cls.from_pretrained( + tokenizer_config.identifier, + eos_token_id=model_config.eos_token_id, + pad_token_id=model_config.pad_token_id, + ) + if model_config.vocab_size != tokenizer.vocab_size: + raise OLMoConfigurationError("vocab size mismatch between config and tokenizer") + return tokenizer + + def add_special_tokens(self, input_ids: List[int]) -> List[int]: + """ + Add special tokens in-place (if not already present) to the given token IDs. + """ + if not input_ids or input_ids[-1] != self.eos_token_id: + input_ids.append(self.eos_token_id) + return input_ids + + def num_special_tokens_to_add(self, is_pair: bool = False) -> int: + return 2 if is_pair else 1 + + def _truncate( + self, input_ids: List[int], truncate_to: Optional[int], direction: TruncationDirection + ) -> list[int]: + if truncate_to is None or len(input_ids) <= truncate_to: + return input_ids + elif direction == TruncationDirection.left: + return input_ids[len(input_ids) - truncate_to :] + else: + return input_ids[: -(len(input_ids) - truncate_to)] + + def encode(self, input: str, add_special_tokens: bool = True) -> List[int]: + """ + Encode a string into token IDs. + """ + return self.encode_batch([input], add_special_tokens=add_special_tokens)[0] + + def encode_batch(self, inputs: List[str], add_special_tokens: bool = True) -> List[List[int]]: + """ + Encode a batch of strings into token IDs. + """ + truncate_to = self.truncate_to + if truncate_to is not None and add_special_tokens: + truncate_to -= self.num_special_tokens_to_add(False) + + batch_encoding = self.base_tokenizer.encode_batch(inputs) + + all_input_ids = [] + for encoding in batch_encoding: + input_ids = self._truncate(encoding.ids, truncate_to, self.truncate_direction) + if add_special_tokens: + input_ids = self.add_special_tokens(input_ids) + all_input_ids.append(input_ids) + + return all_input_ids + + def decode(self, token_ids: List[int], skip_special_tokens: bool = True) -> str: + """ + Decode a list of token IDs to a string. + """ + return self.base_tokenizer.decode(token_ids, skip_special_tokens=skip_special_tokens) \ No newline at end of file diff --git a/3.test_cases/neuronx-distributed/olmo/olmo/torch_util.py b/3.test_cases/neuronx-distributed/olmo/olmo/torch_util.py new file mode 100644 index 00000000..26bffdde --- /dev/null +++ b/3.test_cases/neuronx-distributed/olmo/olmo/torch_util.py @@ -0,0 +1,142 @@ +import gc +import os +from typing import Optional, TypeVar + +import torch +import torch.distributed as dist + +T = TypeVar("T") + + +def seed_all(seed: int): + """Seed all rng objects.""" + import random + + import numpy as np + + if seed < 0 or seed > 2**32 - 1: + raise ValueError(f"Seed {seed} is invalid. It must be on [0; 2^32 - 1]") + random.seed(seed) + np.random.seed(seed) + torch.manual_seed(seed) + # torch.manual_seed may call manual_seed_all but calling it again here + # to make sure it gets called at least once + torch.cuda.manual_seed_all(seed) + + +def is_distributed() -> bool: + return dist.is_available() and dist.is_initialized() + + +def get_node_rank() -> int: + return int(os.environ.get("NODE_RANK") or (get_global_rank() - get_local_rank()) // get_local_world_size()) + + +def get_world_size() -> int: + if is_distributed(): + return dist.get_world_size() + else: + return 1 + + +def get_local_world_size() -> int: + return int(os.environ.get("LOCAL_WORLD_SIZE") or 1) + + +def get_global_rank() -> int: + if is_distributed(): + return int(os.environ.get("RANK") or dist.get_rank()) + else: + return 0 + + +def get_local_rank() -> int: + return int(os.environ.get("LOCAL_RANK") or 0) + + +def get_fs_local_rank() -> int: + """Get the local rank per filesystem, meaning that, regardless of the number of nodes, + if all ranks share the same filesystem then `get_fs_local_rank()` will be equivalent to `get_global_rank()`, + but if nodes do not share the same filesystem then `get_fs_local_rank()` will be equivalent to `get_local_rank()`. + """ + return int(os.environ.get("FS_LOCAL_RANK") or get_local_rank()) + + +def move_to_device(o: T, device: torch.device) -> T: + if isinstance(o, torch.Tensor): + return o.to(device) # type: ignore[return-value] + elif isinstance(o, dict): + return {k: move_to_device(v, device) for k, v in o.items()} # type: ignore[return-value] + elif isinstance(o, list): + return [move_to_device(x, device) for x in o] # type: ignore[return-value] + elif isinstance(o, tuple): + return tuple((move_to_device(x, device) for x in o)) # type: ignore[return-value] + else: + return o + + +def ensure_finite_(x: torch.Tensor, check_neg_inf: bool = True, check_pos_inf: bool = False): + """ + Modify ``x`` in place to replace ``float("-inf")`` with the minimum value of the dtype when ``check_neg_inf`` + is ``True`` and to replace ``float("inf")`` with the maximum value of the dtype when ``check_pos_inf`` is ``True``. + """ + if check_neg_inf: + x.masked_fill_(x == float("-inf"), torch.finfo(x.dtype).min) + if check_pos_inf: + x.masked_fill_(x == float("inf"), torch.finfo(x.dtype).max) + + +def get_default_device() -> torch.device: + if torch.cuda.is_available() and torch.cuda.is_initialized(): + return torch.device("cuda") + else: + return torch.device("cpu") + + +def barrier() -> None: + if is_distributed(): + dist.barrier() + + +def peak_gpu_memory(reset: bool = False) -> Optional[float]: + """ + Get the peak GPU memory usage in MB across all ranks. + Only rank 0 will get the final result. + """ + if not torch.cuda.is_available(): + return None + + device = torch.device("cuda") + peak_mb = torch.cuda.max_memory_allocated(device) / 1000000 + if is_distributed(): + peak_mb_tensor = torch.tensor(peak_mb, device=device) + dist.reduce(peak_mb_tensor, 0, dist.ReduceOp.MAX) + peak_mb = peak_mb_tensor.item() + + if reset: + # Reset peak stats. + torch.cuda.reset_max_memory_allocated(device) + + return peak_mb + + +V = TypeVar("V", bool, int, float) + + +def synchronize_value(value: V, device: torch.device) -> V: + if dist.is_available() and dist.is_initialized(): + value_tensor = torch.tensor(value, device=device) + dist.broadcast(value_tensor, 0) + return value_tensor.item() # type: ignore + else: + return value + + +def synchronize_flag(flag: bool, device: torch.device) -> bool: + return synchronize_value(flag, device) + + +def gc_cuda(): + gc.collect() + if torch.cuda.is_available(): + torch.cuda.empty_cache() \ No newline at end of file diff --git a/3.test_cases/neuronx-distributed/olmo/olmo/util.py b/3.test_cases/neuronx-distributed/olmo/olmo/util.py new file mode 100644 index 00000000..b5c0b1de --- /dev/null +++ b/3.test_cases/neuronx-distributed/olmo/olmo/util.py @@ -0,0 +1,761 @@ +import io +import logging +import os +import re +import socket +import sys +import time +import warnings +from datetime import datetime +from enum import Enum +from itertools import cycle, islice +from pathlib import Path +from queue import Queue +from threading import Thread +from typing import Any, Callable, Dict, Optional, Tuple, Union + +import boto3 +import botocore.exceptions as boto_exceptions +import rich +from botocore.config import Config +from cached_path.schemes import SchemeClient, add_scheme_client +from rich.console import Console, ConsoleRenderable +from rich.highlighter import NullHighlighter +from rich.progress import Progress +from rich.text import Text +from rich.traceback import Traceback + +from .aliases import PathOrStr +from .exceptions import ( + OLMoCliError, + OLMoEnvironmentError, + OLMoError, + OLMoNetworkError, + OLMoThreadError, +) +from .torch_util import get_global_rank, get_local_rank, get_node_rank, is_distributed + +try: + from functools import cache +except ImportError: + from functools import lru_cache as cache + + +class StrEnum(str, Enum): + """ + This is equivalent to Python's :class:`enum.StrEnum` since version 3.11. + We include this here for compatibility with older version of Python. + """ + + def __str__(self) -> str: + return self.value + + def __repr__(self) -> str: + return f"'{str(self)}'" + + +_log_extra_fields: Dict[str, Any] = {} +log = logging.getLogger(__name__) + + +class LogFilterType(StrEnum): + rank0_only = "rank0_only" + local_rank0_only = "local_rank0_only" + all_ranks = "all_ranks" + + +def log_extra_field(field_name: str, field_value: Any) -> None: + global _log_extra_fields + if field_value is None: + if field_name in _log_extra_fields: + del _log_extra_fields[field_name] + else: + _log_extra_fields[field_name] = field_value + + +def setup_logging(log_filter_type: LogFilterType = LogFilterType.rank0_only) -> None: + """ + :param rank0_only: INFO and below messages will only be emitted on the rank0 process. + """ + log_extra_field("hostname", socket.gethostname()) + if is_distributed(): + log_extra_field("node_rank", get_node_rank()) + log_extra_field("local_rank", get_local_rank()) + log_extra_field("global_rank", get_global_rank()) + else: + log_extra_field("node_rank", 0) + log_extra_field("local_rank", 0) + log_extra_field("global_rank", 0) + + old_log_record_factory = logging.getLogRecordFactory() + + def log_record_factory(*args, **kwargs) -> logging.LogRecord: + record = old_log_record_factory(*args, **kwargs) + for field_name, field_value in _log_extra_fields.items(): + setattr(record, field_name, field_value) + return record + + logging.setLogRecordFactory(log_record_factory) + + handler: logging.Handler + if ( + os.environ.get("OLMo_NONINTERACTIVE", False) + or os.environ.get("DEBIAN_FRONTEND", None) == "noninteractive" + or not sys.stdout.isatty() + ): + handler = logging.StreamHandler(sys.stdout) + formatter = logging.Formatter( + "%(asctime)s\t%(hostname)s:%(local_rank)s\t%(name)s:%(lineno)s\t%(levelname)s\t%(message)s" + ) + formatter.default_time_format = "%Y-%m-%d %H:%M:%S" + formatter.default_msec_format = "%s.%03d" + handler.setFormatter(formatter) + else: + handler = RichHandler() + + def rank0_filter(record: logging.LogRecord) -> int: + if record.levelno > logging.INFO: + return 1 + if getattr(record, "global_rank", 0) == 0: + return 1 + else: + return 0 + + def local_rank0_filter(record: logging.LogRecord) -> int: + if record.levelno > logging.INFO: + return 1 + if getattr(record, "local_rank", 0) == 0: + return 1 + else: + return 0 + + if log_filter_type == LogFilterType.rank0_only: + filter = rank0_filter + elif log_filter_type == LogFilterType.local_rank0_only: + filter = local_rank0_filter # type: ignore + elif log_filter_type == LogFilterType.all_ranks: + filter = None + else: + raise ValueError(log_filter_type) + + if filter is not None: + handler.addFilter(filter) # type: ignore + logging.basicConfig(handlers=[handler], level=logging.INFO) + + logging.captureWarnings(True) + logging.getLogger("urllib3").setLevel(logging.ERROR) + + +def excepthook(exctype, value, traceback): + """ + Used to patch `sys.excepthook` in order to log exceptions. + """ + if issubclass(exctype, KeyboardInterrupt): + sys.__excepthook__(exctype, value, traceback) + elif issubclass(exctype, OLMoCliError): + rich.get_console().print(f"[yellow]{value}[/]", highlight=False) + elif issubclass(exctype, OLMoError): + rich.get_console().print(Text(f"{exctype.__name__}:", style="red"), value, highlight=False) + else: + log.critical("Uncaught %s: %s", exctype.__name__, value, exc_info=(exctype, value, traceback)) + + +def install_excepthook(): + sys.excepthook = excepthook + + +def filter_warnings(): + # Filter internal deprecation warnings from torch + warnings.filterwarnings( + action="ignore", + category=UserWarning, + message="torch.distributed.*_base is a private function and will be deprecated.*", + ) + warnings.filterwarnings( + action="ignore", + category=UserWarning, + message="TypedStorage is deprecated.*", + ) + warnings.filterwarnings( + action="ignore", + category=UserWarning, + message="Please use DTensor instead.*", + ) + # Torchvision warnings. We don't actually use torchvision. + warnings.filterwarnings( + action="ignore", + message="failed to load.*", + module="torchvision.io.image", + ) + + +def set_env_variables(): + os.environ["TOKENIZERS_PARALLELISM"] = "false" + + +def prepare_cli_environment(log_filter_type: Optional[LogFilterType] = None): + if log_filter_type is None: + log_filter_type = LogFilterType(os.environ.get("LOG_FILTER_TYPE", "rank0_only")) + rich.reconfigure(width=max(rich.get_console().width, 180), soft_wrap=True) + setup_logging(log_filter_type=log_filter_type) + install_excepthook() + filter_warnings() + set_env_variables() + + +def clean_opt(arg: str) -> str: + if "=" not in arg: + arg = f"{arg}=True" + name, val = arg.split("=", 1) + name = name.strip("-").replace("-", "_") + return f"{name}={val}" + + +class RichHandler(logging.Handler): + """ + A simplified version of rich.logging.RichHandler from + https://github.com/Textualize/rich/blob/master/rich/logging.py + """ + + def __init__( + self, + *, + level: Union[int, str] = logging.NOTSET, + console: Optional[Console] = None, + markup: bool = False, + ) -> None: + super().__init__(level=level) + self.console = console or rich.get_console() + self.highlighter = NullHighlighter() + self.markup = markup + + def emit(self, record: logging.LogRecord) -> None: + try: + if hasattr(record.msg, "__rich__") or hasattr(record.msg, "__rich_console__"): + self.console.print(record.msg) + else: + msg: Any = record.msg + if isinstance(record.msg, str): + msg = self.render_message(record=record, message=record.getMessage()) + renderables = [ + self.get_time_text(record), + self.get_level_text(record), + self.get_location_text(record), + msg, + ] + if record.exc_info is not None: + tb = Traceback.from_exception(*record.exc_info) # type: ignore + renderables.append(tb) + self.console.print(*renderables) + except Exception: + self.handleError(record) + + def render_message(self, *, record: logging.LogRecord, message: str) -> ConsoleRenderable: + use_markup = getattr(record, "markup", self.markup) + message_text = Text.from_markup(message) if use_markup else Text(message) + + highlighter = getattr(record, "highlighter", self.highlighter) + if highlighter: + message_text = highlighter(message_text) + + return message_text + + def get_time_text(self, record: logging.LogRecord) -> Text: + log_time = datetime.fromtimestamp(record.created) + time_str = log_time.strftime("[%Y-%m-%d %X]") + return Text(time_str, style="log.time", end=" ") + + def get_level_text(self, record: logging.LogRecord) -> Text: + level_name = record.levelname + level_text = Text.styled(level_name.ljust(8), f"logging.level.{level_name.lower()}") + level_text.style = "log.level" + level_text.end = " " + return level_text + + def get_location_text(self, record: logging.LogRecord) -> Text: + name_and_line = f"{record.name}:{record.lineno}" if record.name != "root" else "root" + text = f"[{name_and_line}, rank={record.local_rank}]" # type: ignore + return Text(text, style="log.path") + + +def wait_for(condition: Callable[[], bool], description: str, timeout: float = 10.0): + """Wait for the condition function to return True.""" + start_time = time.monotonic() + while not condition(): + time.sleep(0.5) + if time.monotonic() - start_time > timeout: + raise TimeoutError(f"{description} timed out") + + +def is_url(path: PathOrStr) -> bool: + return re.match(r"[a-z0-9]+://.*", str(path)) is not None + + +def dir_is_empty(dir: PathOrStr) -> bool: + dir = Path(dir) + if not dir.is_dir(): + return True + try: + next(dir.glob("*")) + return False + except StopIteration: + return True + + +def get_progress_bar() -> Progress: + from cached_path import get_download_progress + + return get_download_progress() + + +def resource_path( + folder: PathOrStr, fname: str, local_cache: Optional[PathOrStr] = None, progress: Optional[Progress] = None +) -> Path: + if local_cache is not None and (local_path := Path(local_cache) / fname).is_file(): + log.info(f"Found local cache of {fname} at {local_path}") + return local_path + else: + from cached_path import cached_path + + return cached_path(f"{str(folder).rstrip('/')}/{fname}", progress=progress) + + +def file_size(path: PathOrStr) -> int: + """ + Get the size of a local or remote file in bytes. + """ + if is_url(path): + from urllib.parse import urlparse + + parsed = urlparse(str(path)) + if parsed.scheme == "gs": + return _gcs_file_size(parsed.netloc, parsed.path.strip("/")) + elif parsed.scheme in ("s3", "r2", "weka"): + return _s3_file_size(parsed.scheme, parsed.netloc, parsed.path.strip("/")) + elif parsed.scheme in ("http", "https"): + return _http_file_size(parsed.scheme, parsed.netloc, parsed.path.strip("/")) + elif parsed.scheme == "file": + return file_size(str(path).replace("file://", "", 1)) + else: + raise NotImplementedError(f"file size not implemented for '{parsed.scheme}' files") + else: + return os.stat(path).st_size + + +def upload(source: PathOrStr, target: str, save_overwrite: bool = False): + """Upload source file to a target location on GCS or S3.""" + from urllib.parse import urlparse + + source = Path(source) + assert source.is_file() + parsed = urlparse(target) + if parsed.scheme == "gs": + _gcs_upload(source, parsed.netloc, parsed.path.strip("/"), save_overwrite=save_overwrite) + elif parsed.scheme in ("s3", "r2", "weka"): + _s3_upload(source, parsed.scheme, parsed.netloc, parsed.path.strip("/"), save_overwrite=save_overwrite) + else: + raise NotImplementedError(f"Upload not implemented for '{parsed.scheme}' scheme") + + +def get_bytes_range(source: PathOrStr, bytes_start: int, num_bytes: int) -> bytes: + if is_url(source): + from urllib.parse import urlparse + + parsed = urlparse(str(source)) + if parsed.scheme == "gs": + return _gcs_get_bytes_range(parsed.netloc, parsed.path.strip("/"), bytes_start, num_bytes) + elif parsed.scheme in ("s3", "r2", "weka"): + return _s3_get_bytes_range( + parsed.scheme, parsed.netloc, parsed.path.strip("/"), bytes_start, num_bytes + ) + elif parsed.scheme in ("http", "https"): + return _http_get_bytes_range( + parsed.scheme, parsed.netloc, parsed.path.strip("/"), bytes_start, num_bytes + ) + elif parsed.scheme == "file": + return get_bytes_range(str(source).replace("file://", "", 1), bytes_start, num_bytes) + else: + raise NotImplementedError(f"get bytes range not implemented for '{parsed.scheme}' files") + else: + with open(source, "rb") as f: + f.seek(bytes_start) + return f.read(num_bytes) + + +def find_latest_checkpoint(dir: PathOrStr) -> Optional[PathOrStr]: + if is_url(dir): + from urllib.parse import urlparse + + parsed = urlparse(str(dir)) + if parsed.scheme == "gs": + raise NotImplementedError + elif parsed.scheme in ("s3", "r2", "weka"): + return _s3_find_latest_checkpoint(parsed.scheme, parsed.netloc, parsed.path.strip("/")) + elif parsed.scheme == "file": + return find_latest_checkpoint(str(dir).replace("file://", "", 1)) + else: + raise NotImplementedError(f"find_latest_checkpoint not implemented for '{parsed.scheme}' files") + else: + latest_step = 0 + latest_checkpoint: Optional[Path] = None + for path in Path(dir).glob("step*"): + if path.is_dir(): + try: + step = int(path.name.replace("step", "").replace("-unsharded", "")) + except ValueError: + continue + # We prioritize sharded checkpoints over unsharded checkpoints. + if step > latest_step or (step == latest_step and not path.name.endswith("-unsharded")): + latest_step = step + latest_checkpoint = path + return latest_checkpoint + + +def _gcs_upload(source: Path, bucket_name: str, key: str, save_overwrite: bool = False): + from google.cloud import storage as gcs + + storage_client = gcs.Client() + bucket = storage_client.bucket(bucket_name) + blob = bucket.blob(key) + if not save_overwrite and blob.exists(): + raise FileExistsError(f"gs://{bucket_name}/{key} already exists. Use save_overwrite to overwrite it.") + blob.upload_from_filename(source) + + +def _gcs_file_size(bucket_name: str, key: str) -> int: + from google.api_core.exceptions import NotFound + from google.cloud import storage as gcs + + storage_client = gcs.Client() + bucket = storage_client.bucket(bucket_name) + blob = bucket.blob(key) + try: + blob.reload() + except NotFound: + raise FileNotFoundError(f"gs://{bucket_name}/{key}") + assert blob.size is not None + return blob.size + + +def _gcs_get_bytes_range(bucket_name: str, key: str, bytes_start: int, num_bytes: int) -> bytes: + from google.api_core.exceptions import NotFound + from google.cloud import storage as gcs + + storage_client = gcs.Client() + bucket = storage_client.bucket(bucket_name) + blob = bucket.blob(key) + try: + blob.reload() + except NotFound: + raise FileNotFoundError(f"gs://{bucket_name}/{key}") + return blob.download_as_bytes(start=bytes_start, end=bytes_start + num_bytes - 1) + + +def _get_s3_profile_name(scheme: str) -> Optional[str]: + if scheme == "s3": + # For backwards compatibility, we assume S3 uses the default profile if S3_PROFILE is not set. + return os.environ.get("S3_PROFILE") + if scheme == "r2": + profile_name = os.environ.get("R2_PROFILE") + if profile_name is None: + raise OLMoEnvironmentError( + "R2 profile name is not set. Did you forget to set the 'R2_PROFILE' env var?" + ) + + return profile_name + if scheme == "weka": + profile_name = os.environ.get("WEKA_PROFILE") + if profile_name is None: + raise OLMoEnvironmentError( + "Weka profile name is not set. Did you forget to set the 'WEKA_PROFILE' env var?" + ) + + return profile_name + + raise NotImplementedError(f"Cannot get profile name for scheme {scheme}") + + +def _get_s3_endpoint_url(scheme: str) -> Optional[str]: + if scheme == "s3": + return None + if scheme == "r2": + r2_endpoint_url = os.environ.get("R2_ENDPOINT_URL") + if r2_endpoint_url is None: + raise OLMoEnvironmentError( + "R2 endpoint url is not set. Did you forget to set the 'R2_ENDPOINT_URL' env var?" + ) + + return r2_endpoint_url + if scheme == "weka": + weka_endpoint_url = os.environ.get("WEKA_ENDPOINT_URL") + if weka_endpoint_url is None: + raise OLMoEnvironmentError( + "Weka endpoint url is not set. Did you forget to set the 'WEKA_ENDPOINT_URL' env var?" + ) + + return weka_endpoint_url + + raise NotImplementedError(f"Cannot get endpoint url for scheme {scheme}") + + +@cache +def _get_s3_client(scheme: str): + session = boto3.Session(profile_name=_get_s3_profile_name(scheme)) + return session.client( + "s3", + endpoint_url=_get_s3_endpoint_url(scheme), + config=Config(retries={"max_attempts": 10, "mode": "standard"}), + use_ssl=not int(os.environ.get("OLMO_NO_SSL", "0")), + ) + + +def _wait_before_retry(attempt: int): + time.sleep(min(0.5 * 2**attempt, 3.0)) + + +def _s3_upload( + source: Path, scheme: str, bucket_name: str, key: str, save_overwrite: bool = False, max_attempts: int = 3 +): + err: Optional[Exception] = None + if not save_overwrite: + for attempt in range(1, max_attempts + 1): + try: + _get_s3_client(scheme).head_object(Bucket=bucket_name, Key=key) + raise FileExistsError( + f"s3://{bucket_name}/{key} already exists. Use save_overwrite to overwrite it." + ) + except boto_exceptions.ClientError as e: + if e.response["ResponseMetadata"]["HTTPStatusCode"] == 404: + err = None + break + err = e + + if attempt < max_attempts: + log.warning("%s failed attempt %d with retriable error: %s", _s3_upload.__name__, attempt, err) + _wait_before_retry(attempt) + + if err is not None: + raise OLMoNetworkError(f"Failed to check object existence during {scheme} upload") from err + + try: + _get_s3_client(scheme).upload_file(source, bucket_name, key) + except boto_exceptions.ClientError as e: + raise OLMoNetworkError(f"Failed to upload to {scheme}") from e + + +def _s3_file_size(scheme: str, bucket_name: str, key: str, max_attempts: int = 3) -> int: + err: Optional[Exception] = None + for attempt in range(1, max_attempts + 1): + try: + return _get_s3_client(scheme).head_object(Bucket=bucket_name, Key=key)["ContentLength"] + except boto_exceptions.ClientError as e: + if e.response["ResponseMetadata"]["HTTPStatusCode"] == 404: + raise FileNotFoundError(f"s3://{bucket_name}/{key}") from e + err = e + + if attempt < max_attempts: + log.warning("%s failed attempt %d with retriable error: %s", _s3_file_size.__name__, attempt, err) + _wait_before_retry(attempt) + + raise OLMoNetworkError(f"Failed to get {scheme} file size") from err + + +def _s3_get_bytes_range( + scheme: str, bucket_name: str, key: str, bytes_start: int, num_bytes: int, max_attempts: int = 3 +) -> bytes: + err: Optional[Exception] = None + for attempt in range(1, max_attempts + 1): + try: + return ( + _get_s3_client(scheme) + .get_object( + Bucket=bucket_name, Key=key, Range=f"bytes={bytes_start}-{bytes_start + num_bytes - 1}" + )["Body"] + .read() + ) + except boto_exceptions.ClientError as e: + if e.response["ResponseMetadata"]["HTTPStatusCode"] == 404: + raise FileNotFoundError(f"{scheme}://{bucket_name}/{key}") from e + err = e + except (boto_exceptions.HTTPClientError, boto_exceptions.ConnectionError) as e: + # ResponseStreamingError (subclass of HTTPClientError) can happen as + # a result of a failed read from the stream (http.client.IncompleteRead). + # Retrying can help in this case. + err = e + + if attempt < max_attempts: + log.warning( + "%s failed attempt %d with retriable error: %s", _s3_get_bytes_range.__name__, attempt, err + ) + _wait_before_retry(attempt) + + # When torch's DataLoader intercepts exceptions, it may try to re-raise them + # by recalling their constructor with a single message arg. Torch has some + # logic to deal with the absence of a single-parameter constructor, but it + # doesn't gracefully handle other possible failures in calling such a constructor + # This can cause an irrelevant exception (e.g. KeyError: 'error'), resulting + # in us losing the true exception info. To avoid this, we change the exception + # to a type that has a single-parameter constructor. + raise OLMoNetworkError(f"Failed to get bytes range from {scheme}") from err + + +def _s3_find_latest_checkpoint(scheme: str, bucket_name: str, prefix: str) -> Optional[str]: + if not prefix.endswith("/"): + prefix = f"{prefix}/" + response = _get_s3_client(scheme).list_objects(Bucket=bucket_name, Prefix=prefix, Delimiter="/") + assert not response["IsTruncated"] # need to handle this if it happens + latest_step = 0 + latest_checkpoint: Optional[str] = None + for item in response["CommonPrefixes"]: + prefix = item["Prefix"].strip("/") + checkpoint_name = os.path.split(prefix)[-1] + if not checkpoint_name.startswith("step"): + continue + try: + step = int(checkpoint_name.replace("step", "").replace("-unsharded", "")) + except ValueError: + continue + # Make sure the checkpoint dir contains a config, otherwise the checkpoint is incomplete + # (upload might have have failed part way through). + try: + _s3_file_size(scheme, bucket_name, f"{prefix}/config.yaml") + except FileNotFoundError: + continue + # We prioritize sharded checkpoints over unsharded ones. + if step > latest_step or (step == latest_step and not checkpoint_name.endswith("-unsharded")): + latest_step = step + latest_checkpoint = f"{scheme}://{bucket_name}/{prefix}" + return latest_checkpoint + + +def _http_file_size(scheme: str, host_name: str, path: str) -> int: + import requests + + response = requests.head(f"{scheme}://{host_name}/{path}", allow_redirects=True) + return int(response.headers.get("content-length")) + + +def _http_get_bytes_range(scheme: str, host_name: str, path: str, bytes_start: int, num_bytes: int) -> bytes: + import requests + + response = requests.get( + f"{scheme}://{host_name}/{path}", headers={"Range": f"bytes={bytes_start}-{bytes_start+num_bytes-1}"} + ) + result = response.content + assert ( + len(result) == num_bytes + ), f"expected {num_bytes} bytes, got {len(result)}" # Some web servers silently ignore range requests and send everything + return result + + +def default_thread_count() -> int: + return int(os.environ.get("OLMO_NUM_THREADS") or min(32, (os.cpu_count() or 1) + 4)) + + +def pass_through_fn(fn, *args, **kwargs): + return fn(*args, **kwargs) + + +def threaded_generator(g, maxsize: int = 16, thread_name: Optional[str] = None): + q: Queue = Queue(maxsize=maxsize) + + sentinel = object() + + def fill_queue(): + try: + for value in g: + q.put(value) + except Exception as e: + q.put(e) + finally: + q.put(sentinel) + + thread_name = thread_name or repr(g) + thread = Thread(name=thread_name, target=fill_queue, daemon=True) + thread.start() + + for x in iter(q.get, sentinel): + if isinstance(x, Exception): + raise OLMoThreadError(f"generator thread {thread_name} failed") from x + else: + yield x + + +def roundrobin(*iterables): + """ + Call the given iterables in a round-robin fashion. For example: + ``roundrobin('ABC', 'D', 'EF') --> A D E B F C`` + """ + # Adapted from https://docs.python.org/3/library/itertools.html#itertools-recipes + num_active = len(iterables) + nexts = cycle(iter(it).__next__ for it in iterables) + while num_active: + try: + for next in nexts: + yield next() + except StopIteration: + # Remove the iterator we just exhausted from the cycle. + num_active -= 1 + nexts = cycle(islice(nexts, num_active)) + + +def add_cached_path_clients(): + add_scheme_client(WekaClient) + + +class WekaClient(SchemeClient): + recoverable_errors = SchemeClient.recoverable_errors + ( + boto_exceptions.HTTPClientError, + boto_exceptions.ConnectionError, + ) + + scheme = "weka" + + def __init__(self, resource: str) -> None: + SchemeClient.__init__(self, resource) + self.bucket_name, self.path = WekaClient._split_cloud_path(resource, "weka") + self.s3 = _get_s3_client("weka") + self.object_info = None + + @staticmethod + def _split_cloud_path(url: str, provider: str) -> Tuple[str, str]: + """Split a full s3 path into the bucket name and path.""" + from urllib.parse import urlparse + + parsed = urlparse(url) + if not parsed.netloc or not parsed.path: + raise ValueError("bad {} path {}".format(provider, url)) + bucket_name = parsed.netloc + provider_path = parsed.path + # Remove '/' at beginning of path. + if provider_path.startswith("/"): + provider_path = provider_path[1:] + return bucket_name, provider_path + + def _ensure_object_info(self): + if self.object_info is None: + try: + self.object_info = self.s3.head_object(Bucket=self.bucket_name, Key=self.path) + except boto_exceptions.ClientError as e: + if e.response["ResponseMetadata"]["HTTPStatusCode"] == 404: + raise FileNotFoundError(f"weka://{self.bucket_name}/{self.path}") from e + raise e + + def get_etag(self) -> Optional[str]: + self._ensure_object_info() + assert self.object_info is not None + return self.object_info.get("ETag") + + def get_size(self) -> Optional[int]: + self._ensure_object_info() + assert self.object_info is not None + return self.object_info.get("ContentLength") + + def get_resource(self, temp_file: io.BufferedWriter) -> None: + self.s3.download_fileobj(Fileobj=temp_file, Bucket=self.bucket_name, Key=self.path) + + def get_bytes_range(self, index: int, length: int) -> bytes: + response = self.s3.get_object( + Bucket=self.bucket_name, Key=self.path, Range=f"bytes={index}-{index+length-1}" + ) + return response["Body"].read() \ No newline at end of file diff --git a/3.test_cases/neuronx-distributed/olmo/scratch_pad.py b/3.test_cases/neuronx-distributed/olmo/scratch_pad.py new file mode 100644 index 00000000..7d9ea1c8 --- /dev/null +++ b/3.test_cases/neuronx-distributed/olmo/scratch_pad.py @@ -0,0 +1,64 @@ +import os +import torch +from torch.utils.data import DataLoader +from tqdm import tqdm +import torch.nn.functional as F +import torch_xla.core.xla_model as xm +# XLA imports for parallel loader and multi-processing +import torch_xla.distributed.parallel_loader as pl +from torch_xla.distributed.zero_redundancy_optimizer import ZeroRedundancyOptimizer + + +from olmo.config import ModelConfig, TrainConfig, TokenizerConfig +from olmo.datasets import SortDataset +from olmo.model import OLMo +from olmo.tokenizer import Tokenizer + +# Set Neuron SDK environment variables +os.environ["XLA_USE_BF16"] = "1" + + +device = "xla" +olmo_config = TrainConfig.load("./configs/OLMo-1B.yaml") +olmo_config.model.init_device = "cpu" +tokenizer = Tokenizer.from_train_config(olmo_config) +model = OLMo(olmo_config.model) +model = model.to(device) +print("Loaded olmo model") +# Define the batch size and sequence length +batch_size = 4 +# create train and test dataset +train_dataset = SortDataset('train') +test_dataset = SortDataset('test') +train_loader = DataLoader( + train_dataset, + batch_size=batch_size, +) +# We wrap the dataloader with MpDeviceLoader. This dataloader should take +# care of copying the tensors to device +train_loader = pl.MpDeviceLoader(train_loader, device) +#optimizer = torch.optim.Adam(model.parameters(), lr=1e-4) +optimizer = ZeroRedundancyOptimizer( + model.parameters(), torch.optim.Adam, + lr=1e-4 +) +model.train() + +pbar = tqdm(train_loader) +for idx, (x, y) in enumerate(pbar): + optimizer.zero_grad() + # forward the model + logits = model(x) + loss = F.cross_entropy( + logits.view(-1, logits.size(-1)), + y.view(-1), + ignore_index=-1 + ) + # backprop and update the parameters + loss.backward() + optimizer.step() + #xm.optimizer_step(optimizer) # XLA MP: performs grad allreduce and optimizer step + pbar.set_description(f"Iteration: {idx}, train loss: {loss.item():.5f}") + +# XLA: use xm.save instead of torch.save to ensure states are moved back to cpu +xm.save(model.state_dict(), "model.pt") \ No newline at end of file diff --git a/3.test_cases/neuronx-distributed/olmo/tokenizers/.gitignore b/3.test_cases/neuronx-distributed/olmo/tokenizers/.gitignore new file mode 100644 index 00000000..94a2dd14 --- /dev/null +++ b/3.test_cases/neuronx-distributed/olmo/tokenizers/.gitignore @@ -0,0 +1 @@ +*.json \ No newline at end of file From e5b999431737bb126ea8d189eb14dbfbdb728fef Mon Sep 17 00:00:00 2001 From: Keita Watanabe Date: Thu, 13 Jun 2024 12:16:55 +0000 Subject: [PATCH 10/16] update --- .../neuronx-distributed/olmo/run_zero.py | 77 +++++++++++++++++++ .../neuronx-distributed/olmo/run_zero.sbatch | 6 ++ .../neuronx-distributed/olmo/run_zero.sh | 67 ++++++++++++++++ .../olmo/run_zero_compile.sbatch | 6 ++ .../olmo/{scratch_pad.py => train_zero.py} | 0 5 files changed, 156 insertions(+) create mode 100644 3.test_cases/neuronx-distributed/olmo/run_zero.py create mode 100644 3.test_cases/neuronx-distributed/olmo/run_zero.sbatch create mode 100755 3.test_cases/neuronx-distributed/olmo/run_zero.sh create mode 100644 3.test_cases/neuronx-distributed/olmo/run_zero_compile.sbatch rename 3.test_cases/neuronx-distributed/olmo/{scratch_pad.py => train_zero.py} (100%) diff --git a/3.test_cases/neuronx-distributed/olmo/run_zero.py b/3.test_cases/neuronx-distributed/olmo/run_zero.py new file mode 100644 index 00000000..3871fbd9 --- /dev/null +++ b/3.test_cases/neuronx-distributed/olmo/run_zero.py @@ -0,0 +1,77 @@ +import os +import torch +from torch.utils.data import DataLoader +from tqdm import tqdm +import torch.nn.functional as F +import torch_xla.core.xla_model as xm +# XLA imports for parallel loader and multi-processing +import torch_xla.distributed.parallel_loader as pl +from torch.utils.data.distributed import DistributedSampler +import torch_xla.distributed.xla_backend +from torch_xla.distributed.zero_redundancy_optimizer import ZeroRedundancyOptimizer + + +from olmo.config import ModelConfig, TrainConfig, TokenizerConfig +from olmo.datasets import SortDataset +from olmo.model import OLMo +from olmo.tokenizer import Tokenizer + +# Set Neuron SDK environment variables +os.environ["XLA_USE_BF16"] = "1" + + +# Initialize XLA process group for torchrun +torch.distributed.init_process_group('xla') +device = "xla" +# XLA MP: get world size +world_size = xm.xrt_world_size() +olmo_config = TrainConfig.load("./configs/OLMo-1B.yaml") +olmo_config.model.init_device = "cpu" +tokenizer = Tokenizer.from_train_config(olmo_config) +model = OLMo(olmo_config.model) +model = model.to(device) +print("Loaded olmo model") +# Define the batch size and sequence length +batch_size = 1 +# create train and test dataset +train_dataset = SortDataset('train') +test_dataset = SortDataset('test') +train_sampler = DistributedSampler( + train_dataset, + num_replicas=world_size, + rank=xm.get_ordinal(), + shuffle=True +) +train_loader = DataLoader( + train_dataset, + batch_size=1, + sampler=train_sampler +) +# We wrap the dataloader with MpDeviceLoader. This dataloader should take +# care of copying the tensors to device +train_loader = pl.MpDeviceLoader(train_loader, device) +#optimizer = torch.optim.Adam(model.parameters(), lr=1e-4) +optimizer = ZeroRedundancyOptimizer( + model.parameters(), torch.optim.Adam, + lr=1e-4, pin_layout=False +) + +model.train() +pbar = tqdm(train_loader) +for idx, (x, y) in enumerate(pbar): + optimizer.zero_grad() + # forward the model + logits = model(x) + loss = F.cross_entropy( + logits.view(-1, logits.size(-1)), + y.view(-1), + ignore_index=-1 + ) + # backprop and update the parameters + loss.backward() + optimizer.step() + #xm.optimizer_step(optimizer) # XLA MP: performs grad allreduce and optimizer step + pbar.set_description(f"Iteration: {idx}, train loss: {loss.item():.5f}") + +# XLA: use xm.save instead of torch.save to ensure states are moved back to cpu +xm.save(model.state_dict(), "model.pt") \ No newline at end of file diff --git a/3.test_cases/neuronx-distributed/olmo/run_zero.sbatch b/3.test_cases/neuronx-distributed/olmo/run_zero.sbatch new file mode 100644 index 00000000..4e163edb --- /dev/null +++ b/3.test_cases/neuronx-distributed/olmo/run_zero.sbatch @@ -0,0 +1,6 @@ +#!/bin/bash +#SBATCH --nodes=4 +#SBATCH --exclusive +#SBATCH --output=logs/slurm-%x-%j.out + +srun neuron_parallel_compile ./run_zero.sh MIXED \ No newline at end of file diff --git a/3.test_cases/neuronx-distributed/olmo/run_zero.sh b/3.test_cases/neuronx-distributed/olmo/run_zero.sh new file mode 100755 index 00000000..b7b71216 --- /dev/null +++ b/3.test_cases/neuronx-distributed/olmo/run_zero.sh @@ -0,0 +1,67 @@ +#!/bin/bash +set -o pipefail + +sudo rmmod neuron; sudo modprobe neuron +sudo sysctl -w net.ipv4.ip_local_reserved_ports=44000,48620 +sudo sysctl -w kernel.threads-max=10000000 +ulimit -c unlimited + +NUM_NEURONCORES=32 +DISTRIBUTED_ARGS="--nproc_per_node $NUM_NEURONCORES" + +LD_PRELOAD="/usr/lib/x86_64-linux-gnu/libtcmalloc.so.4" +MALLOC_ARENA_MAX=64 +echo "MALLOC_ARENA_MAX" $MALLOC_ARENA_MAX +echo "LD_PRELOAD" $LD_PRELOAD + +if [ ! -z "$SLURM_NTASKS" ]; then + # if running inside slurm, handle here + MASTER_ADDR=(`scontrol show hostnames $SLURM_JOB_NODELIST`) + MASTER_PORT=2022 + WORLD_SIZE_JOB=$SLURM_NTASKS + RANK_NODE=$SLURM_NODEID + JOB_ID_TAG=job-"$SLURM_JOB_ID" + DISTRIBUTED_ARGS="--nproc_per_node $NUM_NEURONCORES --nnodes $WORLD_SIZE_JOB --node_rank $RANK_NODE --master_addr $MASTER_ADDR --master_port $MASTER_PORT" + echo $DISTRIBUTED_ARGS + export NEURON_RT_ROOT_COMM_ID=$MASTER_ADDR:46820 + export FI_EFA_FORK_SAFE=1 + export FI_EFA_USE_DEVICE_RDMA=1 + export FI_PROVIDER=efa + echo "WORLD_SIZE_JOB=$WORLD_SIZE_JOB, RANK_NODE=$RANK_NODE, MASTER_ADDR_JOB=$MASTER_ADDR_JOB, NODE_LIST=$NODE_LIST" + export TRANSFORMERS_CACHE=$HOME/hf_cache/`hostname`/hub + export HF_DATASETS_CACHE=$HOME/hf_cache/`hostname`/datasets +fi + +#Print Slurm Config +date;hostname; + +export TRAINING_PRECISION=$1 #options FP32, BF16, MIXED +export NEURON_RT_STOCHASTIC_ROUNDING_EN=1 + +if [[ "BF16" == $TRAINING_PRECISION ]]; then + echo "USING BF16 ONLY" + export XLA_USE_BF16=1 + export NEURON_CC_FLAGS="--retry_failed_compilation --distribution-strategy llm-training --model-type transformer" +elif [[ "MIXED" == $TRAINING_PRECISION ]]; then + echo "USING MIXED PRECISION BF16 and FP32" + export NEURON_CC_FLAGS="--retry_failed_compilation --enable-mixed-precision-accumulation --distribution-strategy llm-training --model-type transformer" +else + echo "USING FP32 as default" + export NEURON_CC_FLAGS="--retry_failed_compilation --distribution-strategy llm-training --model-type transformer" +fi + +NEURON_CC_FLAGS+=" --cache_dir=$HOME/neuron_cache/gpt_1p5B/`hostname`" + +export DISABLE_NUMERIC_CC_TOKEN=1 +export NEURON_RT_HIERARCHICAL_CC=1 + +export NEURON_RT_EXEC_TIMEOUT=600 +export TF_NUM_INTEROP_THREADS=8192 + +export NEURON_ENABLE_NOSEED_DROPOUT=1 + +GRAD_ACCUM_STEP=1 +BATCH_SIZE=1 + +torchrun $DISTRIBUTED_ARGS run_zero.py \ + |& tee $LOG_FILE_NAME \ No newline at end of file diff --git a/3.test_cases/neuronx-distributed/olmo/run_zero_compile.sbatch b/3.test_cases/neuronx-distributed/olmo/run_zero_compile.sbatch new file mode 100644 index 00000000..4e163edb --- /dev/null +++ b/3.test_cases/neuronx-distributed/olmo/run_zero_compile.sbatch @@ -0,0 +1,6 @@ +#!/bin/bash +#SBATCH --nodes=4 +#SBATCH --exclusive +#SBATCH --output=logs/slurm-%x-%j.out + +srun neuron_parallel_compile ./run_zero.sh MIXED \ No newline at end of file diff --git a/3.test_cases/neuronx-distributed/olmo/scratch_pad.py b/3.test_cases/neuronx-distributed/olmo/train_zero.py similarity index 100% rename from 3.test_cases/neuronx-distributed/olmo/scratch_pad.py rename to 3.test_cases/neuronx-distributed/olmo/train_zero.py From 4c88fafe59abd316c44ab8dfcd85a6527f4488b1 Mon Sep 17 00:00:00 2001 From: Keita Watanabe Date: Thu, 13 Jun 2024 13:10:54 +0000 Subject: [PATCH 11/16] 7B failing --- .../neuronx-distributed/olmo/train_neuron.py | 59 +++++++++++++++++++ 1 file changed, 59 insertions(+) create mode 100644 3.test_cases/neuronx-distributed/olmo/train_neuron.py diff --git a/3.test_cases/neuronx-distributed/olmo/train_neuron.py b/3.test_cases/neuronx-distributed/olmo/train_neuron.py new file mode 100644 index 00000000..962b6a74 --- /dev/null +++ b/3.test_cases/neuronx-distributed/olmo/train_neuron.py @@ -0,0 +1,59 @@ +import os +import torch +from torch.utils.data import DataLoader +from tqdm import tqdm +import torch.nn.functional as F +import torch_xla.core.xla_model as xm +# XLA imports for parallel loader and multi-processing +import torch_xla.distributed.parallel_loader as pl +from torch_xla.distributed.zero_redundancy_optimizer import ZeroRedundancyOptimizer + + +from olmo.config import ModelConfig, TrainConfig, TokenizerConfig +from olmo.datasets import SortDataset +from olmo.model import OLMo +from olmo.tokenizer import Tokenizer + +# Set Neuron SDK environment variables +os.environ["XLA_USE_BF16"] = "1" + + +device = "xla" +olmo_config = TrainConfig.load("./configs/OLMo-7B.yaml") +olmo_config.model.init_device = "cpu" +#tokenizer = Tokenizer.from_train_config(olmo_config) +model = OLMo(olmo_config.model) +model = model.to(device) +print("Loaded olmo model") +# Define the batch size and sequence length +batch_size = 4 +# create train and test dataset +train_dataset = SortDataset('train') +test_dataset = SortDataset('test') +train_loader = DataLoader( + train_dataset, + batch_size=batch_size, +) +# We wrap the dataloader with MpDeviceLoader. This dataloader should take +# care of copying the tensors to device +train_loader = pl.MpDeviceLoader(train_loader, device) +optimizer = torch.optim.Adam(model.parameters(), lr=1e-4) +model.train() + +pbar = tqdm(train_loader) +for idx, (x, y) in enumerate(pbar): + optimizer.zero_grad() + # forward the model + logits = model(x) + loss = F.cross_entropy( + logits.view(-1, logits.size(-1)), + y.view(-1), + ignore_index=-1 + ) + # backprop and update the parameters + loss.backward() + xm.optimizer_step(optimizer) # XLA MP: performs grad allreduce and optimizer step + pbar.set_description(f"Iteration: {idx}, train loss: {loss.item():.5f}") + +# XLA: use xm.save instead of torch.save to ensure states are moved back to cpu +xm.save(model.state_dict(), "model.pt") \ No newline at end of file From 0afd579ea3be6594b7ed18506691e31fccafb3ca Mon Sep 17 00:00:00 2001 From: Keita Watanabe Date: Thu, 13 Jun 2024 13:11:15 +0000 Subject: [PATCH 12/16] add config --- .../olmo/configs/OLMo-7B.yaml | 648 ++++++++++++++++++ 1 file changed, 648 insertions(+) create mode 100644 3.test_cases/neuronx-distributed/olmo/configs/OLMo-7B.yaml diff --git a/3.test_cases/neuronx-distributed/olmo/configs/OLMo-7B.yaml b/3.test_cases/neuronx-distributed/olmo/configs/OLMo-7B.yaml new file mode 100644 index 00000000..002891bc --- /dev/null +++ b/3.test_cases/neuronx-distributed/olmo/configs/OLMo-7B.yaml @@ -0,0 +1,648 @@ +run_name: OLMo-7B +seed: 6198 +dry_run: false + +wandb: + name: ${run_name} + project: olmo-medium + group: OLMo-7B + +model: + d_model: 4096 + n_heads: 32 + n_layers: 32 + mlp_hidden_size: 22016 + weight_tying: false + alibi: false + rope: true + flash_attention: true + attention_dropout: 0.0 + attention_layer_norm: false + multi_query_attention: false + include_bias: false + block_type: sequential + layer_norm_type: default + layer_norm_with_affine: false + bias_for_layer_norm: false + attention_layer_norm_with_affine: false + activation_type: swiglu + residual_dropout: 0.0 + embedding_dropout: 0.0 + max_sequence_length: 2048 + vocab_size: 50280 + embedding_size: 50304 + eos_token_id: 50279 + pad_token_id: 1 + init_device: meta + init_fn: mitchell + +compile: + fullgraph: false + +optimizer: + name: adamw + learning_rate: 3.0e-4 + weight_decay: 0.1 + betas: + - 0.9 + - 0.95 + metrics_log_interval: 10 + +scheduler: + name: linear_with_warmup + t_warmup: 5000 + alpha_f: 0.1 + grad_clip_warmup_steps: 1000 + grad_clip_warmup_factor: 10.0 + +#tokenizer: +# identifier: tokenizers/allenai_eleuther-ai-gpt-neox-20b-pii-special.json +# truncate_direction: right +# +#save_folder: runs/${run_name} +#remote_save_folder: null +#save_overwrite: true +## Sharded checkpoints (best for restarts) +#save_interval: 1000 +#save_num_checkpoints_to_keep: -1 +## Unsharded checkpoints (for final storage) +#save_interval_unsharded: null +#save_num_unsharded_checkpoints_to_keep: -1 +# +#load_path: null +# +#max_duration: 2e12T # 2T tokens +#global_train_batch_size: 2048 +#device_train_microbatch_size: 2 +#time_limit: null +# +#precision: amp_bf16 +# +#fsdp: +# wrapping_strategy: by_block +# precision: mixed +# +#max_grad_norm: 1.0 +#max_grad_norm_ratio: null +# +#speed_monitor: +# window_size: 20 +# +#eval_interval: ${save_interval} +#eval_subset_num_batches: -1 +#device_eval_batch_size: ${device_train_microbatch_size} +#evaluators: +# - label: v3-small-ppl-validation +# data: +# num_workers: 0 +# drop_last: true +# datasets: +# v3-small-c4_en-validation: +# - https://olmo-data.org/eval-data/perplexity/v3_small_gptneox20b/c4_en/val/part-0-00000.npy +# v3-small-dolma_books-validation: +# - https://olmo-data.org/eval-data/perplexity/v3_small_gptneox20b/dolma_books/val/part-0-00000.npy +# v3-small-dolma_common-crawl-validation: +# - https://olmo-data.org/eval-data/perplexity/v3_small_gptneox20b/dolma_common-crawl/val/part-0-00000.npy +# v3-small-dolma_pes2o-validation: +# - https://olmo-data.org/eval-data/perplexity/v3_small_gptneox20b/dolma_pes2o/val/part-0-00000.npy +# v3-small-dolma_reddit-validation: +# - https://olmo-data.org/eval-data/perplexity/v3_small_gptneox20b/dolma_reddit/val/part-0-00000.npy +# v3-small-dolma_stack-validation: +# - https://olmo-data.org/eval-data/perplexity/v3_small_gptneox20b/dolma_stack/val/part-0-00000.npy +# v3-small-dolma_wiki-validation: +# - https://olmo-data.org/eval-data/perplexity/v3_small_gptneox20b/dolma_wiki/val/part-0-00000.npy +# v3-small-ice-validation: +# - https://olmo-data.org/eval-data/perplexity/v3_small_gptneox20b/ice/val/part-0-00000.npy +# v3-small-m2d2_s2orc-validation: +# - https://olmo-data.org/eval-data/perplexity/v3_small_gptneox20b/m2d2_s2orc/val/part-0-00000.npy +# v3-small-pile-validation: +# - https://olmo-data.org/eval-data/perplexity/v3_small_gptneox20b/pile/val/part-0-00000.npy +# v3-small-wikitext_103-validation: +# - https://olmo-data.org/eval-data/perplexity/v3_small_gptneox20b/wikitext_103/val/part-0-00000.npy +# +# - label: v2-small-ppl-validation +# data: +# num_workers: 0 +# drop_last: true +# datasets: +# v2-small-4chan-validation: +# - https://olmo-data.org/eval-data/perplexity/v2_small_gptneox20b/4chan/val.npy +# v2-small-c4_100_domains-validation: +# - https://olmo-data.org/eval-data/perplexity/v2_small_gptneox20b/c4_100_domains/val.npy +# v2-small-c4_en-validation: +# - https://olmo-data.org/eval-data/perplexity/v2_small_gptneox20b/c4_en/val.npy +# v2-small-gab-validation: +# - https://olmo-data.org/eval-data/perplexity/v2_small_gptneox20b/gab/val.npy +# v2-small-ice-validation: +# - https://olmo-data.org/eval-data/perplexity/v2_small_gptneox20b/ice/val.npy +# v2-small-m2d2_s2orc-validation: +# - https://olmo-data.org/eval-data/perplexity/v2_small_gptneox20b/m2d2_s2orc/val.npy +# v2-small-m2d2_wiki-validation: +# - https://olmo-data.org/eval-data/perplexity/v2_small_gptneox20b/m2d2_wiki/val.npy +# v2-small-manosphere-validation: +# - https://olmo-data.org/eval-data/perplexity/v2_small_gptneox20b/manosphere/val.npy +# v2-small-mc4_en-validation: +# - https://olmo-data.org/eval-data/perplexity/v2_small_gptneox20b/mc4_en/val.npy +# v2-small-pile-validation: +# - https://olmo-data.org/eval-data/perplexity/v2_small_gptneox20b/pile/val.npy +# v2-small-ptb-validation: +# - https://olmo-data.org/eval-data/perplexity/v2_small_gptneox20b/ptb/val.npy +# v2-small-twitterAEE-validation: +# - https://olmo-data.org/eval-data/perplexity/v2_small_gptneox20b/twitterAEE/val.npy +# v2-small-wikitext_103-validation: +# - https://olmo-data.org/eval-data/perplexity/v2_small_gptneox20b/wikitext_103/val.npy +# +# ########################## +# # Downstream evaluations # +# ########################## +# - label: piqa +# type: downstream +# +# - label: hellaswag +# type: downstream +# +# - label: winogrande +# type: downstream +# +# - label: openbook_qa +# type: downstream +# +# # - label: boolq # requires implemention of the pmi_dc matrix +# # type: downstream +# +# - label: sciq +# type: downstream +# +# - label: arc_easy +# type: downstream +# +# # - label: arc_challenge # requires implemention of the pmi_dc matrix +# # type: downstream +# +# - label: copa +# type: downstream +# +# - label: rte +# type: downstream +# +# - label: commitment_bank +# type: downstream +# +# - label: mrpc +# type: downstream +# +# - label: sst2 +# type: downstream +# +#data: +# pad_direction: right +# num_workers: 16 +# drop_last: true +# pin_memory: true +# prefetch_factor: 1 +# persistent_workers: true +# timeout: 0 +# paths: +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-000-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-000-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-001-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-001-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-002-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-002-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-003-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-003-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-004-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-004-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-005-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-005-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-006-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-006-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-006-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-007-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-007-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-008-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-008-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-008-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-009-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-009-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-010-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-010-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-010-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-011-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-011-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-012-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-012-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-013-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-013-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-013-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-014-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-014-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-014-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-015-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-015-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-016-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-016-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-017-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-017-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-018-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-018-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-019-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-019-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-020-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-020-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-021-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-021-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-022-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-022-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-023-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-023-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-024-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-024-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-025-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-025-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-025-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-026-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-026-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-027-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-027-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-027-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-028-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-028-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-028-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-029-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-029-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-030-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-030-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-031-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-031-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-032-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-032-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-033-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-033-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-033-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-034-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-034-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-034-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-035-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-035-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-036-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-036-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-037-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-037-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-038-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-038-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-039-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-039-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-040-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-040-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-041-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-041-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-042-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-042-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-042-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-043-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-043-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-043-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-044-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-044-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-044-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-045-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-045-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-046-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-046-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-046-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-046-00003.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-047-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-047-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-048-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-048-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-049-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-049-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-050-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-050-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-051-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-051-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-052-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-052-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-052-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-053-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-053-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-053-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-054-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-054-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-055-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-055-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-055-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-056-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-056-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-056-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-057-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-057-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-057-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-058-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-058-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-059-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-059-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-060-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-060-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-061-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-061-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-062-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-062-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-062-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-063-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-063-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-063-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-064-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-064-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-064-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-065-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-065-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-065-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-066-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-066-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-067-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-067-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-068-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-068-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-069-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-069-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-070-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-070-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-071-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-071-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-072-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-072-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-073-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-073-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-074-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-074-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-075-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-075-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-076-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-076-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-077-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-077-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-078-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-078-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-079-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-079-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-080-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-080-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-081-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-081-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-082-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-082-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-083-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-083-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-084-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-084-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-085-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-085-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-086-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-086-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-087-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-087-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-088-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-088-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-089-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-089-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-089-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-090-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-090-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-091-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-091-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-091-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-092-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-092-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-093-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-093-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-093-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-094-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-094-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-094-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-095-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-095-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-096-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-096-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-097-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-097-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-097-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-098-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-098-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-099-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-099-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-100-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-100-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-100-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-101-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-101-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-102-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-102-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-103-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-103-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-104-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-104-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-105-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-105-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-106-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-106-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-106-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-107-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-107-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-108-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-108-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-109-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-109-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-109-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-110-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-110-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-110-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-111-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-111-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-112-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-112-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-113-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-113-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-114-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-114-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-114-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-115-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-115-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-116-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-116-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-117-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-117-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-118-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-118-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-119-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-119-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-120-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-120-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-120-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-121-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-121-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-122-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-122-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-122-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-123-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-123-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-123-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-124-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-124-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-125-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-125-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-126-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-126-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-127-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-127-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-127-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-128-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-128-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-129-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-129-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-129-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-130-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-130-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-131-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-131-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-132-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-132-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-133-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-133-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-133-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-134-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-134-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-134-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-135-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-135-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-135-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-136-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-136-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-137-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-137-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-137-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-138-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-138-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-139-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-139-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-140-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-140-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-141-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-141-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-141-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-142-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-142-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-142-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-143-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-143-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-144-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-144-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-144-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-145-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-145-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-145-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-146-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-146-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-146-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-147-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-147-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-147-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-148-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-148-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-149-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-149-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-149-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-150-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-150-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-150-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-150-00003.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-151-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-151-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-152-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-152-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-153-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-153-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-154-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-154-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-155-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-155-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-155-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-156-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-156-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-157-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-157-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-157-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-158-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-158-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-159-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-159-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-160-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-160-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-161-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-161-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-161-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-162-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-162-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-163-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-163-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-164-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-164-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-165-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-165-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-165-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-166-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-166-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-166-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-167-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-167-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-167-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-168-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-168-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-169-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-169-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-170-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-170-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-171-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-171-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-172-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-172-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-173-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-173-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-173-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-174-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-174-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-174-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-175-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-175-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-175-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-176-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-176-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-176-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-177-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-177-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-178-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-178-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-179-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-179-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-180-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-180-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-181-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-181-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-182-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-182-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-182-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-183-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-183-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-183-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-184-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-184-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-185-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-185-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-185-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-186-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-186-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-186-00002.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-187-00000.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-187-00001.npy +# - https://olmo-data.org/preprocessed/olmo-mix/v1_5-sample/gpt-neox-20b-pii-special/part-187-00002.npy \ No newline at end of file From 6caa922746d886f2d6e041c568e3e8cb4ebce047 Mon Sep 17 00:00:00 2001 From: Keita Watanabe Date: Wed, 19 Jun 2024 23:57:06 +0000 Subject: [PATCH 13/16] fix zero --- 3.test_cases/neuronx-distributed/olmo/run_zero.py | 4 ++-- 3.test_cases/neuronx-distributed/olmo/train_zero.py | 6 +++--- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/3.test_cases/neuronx-distributed/olmo/run_zero.py b/3.test_cases/neuronx-distributed/olmo/run_zero.py index 3871fbd9..25ef66f7 100644 --- a/3.test_cases/neuronx-distributed/olmo/run_zero.py +++ b/3.test_cases/neuronx-distributed/olmo/run_zero.py @@ -25,7 +25,7 @@ device = "xla" # XLA MP: get world size world_size = xm.xrt_world_size() -olmo_config = TrainConfig.load("./configs/OLMo-1B.yaml") +olmo_config = TrainConfig.load("./configs/OLMo-7B.yaml") olmo_config.model.init_device = "cpu" tokenizer = Tokenizer.from_train_config(olmo_config) model = OLMo(olmo_config.model) @@ -74,4 +74,4 @@ pbar.set_description(f"Iteration: {idx}, train loss: {loss.item():.5f}") # XLA: use xm.save instead of torch.save to ensure states are moved back to cpu -xm.save(model.state_dict(), "model.pt") \ No newline at end of file +xm.save(model.state_dict(), "model.pt") diff --git a/3.test_cases/neuronx-distributed/olmo/train_zero.py b/3.test_cases/neuronx-distributed/olmo/train_zero.py index 7d9ea1c8..6aab6fc3 100644 --- a/3.test_cases/neuronx-distributed/olmo/train_zero.py +++ b/3.test_cases/neuronx-distributed/olmo/train_zero.py @@ -21,7 +21,7 @@ device = "xla" olmo_config = TrainConfig.load("./configs/OLMo-1B.yaml") olmo_config.model.init_device = "cpu" -tokenizer = Tokenizer.from_train_config(olmo_config) +#tokenizer = Tokenizer.from_train_config(olmo_config) model = OLMo(olmo_config.model) model = model.to(device) print("Loaded olmo model") @@ -40,7 +40,7 @@ #optimizer = torch.optim.Adam(model.parameters(), lr=1e-4) optimizer = ZeroRedundancyOptimizer( model.parameters(), torch.optim.Adam, - lr=1e-4 + lr=1e-4, pin_layout=False ) model.train() @@ -61,4 +61,4 @@ pbar.set_description(f"Iteration: {idx}, train loss: {loss.item():.5f}") # XLA: use xm.save instead of torch.save to ensure states are moved back to cpu -xm.save(model.state_dict(), "model.pt") \ No newline at end of file +xm.save(model.state_dict(), "model.pt") From dd37ca07cc4928b702e3ca8cdd782189f64f6448 Mon Sep 17 00:00:00 2001 From: Keita Watanabe Date: Sun, 21 Jul 2024 01:49:33 +0000 Subject: [PATCH 14/16] update with evaluation --- .../neuronx-distributed/mingpt/0.cpu.py | 22 ++++- .../mingpt/2.ddp-neuron.py | 53 ++++++++++ .../mingpt/mingpt/configs.py | 77 ++++++++++++++- .../mingpt/mingpt/datasets.py | 2 +- .../mingpt/mingpt/model.py | 4 +- .../mingpt/mingpt/utils.py | 96 +++++-------------- 6 files changed, 171 insertions(+), 83 deletions(-) create mode 100644 3.test_cases/neuronx-distributed/mingpt/2.ddp-neuron.py diff --git a/3.test_cases/neuronx-distributed/mingpt/0.cpu.py b/3.test_cases/neuronx-distributed/mingpt/0.cpu.py index b79083ef..ecf853b6 100644 --- a/3.test_cases/neuronx-distributed/mingpt/0.cpu.py +++ b/3.test_cases/neuronx-distributed/mingpt/0.cpu.py @@ -5,17 +5,23 @@ from torch.nn import functional as F from mingpt.model import GPT from mingpt.datasets import SortDataset -from mingpt.trainer import Trainer from mingpt.configs import TrainConfig +from mingpt.utils import evaluate # create train and test dataset -train_dataset = SortDataset('train') -test_dataset = SortDataset('test') +length = 6 +num_digits = 3 +train_dataset = SortDataset('train', length, num_digits) +test_dataset = SortDataset('test', length, num_digits) train_config = TrainConfig.get_default_config() train_loader = DataLoader( train_dataset, batch_size=train_config.batch_size, - ) +) +test_loader = DataLoader( + test_dataset, + batch_size=train_config.batch_size, +) # create a GPT instance model_config = GPT.get_default_config() @@ -39,4 +45,10 @@ # backprop and update the parameters loss.backward() optimizer.step() - pbar.set_description(f"Iteration: {idx}, train loss: {loss.item():.5f}") \ No newline at end of file + pbar.set_description(f"Iteration: {idx}, train loss: {loss.item():.5f}") + +model = model.eval() +print("Evaluate performance with train_loader") +evaluate(model, train_loader, length, max_batches=50) +print("Evaluate performance with test_loader") +evaluate(model, test_loader, length, max_batches=50) \ No newline at end of file diff --git a/3.test_cases/neuronx-distributed/mingpt/2.ddp-neuron.py b/3.test_cases/neuronx-distributed/mingpt/2.ddp-neuron.py new file mode 100644 index 00000000..c5863dd8 --- /dev/null +++ b/3.test_cases/neuronx-distributed/mingpt/2.ddp-neuron.py @@ -0,0 +1,53 @@ +import torch +from torch.utils.data import DataLoader +from tqdm import tqdm +from torch.nn import functional as F +import torch_xla.core.xla_model as xm +# XLA imports for parallel loader and multi-processing +import torch_xla.distributed.parallel_loader as pl + +from mingpt.model import GPT +from mingpt.datasets import SortDataset +from mingpt.trainer import Trainer +from mingpt.configs import TrainConfig + + + +device = 'xla' +# create train and test dataset +train_dataset = SortDataset('train') +test_dataset = SortDataset('test') +train_config = TrainConfig.get_default_config() +train_loader = DataLoader( + train_dataset, + batch_size=train_config.batch_size, + ) +# We wrap the dataloader with MpDeviceLoader. This dataloader should take +# care of copying the tensors to device +train_loader = pl.MpDeviceLoader(train_loader, device) + +# create a GPT instance +model_config = GPT.get_default_config() +model_config.model_type = 'gpt-nano' +model_config.vocab_size = train_dataset.get_vocab_size() +model_config.block_size = train_dataset.get_block_size() +model = GPT(model_config) +model = model.to(device) +optimizer = model.configure_optimizers(train_config) + + +model.train() +pbar = tqdm(train_loader) +for idx, (x, y) in enumerate(pbar): + optimizer.zero_grad() + # forward the model + logits = model(x) + loss = F.cross_entropy( + logits.view(-1, logits.size(-1)), + y.view(-1), + ignore_index=-1 + ) + # backprop and update the parameters + loss.backward() + xm.optimizer_step(optimizer) # XLA MP: performs grad allreduce and optimizer step + pbar.set_description(f"Iteration: {idx}, train loss: {loss.item():.5f}") diff --git a/3.test_cases/neuronx-distributed/mingpt/mingpt/configs.py b/3.test_cases/neuronx-distributed/mingpt/mingpt/configs.py index 75114dde..3557b183 100644 --- a/3.test_cases/neuronx-distributed/mingpt/mingpt/configs.py +++ b/3.test_cases/neuronx-distributed/mingpt/mingpt/configs.py @@ -1,16 +1,87 @@ -from mingpt.utils import CfgNode as CN +from ast import literal_eval + +class CfgNode: + """ a lightweight configuration class inspired by yacs """ + + def __init__(self, **kwargs): + self.__dict__.update(kwargs) + + def __str__(self): + return self._str_helper(0) + + def _str_helper(self, indent): + """ need to have a helper to support nested indentation for pretty printing """ + parts = [] + for k, v in self.__dict__.items(): + if isinstance(v, CfgNode): + parts.append("%s:\n" % k) + parts.append(v._str_helper(indent + 1)) + else: + parts.append("%s: %s\n" % (k, v)) + parts = [' ' * (indent * 4) + p for p in parts] + return "".join(parts) + + def to_dict(self): + """ return a dict representation of the config """ + return { k: v.to_dict() if isinstance(v, CfgNode) else v for k, v in self.__dict__.items() } + + def merge_from_dict(self, d): + self.__dict__.update(d) + + def merge_from_args(self, args): + """ + update the configuration from a list of strings that is expected + to come from the command line, i.e. sys.argv[1:]. + + The arguments are expected to be in the form of `--arg=value`, and + the arg can use . to denote nested sub-attributes. Example: + + --model.n_layer=10 --trainer.batch_size=32 + """ + for arg in args: + + keyval = arg.split('=') + assert len(keyval) == 2, "expecting each override arg to be of form --arg=value, got %s" % arg + key, val = keyval # unpack + + # first translate val into a python object + try: + val = literal_eval(val) + """ + need some explanation here. + - if val is simply a string, literal_eval will throw a ValueError + - if val represents a thing (like an 3, 3.14, [1,2,3], False, None, etc.) it will get created + """ + except ValueError: + pass + + # find the appropriate object to insert the attribute into + assert key[:2] == '--' + key = key[2:] # strip the '--' + keys = key.split('.') + obj = self + for k in keys[:-1]: + obj = getattr(obj, k) + leaf_key = keys[-1] + + # ensure that this attribute exists + assert hasattr(obj, leaf_key), f"{key} is not an attribute that exists in the config" + + # overwrite the attribute + print("command line overwriting config attribute %s with %s" % (key, val)) + setattr(obj, leaf_key, val) class TrainConfig: @staticmethod def get_default_config(): - C = CN() + C = CfgNode() # device to train on C.device = 'auto' # dataloder parameters C.num_workers = 0 # optimizer parameters C.batch_size = 8 - C.learning_rate = 3e-4 + C.learning_rate = 5e-4 C.betas = (0.9, 0.95) C.max_iters = 8000 C.weight_decay = 0.1 # only applied on matmul weights diff --git a/3.test_cases/neuronx-distributed/mingpt/mingpt/datasets.py b/3.test_cases/neuronx-distributed/mingpt/mingpt/datasets.py index 95d1f28c..cbb7bbc9 100644 --- a/3.test_cases/neuronx-distributed/mingpt/mingpt/datasets.py +++ b/3.test_cases/neuronx-distributed/mingpt/mingpt/datasets.py @@ -84,7 +84,7 @@ class SortDataset(Dataset): where I is "ignore", as the transformer is reading the input sequence """ - def __init__(self, split, length=6, num_digits=3): + def __init__(self, split, length=8, num_digits=4): assert split in {'train', 'test'} self.split = split self.length = length diff --git a/3.test_cases/neuronx-distributed/mingpt/mingpt/model.py b/3.test_cases/neuronx-distributed/mingpt/mingpt/model.py index 4b1f7cdc..4e41e480 100644 --- a/3.test_cases/neuronx-distributed/mingpt/mingpt/model.py +++ b/3.test_cases/neuronx-distributed/mingpt/mingpt/model.py @@ -14,7 +14,7 @@ import torch.nn as nn from torch.nn import functional as F -from mingpt.utils import CfgNode as CN +from mingpt.configs import CfgNode as CN # ----------------------------------------------------------------------------- @@ -285,7 +285,7 @@ def generate(self, idx, max_new_tokens, temperature=1.0, do_sample=False, top_k= # if the sequence context is growing too long we must crop it at block_size idx_cond = idx if idx.size(1) <= self.block_size else idx[:, -self.block_size:] # forward the model to get the logits for the index in the sequence - logits, _ = self(idx_cond) + logits = self(idx_cond) # pluck the logits at the final step and scale by desired temperature logits = logits[:, -1, :] / temperature # optionally crop the logits to only the top k options diff --git a/3.test_cases/neuronx-distributed/mingpt/mingpt/utils.py b/3.test_cases/neuronx-distributed/mingpt/mingpt/utils.py index 9b7ea6b7..b6e68a49 100644 --- a/3.test_cases/neuronx-distributed/mingpt/mingpt/utils.py +++ b/3.test_cases/neuronx-distributed/mingpt/mingpt/utils.py @@ -3,13 +3,36 @@ import sys import json import random -from ast import literal_eval import numpy as np import torch # ----------------------------------------------------------------------------- +def evaluate(model, loader, n, split="train", max_batches=None): + results = [] + mistakes_printed_already = 0 + for b, (x, y) in enumerate(loader): + # isolate the input pattern alone + inp = x[:, :n] + sol = y[:, -n:] + # let the model sample the rest of the sequence + cat = model.generate(inp, n, do_sample=False) # using greedy argmax, not sampling + sol_candidate = cat[:, n:] # isolate the filled in sequence + # compare the predicted sequence to the true sequence + correct = (sol == sol_candidate).all(1).cpu() # Software 1.0 vs. Software 2.0 fight RIGHT on this line haha + for i in range(x.size(0)): + results.append(int(correct[i])) + if not correct[i] and mistakes_printed_already < 3: # only print up to 5 mistakes to get a sense + mistakes_printed_already += 1 + print("GPT claims that %s sorted is %s but gt is %s" % (inp[i].tolist(), sol_candidate[i].tolist(), sol[i].tolist())) + if max_batches is not None and b+1 >= max_batches: + break + rt = torch.tensor(results, dtype=torch.float) + print("%s final score: %d/%d = %.2f%% correct" % (split, rt.sum(), len(results), 100*rt.mean())) + return rt.sum() + + def set_seed(seed): random.seed(seed) np.random.seed(seed) @@ -27,74 +50,3 @@ def setup_logging(config): # log the config itself with open(os.path.join(work_dir, 'config.json'), 'w') as f: f.write(json.dumps(config.to_dict(), indent=4)) - -class CfgNode: - """ a lightweight configuration class inspired by yacs """ - - def __init__(self, **kwargs): - self.__dict__.update(kwargs) - - def __str__(self): - return self._str_helper(0) - - def _str_helper(self, indent): - """ need to have a helper to support nested indentation for pretty printing """ - parts = [] - for k, v in self.__dict__.items(): - if isinstance(v, CfgNode): - parts.append("%s:\n" % k) - parts.append(v._str_helper(indent + 1)) - else: - parts.append("%s: %s\n" % (k, v)) - parts = [' ' * (indent * 4) + p for p in parts] - return "".join(parts) - - def to_dict(self): - """ return a dict representation of the config """ - return { k: v.to_dict() if isinstance(v, CfgNode) else v for k, v in self.__dict__.items() } - - def merge_from_dict(self, d): - self.__dict__.update(d) - - def merge_from_args(self, args): - """ - update the configuration from a list of strings that is expected - to come from the command line, i.e. sys.argv[1:]. - - The arguments are expected to be in the form of `--arg=value`, and - the arg can use . to denote nested sub-attributes. Example: - - --model.n_layer=10 --trainer.batch_size=32 - """ - for arg in args: - - keyval = arg.split('=') - assert len(keyval) == 2, "expecting each override arg to be of form --arg=value, got %s" % arg - key, val = keyval # unpack - - # first translate val into a python object - try: - val = literal_eval(val) - """ - need some explanation here. - - if val is simply a string, literal_eval will throw a ValueError - - if val represents a thing (like an 3, 3.14, [1,2,3], False, None, etc.) it will get created - """ - except ValueError: - pass - - # find the appropriate object to insert the attribute into - assert key[:2] == '--' - key = key[2:] # strip the '--' - keys = key.split('.') - obj = self - for k in keys[:-1]: - obj = getattr(obj, k) - leaf_key = keys[-1] - - # ensure that this attribute exists - assert hasattr(obj, leaf_key), f"{key} is not an attribute that exists in the config" - - # overwrite the attribute - print("command line overwriting config attribute %s with %s" % (key, val)) - setattr(obj, leaf_key, val) From 7cf634a85842bc70f1f2b068bd40a337dfc33f2c Mon Sep 17 00:00:00 2001 From: Keita Watanabe Date: Sun, 21 Jul 2024 02:04:58 +0000 Subject: [PATCH 15/16] update 1.neuron --- .../neuronx-distributed/mingpt/1.neuron.py | 23 +++++++++++++++---- 1 file changed, 18 insertions(+), 5 deletions(-) diff --git a/3.test_cases/neuronx-distributed/mingpt/1.neuron.py b/3.test_cases/neuronx-distributed/mingpt/1.neuron.py index c5863dd8..2b1b2497 100644 --- a/3.test_cases/neuronx-distributed/mingpt/1.neuron.py +++ b/3.test_cases/neuronx-distributed/mingpt/1.neuron.py @@ -1,6 +1,7 @@ import torch from torch.utils.data import DataLoader from tqdm import tqdm + from torch.nn import functional as F import torch_xla.core.xla_model as xm # XLA imports for parallel loader and multi-processing @@ -8,23 +9,29 @@ from mingpt.model import GPT from mingpt.datasets import SortDataset -from mingpt.trainer import Trainer from mingpt.configs import TrainConfig - +from mingpt.utils import evaluate device = 'xla' # create train and test dataset -train_dataset = SortDataset('train') -test_dataset = SortDataset('test') +length = 6 +num_digits = 3 +train_dataset = SortDataset('train', length, num_digits) +test_dataset = SortDataset('test', length, num_digits) train_config = TrainConfig.get_default_config() train_loader = DataLoader( train_dataset, batch_size=train_config.batch_size, - ) +) +test_loader = DataLoader( + test_dataset, + batch_size=train_config.batch_size, +) # We wrap the dataloader with MpDeviceLoader. This dataloader should take # care of copying the tensors to device train_loader = pl.MpDeviceLoader(train_loader, device) +test_loader = pl.MpDeviceLoader(test_loader, device) # create a GPT instance model_config = GPT.get_default_config() @@ -51,3 +58,9 @@ loss.backward() xm.optimizer_step(optimizer) # XLA MP: performs grad allreduce and optimizer step pbar.set_description(f"Iteration: {idx}, train loss: {loss.item():.5f}") + +model.eval() +print("Evaluate performance with train_loader") +evaluate(model, train_loader, length, max_batches=50) +print("Evaluate performance with test_loader") +evaluate(model, test_loader, length, max_batches=50) \ No newline at end of file From 749cea144630061d2d5ce255091a34208c8efb69 Mon Sep 17 00:00:00 2001 From: Keita Watanabe Date: Sun, 21 Jul 2024 02:36:08 +0000 Subject: [PATCH 16/16] add ddp --- .../neuronx-distributed/mingpt/0.cpu.py | 2 +- .../mingpt/2.ddp-neuron.py | 29 +++++++++++++++---- 2 files changed, 24 insertions(+), 7 deletions(-) diff --git a/3.test_cases/neuronx-distributed/mingpt/0.cpu.py b/3.test_cases/neuronx-distributed/mingpt/0.cpu.py index ecf853b6..3345f63d 100644 --- a/3.test_cases/neuronx-distributed/mingpt/0.cpu.py +++ b/3.test_cases/neuronx-distributed/mingpt/0.cpu.py @@ -47,7 +47,7 @@ optimizer.step() pbar.set_description(f"Iteration: {idx}, train loss: {loss.item():.5f}") -model = model.eval() +model.eval() print("Evaluate performance with train_loader") evaluate(model, train_loader, length, max_batches=50) print("Evaluate performance with test_loader") diff --git a/3.test_cases/neuronx-distributed/mingpt/2.ddp-neuron.py b/3.test_cases/neuronx-distributed/mingpt/2.ddp-neuron.py index c5863dd8..752fdae1 100644 --- a/3.test_cases/neuronx-distributed/mingpt/2.ddp-neuron.py +++ b/3.test_cases/neuronx-distributed/mingpt/2.ddp-neuron.py @@ -1,6 +1,7 @@ import torch from torch.utils.data import DataLoader from tqdm import tqdm + from torch.nn import functional as F import torch_xla.core.xla_model as xm # XLA imports for parallel loader and multi-processing @@ -8,23 +9,33 @@ from mingpt.model import GPT from mingpt.datasets import SortDataset -from mingpt.trainer import Trainer from mingpt.configs import TrainConfig +from mingpt.utils import evaluate +torch.distributed.init_process_group('xla') +device = xm.xla_device() +rank = xm.get_ordinal() +world_size = xm.xrt_world_size() - -device = 'xla' +print(f'rank: {rank}, world size {world_size}') # create train and test dataset -train_dataset = SortDataset('train') -test_dataset = SortDataset('test') +length = 6 +num_digits = 3 +train_dataset = SortDataset('train', length, num_digits) +test_dataset = SortDataset('test', length, num_digits) train_config = TrainConfig.get_default_config() train_loader = DataLoader( train_dataset, batch_size=train_config.batch_size, - ) +) +test_loader = DataLoader( + test_dataset, + batch_size=train_config.batch_size, +) # We wrap the dataloader with MpDeviceLoader. This dataloader should take # care of copying the tensors to device train_loader = pl.MpDeviceLoader(train_loader, device) +test_loader = pl.MpDeviceLoader(test_loader, device) # create a GPT instance model_config = GPT.get_default_config() @@ -51,3 +62,9 @@ loss.backward() xm.optimizer_step(optimizer) # XLA MP: performs grad allreduce and optimizer step pbar.set_description(f"Iteration: {idx}, train loss: {loss.item():.5f}") + +model.eval() +print("Evaluate performance with train_loader") +evaluate(model, train_loader, length, max_batches=50) +print("Evaluate performance with test_loader") +evaluate(model, test_loader, length, max_batches=50) \ No newline at end of file