Transformer-shakesphere-char.ipynb

transformer-shakesphere-char.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "A100",
      "machine_shape": "hm",
      "authorship_tag": "ABX9TyM4gEyjkTeuzJmL6d8pomhl",
      "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/d06d7c38bba222faff8c6b55f80e03d0/transformer-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": "bb1fc1c1-ef69-490d-d18e-ff77d8879c8b"
      },
      "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"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ULd-3x193Olb",
        "outputId": "02db0e67-02e8-4f3d-8cf8-5cf914ac9fd0"
      },
      "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": "352bbe61-8d68-47e3-da73-5e467d85eaa8"
      },
      "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.1/2.0 MB\u001b[0m \u001b[31m2.8 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K     \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m \u001b[32m2.0/2.0 MB\u001b[0m \u001b[31m34.7 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[31m27.8 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": "3b9b6549-15e4-43d1-8627-5338e6304f3e"
      },
      "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",
        "\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, GPTBasicConfig\n",
        "\n",
        "config = GPTBasicConfig(\n",
        "    num_layers=6,\n",
        "    hdn_dim=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": "wpN8Pa0tmj_4",
        "outputId": "ad9c429b-5a34-41ee-fe2c-3ae5194cbfb1"
      },
      "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): MLP(\n",
              "        (mlp_dropout): Dropout(p=0.009999999776482582, inplace=False)\n",
              "        (linear1): Linear(in_features=1024, out_features=4096, bias=True)\n",
              "        (linear2): Linear(in_features=4096, out_features=1024, bias=True)\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": [
        "def count_parameters(model):\n",
        "    return sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
        "\n",
        "count_parameters(model)"
      ],
      "metadata": {
        "id": "0iOwty520VIw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "de5ee3c0-7537-483d-fd15-b44304293cb7"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "75974656"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "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": "b1f65f5c-2078-4e26-999d-3cc16b52b33b"
      },
      "execution_count": 8,
      "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): MLP(\n",
              "        (mlp_dropout): Dropout(p=0.009999999776482582, inplace=False)\n",
              "        (linear1): Linear(in_features=1024, out_features=4096, bias=True)\n",
              "        (linear2): Linear(in_features=4096, out_features=1024, bias=True)\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": 8
        }
      ]
    },
    {
      "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": 9,
      "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": 10,
      "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": 11,
      "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)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 831
        },
        "id": "UKza08rUNVHw",
        "outputId": "8ecf2026-b8de-49e8-8ec7-427a42f5b354"
      },
      "execution_count": 12,
      "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.081, max:    4.281, cur:    0.084)\n",
            "lr\n",
            "\tlr               \t (min:    0.000, max:    0.001, cur:    0.000)\n",
            "val_acc\n",
            "\tval_acc          \t (min:    0.006, max:    0.551, cur:    0.541)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "root = './drive/MyDrive/transformer-experiments'\n",
        "if not os.path.isdir(f'{root}/basic'):\n",
        "    os.mkdir(f'{root}/basic')\n",
        "model.save_state(os.path.join(f'{root}/basic', 'model_state.pt'))"
      ],
      "metadata": {
        "id": "FOIvcB0tDG77"
      },
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import json\n",
        "\n",
        "with open(f'{root}/basic/history.json', 'w') as history_file:\n",
        "    history_file.write(json.dumps(history))"
      ],
      "metadata": {
        "id": "7XFVOlZsmfsy"
      },
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "root = './drive/MyDrive/transformer-experiments'\n",
        "model.load_state(os.path.join(f'{root}/basic', 'model_state.pt'))"
      ],
      "metadata": {
        "id": "PNp1s4UrY3I-"
      },
      "execution_count": 15,
      "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": "7689c672-2624-4a23-9f53-3eff9c4f0c52"
      },
      "execution_count": 16,
      "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": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "text = \"Where \"\n",
        "print(decode(model, text, temp=0.7, limit=200))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Apkc2hUWRZz_",
        "outputId": "4cabc792-5721-4bf8-bd5f-1a7e6c968ed6"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 200/200 [00:01<00:00, 117.39it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Where slaved in the heat of that water,\n",
            "Not Rome home from the ready he cried in\n",
            "Your the gods and o'erthese wounds, the contracted to the way; not of the whole the were, the sire and the\n",
            "complaint the gave\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": "a6a41185-70a8-430d-916e-354ea52a0499"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(0.5354, device='cuda:0')"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "s4x21oqxNGI5"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}