ML_pp1.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "import math\n",
        "import copy\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n"
      ],
      "metadata": {
        "id": "2wm0TOCRiuA1"
      },
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "IiaF6CN-GhdI"
      },
      "outputs": [],
      "source": [
        "txt_file = open(\"training_data.txt\", \"r\")\n",
        "file_content = txt_file.read()\n",
        "training_data = file_content.split(\" \")\n",
        "txt_file.close()\n",
        "training_data=training_data[0:640000]\n",
        "\n",
        "txt_file = open(\"test_data.txt\", \"r\")\n",
        "file_content = txt_file.read()\n",
        "test_data = file_content.split(\" \")\n",
        "txt_file.close()\n",
        "test_data=test_data[0:640000]\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def bag(my_list,freq):\n",
        "   \n",
        "   \n",
        "    for item in my_list:\n",
        "            freq[item] = 0\n",
        "           \n",
        "    \n",
        "vocab_dict={}\n",
        "bag(training_data+test_data,vocab_dict)\n",
        "\n"
      ],
      "metadata": {
        "id": "PjqDL3dGGrPD"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "def CountFrequency(my_list):\n",
        "    freq=copy.copy(vocab_dict)  \n",
        "    for item in my_list:\n",
        "        if (item in freq):\n",
        "            freq[item] +=1\n",
        "\n",
        "\n",
        "    return freq        \n",
        "\n",
        "def perplexity_mle(n,freq,data):\n",
        "     sum=0\n",
        "     for i in range(len(data)):\n",
        "         p=freq[data[i]]/len(data)\n",
        "         if(p==0):\n",
        "            sum=sum-float('inf')\n",
        "         else:\n",
        "            sum=sum+math.log(p)\n",
        "     sum=sum/(-n)\n",
        "     return math.exp(sum)    \n",
        "\n",
        "def perplexity_map(n,freq,data,alpha0,alphak,k,l):\n",
        "     sum=0\n",
        "     for i in range(len(data)):\n",
        "         p=(freq[data[i]]+alphak-1)/(l+alpha0-k)\n",
        "         if(p==0):\n",
        "              return \"a\"\n",
        "         sum=sum+math.log(p)\n",
        "     sum=sum/(-n)\n",
        "     return math.exp(sum) \n",
        "\n",
        "\n",
        "def perplexity_pred_dist(n,freq,data,alpha0,alphak,l):\n",
        "     sum=0\n",
        "     for i in range(len(data)):\n",
        "         p=(freq[data[i]]+alphak)/(l+alpha0)\n",
        "         sum=sum+math.log(p)\n",
        "     sum=sum/(-n)\n",
        "     return math.exp(sum) \n",
        "\n"
      ],
      "metadata": {
        "id": "Q4vXNa9aNtia"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "training_data1=training_data[0:5000] #n/128=5000\n",
        "training_data2=training_data[0:10000] #n/64=10000\n",
        "training_data3=training_data[0:40000] #n/16=40000\n",
        "training_data4=training_data[0:160000] #n/4=160000\n",
        "training_data5=training_data #n=640000\n",
        "\n",
        "\n",
        "#count of words in each training data\n",
        "freq_1=CountFrequency(training_data1) #in training_data1\n",
        "freq_2=CountFrequency(training_data2)#in training_data2\n",
        "freq_3=CountFrequency(training_data3)#in training_data3\n",
        "freq_4=CountFrequency(training_data4)#in training_data4\n",
        "freq_5=CountFrequency(training_data5)#in training_data5\n"
      ],
      "metadata": {
        "id": "VtRD9d0FMW0z"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# When training set is of 5000 element\n",
        "#MLE\n",
        "print(\"*MLE*\")\n",
        "perplexity_mle_ans_5k_tr=perplexity_mle(640000,freq_1,training_data)\n",
        "print(\"Perplexity using the maximum likelihood estimate for Train :\",(perplexity_mle_ans_5k_tr))\n",
        "\n",
        "perplexity_mle_ans_5k=perplexity_mle(640000,freq_1,test_data)\n",
        "print(\"Perplexity using the maximum likelihood estimate for Test :\",(perplexity_mle_ans_5k))\n",
        "#MAP\n",
        "print(\"*MAP*\")\n",
        "perplexity_map_ans_5k_tr=perplexity_map(640000,freq_1,training_data,20000,2,10000,5000)\n",
        "print(\"Perplexity using the MAP estimate for Train\",perplexity_map_ans_5k_tr)\n",
        "\n",
        "perplexity_map_ans_5k=perplexity_map(640000,freq_1,test_data,20000,2,10000,5000)\n",
        "print(\"Perplexity using the MAP estimate for Test\",perplexity_map_ans_5k)\n",
        " # **Predective dist**\n",
        "print(\"*Pred dist*\")\n",
        "perplexity_pred_dist_ans_5k_tr=perplexity_pred_dist(640000,freq_1,training_data,20000,2,5000)\n",
        "print(\"Perplexity using the predictive distribution for Train\",perplexity_pred_dist_ans_5k_tr)\n",
        "\n",
        "perplexity_pred_dist_ans_5k=perplexity_pred_dist(640000,freq_1,test_data,20000,2,5000)\n",
        "print(\"Perplexity using the predictive distribution for Test\",perplexity_pred_dist_ans_5k)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jQ0pE_Q8N7KF",
        "outputId": "07828177-a865-4326-b9ac-756113c78f35"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "*MLE*\n",
            "Perplexity using the maximum likelihood estimate for Train : inf\n",
            "Perplexity using the maximum likelihood estimate for Test : inf\n",
            "*MAP*\n",
            "Perplexity using the MAP estimate for Train 10047.88041220642\n",
            "Perplexity using the MAP estimate for Test 10098.36492411617\n",
            "*Pred dist*\n",
            "Perplexity using the predictive distribution for Train 9782.98313217559\n",
            "Perplexity using the predictive distribution for Test 9814.024919445475\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# When training set is of 10000 element\n",
        "#Mle\n",
        "print(\"*MLe*\")\n",
        "perplexity_mle_ans_10k_tr=perplexity_mle(640000,freq_2,training_data)\n",
        "print(\"Perplexity using the maximum likelihood estimate for train :\",(perplexity_mle_ans_10k_tr))\n",
        "\n",
        "\n",
        "perplexity_mle_ans_10k=perplexity_mle(640000,freq_2,test_data)\n",
        "print(\"Perplexity using the maximum likelihood estimate for test :\",(perplexity_mle_ans_10k))\n",
        "#MAP\n",
        "print(\"*MAP\")\n",
        "perplexity_map_ans_10k_tr=perplexity_map(640000,freq_2,training_data,20000,2,10000,10000)\n",
        "print(\"Perplexity using the MAP estimate for train\",perplexity_map_ans_10k_tr)\n",
        "\n",
        "\n",
        "perplexity_map_ans_10k=perplexity_map(640000,freq_2,test_data,20000,2,10000,10000)\n",
        "print(\"Perplexity using the MAP estimate for test\",perplexity_map_ans_10k)\n",
        "#pred dis\n",
        "print(\"*pred dis*\")\n",
        "perplexity_pred_dist_ans_10k_tr=perplexity_pred_dist(640000,freq_2,training_data,20000,2,10000)\n",
        "print(\"Perplexity using the predictive distribution for train\",perplexity_pred_dist_ans_10k_tr)\n",
        "\n",
        "perplexity_pred_dist_ans_10k=perplexity_pred_dist(640000,freq_2,test_data,20000,2,10000)\n",
        "print(\"Perplexity using the predictive distribution for test\",perplexity_pred_dist_ans_10k)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4NxpSFavjIou",
        "outputId": "7cf8eaf1-fd03-402a-cec3-baff55c9507f"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "*MLe*\n",
            "Perplexity using the maximum likelihood estimate for train : inf\n",
            "Perplexity using the maximum likelihood estimate for test : inf\n",
            "*MAP\n",
            "Perplexity using the MAP estimate for train 9917.43567943996\n",
            "Perplexity using the MAP estimate for test 9992.362371992125\n",
            "*pred dis*\n",
            "Perplexity using the predictive distribution for train 9619.499986112396\n",
            "Perplexity using the predictive distribution for test 9668.062580182157\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# When training set is of 40000 element\n",
        "#mle\n",
        "print(\"*MLE*\")\n",
        "perplexity_mle_ans_40k_tr=perplexity_mle(640000,freq_3,training_data)\n",
        "print(\"Perplexity using the maximum likelihood estimate for train:\",(perplexity_mle_ans_40k_tr))\n",
        "\n",
        "\n",
        "perplexity_mle_ans_40k=perplexity_mle(640000,freq_3,test_data)\n",
        "print(\"Perplexity using the maximum likelihood estimate for test:\",(perplexity_mle_ans_40k))\n",
        "#map\n",
        "print(\"*MAP*\")\n",
        "perplexity_map_ans_40k_tr=perplexity_map(640000,freq_3,training_data,20000,2,10000,40000)\n",
        "print(\"Perplexity using the MAP estimate for train\",perplexity_map_ans_40k_tr)\n",
        "\n",
        "\n",
        "perplexity_map_ans_40k=perplexity_map(640000,freq_3,test_data,20000,2,10000,40000)\n",
        "print(\"Perplexity using the MAP estimate for test\",perplexity_map_ans_40k)\n",
        "#pred dis\n",
        "print(\"*Pred Dist*\")\n",
        "perplexity_pred_dist_ans_40k_tr=perplexity_pred_dist(640000,freq_3,training_data,20000,2,40000)\n",
        "print(\"Perplexity using the predictive distribution for train\",perplexity_pred_dist_ans_40k_tr)\n",
        "\n",
        "perplexity_pred_dist_ans_40k=perplexity_pred_dist(640000,freq_3,test_data,20000,2,40000)\n",
        "print(\"Perplexity using the predictive distribution for test\",perplexity_pred_dist_ans_40k)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "l2yshfUXSmqk",
        "outputId": "6ddcbe43-29b1-4740-e0ca-88d46b2d9dfd"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "*MLE*\n",
            "Perplexity using the maximum likelihood estimate for train: inf\n",
            "Perplexity using the maximum likelihood estimate for test: inf\n",
            "*MAP*\n",
            "Perplexity using the MAP estimate for train 9255.182346253425\n",
            "Perplexity using the MAP estimate for test 9380.752312326787\n",
            "*Pred Dist*\n",
            "Perplexity using the predictive distribution for train 9127.235965446844\n",
            "Perplexity using the predictive distribution for test 9224.511912933269\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# When training set is of 160000 element\n",
        "#MLE\n",
        "print(\"*MLE*\")\n",
        "perplexity_mle_ans_160k_tr=perplexity_mle(640000,freq_4,training_data)\n",
        "print(\"Perplexity using the maximum likelihood estimate for train :\",perplexity_mle_ans_160k_tr)\n",
        "\n",
        "\n",
        "perplexity_mle_ans_160k=perplexity_mle(640000,freq_4,test_data)\n",
        "print(\"Perplexity using the maximum likelihood estimate for test:\",perplexity_mle_ans_160k)\n",
        "#MAP\n",
        "print(\"*MAP*\")\n",
        "perplexity_map_ans_160k_tr=perplexity_map(640000,freq_4,training_data,20000,2,10000,160000)\n",
        "print(\"Perplexity using the MAP estimate for train\",perplexity_map_ans_160k_tr)\n",
        "\n",
        "\n",
        "perplexity_map_ans_160k=perplexity_map(640000,freq_4,test_data,20000,2,10000,160000)\n",
        "print(\"Perplexity using the MAP estimate for test\",perplexity_map_ans_160k)\n",
        "#pred dis\n",
        "print(\"*Pred Dis*\")\n",
        "perplexity_pred_dist_ans_160k_tr=perplexity_pred_dist(640000,freq_4,training_data,20000,2,160000)\n",
        "print(\"Perplexity using the predictive distribution for train\",perplexity_pred_dist_ans_160k_tr)\n",
        "\n",
        "perplexity_pred_dist_ans_160k=perplexity_pred_dist(640000,freq_4,test_data,20000,2,160000)\n",
        "print(\"Perplexity using the predictive distribution for test\",perplexity_pred_dist_ans_160k)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GZoPTqLLjcpd",
        "outputId": "466bf956-0f2a-4dad-ad20-7789bc372c7a"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "*MLE*\n",
            "Perplexity using the maximum likelihood estimate for train : inf\n",
            "Perplexity using the maximum likelihood estimate for test: inf\n",
            "*MAP*\n",
            "Perplexity using the MAP estimate for train 8693.509011629605\n",
            "Perplexity using the MAP estimate for test 8839.546029448937\n",
            "*Pred Dis*\n",
            "Perplexity using the predictive distribution for train 8683.653146964924\n",
            "Perplexity using the predictive distribution for test 8817.904839672385\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# When training set is of 640000 element\n",
        "#MLE\n",
        "print(\"*MLE*\")\n",
        "perplexity_mle_ans_640k_tr=perplexity_mle(640000,freq_5,training_data)\n",
        "print(\"Perplexity using the maximum likelihood estimate for train:\",perplexity_mle_ans_640k_tr)\n",
        "\n",
        "\n",
        "perplexity_mle_ans_640k=perplexity_mle(640000,freq_5,test_data)\n",
        "print(\"Perplexity using the maximum likelihood estimate for test:\",perplexity_mle_ans_640k)\n",
        "#MAP\n",
        "print(\"*MAP*\")\n",
        "perplexity_map_ans_640k_tr=perplexity_map(640000,freq_5,training_data,20000,2,10000,640000)\n",
        "print(\"Perplexity using the MAP estimate for train\",perplexity_map_ans_640k_tr)\n",
        "\n",
        "\n",
        "perplexity_map_ans_640k=perplexity_map(640000,freq_5,test_data,20000,2,10000,640000)\n",
        "print(\"Perplexity using the MAP estimate for test\",perplexity_map_ans_640k)\n",
        "#pred dist\n",
        "print(\"*Pred dist*\")\n",
        "perplexity_pred_dist_ans_640k_tr=perplexity_pred_dist(640000,freq_5,training_data,20000,2,640000)\n",
        "print(\"Perplexity using the predictive distribution for train\",perplexity_pred_dist_ans_640k_tr)\n",
        "\n",
        "perplexity_pred_dist_ans_640k=perplexity_pred_dist(640000,freq_5,test_data,20000,2,640000)\n",
        "print(\"Perplexity using the predictive distribution for test\",perplexity_pred_dist_ans_640k)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qmJTqJfWlt8_",
        "outputId": "8fd14ceb-7d2e-4555-9131-20f4dc78808c"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "*MLE*\n",
            "Perplexity using the maximum likelihood estimate for train: 8506.43367662384\n",
            "Perplexity using the maximum likelihood estimate for test: 8657.623041731129\n",
            "*MAP*\n",
            "Perplexity using the MAP estimate for train 8506.96513236839\n",
            "Perplexity using the MAP estimate for test 8654.590090965366\n",
            "*Pred dist*\n",
            "Perplexity using the predictive distribution for train 8508.427803625034\n",
            "Perplexity using the predictive distribution for test 8652.803792634657\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x = np.array([5000,10000,40000,160000,640000])\n",
        "y1 = np.array([perplexity_mle_ans_5k,perplexity_mle_ans_10k,perplexity_mle_ans_40k,perplexity_mle_ans_160k,perplexity_mle_ans_640k])\n",
        "y2 = np.array([perplexity_map_ans_5k,perplexity_map_ans_10k,perplexity_map_ans_40k,perplexity_map_ans_160k,perplexity_map_ans_640k])\n",
        "y3 = np.array([perplexity_pred_dist_ans_5k,perplexity_pred_dist_ans_10k,perplexity_pred_dist_ans_40k,perplexity_pred_dist_ans_160k,perplexity_pred_dist_ans_640k])\n",
        "\n",
        "\n",
        "plt.scatter(x, y1, color='green')\n",
        "plt.scatter(x, y2, color='red')\n",
        "plt.scatter(x, y3, color='blue')\n",
        "\n",
        "# Scatter Plot color array\n",
        "plt.title(\"Perplexity with respect to length of data set\")\n",
        "\n",
        "plt.xlabel(\"Number of words in training data\")\n",
        "\n",
        "# Display\n",
        "plt.plot(x,y1,color='green')\n",
        "plt.plot(x,y2,color='red')\n",
        "plt.plot(x,y3,color='blue')\n",
        "\n",
        "plt.legend(['MLE', 'MAP','Predictive Dist'])\n",
        "plt.show()\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "nH9Yv7lazGZz",
        "outputId": "cb993a85-4bd2-49f5-b3c0-3caeb3132120"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x = np.array([5000,10000,40000,160000,640000])\n",
        "y1 = np.array([15000,15000,15000,15000,perplexity_mle_ans_640k])\n",
        "y2 = np.array([perplexity_map_ans_5k,perplexity_map_ans_10k,perplexity_map_ans_40k,perplexity_map_ans_160k,perplexity_map_ans_640k])\n",
        "y3 = np.array([perplexity_pred_dist_ans_5k,perplexity_pred_dist_ans_10k,perplexity_pred_dist_ans_40k,perplexity_pred_dist_ans_160k,perplexity_pred_dist_ans_640k])\n",
        "\n",
        "\n",
        "plt.scatter(x, y1, color='green')\n",
        "plt.scatter(x, y2, color='red')\n",
        "plt.scatter(x, y3, color='blue')\n",
        "\n",
        "# Scatter Plot color array\n",
        "plt.title(\"Perplexity with respect to length of data set taking 15000 instead of infinity for mle\")\n",
        "\n",
        "plt.xlabel(\"Number of words in training data\")\n",
        "\n",
        "# Display\n",
        "plt.plot(x,y1,color='green')\n",
        "plt.plot(x,y2,color='red')\n",
        "plt.plot(x,y3,color='blue')\n",
        "\n",
        "plt.legend(['MLE', 'MAP','Predictive Dist'])\n",
        "plt.show()\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "TW-BiAzVi6Uy",
        "outputId": "3609eeae-07b3-4e8f-d27c-ae0ba4a90538"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Task 2\n",
        "#With use of training_data1 ,freq_1 "
      ],
      "metadata": {
        "id": "YivSsFIllt_D"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "alpha=[1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0]\n"
      ],
      "metadata": {
        "id": "LQ1mRpbMluB4"
      },
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def per_all_alpha(n,freq,data,alpha,ans_list_per,l):\n",
        "                   \n",
        "    for j in alpha: \n",
        "     sum=0\n",
        "     for i in range(len(data)):\n",
        "         p=(freq[data[i]]+j)/(l+ (j*10000))\n",
        "         sum=sum+math.log(p)\n",
        "     sum=math.exp(sum/(-n))\n",
        "     ans_list_per.append(sum)\n",
        "    \n",
        "     \n",
        "\n",
        "    \n",
        "\n",
        "\n",
        "def evidence(freq,data,alpha,evidence_ans):\n",
        "  \n",
        "  for j in alpha:\n",
        "      sum=0\n",
        "      for i in freq:\n",
        "        sum=sum+ (math.log(math.factorial(j+freq[i]-1)))  -math.log(math.factorial(j-1))\n",
        "        ##print(sum) \n",
        "      #print(sum)  \n",
        "      sum=sum+(math.log(math.factorial( ( 10000*j ) -1 )) - math.log ( math.factorial ( 10000*j+5000-1   )))\n",
        "      #print(sum)\n",
        "      evidence_ans.append(sum)\n",
        "      \n",
        "       \n"
      ],
      "metadata": {
        "id": "FElQf9x5luEQ"
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "ans_list_per=[]\n",
        "per_all_alpha(640000,freq_1,test_data,alpha,ans_list_per,5000)\n",
        "print(\"list of perplexity values for each α :\\n\",ans_list_per)\n",
        "\n",
        "evidence_ans=[]\n",
        "evidence(freq_1,test_data,alpha,evidence_ans)\n",
        "print(\"list of evidence values for each α :\\n\", evidence_ans)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tns0U08IluG7",
        "outputId": "16581ae9-91b5-42d4-d5b4-faa89307bac4"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "list of perplexity values for each α :\n",
            " [10098.36492411617, 9814.024919445475, 9786.08170018863, 9795.817303703838, 9812.080606261894, 9828.21403004244, 9842.709323329726, 9855.37841243399, 9866.383690155306, 9875.959835677339]\n",
            "list of evidence values for each α :\n",
            " [-46113.90994393522, -46016.42218337306, -46004.65053748851, -46005.4713075168, -46008.750364784675, -46012.29823477565, -46015.57636918427, -46018.47568448576, -46021.00839884648, -46023.21824468622]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x = np.array([1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0])\n",
        "y1=ans_list_per\n",
        "y2=evidence_ans\n",
        "\n",
        "#plt.scatter(x, y1, color='green')\n",
        "plt.scatter(x, y1, color='blue')\n",
        "\n",
        "# Scatter Plot color array\n",
        "plt.title(\"Perplexity with respect to alpha\")\n",
        "\n",
        "plt.xlabel(\"alpha\")\n",
        "\n",
        "# Display\n",
        "plt.plot(x,y1,color='blue')\n",
        "\n",
        "plt.show()\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "PtozMgGzDNG8",
        "outputId": "6e7ebb0c-27f9-4c35-9f73-94244643ba9d"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x = np.array([1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0])\n",
        "y1=ans_list_per\n",
        "y2=evidence_ans\n",
        "\n",
        "plt.scatter(x, y2, color='red')\n",
        "\n",
        "# Scatter Plot color array\n",
        "plt.title(\"log evidence with respect to alpha\")\n",
        "\n",
        "plt.xlabel(\"alpha\")\n",
        "\n",
        "# Display\n",
        "plt.plot(x,y2,color='red')\n",
        "\n",
        "plt.show()\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "qIdjLuJhBonS",
        "outputId": "cd4267a2-d36a-41ec-bb40-559413f3f3ea"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Vz2CrU1TBo1T"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Task 3\n",
        "import re\n",
        "import copy\n",
        "import math\n"
      ],
      "metadata": {
        "id": "Yn4pCldHluKX"
      },
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "txt_file = open(\"pg121.txt.clean\", \"r\")\n",
        "file_content = txt_file.read()\n",
        "data_training = re.split(r'\\W+', file_content)\n",
        "data_training.remove(\"\")\n",
        "#data_training.remove('\\n')\n",
        "txt_file.close()\n",
        "#training_data=training_data[0:640000]\n",
        "\n",
        "txt_file = open(\"pg1400.txt.clean\", \"r\")\n",
        "file_content = txt_file.read()\n",
        "data_test1 = re.split(r'\\W+', file_content)\n",
        "data_test1.remove(\"\")\n",
        "#data_test1.remove('\\n')\n",
        "txt_file.close()\n",
        "\n",
        "txt_file = open(\"pg141.txt.clean\", \"r\")\n",
        "file_content = txt_file.read()\n",
        "data_test2 = re.split(r'\\W+', file_content)\n",
        "data_test2.remove(\"\")\n",
        "#data_test2.remove('\\n')\n",
        "txt_file.close()\n",
        "\n"
      ],
      "metadata": {
        "id": "u8zXXfLPXJak"
      },
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def bag(my_list,freq):\n",
        "   \n",
        "   \n",
        "    for item in my_list:\n",
        "            freq[item] = 0\n",
        "           \n",
        "    \n",
        "vocab={}\n",
        "bag(data_training+data_test1 +data_test2,vocab)\n",
        "#del vocab['']"
      ],
      "metadata": {
        "id": "rNvmSQCA-A_f"
      },
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def CountFrequency_t3(my_list):\n",
        "    freq=copy.copy(vocab)  \n",
        "    for item in my_list:\n",
        "        if (item in freq):\n",
        "            freq[item] +=1\n",
        "\n",
        "\n",
        "    return freq        \n"
      ],
      "metadata": {
        "id": "kMgOrDFFlu4H"
      },
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def perplexity_pred_dist_t3(freq,data,alpha0,alphak):\n",
        "     sum=0\n",
        "     for i in range(len(data)):\n",
        "         p=(freq[data[i]]+alphak)/(len(data_training)+alpha0)\n",
        "         sum=sum+math.log(p)\n",
        "     sum=sum/(-(len(data)))\n",
        "     return math.exp(sum) \n",
        "\n"
      ],
      "metadata": {
        "id": "43SfB5vJctKM"
      },
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "freq=CountFrequency_t3(data_training)\n"
      ],
      "metadata": {
        "id": "7TjD4j9ll2N4"
      },
      "execution_count": 26,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "task_3_1=perplexity_pred_dist_t3(freq,data_test1,(18251*2),2)\n",
        "print(\"Perplexity using the predictive distribution\",task_3_1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eXPqKZUPlE6Y",
        "outputId": "23ad3279-09cc-41d5-ba3b-404ffaedc151"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Perplexity using the predictive distribution 6397.359553488723\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "task_3_2=perplexity_pred_dist_t3(freq,data_test2,(18251*2),2)\n",
        "print(\"Perplexity using the predictive distribution\",task_3_2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QSawvHaFmf4p",
        "outputId": "7c03f5c6-2818-49a2-ecad-1751bf1e3f69"
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Perplexity using the predictive distribution 4784.562471838497\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "eAiNOQqI1Urn"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}