IBM  model 1 Perplexity by Sahoo.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "_cell_guid": "49c16e49-beea-6181-b456-c93e4a95cf24",
    "_uuid": "6116c83c7788af0e33dc6c704ece9b96d8d70845"
   },
   "source": [
    "#  IBM model 1\n",
    "\n",
    "A Python implementation of IBM model 1. See [Statistical Machine Translation] by Philipp Koehn for details.\n",
    "\n",
    "Note: My output diverges from the example in the book starting with the 2nd iteration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "_cell_guid": "55ff3ac8-e1cc-70b9-7dec-58d0078baa43",
    "_uuid": "6a68c3f95e4fe5a443610d5825440d120ac1607d"
   },
   "outputs": [],
   "source": [
    "import math\n",
    "import numpy\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "_cell_guid": "37beeac7-0cda-5205-ac0a-ec1ad945472e",
    "_uuid": "4a0e4f2e3864eab69fcb69f8b4897e3a7ba6ded6"
   },
   "outputs": [],
   "source": [
    "# Input: english sentence e, foreign sentence f, hash of translation probabilities t, epsilon \n",
    "# Output: probability of e given f\n",
    "\n",
    "def probability_e_f(e, f, t, epsilon=1):\n",
    "    l_e = len(e)\n",
    "    l_f = len(f)\n",
    "    p_e_f = 1\n",
    "    \n",
    "    for ew in e: # iterate over english words ew in english sentence e\n",
    "        inner_sum = 0\n",
    "        for fw in f: # iterate over foreign words fw in foreign sentence f\n",
    "            inner_sum += t[(ew, fw)]\n",
    "        p_e_f = inner_sum * p_e_f\n",
    "    \n",
    "    p_e_f = p_e_f * epsilon / (l_f**l_e)\n",
    "    \n",
    "    return p_e_f            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "_cell_guid": "ddfd87eb-4df0-45df-4e41-759beaa33627",
    "_uuid": "66db5e3bbbd263d3d26b6db9ded4a6601bd50aa5"
   },
   "outputs": [],
   "source": [
    "# Input: Collection of sentence pairs sentence_pairs, hash of translation probabilities t, epsilon\n",
    "# Output: Perplexity of model\n",
    "\n",
    "def perplexity(sentence_pairs, t, epsilon=1, debug_output=False):\n",
    "    pp = 0\n",
    "    \n",
    "    for sp in sentence_pairs:\n",
    "        prob = probability_e_f(sp[1], sp[0], t)\n",
    "        if debug_output:\n",
    "            print('english sentence:', sp[1], 'foreign sentence:', sp[0])\n",
    "            print(prob)\n",
    "            print()\n",
    "        pp += math.log(prob, 2) # log base 2\n",
    "        \n",
    "    pp = 2.0**(-pp)\n",
    "    return pp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "_cell_guid": "27c9ed46-444a-15ff-b00c-04cc6942226a",
    "_uuid": "e7308f46a05117bdb3bbac335ec5d345b800f0f6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No. of sentences in translation memory:  3\n",
      "Content:  [[['das', 'Haus'], ['the', 'house']], [['das', 'Buch'], ['the', 'book']], [['ein', 'Buch'], ['a', 'book']]]\n"
     ]
    }
   ],
   "source": [
    "# Get sentence pairs for toy experiment\n",
    "sentence_pairs = [ \n",
    "    [ ['das', 'Haus'], ['the', 'house'] ], \n",
    "    [ ['das', 'Buch'], ['the', 'book'] ], \n",
    "    [ ['ein', 'Buch'], ['a', 'book'] ]\n",
    "]\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "print('No. of sentences in translation memory: ', len(sentence_pairs))\n",
    "print('Content: ', sentence_pairs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "_cell_guid": "0e89196d-1873-2e75-050d-5ea5dbaf5367",
    "_uuid": "df586036e88cf17a747d7d4bac61f7da3b93863d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "English vocab:  ['a', 'book', 'house', 'the']\n",
      "Foreign vocab:  ['Buch', 'das', 'ein', 'Haus']\n",
      "english_vocab_size:  4\n",
      "foreign_vocab_size:  4\n"
     ]
    }
   ],
   "source": [
    "# Extract foreign and english vocabularies\n",
    "foreign_words = []\n",
    "english_words = []\n",
    "\n",
    "for sp in sentence_pairs:\n",
    "    for ew in sp[1]: \n",
    "        english_words.append(ew)\n",
    "    for fw in sp[0]: \n",
    "        foreign_words.append(fw)\n",
    "        \n",
    "english_words = sorted(list(set(english_words)), key=lambda s: s.lower()) \n",
    "foreign_words = sorted(list(set(foreign_words)), key=lambda s: s.lower())\n",
    "print('English vocab: ', english_words)\n",
    "print('Foreign vocab: ', foreign_words)\n",
    "\n",
    "english_vocab_size = len(english_words)\n",
    "foreign_vocab_size = len(foreign_words)\n",
    "print('english_vocab_size: ', english_vocab_size)\n",
    "print('foreign_vocab_size: ', foreign_vocab_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "_cell_guid": "184055fb-1d01-b411-3790-7ea229f8a594",
    "_uuid": "e5f529a587968169d5c0e645cf3400f3dd21dc17"
   },
   "outputs": [],
   "source": [
    "# Routine to uniformly initialize word translation probabilities in t hash\n",
    "\n",
    "def init_prob(t, init_val, english_words, foreign_words):\n",
    "    for fw in foreign_words:\n",
    "        for ew in english_words:\n",
    "            tup = (ew, fw) # tuple required because dict key cannot be list\n",
    "            t[tup] = init_val"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "_cell_guid": "d253ccb5-c5e8-9005-5131-ee90bc745837",
    "_uuid": "f7a913c1f5ad7a8e8b3723d844b4457357b17aa0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hash initialized\n",
      "No. of foreign/english pairs:  16\n",
      "Content:  {('a', 'Buch'): 0.25, ('book', 'Buch'): 0.25, ('house', 'Buch'): 0.25, ('the', 'Buch'): 0.25, ('a', 'das'): 0.25, ('book', 'das'): 0.25, ('house', 'das'): 0.25, ('the', 'das'): 0.25, ('a', 'ein'): 0.25, ('book', 'ein'): 0.25, ('house', 'ein'): 0.25, ('the', 'ein'): 0.25, ('a', 'Haus'): 0.25, ('book', 'Haus'): 0.25, ('house', 'Haus'): 0.25, ('the', 'Haus'): 0.25}\n",
      "**************\n",
      "\n",
      "english sentence: ['the', 'house'] foreign sentence: ['das', 'Haus']\n",
      "0.0625\n",
      "\n",
      "english sentence: ['the', 'book'] foreign sentence: ['das', 'Buch']\n",
      "0.0625\n",
      "\n",
      "english sentence: ['a', 'book'] foreign sentence: ['ein', 'Buch']\n",
      "0.0625\n",
      "\n",
      "4096.0\n",
      "**************\n",
      "--> *** t[('the','das')] 0.5\n",
      "--> *** t[('book','das')] 0.25\n",
      "--> t[('house','das')] 0.25\n",
      "--> *** t[('the','Buch')] 0.25\n",
      "--> *** t[('book','Buch')] 0.5\n",
      "--> t[('a','Buch')] 0.25\n",
      "--> t[('book','ein')] 0.5\n",
      "--> t[('a','ein')] 0.5\n",
      "--> t[('the','Haus')] 0.5\n",
      "--> t[('house','Haus')] 0.5\n",
      "english sentence: ['the', 'house'] foreign sentence: ['das', 'Haus']\n",
      "0.1875\n",
      "\n",
      "english sentence: ['the', 'book'] foreign sentence: ['das', 'Buch']\n",
      "0.140625\n",
      "\n",
      "english sentence: ['a', 'book'] foreign sentence: ['ein', 'Buch']\n",
      "0.1875\n",
      "\n",
      "202.27160493827165\n",
      "**************\n",
      "--> *** t[('the','das')] 0.6363636363636364\n",
      "--> *** t[('book','das')] 0.18181818181818182\n",
      "--> t[('house','das')] 0.18181818181818182\n",
      "--> *** t[('the','Buch')] 0.18181818181818182\n",
      "--> *** t[('book','Buch')] 0.6363636363636364\n",
      "--> t[('a','Buch')] 0.18181818181818182\n",
      "--> t[('book','ein')] 0.4285714285714286\n",
      "--> t[('a','ein')] 0.5714285714285715\n",
      "--> t[('the','Haus')] 0.4285714285714286\n",
      "--> t[('house','Haus')] 0.5714285714285715\n",
      "english sentence: ['the', 'house'] foreign sentence: ['das', 'Haus']\n",
      "0.20053972002023954\n",
      "\n",
      "english sentence: ['the', 'book'] foreign sentence: ['das', 'Buch']\n",
      "0.16735537190082642\n",
      "\n",
      "english sentence: ['a', 'book'] foreign sentence: ['ein', 'Buch']\n",
      "0.20053972002023954\n",
      "\n",
      "148.57971953377827\n",
      "**************\n",
      "--> *** t[('the','das')] 0.7478974515333995\n",
      "--> *** t[('book','das')] 0.1208425438930813\n",
      "--> t[('house','das')] 0.13126000457351933\n",
      "--> *** t[('the','Buch')] 0.1208425438930813\n",
      "--> *** t[('book','Buch')] 0.7478974515333995\n",
      "--> t[('a','Buch')] 0.13126000457351933\n",
      "--> t[('book','ein')] 0.34661354581673304\n",
      "--> t[('a','ein')] 0.6533864541832669\n",
      "--> t[('the','Haus')] 0.34661354581673304\n",
      "--> t[('house','Haus')] 0.6533864541832669\n",
      "english sentence: ['the', 'house'] foreign sentence: ['das', 'Haus']\n",
      "0.21470104453528496\n",
      "\n",
      "english sentence: ['the', 'book'] foreign sentence: ['das', 'Buch']\n",
      "0.18867729491340043\n",
      "\n",
      "english sentence: ['a', 'book'] foreign sentence: ['ein', 'Buch']\n",
      "0.21470104453528496\n",
      "\n",
      "114.97728367667098\n",
      "**************\n",
      "--> *** t[('the','das')] 0.8344395715124338\n",
      "--> *** t[('book','das')] 0.07516523179034365\n",
      "--> t[('house','das')] 0.09039519669722251\n",
      "--> *** t[('the','Buch')] 0.07516523179034365\n",
      "--> *** t[('book','Buch')] 0.8344395715124339\n",
      "--> t[('a','Buch')] 0.09039519669722253\n",
      "--> t[('book','ein')] 0.2755211789521138\n",
      "--> t[('a','ein')] 0.7244788210478862\n",
      "--> t[('the','Haus')] 0.2755211789521138\n",
      "--> t[('house','Haus')] 0.7244788210478862\n",
      "english sentence: ['the', 'house'] foreign sentence: ['das', 'Haus']\n",
      "0.22611954406760545\n",
      "\n",
      "english sentence: ['the', 'book'] foreign sentence: ['das', 'Buch']\n",
      "0.2068452245478711\n",
      "\n",
      "english sentence: ['a', 'book'] foreign sentence: ['ein', 'Buch']\n",
      "0.2261195440676055\n",
      "\n",
      "94.55365015392323\n",
      "**************\n",
      "--> *** t[('the','das')] 0.8960831177730378\n",
      "--> *** t[('book','das')] 0.04436291470681886\n",
      "--> t[('house','das')] 0.05955396752014332\n",
      "--> *** t[('the','Buch')] 0.044362914706818864\n",
      "--> *** t[('book','Buch')] 0.8960831177730377\n",
      "--> t[('a','Buch')] 0.059553967520143324\n",
      "--> t[('book','ein')] 0.21826012818351037\n",
      "--> t[('a','ein')] 0.7817398718164896\n",
      "--> t[('the','Haus')] 0.21826012818351043\n",
      "--> t[('house','Haus')] 0.7817398718164896\n"
     ]
    }
   ],
   "source": [
    "# Main routine\n",
    "num_iterations = 5\n",
    "perplex = []\n",
    "debug_output = True\n",
    "s_total = {}\n",
    "\n",
    "# Initialize probabilities uniformly\n",
    "t = {}\n",
    "init_val = 1.0 / foreign_vocab_size\n",
    "init_prob(t, init_val, english_words, foreign_words)\n",
    "if debug_output:\n",
    "    print('Hash initialized')\n",
    "    print('No. of foreign/english pairs: ', len(t))\n",
    "    print('Content: ', t)\n",
    "    print('**************')\n",
    "    print()\n",
    "\n",
    "# Loop while not converged\n",
    "for iter in range(num_iterations):\n",
    "    \n",
    "    # Calculate perplexity\n",
    "    pp = perplexity(sentence_pairs, t, 1, True)\n",
    "    print(pp)\n",
    "    print('**************')\n",
    "    perplex.append(pp)\n",
    "\n",
    "    # Initialize\n",
    "    count = {}\n",
    "    total = {}\n",
    "\n",
    "    for fw in foreign_words:\n",
    "        total[fw] = 0.0\n",
    "        for ew in english_words:\n",
    "            count[(ew, fw)] = 0.0\n",
    "\n",
    "    for sp in sentence_pairs:\n",
    "\n",
    "        # Compute normalization\n",
    "        for ew in sp[1]:\n",
    "            s_total[ew] = 0.0\n",
    "            for fw in sp[0]:\n",
    "                s_total[ew] += t[(ew, fw)]\n",
    "\n",
    "        # Collect counts\n",
    "        for ew in sp[1]:\n",
    "            for fw in sp[0]:\n",
    "                count[(ew, fw)] += t[(ew, fw)] / s_total[ew]\n",
    "                total[fw] += t[(ew, fw)] / s_total[ew]\n",
    "\n",
    "    # Estimate probabilities\n",
    "    for fw in foreign_words:\n",
    "        for ew in english_words:\n",
    "            t[(ew, fw)] = count[(ew, fw)] / total[fw]\n",
    "\n",
    "    if debug_output:\n",
    "        print(\"--> *** t[('the','das')]\", t[('the','das')])\n",
    "        print(\"--> *** t[('book','das')]\", t[('book','das')])\n",
    "    \n",
    "        print(\"--> t[('house','das')]\", t[('house','das')])\n",
    "        print(\"--> *** t[('the','Buch')]\", t[('the','Buch')])\n",
    "        print(\"--> *** t[('book','Buch')]\", t[('book','Buch')])\n",
    "        print(\"--> t[('a','Buch')]\", t[('a','Buch')])\n",
    "        print(\"--> t[('book','ein')]\", t[('book','ein')])\n",
    "        print(\"--> t[('a','ein')]\", t[('a','ein')])\n",
    "\n",
    "        print(\"--> t[('the','Haus')]\", t[('the','Haus')])\n",
    "        print(\"--> t[('house','Haus')]\", t[('house','Haus')])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plot of perplexity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "_cell_guid": "527cb2cb-eece-5abf-84ec-8e9c7c79c7c7",
    "_uuid": "35ff6d74db28e755f7dc9c5e74c796be572ad7c6"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 700x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "plt.figure(figsize=(7,4))\n",
    "plt.plot(range(1, num_iterations+1), perplex, linewidth=4)\n",
    "plt.xlabel('# Iterations')\n",
    "plt.ylabel('Perplexity')\n",
    "plt.title('Perplexity vs. iterations')\n",
    "plt.rcParams.update({'font.size': 12})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot of log base 10 of perplexity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "_cell_guid": "4581c0c1-eeb9-65f8-919c-20b57961874e",
    "_uuid": "bb6bcb9adad8f142b035d41cd9013c6732f707d5"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 700x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "plt.figure(figsize=(7,4))\n",
    "plt.plot(range(1, num_iterations+1), numpy.log10(perplex), linewidth=4)\n",
    "plt.xlabel('# Iterations')\n",
    "plt.ylabel('Log perplexity')\n",
    "plt.title('Log perplexity vs. iterations')\n",
    "plt.rcParams.update({'font.size': 12})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_cell_guid": "b86e491e-488f-1c0c-c4db-cc8e1474fdd9",
    "_uuid": "14e673dc6a388c6e60944ddc680bc161eb632e31"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "_change_revision": 0,
  "_is_fork": false,
  "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}