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

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

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "A100",
      "machine_shape": "hm",
      "authorship_tag": "ABX9TyMCT1vfvRfMGroIca6boAwW",
      "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/cc2cc776f524d0144ba9ee0e53436bd6/transformer-expert-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": "b6339dad-f2b0-4fc8-a7df-7c66f2f89036"
      },
      "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@bugfix/fix-k-calc"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ULd-3x193Olb",
        "outputId": "f8581002-adce-415c-93b7-a63dd4079eff"
      },
      "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": "1e4b35f7-15e0-4ba6-a99a-eebb65deb6e2"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[?25l     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/2.0 MB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K     \u001b[91m━━━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m\u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.5/2.0 MB\u001b[0m \u001b[31m14.2 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.0/2.0 MB\u001b[0m \u001b[31m31.9 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": "611d6a9c-6dde-4959-c685-cc8226fe174a"
      },
      "execution_count": 4,
      "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": [
        "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": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from pytfex.models import get_model, GPTExpertChoiceMoEConfig\n",
        "\n",
        "config = GPTExpertChoiceMoEConfig(\n",
        "    num_layers=6,\n",
        "    num_experts=16,\n",
        "    c=3,\n",
        "    hdn_dim=1024,\n",
        "    mlp_hdn_dim=int(1024/2),\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": "27423df6-9d29-446a-cd69-4436b936b411"
      },
      "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): ExpertChoiceMoE(\n",
              "        (experts): ModuleList(\n",
              "          (0-15): 16 x MLP(\n",
              "            (mlp_dropout): Dropout(p=0.009999999776482582, inplace=False)\n",
              "            (linear1): Linear(in_features=1024, out_features=512, bias=True)\n",
              "            (linear2): Linear(in_features=512, out_features=1024, bias=True)\n",
              "          )\n",
              "        )\n",
              "        (gate): Linear(in_features=1024, out_features=16, 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": [
        "from pytfex.utils import count_parameters\n",
        "\n",
        "count_parameters(model)"
      ],
      "metadata": {
        "id": "0iOwty520VIw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e2c23134-0f62-4a3c-dbd4-ed04f1c13574"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "126521344"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "75974656"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KUK5nG0XGqs0",
        "outputId": "9d86c42d-2c2a-4d98-ddfe-f080c84119c5"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "75974656"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "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": "4902ced2-7e3a-48d3-fcfd-336ad14a1eb8"
      },
      "execution_count": 9,
      "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): ExpertChoiceMoE(\n",
              "        (experts): ModuleList(\n",
              "          (0-15): 16 x MLP(\n",
              "            (mlp_dropout): Dropout(p=0.009999999776482582, inplace=False)\n",
              "            (linear1): Linear(in_features=1024, out_features=512, bias=True)\n",
              "            (linear2): Linear(in_features=512, out_features=1024, bias=True)\n",
              "          )\n",
              "        )\n",
              "        (gate): Linear(in_features=1024, out_features=16, 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": 9
        }
      ]
    },
    {
      "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": 10,
      "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": 11,
      "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": 12,
      "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": "125901b9-3daa-4b94-94c1-af0b0e8f8c95"
      },
      "execution_count": 13,
      "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.071, max:    4.371, cur:    0.075)\n",
            "lr\n",
            "\tlr               \t (min:    0.000, max:    0.001, cur:    0.000)\n",
            "val_acc\n",
            "\tval_acc          \t (min:    0.010, max:    0.550, cur:    0.543)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "root = './drive/MyDrive/transformer-experiments'"
      ],
      "metadata": {
        "id": "CRKjd9o8romF"
      },
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "exp_name = 'moe-2'"
      ],
      "metadata": {
        "id": "ahLHhmGAfZVS"
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "if not os.path.isdir(f'{root}/{exp_name}'):\n",
        "    os.mkdir(f'{root}/{exp_name}')\n",
        "model.save_state(os.path.join(f'{root}/{exp_name}', 'model_state.pt'))"
      ],
      "metadata": {
        "id": "FOIvcB0tDG77"
      },
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import json\n",
        "\n",
        "with open(f'{root}/{exp_name}/history.json', 'w') as history_file:\n",
        "    history_file.write(json.dumps(history))"
      ],
      "metadata": {
        "id": "ARKA4CQEkWL2"
      },
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "root = './drive/MyDrive/transformer-experiments'\n",
        "model.load_state(os.path.join(f'{root}/{exp_name}', 'model_state.pt'))"
      ],
      "metadata": {
        "id": "PNp1s4UrY3I-"
      },
      "execution_count": 18,
      "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": "fcb83490-37e7-4cfe-d7c8-c9bab3089c6a"
      },
      "execution_count": 19,
      "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": 20,
      "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": "970870c4-9ebb-45b4-adec-30d3e46aa85e"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 200/200 [00:09<00:00, 22.13it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Who isk hastely Hellought,\n",
            "His and I speak not be a wife revered of England to my wife's instrument?\n",
            "\n",
            "Page:\n",
            "And thus, that and all deck the justial Clarence of Edward fall of her that have I was cursed me\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": "1c49e497-5f14-486f-a65d-b7f0a9d9c1f6"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(0.5449, device='cuda:0')"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "aNkzn6D6Mm6D"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}