language_modelling.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "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.7.3"
    },
    "colab": {
      "name": "language_modelling.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/sayarghoshroy/Language-Modelling/blob/master/language_modelling.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YJPOAJCUZXm2",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# tokenizer implemented using regex from scratch\n",
        "# implementation of language modelling algorithm\n",
        "# with Kneser-Ney Smoothing and interpolation in Python\n",
        "# N-grams upto order 6 have been considered\n",
        "# model perplexity computation\n",
        "# Sentence generation using language models"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WplBcvBwZXnG",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import sys\n",
        "import re\n",
        "import copy"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RjZF6gCnZXnS",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "regex_dict = {\n",
        "    'url_regex_a' : \"(http|ftp|https)://([\\w_-]+(?:(?:\\.[\\w_-]+)+))([\\w.,@?^=%&:/~+#-]*[\\w@?^=%&/~+#-])?\",\n",
        "    'url_regex_b' : \"(http|ftp|https)://\\w*.\\w*/\\w*\",\n",
        "    'mention_regex' : \"@.+\",\n",
        "    'dollar_regex' : \"$[0-9]+\\.?[0-9]*\",\n",
        "    'rupee_regex' : \"Rs\\.[0-9]*\\.?[0-9]*\",\n",
        "    'hashtag_regex' : \"#.+\",\n",
        "    'number_regex' : \"[0-9]*[0-9\\.][0-9]+\",\n",
        "    'number_comma_regex' : \"([0-9]*\\,?[0-9]+)+\",\n",
        "    'email_regex' : \"'\\S+@\\S+'\",\n",
        "    'name_regex' : \"(Mr\\.|Mrs\\.|Ms\\.|Smt\\.|Shri\\.|Sri\\.|Shree\\.)[a-zA-Z]*\",\n",
        "    'name_middle' : \"[A-Z]\\.\"\n",
        "}"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lWGbQ49FZXnc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def check(unit):\n",
        "    for regex in regex_dict.values():\n",
        "        if re.match(regex, unit):\n",
        "            return True\n",
        "    return False"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tz4yR4AAZXnm",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# filename = sys.argv[1]\n",
        "# access the filename as a command line argument\n",
        "filename = 'corpus_EN.txt'\n",
        "fp = open(filename)\n",
        "file_string = fp.read()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w9HJv7BrZXnv",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "sentence_list = file_string.split('\\n')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "exwns0C2ZXn1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Building the Language Model\n",
        "def generate_ngrams(tokenized_list, n):\n",
        "    temp_list = copy.deepcopy(tokenized_list)\n",
        "    complete_list = []\n",
        "    for sentence_tokens in temp_list:\n",
        "        for counter in range(0, n - 1):\n",
        "            sentence_tokens.insert(0, '<s>')\n",
        "            sentence_tokens.append('</s>')\n",
        "        size = len(sentence_tokens)\n",
        "        ngram_list = [sentence_tokens[i: i + n] for i in range(size - (n - 1))]\n",
        "        complete_list = complete_list + ngram_list\n",
        "\n",
        "    return complete_list\n",
        "\n",
        "def find_ngrams(tokens, n):\n",
        "    size = len(tokens)\n",
        "    ngram_list = [tokens[i: i + n] for i in range(size - (n - 1))]\n",
        "    return ngram_list"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lEEvx6GJZXn8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "tokenized_string = \"\"\n",
        "# the final output\n",
        "\n",
        "tokenized_sentences = []\n",
        "\n",
        "frequencies = [[], { }, { }, { }, { }, { }, { }]\n",
        "# to store N-gram counts for N in {1, 2, 3, 4, 5, 6}\n",
        "\n",
        "def tokenize_sentence(sentence):\n",
        "    units = sentence.split(\" \")\n",
        "    tokens = []\n",
        "    for unit in units:\n",
        "        if check(unit):\n",
        "            tokens.append(unit)\n",
        "                \n",
        "            continue\n",
        "        \n",
        "        divider = re.findall(r\"[\\w']+|[’.,!?;-~`]\", unit)\n",
        "        for elem in divider:\n",
        "            if elem == '':\n",
        "                continue\n",
        "\n",
        "            if \"\\\"\" in elem:\n",
        "                storage = elem.split(\"\\\"\")\n",
        "                for item in storage:\n",
        "                    if \"\\'\" in item:\n",
        "                        new_storage = item.split(\"\\'\")\n",
        "                        for item_sep in new_storage:\n",
        "                            tokens.append(item_sep)\n",
        "                            tokens.append(\"\\'\")\n",
        "                        tokens.pop()\n",
        "                    else:\n",
        "                        tokens.append(item)\n",
        "                        tokens.append(\"\\\"\")\n",
        "                tokens.pop()\n",
        "                            \n",
        "            elif \"\\'\" in elem:\n",
        "                new_storage = elem.split(\"\\'\")\n",
        "                for item_sep in new_storage:\n",
        "                    tokens.append(item_sep)\n",
        "                    tokens.append(\"\\'\")\n",
        "                tokens.pop()\n",
        "\n",
        "            else:\n",
        "                tokens.append(elem)\n",
        "    return tokens\n",
        "\n",
        "for sentence in sentence_list:\n",
        "    units = sentence.split(\" \")\n",
        "    tokens = tokenize_sentence(sentence)\n",
        "    if len(tokens) == 1 and tokens[0] == '' or tokens == []:\n",
        "        continue\n",
        "    \n",
        "    for token in tokens:\n",
        "        if token in frequencies[1]:\n",
        "            frequencies[1][token] += 1\n",
        "        else:\n",
        "            frequencies[1][token] = 1\n",
        "        tokenized_string = tokenized_string + \" \" + str(token)\n",
        "    \n",
        "    tokenized_sentences.append(tokens)\n",
        "        \n",
        "all_tokens = tokenized_string.split(' ')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rWp0oFdMZXoE",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# 'Uncomment the lines to create a file containing all tokenized sentences from corpus\n",
        "#f_tokens_ = open(\"corpus__tokens.txt\",\"w+\")\n",
        "for sentence_sep in tokenized_sentences:\n",
        "    output_line  = \"\"\n",
        "    for unit in sentence_sep:\n",
        "        if unit == \" \":\n",
        "            continue\n",
        "        output_line = output_line + unit.strip() + \" \"\n",
        "    output_line = re.sub(r\"  \", r\" \", output_line)\n",
        "    #print(output_line)\n",
        "    \n",
        "    #f_tokens_.write(output_line.strip())\n",
        "    #f_tokens_.write(\"\\n\")\n",
        "#f_tokens_.close()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s-Jq4RDAZXoO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "N_gram_collections = [ [] ]\n",
        "for N in range(1, 7):\n",
        "    N_gram_collections.append(generate_ngrams(tokenized_sentences[:], N))\n",
        "        \n",
        "# Compute Frequencies of N-grams for N on {2, 3, 4, 5, 6}\n",
        "# Preprocesing\n",
        "for N in range(2, 7):\n",
        "    for gram in N_gram_collections[N]:\n",
        "        key = tuple(gram)\n",
        "        if key in frequencies[N]:\n",
        "            frequencies[N][key] += 1\n",
        "        else:\n",
        "            frequencies[N][key] = 1"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "73mzb0nhZXoW",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Uncomment to display generated 5-grams\n",
        "# print(generate_ngrams(tokenized_sentences, 5))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KDgFZ0cVZXof",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# The language model is the collection of frequencies of all N-grams\n",
        "# Here, N is in the range (1, 2, 3, 4, 5, 6)\n",
        "# Hence, the 'frequencies' component stores all necessary information for the LM\n",
        "# Storing it in a file\n",
        "\n",
        "fp = open(\"LM\", \"w+\")\n",
        "fp.write(str(frequencies))\n",
        "fp.close()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UT72aItJZXom",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Uncomment to view the tokenized text\n",
        "#print(tokenized_string)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9_Ij3WBkZXou",
        "colab_type": "code",
        "outputId": "ab2f41c3-2d76-4043-c386-71c30598f399",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "not_word = ['.', ',', '!', '?', ';', ':', '/', '\\\\', '(', ')', ' ', '\\n', '']\n",
        "word_id = []\n",
        "frequency = []\n",
        "count = 1\n",
        "for key, value in sorted(frequencies[1].items(), key = lambda kv: kv[1], reverse = True):\n",
        "    if key in not_word:\n",
        "        continue\n",
        "    word_id.append(count)\n",
        "    frequency.append(value)\n",
        "    count += 1\n",
        "print(\"Number of tokens in corpus:\", count)"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Number of tokens in corpus: 7171\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O1WTxeTBZXo2",
        "colab_type": "code",
        "outputId": "b3a4dd77-51ac-4454-fe7d-31d92d58f136",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 520
        }
      },
      "source": [
        "# Drawing a Frequency v/s Token Rank Graph\n",
        "num = 1000 # Number of values to consider for Frequency v/s Word Rank Plot\n",
        "x = word_id[:num]\n",
        "y = frequency[:num]\n",
        "\n",
        "plt.figure(figsize = (12, 8))\n",
        "plt.title(\"Zipf Law Illustration : Frequency v/s Token Rank - Top 1000\", fontsize = 16)\n",
        "plt.xlabel(\"Rank\", fontsize = 16)\n",
        "plt.ylabel('Frequency', fontsize = 16)\n",
        "plt.plot(x, y, color = 'darkblue')\n",
        "# plt.savefig('less_EN.png')\n",
        "plt.show()"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 864x576 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bp44DrodZXo8",
        "colab_type": "code",
        "outputId": "154317c3-a5b5-4076-9b86-451d64f1fb60",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 520
        }
      },
      "source": [
        "# Plot for 1000 to 2000 ranked Tokens\n",
        "x = word_id[1000: 2001]\n",
        "y = frequency[1000: 2001]\n",
        "\n",
        "plt.figure(figsize = (12, 8))\n",
        "plt.title(\"Frequency v/s Word Rank - 1000 to 2000 ranked Tokens\", fontsize = 16)\n",
        "plt.xlabel(\"Rank\", fontsize = 16)\n",
        "plt.ylabel('Frequency', fontsize = 16)\n",
        "plt.plot(x, y, 'blue')\n",
        "# plt.savefig('more_EN.png')\n",
        "plt.show()"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 864x576 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N-yMvaXLZXpC",
        "colab_type": "code",
        "outputId": "37d9872f-06e4-4d1a-d608-a7aaa8f50124",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "def P_Kneser_Ney(word, previous_words, is_top):\n",
        "    # I want an ice-cream. word: \"ice-cream\", previous_words = [\"I\", \"want\", \"an\"]\n",
        "    # Base Case\n",
        "    if previous_words == []:\n",
        "        if is_top == 1:\n",
        "            count = 0\n",
        "            if word in frequencies[1]:\n",
        "                count = frequencies[1][word]\n",
        "            return (count / len(all_tokens))\n",
        "        else:\n",
        "            numerator_base = 0\n",
        "            for key in frequencies[2]:\n",
        "                if key[1] == word:\n",
        "                    numerator_base += 1\n",
        "            #print(\"Numerator_base :\", numerator_base)\n",
        "            return (numerator_base / len(frequencies[2]))\n",
        "            \n",
        "    \n",
        "    delta = 0.7\n",
        "    words = [token for token in previous_words]\n",
        "    words.append(word)\n",
        "    \n",
        "    # Computing the numerator\n",
        "    look_at_all = len(words)\n",
        "    look_at_prev = len(previous_words)\n",
        "    key = tuple(words)\n",
        "    \n",
        "    if is_top == 1:\n",
        "        numerator_A = 0\n",
        "        if key in frequencies[look_at_all]:\n",
        "            numerator_A = max(frequencies[look_at_all][key] - delta, 0)\n",
        "    else:\n",
        "        numerator_A = 0\n",
        "        checker = tuple(words[1:])\n",
        "        if(len(key) == 1):\n",
        "            key = key[0]\n",
        "        for key in frequencies[look_at_all]:\n",
        "            if (tuple(list(key)[1: len(list(key))]) == checker):\n",
        "                numerator_A += 1\n",
        "        #print(numerator_A)\n",
        "    \n",
        "    # Computing the Denominator\n",
        "    key = tuple(previous_words)\n",
        "    if(len(key) == 1):\n",
        "        key = key[0]\n",
        "    \n",
        "    if is_top == 1:\n",
        "        denominator = 0\n",
        "        if key in frequencies[look_at_prev]:\n",
        "            denominator = frequencies[look_at_prev][key]\n",
        "        else:\n",
        "            denominator = 1\n",
        "    else:\n",
        "        denominator = len(frequencies[look_at_all])\n",
        "    \n",
        "    numerator_B = 0\n",
        "    for key in frequencies[look_at_all]:\n",
        "        if (tuple(list(key)[0: len(list(key)) - 1]) == (tuple(previous_words))):\n",
        "            numerator_B += 1\n",
        "            \n",
        "    if denominator == 0:\n",
        "        denominator = 1\n",
        "    \n",
        "    if numerator_B == 0:\n",
        "        return (numerator_A / denominator)\n",
        "    \n",
        "    return (numerator_A / denominator) + delta * (numerator_B / denominator) * P_Kneser_Ney(word, previous_words[1:], 0)\n",
        "    \n",
        "    \n",
        "P_Kneser_Ney('not', ['This', 'must'], 1)"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.3011867444638436"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TwDAzsqEZXpJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def prob_perplexity_sentence(sentence, gram_size):\n",
        "    if(gram_size > 6):\n",
        "        gram_size = 6\n",
        "    elif(gram_size < 1):\n",
        "        gram_size = 1\n",
        "        \n",
        "    tokens = tokenize_sentence(sentence)\n",
        "    n_grams_generated = find_ngrams(tokens, gram_size)\n",
        "\n",
        "    probability = 1\n",
        "    perplex_sum = 0\n",
        "    \n",
        "    for gram in n_grams_generated:\n",
        "        word = gram[len(gram) - 1]\n",
        "        previous_words = gram[0: len(gram) - 1]\n",
        "        probability *= P_Kneser_Ney(word, previous_words, 1)\n",
        "        if probability == 0:\n",
        "            continue\n",
        "        perplex_sum -= (probability * np.log(probability) / np.log(2))\n",
        "    \n",
        "    perplexity = np.power(2, perplex_sum)\n",
        "    \n",
        "    return({'sentence' : sentence, 'probability' : probability, 'perplexity' : perplexity})"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_B7wBR5WZXpP",
        "colab_type": "code",
        "outputId": "af322684-1971-4594-8810-27735a65bf36",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# Play around with various strings with a corresponding maximum N-gram length\n",
        "print(prob_perplexity_sentence(\"including India.\", 2))"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'sentence': 'including India.', 'probability': 0.09806155456408601, 'perplexity': 1.80212892123132}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4t-zEKECZXpU",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def generate(gram_size, rcvd_key):\n",
        "    key = rcvd_key\n",
        "    sentence = rcvd_key[gram_size - 1] + \" \"\n",
        "    length = 0\n",
        "    \n",
        "    while(key[gram_size - 1] != '</s>'):\n",
        "        new_key_init = []\n",
        "        for i in range(1, gram_size):\n",
        "            new_key_init.append(key[i])\n",
        "            \n",
        "        consider_keys = []\n",
        "        \n",
        "        for key_iter in frequencies[gram_size]:\n",
        "            if tuple(list(key_iter)[0: len(rcvd_key) - 1]) == tuple(new_key_init):\n",
        "                consider_keys.append(key_iter)\n",
        "                \n",
        "        build_dict = {}\n",
        "        for key in consider_keys:\n",
        "            build_dict[key] = frequencies[gram_size][key]\n",
        "        \n",
        "        key_next = 0\n",
        "        for key_take, value in sorted(build_dict.items(), key = lambda kv: kv[1], reverse = True):\n",
        "            key_next = key_take\n",
        "            if key_next[gram_size - 1] != \"</s>\":\n",
        "                sentence = sentence + \" \" + key_next[gram_size - 1]\n",
        "            break\n",
        "        key = key_next\n",
        "        length += 1\n",
        "        if length == 20:\n",
        "            break\n",
        "    sentence = re.sub(r\"  \", r\" \", sentence)\n",
        "    print(sentence)\n",
        "\n",
        "def generate_init(gram_size, create):\n",
        "    # generates a set of 'create' sentences considering the language model of the given gram_size\n",
        "    if(gram_size > 6):\n",
        "        gram_size = 6\n",
        "    elif(gram_size < 1):\n",
        "        gram_size = 1\n",
        "    if gram_size == 1:\n",
        "        count = 10\n",
        "        for key, value in sorted(frequencies[1].items(), key = lambda kv: kv[1], reverse = True):\n",
        "            print(key)\n",
        "            count -= 1\n",
        "            if(count <= 0):\n",
        "                return\n",
        "    init = []\n",
        "    for i in range(gram_size - 1):\n",
        "        init.append('<s>')\n",
        "    consider_keys = []\n",
        "    for key in frequencies[gram_size]:\n",
        "        if tuple(list(key)[0: len(key) - 1]) == tuple(init):\n",
        "            consider_keys.append(key)\n",
        "            #print(key)\n",
        "            \n",
        "    build_dict = {}\n",
        "    for key in consider_keys:\n",
        "        build_dict[key] = frequencies[gram_size][key]\n",
        "        \n",
        "    count = min(create, 25)\n",
        "    for key, value in sorted(build_dict.items(), key = lambda kv: kv[1], reverse = True):\n",
        "        generate(gram_size, key)\n",
        "\n",
        "        count -= 1\n",
        "        if(count <= 0):\n",
        "            break"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ICWQCVGGZXpa",
        "colab_type": "code",
        "outputId": "57ef2ca4-2124-472a-f97b-b3e62021ac41",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 383
        }
      },
      "source": [
        "# Generate Sentences using a maximum N-gram size as argument\n",
        "generate_init(5, 20)"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "He is a well off person .\n",
            "I am not going to answer the question .\n",
            "The boy is being brave .\n",
            "How many people are about to come in this party ?\n",
            "What is the name of this thing ?\n",
            "You are not the first man that has been deceived by appearances .\n",
            "We are not working .\n",
            "She is not going to work out .\n",
            "They are not going to walk in the mountains .\n",
            "Will you be able to spare time for me ?\n",
            "It is a very good example of social service .\n",
            "This is the boy whose pencil I have .\n",
            "There is a cow in the field .\n",
            "A girl eats an apple .\n",
            "John is giving bananas , Saidi oranges .\n",
            "My sister , who works in IT , is coming to visit me tomorrow .\n",
            "If you had left that wasp alone it might not have stung you .\n",
            "Does he know that you love him ?\n",
            "Which is the best book ?\n",
            "Who did you give the book to ?\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9vlr1G3QZXph",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Accepts a corpus as input and calculate perplexities of all its sentences\n",
        "test_corpus = 'corpus_EN.txt'\n",
        "f_test = open(test_corpus)\n",
        "test_file_string = f_test.read()\n",
        "\n",
        "test_sentence_list = test_file_string.split('\\n')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "l6RjhEtOZXpn",
        "colab_type": "code",
        "outputId": "25c1740e-39c8-4a9e-9c94-00717bfb9692",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "count = 0\n",
        "f_perplex = open(\"perplexity_scores\", \"w+\")\n",
        "avg_perplexities = [0, 0, 0, 0, 0, 0]\n",
        "for N_gram_used in range(1, 7):\n",
        "    sum = 0\n",
        "    count = 0\n",
        "    f_perplex.write(\"Perplexity Scores using N-gram Size = \"+ str(N_gram_used) + \"\\n\")\n",
        "    for test_sentence in test_sentence_list:\n",
        "        unit = prob_perplexity_sentence(test_sentence, N_gram_used)\n",
        "        string_to_write = test_sentence + \"\\t\" + str(unit['perplexity']) + \"\\n\"\n",
        "        f_perplex.write(string_to_write)\n",
        "        sum += unit['perplexity']\n",
        "        count += 1\n",
        "        if(count > 10):\n",
        "            break\n",
        "    avg_perplexities[N_gram_used - 1] = sum / count\n",
        "    f_perplex.write(\"Average Perplexity : \" + str(sum / count) + \"\\n\")\n",
        "print(\"Average Perplexities using various sized N-grams:\", avg_perplexities)\n",
        "f_perplex.close()"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Average Perplexities using various sized N-grams: [1.0381730218581977, 1.1825251861497608, 1.5340727778755736, 1.694116831502953, 1.681301153192944, 1.5338029311263925]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mADqff_IZXpr",
        "colab_type": "code",
        "outputId": "71b08191-0896-415f-abd2-7c2ef0fcd066",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 520
        }
      },
      "source": [
        "# Plot for the generated language models\n",
        "# Unigram, Bigram, Trigram, ... , 6-gram\n",
        "x = [i for i in range(1, 7)]\n",
        "y = avg_perplexities[0:]\n",
        "\n",
        "plt.figure(figsize = (12, 8))\n",
        "plt.title(\"Plot of LMs - Average Perplexity v/s N-gram size used\", fontsize = 16)\n",
        "plt.xlabel(\"N\", fontsize = 16)\n",
        "plt.ylabel('Average Perplexity', fontsize = 16)\n",
        "plt.bar(x, y, color = 'darkgreen')\n",
        "# plt.savefig('perplexity_en.png')\n",
        "plt.show()"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 864x576 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TXSsGp0UZXpx",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#  ^_^ Thank You\n",
        "# Author: Sayar Ghosh Roy"
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}