NLP_C3W1_perplexity.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Calculating perplexity using numpy: Ungraded Lecture Notebook\n",
    "\n",
    "In this notebook you will learn how to calculate perplexity. You will calculate it from scratch using `numpy` library. First you can import it and set the random seed, so that the results will be reproducible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Setting random seeds\n",
    "np.random.seed(32)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calculating Perplexity"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The perplexity is a metric that measures how well a probability model predicts a sample and it is commonly used to evaluate language models. It is defined as: \n",
    "\n",
    "$$PP(W) = \\sqrt[N]{\\prod_{i=1}^{N} \\frac{1}{P(w_i| w_1,...,w_{i-1})}}$$\n",
    "\n",
    "Where  $P()$ denotes probability and $w_i$ denotes the i-th word, so $P(w_i| w_1,...,w_{i-1})$ is the probability of word $i$, given all previous words ($1$ to $i-1$).\n",
    "As an implementation hack, you would usually take the log of that formula (so the computation is less prone to underflow problems). You would also need to take care of the padding, since you do not want to include the padding when calculating the perplexity (to avoid an artificially good metric).\n",
    "\n",
    "After taking the logarithm of $P(W)$ you have:\n",
    "\n",
    "$$\\log P(W) = {\\log\\left(\\sqrt[N]{\\prod_{i=1}^{N} \\frac{1}{P(w_i| w_1,...,w_{i-1})}}\\right)}$$\n",
    "\n",
    "\n",
    "$$ = \\log\\left(\\left(\\prod_{i=1}^{N} \\frac{1}{P(w_i| w_1,...,w_{i-1})}\\right)^{\\frac{1}{N}}\\right)$$\n",
    "\n",
    "$$ = \\log\\left(\\left({\\prod_{i=1}^{N}{P(w_i| w_1,...,w_{i-1})}}\\right)^{-\\frac{1}{N}}\\right)$$\n",
    "\n",
    "$$ = -\\frac{1}{N}{\\log\\left({\\prod_{i=1}^{N}{P(w_i| w_1,...,w_{i-1})}}\\right)} $$\n",
    "\n",
    "$$ = -\\frac{1}{N}{{\\sum_{i=1}^{N}{\\log P(w_i| w_1,...,w_{i-1})}}} $$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You will be working with a real example from this week's assignment. The example is made up of:\n",
    "   - `predictions` : log probabilities for each element in the vocabulary for 32 sequences with 64 elements (after padding).\n",
    "   - `targets` : 32 observed sequences of 64 elements (after padding)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load from .npy files\n",
    "predictions = np.load('predictions.npy')\n",
    "targets = np.load('targets.npy')\n",
    "\n",
    "# Print shapes\n",
    "print(f'predictions has shape: {predictions.shape}')\n",
    "print(f'targets has shape: {targets.shape}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that the predictions have an extra dimension with the same length as the size of the vocabulary used.\n",
    "\n",
    "Because of this you will need a way of reshaping `targets` to match this shape. For this you can use `np.eye()`, which you can use to create one-hot vectors.\n",
    "\n",
    "Notice that `predictions.shape[-1]` will return the size of the last dimension of `predictions`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "reshaped_targets = np.eye(predictions.shape[-1])[targets]\n",
    "print(f'reshaped_targets has shape: {reshaped_targets.shape}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By calculating the product of the predictions and the reshaped targets and summing across the last dimension, the total log probability of each observed element within the sequences can be computed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "log_p = np.sum(predictions * reshaped_targets, axis= -1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now you will need to account for the padding so this metric is not artificially deflated (since a lower perplexity means a better model). For identifying which elements are padding and which are not, you can use `np.equal()` and get a tensor with `1s` in the positions of actual values and `0s` where there are paddings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "non_pad = 1.0 - np.equal(targets, 0)\n",
    "print(f'non_pad has shape: {non_pad.shape}\\n')\n",
    "print(f'non_pad looks like this: \\n\\n {non_pad}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By computing the product of the log probabilities and the non_pad tensor you remove the effect of padding on the metric:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "real_log_p = log_p * non_pad\n",
    "print(f'real log probabilities still have shape: {real_log_p.shape}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can check the effect of filtering out the padding by looking at the two log probabilities tensors:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f'log probabilities before filtering padding: \\n\\n {log_p}\\n')\n",
    "print(f'log probabilities after filtering padding: \\n\\n {real_log_p}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, to get the average log perplexity of the model across all sequences in the batch, you will sum the log probabilities in each sequence and divide by the number of non padding elements (which will give you the negative log perplexity per sequence). After that, you can get the mean of the log perplexity across all sequences in the batch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "log_ppx = np.sum(real_log_p, axis=1) / np.sum(non_pad, axis=1)\n",
    "log_ppx = np.mean(-log_ppx)\n",
    "print(f'The log perplexity and perplexity of the model are respectively: {log_ppx} and {np.exp(log_ppx)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Congratulations on finishing this lecture notebook!** Now you should have a clear understanding of how to compute the perplexity to evaluate your language models. **Keep it up!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}