Transformer-Token-Choice-MoE-shakesphere-char.ipynb

transformer-token-choice-moe-shakesphere-char.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "A100",
      "machine_shape": "hm",
      "authorship_tag": "ABX9TyMtnzK/yele0ZtwFKR5kJWj",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/gist/mauicv/75b8a40edafc96c0f9d6a84b16f3c708/transformer-token-choice-moe-shakesphere-char.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "26UTHYvigRm_",
        "outputId": "4020e4cb-c03d-4ea0-dce9-822f1ab0440b"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ],
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install -q git+https://github.com/mauicv/transformers@feature/token-choice-moe"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ULd-3x193Olb",
        "outputId": "eb94442a-38c8-42f2-f2e1-f44e58059b74"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "  Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n",
            "  Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n",
            "  Installing backend dependencies ... \u001b[?25l\u001b[?25hdone\n",
            "  Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n",
            "  Building wheel for pytfex (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install -q tokenizers\n",
        "!pip install -q tiktoken\n",
        "!pip install -q livelossplot"
      ],
      "metadata": {
        "id": "QQB3fgwIgdQW",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9bbcd3b4-87fd-4d5f-d7eb-8f4457635d4a"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.0/2.0 MB\u001b[0m \u001b[31m9.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25h\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n",
            "llmx 0.0.15a0 requires cohere, which is not installed.\n",
            "llmx 0.0.15a0 requires openai, which is not installed.\u001b[0m\u001b[31m\n",
            "\u001b[0m"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# The following is taken from https://github.com/karpathy/nanoGPT/tree/master/data/shakespeare_char\n",
        "\n",
        "\"\"\"\n",
        "Prepare the Shakespeare dataset for character-level language modeling.\n",
        "So instead of encoding with GPT-2 BPE tokens, we just map characters to ints.\n",
        "Will save train.bin, val.bin containing the ids, and meta.pkl containing the\n",
        "encoder and decoder and some other related info.\n",
        "\"\"\"\n",
        "import os\n",
        "import pickle\n",
        "import requests\n",
        "import numpy as np\n",
        "\n",
        "# download the tiny shakespeare dataset\n",
        "data_dir = './data'\n",
        "if not os.path.isdir(data_dir):\n",
        "    os.mkdir(data_dir)\n",
        "input_file_path = os.path.join(data_dir, 'input.txt')\n",
        "if not os.path.exists(input_file_path):\n",
        "    data_url = 'https://raw.githubusercontent.com/karpathy/char-rnn/master/data/tinyshakespeare/input.txt'\n",
        "    with open(input_file_path, 'w') as f:\n",
        "        f.write(requests.get(data_url).text)\n",
        "\n",
        "with open(input_file_path, 'r') as f:\n",
        "    data = f.read()\n",
        "print(f\"length of dataset in characters: {len(data):,}\")\n",
        "\n",
        "# get all the unique characters that occur in this text\n",
        "chars = sorted(list(set(data)))\n",
        "vocab_size = len(chars)\n",
        "print(\"all the unique characters:\", ''.join(chars))\n",
        "print(f\"vocab size: {vocab_size:,}\")\n",
        "\n",
        "# create a mapping from characters to integers\n",
        "stoi = { ch:i for i,ch in enumerate(chars) }\n",
        "itos = { i:ch for i,ch in enumerate(chars) }\n",
        "def encode(s):\n",
        "    return [stoi[c] for c in s] # encoder: take a string, output a list of integers\n",
        "def decode(l):\n",
        "    return ''.join([itos[i] for i in l]) # decoder: take a list of integers, output a string\n",
        "\n",
        "# create the train and test splits\n",
        "n = len(data)\n",
        "train_data = data[:int(n*0.9)]\n",
        "val_data = data[int(n*0.9):]\n",
        "\n",
        "# encode both to integers\n",
        "train_ids = encode(train_data)\n",
        "val_ids = encode(val_data)\n",
        "print(f\"train has {len(train_ids):,} tokens\")\n",
        "print(f\"val has {len(val_ids):,} tokens\")\n",
        "\n",
        "# export to bin files\n",
        "train_ids = np.array(train_ids, dtype=np.uint16)\n",
        "val_ids = np.array(val_ids, dtype=np.uint16)\n",
        "train_ids.tofile(os.path.join(data_dir, 'train.bin'))\n",
        "val_ids.tofile(os.path.join(data_dir, 'val.bin'))\n",
        "\n",
        "# save the meta information as well, to help us encode/decode later\n",
        "meta = {\n",
        "    'vocab_size': vocab_size,\n",
        "    'itos': itos,\n",
        "    'stoi': stoi,\n",
        "}\n",
        "with open(os.path.join(data_dir, 'meta.pkl'), 'wb') as f:\n",
        "    pickle.dump(meta, f)\n",
        "\n",
        "# length of dataset in characters:  1115394\n",
        "# all the unique characters:\n",
        "#  !$&',-.3:;?ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\n",
        "# vocab size: 65\n",
        "# train has 1003854 tokens\n",
        "# val has 111540 tokens"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gwue7RgXNarJ",
        "outputId": "1499ce02-9e7f-493b-da2d-325ddbe59b4f"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "length of dataset in characters: 1,115,394\n",
            "all the unique characters: \n",
            " !$&',-.3:;?ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\n",
            "vocab size: 65\n",
            "train has 1,003,854 tokens\n",
            "val has 111,540 tokens\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "import numpy as np\n",
        "import os\n",
        "import torch\n",
        "import yaml\n",
        "\n",
        "from pytfex.transformer.mask import get_causal_mask\n",
        "from torch.optim.lr_scheduler import ExponentialLR\n",
        "\n",
        "data_dir = 'data'\n",
        "block_size = 256\n",
        "batch_size = 64+32\n",
        "device = 'cuda'\n",
        "# device = 'cpu'\n",
        "\n",
        "train_data = np.memmap(os.path.join(data_dir, 'train.bin'), dtype=np.uint16, mode='r')\n",
        "val_data = np.memmap(os.path.join(data_dir, 'val.bin'), dtype=np.uint16, mode='r')\n",
        "\n",
        "def get_batch(split):\n",
        "    data = train_data if split == 'train' else val_data\n",
        "    ix = torch.randint(len(data) - block_size, (batch_size,))\n",
        "    x = torch.stack([torch.from_numpy((data[i:i+block_size]).astype(np.int64)) for i in ix])\n",
        "    y = torch.stack([torch.from_numpy((data[i+1:i+1+block_size]).astype(np.int64)) for i in ix])\n",
        "    x, y = x.to(device), y.to(device)\n",
        "    return x, y\n",
        "\n",
        "def validate(model):\n",
        "    total = 0\n",
        "    sum_acc = 0\n",
        "    mask = get_causal_mask(block_size).to(device)\n",
        "    for _ in range(3):\n",
        "        x, y_true = get_batch('val')\n",
        "        y_pred = model(x, mask=mask)\n",
        "        r = torch.eq(y_true, y_pred.argmax(dim=-1))\n",
        "        b, l = r.shape\n",
        "        total += b*l\n",
        "        sum_acc += r.sum()\n",
        "    acc = sum_acc / total\n",
        "    return acc\n",
        "\n"
      ],
      "metadata": {
        "id": "qW7GwKWphn0c"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from pytfex.models import get_model, GPTTokenChoiceMoEConfig\n",
        "\n",
        "config = GPTTokenChoiceMoEConfig(\n",
        "    num_layers=6,\n",
        "    num_experts=8,\n",
        "    k=2,\n",
        "    hdn_dim=1024,\n",
        "    mlp_hdn_dim=int(1024),\n",
        "    batch_size=batch_size,\n",
        "    dropout=0.01,\n",
        "    num_heads=16\n",
        ")\n",
        "\n",
        "model = get_model(config)\n",
        "model.to(device)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xuNofb90h_8l",
        "outputId": "7e2238f7-c276-4f70-bc6a-97d433b50147"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "GPT(\n",
              "  (drop): Dropout(p=0.01, inplace=False)\n",
              "  (embedder): MultiEmbedder(\n",
              "    (embedders): ModuleList(\n",
              "      (0): TokenEmbedder(\n",
              "        (tok_emb): Embedding(65, 1024)\n",
              "      )\n",
              "      (1): PositionEmbedder(\n",
              "        (pos_emb): Embedding(256, 1024)\n",
              "      )\n",
              "    )\n",
              "  )\n",
              "  (layers): ModuleList(\n",
              "    (0-5): 6 x TransformerLayer(\n",
              "      (attn): Attention(\n",
              "        (attn_dropout): Dropout(p=0.009999999776482582, inplace=False)\n",
              "        (resid_dropout): Dropout(p=0.009999999776482582, inplace=False)\n",
              "        (qkv): Linear(in_features=1024, out_features=3072, bias=True)\n",
              "        (linear): Linear(in_features=1024, out_features=1024, bias=True)\n",
              "      )\n",
              "      (mlp): TokenChoiceMoE(\n",
              "        (experts): ModuleList(\n",
              "          (0-7): 8 x MLP(\n",
              "            (mlp_dropout): Dropout(p=0.009999999776482582, inplace=False)\n",
              "            (linear1): Linear(in_features=1024, out_features=1024, bias=True)\n",
              "            (linear2): Linear(in_features=1024, out_features=1024, bias=True)\n",
              "          )\n",
              "        )\n",
              "        (gate): Linear(in_features=1024, out_features=8, bias=False)\n",
              "      )\n",
              "      (ln_1): LayerNorm((1024,), eps=1e-05, elementwise_affine=True)\n",
              "      (ln_2): LayerNorm((1024,), eps=1e-05, elementwise_affine=True)\n",
              "    )\n",
              "  )\n",
              "  (head): ClassificationHead(\n",
              "    (ln_f): LayerNorm((1024,), eps=1e-05, elementwise_affine=True)\n",
              "    (linear): Linear(in_features=1024, out_features=65, bias=False)\n",
              "  )\n",
              ")"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from pytfex.utils import count_parameters\n",
        "\n",
        "count_parameters(model)"
      ],
      "metadata": {
        "id": "0iOwty520VIw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "de8e0167-90df-4ad0-c8d7-87a3058cfba8"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "126423040"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "75974656"
      ],
      "metadata": {
        "id": "KUK5nG0XGqs0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "383438a3-e142-485a-9132-bddd405da1c8"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "75974656"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torch.nn as nn\n",
        "\n",
        "def _init_weights(module):\n",
        "    if isinstance(module, (nn.Linear, nn.Embedding)):\n",
        "        module.weight.data.normal_(mean=0.0, std=0.02)\n",
        "        if isinstance(module, nn.Linear) and module.bias is not None:\n",
        "            module.bias.data.zero_()\n",
        "    elif isinstance(module, nn.LayerNorm):\n",
        "        module.bias.data.zero_()\n",
        "        module.weight.data.fill_(1.0)\n",
        "\n",
        "model.apply(_init_weights)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1jtKtIisTbH7",
        "outputId": "4af1e72b-6ba1-461a-f27f-3e59ea5e063d"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "GPT(\n",
              "  (drop): Dropout(p=0.01, inplace=False)\n",
              "  (embedder): MultiEmbedder(\n",
              "    (embedders): ModuleList(\n",
              "      (0): TokenEmbedder(\n",
              "        (tok_emb): Embedding(65, 1024)\n",
              "      )\n",
              "      (1): PositionEmbedder(\n",
              "        (pos_emb): Embedding(256, 1024)\n",
              "      )\n",
              "    )\n",
              "  )\n",
              "  (layers): ModuleList(\n",
              "    (0-5): 6 x TransformerLayer(\n",
              "      (attn): Attention(\n",
              "        (attn_dropout): Dropout(p=0.009999999776482582, inplace=False)\n",
              "        (resid_dropout): Dropout(p=0.009999999776482582, inplace=False)\n",
              "        (qkv): Linear(in_features=1024, out_features=3072, bias=True)\n",
              "        (linear): Linear(in_features=1024, out_features=1024, bias=True)\n",
              "      )\n",
              "      (mlp): TokenChoiceMoE(\n",
              "        (experts): ModuleList(\n",
              "          (0-7): 8 x MLP(\n",
              "            (mlp_dropout): Dropout(p=0.009999999776482582, inplace=False)\n",
              "            (linear1): Linear(in_features=1024, out_features=1024, bias=True)\n",
              "            (linear2): Linear(in_features=1024, out_features=1024, bias=True)\n",
              "          )\n",
              "        )\n",
              "        (gate): Linear(in_features=1024, out_features=8, bias=False)\n",
              "      )\n",
              "      (ln_1): LayerNorm((1024,), eps=1e-05, elementwise_affine=True)\n",
              "      (ln_2): LayerNorm((1024,), eps=1e-05, elementwise_affine=True)\n",
              "    )\n",
              "  )\n",
              "  (head): ClassificationHead(\n",
              "    (ln_f): LayerNorm((1024,), eps=1e-05, elementwise_affine=True)\n",
              "    (linear): Linear(in_features=1024, out_features=65, bias=False)\n",
              "  )\n",
              ")"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import math\n",
        "\n",
        "learning_rate = 1e-3 # with baby networks can afford to go a bit higher\n",
        "max_iters = 2500\n",
        "lr_decay_iters = 2500 # make equal to max_iters usually\n",
        "min_lr = 1e-4 # learning_rate / 10 usually\n",
        "beta2 = 0.99 # make a bit bigger because number of tokens per iter is small\n",
        "\n",
        "warmup_iters = 100 # not super necessary potentially\n",
        "# learning rate decay scheduler (cosine with warmup)\n",
        "def get_lr(it):\n",
        "    # 1) linear warmup for warmup_iters steps\n",
        "    if it < warmup_iters:\n",
        "        return learning_rate * it / warmup_iters\n",
        "    # 2) if it > lr_decay_iters, return min learning rate\n",
        "    if it > lr_decay_iters:\n",
        "        return min_lr\n",
        "    # 3) in between, use cosine decay down to min learning rate\n",
        "    decay_ratio = (it - warmup_iters) / (lr_decay_iters - warmup_iters)\n",
        "    assert 0 <= decay_ratio <= 1\n",
        "    coeff = 0.5 * (1.0 + math.cos(math.pi * decay_ratio)) # coeff ranges 0..1\n",
        "    return min_lr + coeff * (learning_rate - min_lr)"
      ],
      "metadata": {
        "id": "Nic2IGjJBOOM"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from torch.optim import AdamW\n",
        "\n",
        "opt = AdamW(model.get_parameters(weight_decay=0.1), lr=0.001)"
      ],
      "metadata": {
        "id": "3yiPL7ECiI7U"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from livelossplot import PlotLosses\n",
        "\n",
        "plotlosses = PlotLosses(\n",
        "    groups={\n",
        "          'loss': ['loss'],\n",
        "          'val_acc': ['val_acc'],\n",
        "          'lr': ['lr']\n",
        "        }\n",
        "    )"
      ],
      "metadata": {
        "id": "0WAda9maHLt8"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from torch.nn import functional as F\n",
        "import time\n",
        "\n",
        "torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)\n",
        "acc = validate(model)\n",
        "mask = get_causal_mask(block_size).to(device)\n",
        "\n",
        "history = []\n",
        "for epoch in range(int(2500)):\n",
        "    ts = time.time()\n",
        "    lr = get_lr(epoch)\n",
        "    for param_group in opt.param_groups:\n",
        "        param_group['lr'] = lr\n",
        "\n",
        "    opt.zero_grad()\n",
        "    x, y_true = get_batch('train')\n",
        "    logits = model(x, mask=mask)\n",
        "    loss = F.cross_entropy(\n",
        "        logits.view(-1, logits.size(-1)),\n",
        "        y_true.view(-1), ignore_index=-1\n",
        "    )\n",
        "    loss.backward()\n",
        "    opt.step()\n",
        "\n",
        "    if (epoch % 25) == 0:\n",
        "        acc = validate(model)\n",
        "        data = {\n",
        "            'loss': loss.detach().cpu().item(),\n",
        "            'val_acc': acc.cpu().item(),\n",
        "            'lr': lr\n",
        "        }\n",
        "        plotlosses.update(data)\n",
        "        plotlosses.send()\n",
        "        data['ts'] = ts\n",
        "        history.append(data)\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 831
        },
        "id": "UKza08rUNVHw",
        "outputId": "99fb77b3-234b-4626-fe67-9035278ffb43"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1200x1200 with 4 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Loss\n",
            "\tloss             \t (min:    0.078, max:    4.155, cur:    0.078)\n",
            "lr\n",
            "\tlr               \t (min:    0.000, max:    0.001, cur:    0.000)\n",
            "val_acc\n",
            "\tval_acc          \t (min:    0.025, max:    0.548, cur:    0.543)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "root = './drive/MyDrive/transformer-experiments'"
      ],
      "metadata": {
        "id": "CRKjd9o8romF"
      },
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "if not os.path.isdir(f'{root}/moe-tc'):\n",
        "    os.mkdir(f'{root}/moe-tc')\n",
        "model.save_state(os.path.join(f'{root}/moe-tc', 'model_state.pt'))"
      ],
      "metadata": {
        "id": "FOIvcB0tDG77"
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import json\n",
        "\n",
        "with open(f'{root}/moe-tc/history.json', 'w') as history_file:\n",
        "    history_file.write(json.dumps(history))"
      ],
      "metadata": {
        "id": "ARKA4CQEkWL2"
      },
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "root = './drive/MyDrive/transformer-experiments'\n",
        "model.load_state(os.path.join(f'{root}/moe-tc', 'model_state.pt'))"
      ],
      "metadata": {
        "id": "PNp1s4UrY3I-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import pickle\n",
        "\n",
        "meta_path = os.path.join(data_dir, 'meta.pkl')\n",
        "meta_vocab_size = None\n",
        "if os.path.exists(meta_path):\n",
        "    with open(meta_path, 'rb') as f:\n",
        "        meta = pickle.load(f)\n",
        "    meta_vocab_size = meta['vocab_size']\n",
        "    print(f\"found vocab_size = {meta_vocab_size} (inside {meta_path})\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "so9W-VqQD4Ag",
        "outputId": "ad23a51a-5884-4292-c8b1-247bea630dbb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "found vocab_size = 65 (inside data/meta.pkl)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from tqdm import tqdm\n",
        "\n",
        "\n",
        "def decode(model, text, temp=1, limit=16, sample=True):\n",
        "    input_ids = torch.tensor([meta['stoi'][char] for char in text])[None]\n",
        "\n",
        "    if torch.cuda.is_available():\n",
        "        input_ids = input_ids.cuda()\n",
        "\n",
        "    result = text\n",
        "    for _ in tqdm(range(limit)):\n",
        "        mask = get_causal_mask(len(input_ids)).to(device)\n",
        "        preds = model(input_ids, mask=mask)\n",
        "        y = (preds[:, -1, :] / temp).softmax(dim=-1)\n",
        "        if sample:\n",
        "            next_token = torch.multinomial(y, 1)\n",
        "        else:\n",
        "            next_token = torch.argmax(y, dim=-1)\n",
        "        result += meta['itos'][next_token.item()]\n",
        "        if not sample: next_token = next_token[None]\n",
        "        input_ids = torch.cat((input_ids, next_token), dim=-1)\n",
        "\n",
        "    return result\n"
      ],
      "metadata": {
        "id": "Vd97wNDzOdxw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "text = \"Who \"\n",
        "print(decode(model, text, temp=0.7, limit=200))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Apkc2hUWRZz_",
        "outputId": "0f020368-90ff-460e-ab88-659a5b8797e2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 200/200 [00:13<00:00, 15.22it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Who know ?\n",
            "\n",
            "BRSH:\n",
            "Whither nothink you were he that one but better need I was ere he, my liege, my liege.\n",
            "\n",
            "BUCKINGHAM:\n",
            "You confess it not, the lorder I rest malice yet is for the rest for Engly the rest an\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "validate(model)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NbnQd_2_RbO7",
        "outputId": "d33417ed-fe9f-421f-afa7-8bed375f82c1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(0.5412, device='cuda:0')"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "aNkzn6D6Mm6D"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}