Upload TransformerWIthTiktoken.ipynb

TransformerWIthTiktoken.ipynb

@@ -0,0 +1,651 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4",
+      "authorship_tag": "ABX9TyNJTibhP/0M1eYUw/zipgqC",
+      "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/github/shivendrra/SmallLanguageModel-project/blob/main/Final%20Models/Transformer/TransformerWIthTiktoken.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from google.colab import drive\n",
+        "drive.mount('/content/drive')"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "6XXCT7w0YSV6",
+        "outputId": "7b15e501-987f-4a3b-e6a6-5cc6757c0082"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Mounted at /content/drive\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# data for training the BPE\n",
+        "with open('/content/drive/MyDrive/new_training_data.txt', 'r', encoding='utf-8') as file:\n",
+        "  captions = file.read()\n",
+        "\n",
+        "print(len(captions)/1e6, 'million words')"
+      ],
+      "metadata": {
+        "id": "xUND_jGmYUqM",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "4d9cdffa-8b3f-4967-933f-b5fef6256ca6"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "219.382798 million words\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install tiktoken"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "65WnHhhvOiXL",
+        "outputId": "36664169-aaa7-4a2a-e860-9ac0db1eea5b"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Collecting tiktoken\n",
+            "  Downloading tiktoken-0.6.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.8 MB)\n",
+            "\u001b[?25l     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/1.8 MB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K     \u001b[91m━━━━━━━━\u001b[0m\u001b[90m╺\u001b[0m\u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.4/1.8 MB\u001b[0m \u001b[31m11.0 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.8/1.8 MB\u001b[0m \u001b[31m33.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hRequirement already satisfied: regex>=2022.1.18 in /usr/local/lib/python3.10/dist-packages (from tiktoken) (2023.12.25)\n",
+            "Requirement already satisfied: requests>=2.26.0 in /usr/local/lib/python3.10/dist-packages (from tiktoken) (2.31.0)\n",
+            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests>=2.26.0->tiktoken) (3.3.2)\n",
+            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests>=2.26.0->tiktoken) (3.6)\n",
+            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests>=2.26.0->tiktoken) (2.0.7)\n",
+            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests>=2.26.0->tiktoken) (2024.2.2)\n",
+            "Installing collected packages: tiktoken\n",
+            "Successfully installed tiktoken-0.6.0\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import timeit\n",
+        "start_time = timeit.default_timer()"
+      ],
+      "metadata": {
+        "id": "OHalNluSZeZD"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import tiktoken\n",
+        "tokenizer = tiktoken.get_encoding(\"p50k_base\")\n",
+        "tokenizer = tiktoken.encoding_for_model(\"text-davinci-003\")\n",
+        "\n",
+        "input_data = tokenizer.encode(captions)\n",
+        "end_time = timeit.default_timer()\n",
+        "total_time = (end_time - start_time) / 60\n",
+        "\n",
+        "print(\"total tokens\", len(input_data)/1e6, 'million')\n",
+        "print(f\"time taken to train the tokenizer {total_time}mins\")"
+      ],
+      "metadata": {
+        "id": "TtddSd8AYXTX",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "1aa24aee-edf7-4ea8-ab80-afea0beb40cb"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "total tokens 47.994108 million\n",
+            "time taken to train the tokenizer 0.7022969253666669mins\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "n = int(0.9*len(input_data)) # first 90% will be train, rest val\n",
+        "train_data = input_data[:n]\n",
+        "val_data = input_data[n:]\n",
+        "print(f\"train data {len(train_data) / 1e6} million'\\n'validation data {len(val_data) / 1e6} million\")"
+      ],
+      "metadata": {
+        "id": "oIKFNoIjYkhi",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "c76669ed-17f6-45c5-84ff-c8d8387873d3"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "train data 43.194697 million'\n",
+            "'validation data 4.799411 million\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Trimming data for a multiple of 4\n",
+        "# train_remainder = len(train_data) % 4\n",
+        "# val_remainder = len(val_data) % 4\n",
+        "# train_data = train_data[:-train_remainder] if train_remainder != 0 else train_data\n",
+        "# val_data = val_data[:-val_remainder] if val_remainder != 0 else val_data\n",
+        "\n",
+        "# print(len(train_data), len(val_data))"
+      ],
+      "metadata": {
+        "id": "s8tNsyEhYyxz",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "075f902c-45a5-495c-c3a7-21407f40db5b"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "18692412 2076932\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import torch\n",
+        "\n",
+        "# Convert to tensors\n",
+        "train_data = torch.tensor(train_data, dtype=torch.long)\n",
+        "val_data = torch.tensor(val_data, dtype=torch.long)\n",
+        "\n",
+        "print(f\"train data = {train_data[:10]}, \\nval data = {val_data[:10]}\")"
+      ],
+      "metadata": {
+        "id": "qevMG1AtY5Mi",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "77a4f3be-0c10-4e57-ef4e-0a4de9ea9918"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "train data = tensor([ 5195,   547,   262, 13666,   319,  1468,   640,    88,   198,    65]), \n",
+            "val data = tensor([   13, 11361,   286, 23748,    13,  9078,    11,  1623,  1122,    11])\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "vocab_size = tokenizer.n_vocab\n",
+        "print(vocab_size)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "ayXltgrIafF4",
+        "outputId": "74084e34-9a4e-4e34-9488-f8bfa930d5ea"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "50281\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import torch\n",
+        "import torch.nn as nn\n",
+        "from torch.nn import functional as F\n",
+        "\n",
+        "# hyperparameters\n",
+        "batch_size = 32 # independent sequences process in parallel\n",
+        "block_size = 128 # maximum context length for predictions\n",
+        "max_iters = 5000\n",
+        "eval_interval = 100\n",
+        "learning_rate = 3e-4\n",
+        "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
+        "eval_iters = 200\n",
+        "n_embd = 384\n",
+        "n_head = 8\n",
+        "n_layer = 8\n",
+        "dropout = 0.2\n",
+        "norm_eps = 1e-05\n",
+        "# ------------\n",
+        "\n",
+        "torch.manual_seed(1400)\n",
+        "\n",
+        "# data loading\n",
+        "def get_batch(split):\n",
+        "    # generate a small batch of data of inputs x and targets y\n",
+        "    data = train_data if split == 'train' else val_data\n",
+        "    ix = torch.randint(len(data) - block_size, (batch_size,))\n",
+        "    x = torch.stack([data[i:i+block_size] for i in ix])\n",
+        "    y = torch.stack([data[i+1:i+block_size+1] for i in ix])\n",
+        "    x, y = x.to(device), y.to(device)\n",
+        "    return x, y\n",
+        "\n",
+        "@torch.no_grad()\n",
+        "def estimate_loss():\n",
+        "    out = {}\n",
+        "    model.eval()\n",
+        "    for split in ['train', 'val']:\n",
+        "        losses = torch.zeros(eval_iters)\n",
+        "        for k in range(eval_iters):\n",
+        "            X, Y = get_batch(split)\n",
+        "            logits, loss = model(X, Y)\n",
+        "            losses[k] = loss.item()\n",
+        "        out[split] = losses.mean()\n",
+        "    model.train()\n",
+        "    return out\n",
+        "\n",
+        "class Head(nn.Module):\n",
+        "    \"\"\" one head of self-attention \"\"\"\n",
+        "\n",
+        "    def __init__(self, head_size):\n",
+        "        super().__init__()\n",
+        "        self.key = nn.Linear(n_embd, head_size, bias=False)\n",
+        "        self.query = nn.Linear(n_embd, head_size, bias=False)\n",
+        "        self.value = nn.Linear(n_embd, head_size, bias=False)\n",
+        "        self.register_buffer('tril', torch.tril(torch.ones(block_size, block_size)))\n",
+        "\n",
+        "        self.dropout = nn.Dropout(dropout)\n",
+        "\n",
+        "    def forward(self, x):\n",
+        "        # input of size (batch, time-step, channels)\n",
+        "        # output of size (batch, time-step, head size)\n",
+        "        B,T,C = x.shape\n",
+        "        k = self.key(x)   # (B,T,hs)\n",
+        "        q = self.query(x) # (B,T,hs)\n",
+        "        # compute attention scores (\"affinities\")\n",
+        "        wei = q @ k.transpose(-2,-1) * k.shape[-1]**-0.5 # (B, T, hs) @ (B, hs, T) -> (B, T, T)\n",
+        "        wei = wei.masked_fill(self.tril[:T, :T] == 0, float('-inf')) # (B, T, T)\n",
+        "        wei = F.softmax(wei, dim=-1) # (B, T, T)\n",
+        "        wei = self.dropout(wei)\n",
+        "        # perform the weighted aggregation of the values\n",
+        "        v = self.value(x) # (B,T,hs)\n",
+        "        out = wei @ v # (B, T, T) @ (B, T, hs) -> (B, T, hs)\n",
+        "        return out\n",
+        "\n",
+        "class MultiHeadAttention(nn.Module):\n",
+        "    \"\"\" multiple heads of self-attention in parallel \"\"\"\n",
+        "\n",
+        "    def __init__(self, num_heads, head_size):\n",
+        "        super().__init__()\n",
+        "        self.heads = nn.ModuleList([Head(head_size) for _ in range(num_heads)])\n",
+        "        self.proj = nn.Linear(head_size * num_heads, n_embd)\n",
+        "        self.dropout = nn.Dropout(dropout)\n",
+        "\n",
+        "    def forward(self, x):\n",
+        "        out = torch.cat([h(x) for h in self.heads], dim=-1)\n",
+        "        out = self.dropout(self.proj(out))\n",
+        "        return out\n",
+        "\n",
+        "class FeedFoward(nn.Module):\n",
+        "    \"\"\" a simple linear layer followed by a non-linearity \"\"\"\n",
+        "\n",
+        "    def __init__(self, n_embd):\n",
+        "        super().__init__()\n",
+        "        self.net = nn.Sequential(\n",
+        "            nn.Linear(n_embd, 4 * n_embd),\n",
+        "            nn.ReLU(),\n",
+        "            nn.Linear(4 * n_embd, n_embd),\n",
+        "            nn.Dropout(dropout),\n",
+        "        )\n",
+        "\n",
+        "    def forward(self, x):\n",
+        "        return self.net(x)\n",
+        "class Block(nn.Module):\n",
+        "    \"\"\" Transformer block: communication followed by computation \"\"\"\n",
+        "\n",
+        "    def __init__(self, n_embd, n_head):\n",
+        "        # n_embd: embedding dimension, n_head: the number of heads we'd like\n",
+        "        super().__init__()\n",
+        "        head_size = n_embd // n_head\n",
+        "        self.sa = MultiHeadAttention(n_head, head_size)\n",
+        "        self.ffwd = FeedFoward(n_embd)\n",
+        "        self.ln1 = nn.LayerNorm(n_embd, eps=norm_eps)\n",
+        "        self.ln2 = nn.LayerNorm(n_embd, eps=norm_eps)\n",
+        "\n",
+        "    def forward(self, x):\n",
+        "        x = x + self.sa(self.ln1(x))\n",
+        "        x = x + self.ffwd(self.ln2(x))\n",
+        "        return x\n",
+        "\n",
+        "class GPTLanguageModel(nn.Module):\n",
+        "\n",
+        "    def __init__(self):\n",
+        "        super().__init__()\n",
+        "        # each token directly reads off the logits for the next token from a lookup table\n",
+        "        self.token_embedding_table = nn.Embedding(vocab_size, n_embd)\n",
+        "        self.position_embedding_table = nn.Embedding(block_size, n_embd)\n",
+        "        self.blocks = nn.Sequential(*[Block(n_embd, n_head=n_head) for _ in range(n_layer)])\n",
+        "        self.ln_f = nn.LayerNorm(n_embd, eps=norm_eps) # final layer norm\n",
+        "        self.lm_head = nn.Linear(n_embd, vocab_size)\n",
+        "        self.apply(self._init_weights)\n",
+        "\n",
+        "    def _init_weights(self, module):\n",
+        "        if isinstance(module, nn.Linear):\n",
+        "            torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)\n",
+        "            if module.bias is not None:\n",
+        "                torch.nn.init.zeros_(module.bias.data)\n",
+        "        elif isinstance(module, nn.Embedding):\n",
+        "            torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)\n",
+        "\n",
+        "    def forward(self, idx, targets=None):\n",
+        "        B, T = idx.shape\n",
+        "\n",
+        "        # idx and targets are both (B,T) tensor of integers\n",
+        "        tok_emb = self.token_embedding_table(idx) # (B,T,C)\n",
+        "        pos_emb = self.position_embedding_table(torch.arange(T, device=device)) # (T,C)\n",
+        "        x = tok_emb + pos_emb # (B,T,C)\n",
+        "        x = self.blocks(x) # (B,T,C)\n",
+        "        x = self.ln_f(x) # (B,T,C)\n",
+        "        logits = self.lm_head(x) # (B,T,vocab_size)\n",
+        "\n",
+        "        if targets is None:\n",
+        "            loss = None\n",
+        "        else:\n",
+        "            B, T, C = logits.shape\n",
+        "            logits = logits.view(B*T, C)\n",
+        "            targets = targets.view(B*T)\n",
+        "            loss = F.cross_entropy(logits, targets)\n",
+        "\n",
+        "        return logits, loss\n",
+        "\n",
+        "    def generate(self, idx, max_new_tokens):\n",
+        "        # idx is (B, T) array of indices in the current context\n",
+        "        for _ in range(max_new_tokens):\n",
+        "            # crop idx to the last block_size tokens\n",
+        "            idx_cond = idx[:, -block_size:]\n",
+        "            # get the predictions\n",
+        "            logits, loss = self(idx_cond)\n",
+        "            # focus only on the last time step\n",
+        "            logits = logits[:, -1, :] # becomes (B, C)\n",
+        "            # apply softmax to get probabilities\n",
+        "            probs = F.softmax(logits, dim=-1) # (B, C)\n",
+        "            # sample from the distribution\n",
+        "            idx_next = torch.multinomial(probs, num_samples=1) # (B, 1)\n",
+        "            # append sampled index to the running sequence\n",
+        "            idx = torch.cat((idx, idx_next), dim=1) # (B, T+1)\n",
+        "        return idx\n",
+        "\n",
+        "model = GPTLanguageModel()\n",
+        "checkpoint_path = '/content/drive/MyDrive/52.9_transformer_model.pth'\n",
+        "checkpoint = torch.load(checkpoint_path)\n",
+        "model.load_state_dict(checkpoint)\n",
+        "m = model.to(device)\n",
+        "\n",
+        "# print the number of parameters in the model\n",
+        "n_param = sum(p.numel() for p in m.parameters())/1e6\n",
+        "print(n_param, 'million')\n",
+        "\n",
+        "# create a PyTorch optimizer\n",
+        "optimizer = torch.optim.AdamW(model.parameters(), lr=learning_rate)\n",
+        "steps = []\n",
+        "train_losses = []\n",
+        "val_losses = []\n",
+        "\n",
+        "for iter in range(max_iters):\n",
+        "\n",
+        "    # every once in a while evaluate the loss on train and val sets\n",
+        "    if iter % eval_interval == 0 or iter == max_iters - 1:\n",
+        "        losses = estimate_loss()\n",
+        "        print(f\"step {iter}: train loss {losses['train']:.4f}, val loss {losses['val']:.4f}\")\n",
+        "\n",
+        "        # Store step and loss values for visualization\n",
+        "        steps.append(iter)\n",
+        "        train_losses.append(losses['train'])\n",
+        "        val_losses.append(losses['val'])\n",
+        "\n",
+        "    # sample a batch of data\n",
+        "    xb, yb = get_batch('train')\n",
+        "\n",
+        "    # evaluate the loss\n",
+        "    logits, loss = model(xb, yb)\n",
+        "    optimizer.zero_grad(set_to_none=True)\n",
+        "    loss.backward()\n",
+        "    optimizer.step()"
+      ],
+      "metadata": {
+        "id": "zLfgRvabDkxs",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "36e05382-e436-4fd6-bb7a-4f491e3e9994"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "52.902505 million\n",
+            "step 0: train loss 5.2925, val loss 5.2780\n",
+            "step 100: train loss 5.1310, val loss 4.9329\n",
+            "step 200: train loss 5.0658, val loss 4.8052\n",
+            "step 300: train loss 5.0129, val loss 4.7458\n",
+            "step 400: train loss 4.9957, val loss 4.6957\n",
+            "step 500: train loss 4.9448, val loss 4.6594\n",
+            "step 600: train loss 4.9200, val loss 4.6308\n",
+            "step 700: train loss 4.8983, val loss 4.6060\n",
+            "step 800: train loss 4.8582, val loss 4.5643\n",
+            "step 900: train loss 4.8539, val loss 4.5691\n",
+            "step 1000: train loss 4.8376, val loss 4.5232\n",
+            "step 1100: train loss 4.8215, val loss 4.5027\n",
+            "step 1200: train loss 4.8017, val loss 4.4783\n",
+            "step 1300: train loss 4.7649, val loss 4.4671\n",
+            "step 1400: train loss 4.7626, val loss 4.4521\n",
+            "step 1500: train loss 4.7515, val loss 4.4271\n",
+            "step 1600: train loss 4.7322, val loss 4.4010\n",
+            "step 1700: train loss 4.7119, val loss 4.4046\n",
+            "step 1800: train loss 4.7023, val loss 4.3749\n",
+            "step 1900: train loss 4.6986, val loss 4.3732\n",
+            "step 2000: train loss 4.6837, val loss 4.3539\n",
+            "step 2100: train loss 4.6763, val loss 4.3663\n",
+            "step 2200: train loss 4.6550, val loss 4.3402\n",
+            "step 2300: train loss 4.6396, val loss 4.3261\n",
+            "step 2400: train loss 4.6420, val loss 4.3203\n",
+            "step 2500: train loss 4.6337, val loss 4.3279\n",
+            "step 2600: train loss 4.6219, val loss 4.3131\n",
+            "step 2700: train loss 4.6139, val loss 4.3056\n",
+            "step 2800: train loss 4.5988, val loss 4.2781\n",
+            "step 2900: train loss 4.5987, val loss 4.2741\n",
+            "step 3000: train loss 4.5980, val loss 4.2652\n",
+            "step 3100: train loss 4.5729, val loss 4.2660\n",
+            "step 3200: train loss 4.5688, val loss 4.2703\n",
+            "step 3300: train loss 4.5536, val loss 4.2384\n",
+            "step 3400: train loss 4.5469, val loss 4.2426\n",
+            "step 3500: train loss 4.5486, val loss 4.2287\n",
+            "step 3600: train loss 4.5317, val loss 4.2261\n",
+            "step 3700: train loss 4.5175, val loss 4.2164\n",
+            "step 3800: train loss 4.5175, val loss 4.2231\n",
+            "step 3900: train loss 4.5129, val loss 4.2031\n",
+            "step 4000: train loss 4.5059, val loss 4.2053\n",
+            "step 4100: train loss 4.5076, val loss 4.1966\n",
+            "step 4200: train loss 4.4828, val loss 4.2038\n",
+            "step 4300: train loss 4.4967, val loss 4.2048\n",
+            "step 4400: train loss 4.4886, val loss 4.1737\n",
+            "step 4500: train loss 4.4836, val loss 4.1745\n",
+            "step 4600: train loss 4.4664, val loss 4.1736\n",
+            "step 4700: train loss 4.4461, val loss 4.1667\n",
+            "step 4800: train loss 4.4594, val loss 4.1599\n",
+            "step 4900: train loss 4.4391, val loss 4.1523\n",
+            "step 4999: train loss 4.4484, val loss 4.1480\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# save the trained model\n",
+        "torch.save(model.state_dict(), f\"{n_param:.1f}_model.pth\")"
+      ],
+      "metadata": {
+        "id": "G1kHzG4M9IyF"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "torch.save(model, f\"{n_param:.0f}million_model.pth\")"
+      ],
+      "metadata": {
+        "id": "wNngWs_gjvEe"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "plt.figure(figsize=(10, 6))\n",
+        "plt.plot(steps, train_losses, label='Train Loss')\n",
+        "plt.plot(steps, val_losses, label='Validation Loss')\n",
+        "plt.title('Loss Over Steps')\n",
+        "plt.xlabel('Steps')\n",
+        "plt.ylabel('Loss')\n",
+        "plt.legend()\n",
+        "\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 564
+        },
+        "id": "dhXmIXq1dOZj",
+        "outputId": "e791d2fb-881f-4144-a5e4-f7f87a2865a5"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x600 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "target_text = \"Would you like to tell me your name because \"\n",
+        "context = torch.tensor([tokenizer.encode(target_text)], dtype=torch.long, device=device)\n",
+        "generated_output = tokenizer.decode(m.generate(context, max_new_tokens=10)[0].tolist())\n",
+        "print(generated_output)"
+      ],
+      "metadata": {
+        "id": "3b2C86R081GT",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "5bada3b8-fded-4348-f2bd-465ca0490eb5"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Would you like to tell me your name because iphone is used to apologize for your child but\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [],
+      "metadata": {
+        "id": "6aatdjpLiIAK"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}