fomc_language.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f1c61875",
   "metadata": {},
   "source": [
    "# FedSpeak Language Modeling\n",
    "\n",
    "_Attention is all you need_ - Vaswani et al\n",
    "\n",
    "Concepts:\n",
    "- Transformers\n",
    "- Language modeling\n",
    "\n",
    "References:\n",
    "- https://pytorch.org/tutorials/beginner/transformer_tutorial.html\n",
    "- Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin. 2017. Attention Is All You Need. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "5b6513df",
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Callable, List\n",
    "import math\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from pandas import Series, DataFrame\n",
    "import bisect\n",
    "import matplotlib.pyplot as plt\n",
    "from nltk.tokenize import wordpunct_tokenize as tokenize\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from torch.optim import Adam\n",
    "from torch.optim.lr_scheduler import StepLR\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "import torchinfo\n",
    "from tqdm import tqdm\n",
    "from finds.database.mongodb import MongoDB\n",
    "from finds.unstructured import Unstructured, Vocab\n",
    "from secret import credentials, paths\n",
    "# %matplotlib qt\n",
    "VERBOSE = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "eb022407",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Device: cuda\n"
     ]
    }
   ],
   "source": [
    "mongodb = MongoDB(**credentials['mongodb'], verbose=VERBOSE)\n",
    "fomc = Unstructured(mongodb, 'FOMC')\n",
    "outdir = paths['scratch']\n",
    "device = 'cuda' if  torch.cuda.is_available() else 'cpu'\n",
    "print('Device:', device)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff1b0623",
   "metadata": {},
   "source": [
    "Retrieve FOMC meeting minutes text, and count number of unique words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "4d848088",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8622\n"
     ]
    }
   ],
   "source": [
    "# Retrieve and preprocess FOMC minutes text\n",
    "dates = fomc['minutes'].distinct('date')       # check dates stored in MongoDB\n",
    "docs = Series({doc['date']: [w.lower() for w in tokenize(doc['text'])]\n",
    "               for doc in fomc.select('minutes')},\n",
    "              name='minutes').sort_index()\n",
    "UNK = \" \"\n",
    "vocab = Vocab(set().union(*docs.tolist()), unk=UNK)\n",
    "print(len(vocab))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "758a97a8",
   "metadata": {},
   "source": [
    "Implement subclass of torch Dataset with FOMC minutes data.\n",
    "Each document is split into chunks of length `seq_len`.\n",
    "An index over all chunks is converted to an index to the document and location of a chunk within the document."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "66874b13",
   "metadata": {
    "lines_to_next_cell": 1
   },
   "outputs": [],
   "source": [
    "# Pytorch Dataset and DataLoader\n",
    "class FOMCDataset(Dataset):\n",
    "    \"\"\"Subclass of torch Dataset\n",
    "\n",
    "    Notes:\n",
    "      All subclasses should overwrite __getitem__(),\n",
    "      supporting fetching a data sample for a given key. Subclasses\n",
    "      could also optionally overwrite __len__(), which is expected to\n",
    "      return the size of the dataset\n",
    "    \"\"\"\n",
    "    def __init__(self, text: Series, seq_len: int, get_index: Callable[[str], int]):\n",
    "        self.text = text\n",
    "        self.seq_len = seq_len\n",
    "        self.get_index = get_index\n",
    "        self.counts = np.cumsum([len(s) // seq_len for s in text])\n",
    "\n",
    "    def __len__(self):\n",
    "        return self.counts[-1]\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        assert 0 <= idx < len(self), \"idx out of range\"\n",
    "        doc = bisect.bisect_right(self.counts, idx)\n",
    "\n",
    "        start = (idx - (self.counts[doc-1] if doc > 0 else 0)) * self.seq_len\n",
    "        end = start + self.seq_len\n",
    "        chunk = self.text.iloc[doc][start:end]\n",
    "        return (torch.LongTensor([0] + self.get_index(chunk[:-1])),\n",
    "                torch.LongTensor(self.get_index(chunk)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "52dd7255",
   "metadata": {},
   "outputs": [],
   "source": [
    "# length of input sequence\n",
    "seq_len = 30 # 40 # 20"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f741b5e6",
   "metadata": {},
   "source": [
    "Last document will be test set (to evaluate perplexity of the model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "2e6ff19f",
   "metadata": {
    "lines_to_next_cell": 1
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>docs</th>\n",
       "      <th>chunks</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Train</th>\n",
       "      <td>248</td>\n",
       "      <td>53336</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       docs  chunks\n",
       "Train   248   53336"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# split last document to be test set\n",
    "test_len = 1\n",
    "test_set = docs.iloc[-test_len:].tolist()\n",
    "train_set = FOMCDataset(docs.iloc[:-test_len], seq_len, vocab.get_index)\n",
    "dataloader = DataLoader(train_set, batch_size=32, shuffle=True)\n",
    "DataFrame({'docs': len(docs)-test_len, 'chunks': len(train_set)}, index=['Train'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96a6fb84",
   "metadata": {},
   "source": [
    "## Transformers\n",
    "\n",
    "Transformers are a type of neural network architecture that has become the foundation for many modern large language models (LLMs).  They are designed to handle sequential data, and are effective for natural language processing (NLP) tasks such as language modeling, translation, and text generation.\n",
    "\n",
    "### Position Encoding\n",
    "\n",
    "The input text is tokenized and converted into word embeddings. \n",
    "Positional encodings, which introduce information about the position of each word in the sequence are added to the word embeddings.\n",
    "A common approach uses sinusoidal functions to create positional encodings, which enable the model can learn the positions of tokens in a way that generalizes to sequences of different lengths. Alternatively, an embeddings layer can also be used to learn position encodings from the training data.\n",
    "\n",
    "### Attention\n",
    "\n",
    "Self-attention is the mechanism by which the model focuses on (i.e. weighs the importance of)  different parts of the input sequence when producing each element of the output sequence. Each word in a sequence is compared to every other word, and a weighted sum of these words is computed. Long-range dependencies and relationships between words in a sentence can be captured, regardless of their distance from each other.\n",
    "\n",
    "- Each word is represented by three vectors: _query_, _key_, and _value_. The attention score is calculated using the dot product of the query vector of one word with the key vectors of all other words. These scores are used to compute a weighted sum of the value vectors.\n",
    "\n",
    "- Feedforward Neural Networks apply a linear transformation followed by a non-linear activation to the attention output. These add capacity to model non-linear relationships.\n",
    "\n",
    "Multiple layers of self-attention and feedforward networks transform these embeddings into contextualized representations of each token.\n",
    "\n",
    "### Causal mask\n",
    "\n",
    "For decoding in autoregressive applications, a causal mask\n",
    "ensures each token only attends to previous tokens. \n",
    "The mask is just a triangular matrix applied to the attention scores to zero out  the positions that correspond to future tokens. By ensuring that each token only attends to itself and previous tokens, not future ones, it prevents the model from \"cheating\" by looking at future tokens when generating or predicting a sequence.  This is crucial for tasks like language generation, where each word should only be influenced by the words that came before it.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4120cefb",
   "metadata": {},
   "outputs": [],
   "source": [
    "class PositionalEncoding(nn.Module):\n",
    "    \"\"\"Positional encoder, learned with an embeddings layer\"\"\"\n",
    "    def __init__(self, d_model: int, max_len: int, dropout: float= 0.0):\n",
    "        super().__init__()\n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "        self.emb = nn.Embedding(num_embeddings=max_len, embedding_dim=d_model)\n",
    "\n",
    "    def forward(self, x):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            x: Tensor, shape [seq_len, batch_size, embedding_dim]\n",
    "        \"\"\"\n",
    "        to_embed = torch.LongTensor(np.asarray(range(0, x.size(1))))\\\n",
    "                        .to(x.device)\n",
    "        embedded = self.emb(to_embed)\n",
    "        embedded = self.dropout(embedded)\n",
    "        return x + embedded.unsqueeze(0)\n",
    "    \n",
    "    \"\"\" Instead of sine functions, positional encodings are learned with embeddings layer\n",
    "    def __init__(self, d_model: int, max_len: int, dropout: float = 0.1):\n",
    "        super().__init__()\n",
    "        self.dropout = nn.Dropout(p=dropout)\n",
    "        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)\n",
    "        div_term = torch.exp(torch.arange(0, d_model, 2)\n",
    "                             * (-math.log(10000.0) / d_model))\n",
    "        pe = torch.zeros(max_len, d_model)\n",
    "        pe[:, 0::2] = torch.sin(position * div_term)\n",
    "        pe[:, 1::2] = torch.cos(position * div_term)\n",
    "        pe = pe[:, None, :] \n",
    "        self.register_buffer('pe', pe)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = x + self.pe[:x.size(1), 0, :]\n",
    "        return self.dropout(x)\n",
    "    \"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "785ce23b",
   "metadata": {
    "lines_to_next_cell": 1
   },
   "outputs": [],
   "source": [
    "class Transformer(nn.Module):\n",
    "    \"\"\"Transformer neural network\"\"\"\n",
    "    def __init__(self, seq_len: int, vocab_size: int, d_model: int, nhead: int,\n",
    "                 num_layers: int, dim_feedforward: int, dropout: float):\n",
    "        super().__init__()\n",
    "\n",
    "        # model dimensions\n",
    "        self.seq_len = seq_len\n",
    "        self.vocab_size = vocab_size\n",
    "        self.d_model = d_model\n",
    "\n",
    "        # define layers\n",
    "        self.embedding = nn.Embedding(num_embeddings=vocab_size,\n",
    "                                      embedding_dim=d_model)\n",
    "        self.positional = PositionalEncoding(max_len=seq_len,\n",
    "                                             d_model=d_model,\n",
    "                                             dropout=dropout)\n",
    "\n",
    "        layer = nn.TransformerEncoderLayer(d_model=d_model,\n",
    "                                           nhead=nhead,\n",
    "                                           dim_feedforward=dim_feedforward,\n",
    "                                           dropout=dropout,\n",
    "                                           batch_first=True)\n",
    "        self.encoder = nn.TransformerEncoder(encoder_layer=layer,\n",
    "                                             num_layers=num_layers)\n",
    "        self.decoder = nn.Linear(in_features=d_model,\n",
    "                                 out_features=vocab_size)\n",
    "\n",
    "        # initialize weights\n",
    "        self.embedding.weight.data.uniform_(-0.1, 0.1)\n",
    "        self.decoder.weight.data.uniform_(-0.1, 0.1)\n",
    "        self.decoder.bias.data.zero_()\n",
    "\n",
    "    def causal_mask(self, sz: int, device: str = 'cpu'):\n",
    "        \"\"\"returns upper triu set to -inf\"\"\"\n",
    "        return nn.Transformer.generate_square_subsequent_mask(sz=self.seq_len,\n",
    "                                                              device=device)\n",
    "\n",
    "    def forward(self, x):\n",
    "        if len(x.shape) == 1:\n",
    "            x = x[None, :]\n",
    "        assert x.size(-1) == self.seq_len\n",
    "        x = self.embedding(x) * math.sqrt(self.d_model)  # embedding\n",
    "        x = self.positional(x)                           # position encoding\n",
    "        x = self.encoder(x, mask=self.causal_mask(sz=len(x), device=x.device))\n",
    "        x = self.decoder(x)                              # linear layer\n",
    "        x = F.log_softmax(x, dim=-1)                     # classify\n",
    "        return x\n",
    "\n",
    "    def save(self, filename):\n",
    "        \"\"\"save model state to filename\"\"\"\n",
    "        return torch.save(self.state_dict(), filename)\n",
    "\n",
    "    def load(self, filename):\n",
    "        \"\"\"load model name from filename\"\"\"\n",
    "        self.load_state_dict(torch.load(filename, map_location='cpu'))\n",
    "        return self"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc032781",
   "metadata": {},
   "source": [
    "## Language modeling\n",
    "\n",
    "Language modeling is the task of predicting the probability of a sequence of words based on the probability distribution learned from a training corpus of text. By learning the inherent structure of a language, including grammar, semantics, and context, this enables downstream NLP tasks such as machine translation, speech recognition, and text generation.\n",
    "\n",
    "### Perplexity\n",
    "\n",
    "Perplexity is used to evaluate the performance of a language model, by quantifying how well the it predicts test set. It is calculated as the exponentiation of the average negative log likelihood of the test set:\n",
    "\n",
    "$$\\text{Perplexity} = \\exp\\left( -\\frac{1}{N} \\sum_{i=1}^{N} \\log P(w_i | w_{i-1}, \\ldots, w_{i-n+1}) \\right)$$\n",
    "\n",
    "- $N$ is the total number of words in the test set.\n",
    "- $P(w_i | w_{i-1}, \\ldots, w_{i-n+1})$ is the probability assigned by the language model to the word $w_i$ given its context $w_{i-1}, \\ldots, w_{i-n+1}$.\n",
    "\n",
    "Perplexity, intuitively, measures how surprised the model is by the text. Lower perplexity score on a test set indicates better generalization to unseen data.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "30bf0fa1",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_next_log_probs(model, context: List[str], unk=UNK):\n",
    "    \"\"\"log P(word | context) where word ranges over the vocab\"\"\"\n",
    "\n",
    "    # pad to length seq_len\n",
    "    if len(context) > model.seq_len:\n",
    "        context = context[-model.seq_len:]\n",
    "    elif len(context) < model.seq_len:\n",
    "        context = ([unk] * (model.seq_len - len(context))) + context\n",
    "    assert len(context) == model.seq_len\n",
    "\n",
    "    context = torch.LongTensor(vocab.get_index(context))\\\n",
    "                   .to(device)\\\n",
    "                   .unsqueeze(0)\n",
    "    output = model(context)\n",
    "    logits = output[0, -1, :] \n",
    "    return logits.cpu().detach().numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "489a4589",
   "metadata": {
    "lines_to_next_cell": 1
   },
   "outputs": [],
   "source": [
    "def get_log_prob_sequence(model, next_words: List[str], context: List[str] = []):\n",
    "    \"\"\"Scores a a list of words following the given words context\"\"\"\n",
    "    if not context:\n",
    "        context = [UNK]\n",
    "    context = context + next_words\n",
    "    \n",
    "    log_probs = 0\n",
    "    for i in range(len(context) - len(next_words), len(context)):\n",
    "        log_prob = get_next_log_probs(model=model, context=context[:i])\n",
    "        log_probs += log_prob[vocab.get_index(context[i])]\n",
    "    return log_probs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "595b791e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_perplexity(model, context: List[str]) -> float:\n",
    "    \"\"\"Compute perpexlity score\"\"\"\n",
    "    log_prob = get_log_prob_sequence(model=model, next_words=context, context=[])\n",
    "    return np.exp(-log_prob / len(context))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc543181",
   "metadata": {},
   "source": [
    "Model and training parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "0006ada3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the model\n",
    "lr = 0.0001\n",
    "step_size = 30\n",
    "num_epochs = 50 #step_size * 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "a2f9ee46",
   "metadata": {},
   "outputs": [],
   "source": [
    "d_model = 256 #512\n",
    "nhead = 4 # 4\n",
    "num_layers = 3 # 2\n",
    "dim_feedforward = 2048 # 512 #1024\n",
    "dropout = 0.2 # 0.3 # 0.2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "baa3fb5b",
   "metadata": {
    "lines_to_next_cell": 2
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "==========================================================================================\n",
       "Layer (type:depth-idx)                                            Param #\n",
       "==========================================================================================\n",
       "Transformer                                                       --\n",
       "├─Embedding: 1-1                                                  2,207,232\n",
       "├─PositionalEncoding: 1-2                                         --\n",
       "│    └─Dropout: 2-1                                               --\n",
       "│    └─Embedding: 2-2                                             7,680\n",
       "├─TransformerEncoder: 1-3                                         --\n",
       "│    └─ModuleList: 2-3                                            --\n",
       "│    │    └─TransformerEncoderLayer: 3-1                          1,315,072\n",
       "│    │    └─TransformerEncoderLayer: 3-2                          1,315,072\n",
       "│    │    └─TransformerEncoderLayer: 3-3                          1,315,072\n",
       "├─Linear: 1-4                                                     2,215,854\n",
       "==========================================================================================\n",
       "Total params: 8,375,982\n",
       "Trainable params: 8,375,982\n",
       "Non-trainable params: 0\n",
       "=========================================================================================="
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = Transformer(seq_len=seq_len,\n",
    "                    vocab_size=len(vocab), \n",
    "                    d_model=d_model, \n",
    "                    nhead=nhead,\n",
    "                    num_layers=num_layers,\n",
    "                    dim_feedforward=dim_feedforward,\n",
    "                    dropout=dropout).to(device)\n",
    "torchinfo.summary(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb674aa9",
   "metadata": {},
   "source": [
    "Train the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "c733edc1",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/terence/env3.11/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "# Specify training parameters\n",
    "criterion = nn.NLLLoss().to(device)\n",
    "optimizer = Adam(model.parameters(), lr=lr)\n",
    "scheduler = StepLR(optimizer, step_size=step_size, gamma=0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "b0b24a48",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 50/50 [21:17<00:00, 25.55s/it]\n"
     ]
    }
   ],
   "source": [
    "perplexity = []\n",
    "losses = []\n",
    "for epoch in tqdm(range(num_epochs)):\n",
    "    model.train()\n",
    "    for train_ex, target_ex in dataloader:\n",
    "        optimizer.zero_grad()\n",
    "        train_ex, target_ex = train_ex.to(device), target_ex.to(device)\n",
    "        output = model(train_ex)\n",
    "        loss = criterion(output.view(-1, len(vocab)), target_ex.view(-1))\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "    scheduler.step()\n",
    "    \n",
    "    # Evaluate perplexity on test set\n",
    "    model.eval()\n",
    "    perplexity.append(np.mean([get_perplexity(model, s) for s in test_set]))\n",
    "    losses.append(loss.item())\n",
    "    if VERBOSE:\n",
    "        print(f\"Epoch: {epoch}, Loss: {loss.item()}, Perplexity: {perplexity[-1]}\")\n",
    "model.save(outdir / f\"transformer{nhead}_{dim_feedforward}.pt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "5e07c839",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Transformer(\n",
       "  (embedding): Embedding(8622, 256)\n",
       "  (positional): PositionalEncoding(\n",
       "    (dropout): Dropout(p=0.2, inplace=False)\n",
       "    (emb): Embedding(30, 256)\n",
       "  )\n",
       "  (encoder): TransformerEncoder(\n",
       "    (layers): ModuleList(\n",
       "      (0-2): 3 x TransformerEncoderLayer(\n",
       "        (self_attn): MultiheadAttention(\n",
       "          (out_proj): NonDynamicallyQuantizableLinear(in_features=256, out_features=256, bias=True)\n",
       "        )\n",
       "        (linear1): Linear(in_features=256, out_features=2048, bias=True)\n",
       "        (dropout): Dropout(p=0.2, inplace=False)\n",
       "        (linear2): Linear(in_features=2048, out_features=256, bias=True)\n",
       "        (norm1): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n",
       "        (norm2): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n",
       "        (dropout1): Dropout(p=0.2, inplace=False)\n",
       "        (dropout2): Dropout(p=0.2, inplace=False)\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (decoder): Linear(in_features=256, out_features=8622, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# save model checkpoint\n",
    "model.load(outdir / f\"transformer{nhead}_{dim_feedforward}.pt\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f13d7ed",
   "metadata": {},
   "source": [
    "Evaluate model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "fd3152ec",
   "metadata": {
    "lines_to_next_cell": 1
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Perplexity: 11.667960207233376   Loss: 2.023679733276367\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot perplexity\n",
    "fig, ax = plt.subplots(figsize=(10,6))\n",
    "ax.plot(perplexity, color=\"C0\")\n",
    "ax.set_ylabel('Perplexity on test set', color=\"C0\")\n",
    "bx = ax.twinx()\n",
    "bx.plot(losses, color=\"C1\")\n",
    "bx.set_ylabel('Training error', color=\"C1\")\n",
    "plt.title('Training a transformer language model on FOMC minutes')\n",
    "print('Perplexity:', perplexity[-1], '  Loss:', losses[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a282408c",
   "metadata": {},
   "source": [
    "### Decoding\n",
    "\n",
    "Decoding refers to the process of generating a sequence of words from a language model based on learned probabilities.\n",
    "\n",
    "- __Greedy__ approach: At each step of generation, the word with the highest probability according to the model is selected as the next word. While simple and computationally efficient, this results in repetitive or less diverse outputs.\n",
    "\n",
    "- __Beam search__ maintains a fixed number (beam width) of partial candidate sequences of words.At each step, it expands all possible next words for each candidate, keeping the top $k$ based on their joint probabilities. This allows exploration of multiple promising paths, but can be computationally expensive, and may still produce suboptimal outputs due to early pruning.\n",
    "\n",
    "- __Nucleus Sampling__ samples from the smallest set of $k$ words whose cumulative probability mass exceeds a pre-defined threshold $p$. This approach promotes diversity in generated text by allowing for the possibility of sampling from a larger set of words. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "703459c2",
   "metadata": {
    "lines_to_next_cell": 1
   },
   "outputs": [],
   "source": [
    "def get_nuclear_sequence(model, n: int, p: float, context: List[str] = []):\n",
    "    \"\"\"Sample sequence of words given context using nucleus sampling\"\"\"\n",
    "    if not context:\n",
    "        context = [UNK]\n",
    "    \n",
    "    for i in range(n):\n",
    "        probs = np.exp(get_next_log_probs(model, context))\n",
    "        probs_sorted = sorted(probs, reverse=True)\n",
    "        probs_cum = np.cumsum(probs_sorted)\n",
    "        num_drop = sum(probs_cum > p)\n",
    "        threshold = probs_sorted[-num_drop]\n",
    "        probs[probs < threshold] = 0.\n",
    "        probs /= sum(probs)\n",
    "        choice = vocab.get_word(np.random.choice(len(probs), p=probs))\n",
    "        context.append(choice)\n",
    "        #print(i, drop, len(probs), len(probs_sorted))\n",
    "    return context"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "37e7947b",
   "metadata": {},
   "outputs": [],
   "source": [
    "import textwrap\n",
    "wrapper = textwrap.TextWrapper(width=80, fix_sentence_endings=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a550f8bb",
   "metadata": {},
   "source": [
    "Finally, generate language with nuclear sampling, given some starting contexts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "ef4d440d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "THE FINANCIAL MARKETS...\n",
      "The financial markets that had occurred in mortgage interest rates since the\n",
      "start of 2014. Consequently, the committee anticipates that it will be\n",
      "appropriate to maintain the target range for the federal funds rate at 0 to 1/ 4\n",
      "percent.  The committee directs the desk to purchase gse debt and agency\n",
      "mortgage-backed securities( mbs) the\n",
      "\n",
      "PARTICIPANTS NOTED THAT...\n",
      "Participants noted that overall financial conditions remained accommodative, in\n",
      "part reflecting policy measures to support the economy.  They noted that since\n",
      "midyear, a tightening was necessary, though the unemployment rate remained\n",
      "elevated.  Some participants suggested that underlying growth in consumption\n",
      "expenditures remained sluggish, likely reflecting growth in the output of high-\n",
      "tech equipment.  Nonetheless,\n",
      "\n"
     ]
    }
   ],
   "source": [
    "n, p = seq_len * 2, 0.95\n",
    "for context in ['the financial markets' , 'participants noted that']:\n",
    "\n",
    "    # generate from context with nuclear sampling\n",
    "    words = get_nuclear_sequence(model, n=n, p=p, context=context.split())\n",
    "\n",
    "    # pretty-print the output\n",
    "    out = ''\n",
    "    is_end = True\n",
    "    is_space = ''\n",
    "    for w in words:\n",
    "        if not w.isalnum():\n",
    "            out += w\n",
    "        else:\n",
    "            if is_end:\n",
    "                w = w.capitalize()\n",
    "            out += is_space + w\n",
    "        is_end = w in ['!', '?', '.']\n",
    "        is_space = ' '*bool(w not in [\"'\", '-', '–'])\n",
    "    print(f\"{context.upper()}...\")\n",
    "    print(wrapper.fill(out))\n",
    "    print()"
   ]
  }
 ],
 "metadata": {
  "jupytext": {
   "cell_metadata_filter": "-all",
   "main_language": "python",
   "notebook_metadata_filter": "-all"
  },
  "kernelspec": {
   "display_name": "env3.11",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}