noshot 0.1.0__py3-none-any.whl

noshot/data/AIDS CN NLP/NLP/NLP 2/Lab07(HMM,Viterbi)/NLP Exp 4.ipynb

@@ -0,0 +1,255 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "3be05c09",
+   "metadata": {},
+   "source": [
+    "# Hidden Markov Model - Forward and backward algorithm\n",
+    "\n",
+    "\"Code credits: [**V Tarun Thothadri**](https://github.com/TarunThothadri)\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "96e855aa",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Enter no of states : 2\n",
+      "Enter state 1 : cp\n",
+      "Enter initial probability of the state 1 : 1.0\n",
+      "Enter state 2 : ip\n",
+      "Enter initial probability of the state 2 : 0.0\n",
+      "Enter stp from cp to cp : 0.7\n",
+      "Enter stp from cp to ip : 0.3\n",
+      "Enter stp from ip to cp : 0.5\n",
+      "Enter stp from ip to ip : 0.5\n",
+      "Enter no of observations : 3\n",
+      "Enter observation 1 : lem\n",
+      "Enter observation 2 : ice\n",
+      "Enter observation 3 : cola\n",
+      "Enter probability of getting lem from cp : 0.3\n",
+      "Enter probability of getting ice from cp : 0.1\n",
+      "Enter probability of getting cola from cp : 0.6\n",
+      "Enter probability of getting lem from ip : 0.2\n",
+      "Enter probability of getting ice from ip : 0.7\n",
+      "Enter probability of getting cola from ip : 0.1\n",
+      "['cp', 'ip']\n",
+      "[1.0, 0.0]\n",
+      "[[0.7, 0.3], [0.5, 0.5]]\n",
+      "['lem', 'ice', 'cola']\n",
+      "[[0.3, 0.1, 0.6], [0.2, 0.7, 0.1]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "'''states = ['cp','ip']\n",
+    "ls = len(states)\n",
+    "\n",
+    "#Initial Probability\n",
+    "ip = [1.0,0.0]\n",
+    "\n",
+    "#State transition probability\n",
+    "stp = [[0.7,0.3],\n",
+    "       [0.5,0.5]]\n",
+    "\n",
+    "#Observations\n",
+    "op = ['lem','ice','cola']\n",
+    "lop = len(op)\n",
+    "\n",
+    "#Obs probablity\n",
+    "opp = [[0.3,0.1,0.6],\n",
+    "       [0.2,0.7,0.1]]'''\n",
+    "\n",
+    "states = []\n",
+    "ip = []\n",
+    "stp = []\n",
+    "op = []\n",
+    "opp = []\n",
+    "\n",
+    "ls = int(input(\"Enter no of states : \"))\n",
+    "\n",
+    "for i in range(ls):\n",
+    "    states.append(input(f\"Enter state {i+1} : \"))\n",
+    "    ip.append(float(input(f\"Enter initial probability of the state {i+1} : \")))\n",
+    "\n",
+    "for i in range(ls):\n",
+    "    sp_row = []\n",
+    "    for j in range(ls):\n",
+    "        sp = float(input(f\"Enter stp from {states[i]} to {states[j]} : \"))\n",
+    "        sp_row.append(sp)\n",
+    "    stp.append(sp_row)\n",
+    "    \n",
+    "lop = int(input(\"Enter no of observations : \"))\n",
+    "\n",
+    "for i in range(lop):\n",
+    "    op.append(input(f\"Enter observation {i+1} : \"))\n",
+    "\n",
+    "for i in range(ls):\n",
+    "    opp_row = []\n",
+    "    for j in range(lop):\n",
+    "        opp_row.append(float(input(f\"Enter probability of getting {op[j]} from {states[i]} : \")))\n",
+    "        \n",
+    "    opp.append(opp_row)\n",
+    "    \n",
+    "print(states)\n",
+    "print(ip)\n",
+    "print(stp)\n",
+    "print(op)\n",
+    "print(opp)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ac0d52fe",
+   "metadata": {},
+   "source": [
+    "Forward Algorithm"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "aad5d765",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def forward_alg():\n",
+    "    alpha = []\n",
+    "    for _ in range(len(op)+1):\n",
+    "        alpha.append([0,0])\n",
+    "\n",
+    "    '''alpha[0][0] = 1.0\n",
+    "    alpha[0][1] = 0.0\n",
+    "    #print(alpha)'''\n",
+    "    \n",
+    "    for i in range(len(alpha)):\n",
+    "        if i == 0:\n",
+    "            alpha[i][0] = ip[0]\n",
+    "            alpha[i][1] = ip[1]\n",
+    "            continue\n",
+    "        \n",
+    "        alpha[i][0] = float(float(stp[0][0]*opp[0][i-1]*alpha[i-1][0]) + float(stp[1][0]*opp[1][i-1]*alpha[i-1][1]))\n",
+    "\n",
+    "        alpha[i][1] = float(float(stp[1][1]*opp[1][i-1]*alpha[i-1][1]) + float(stp[0][1]*opp[0][i-1]*alpha[i-1][0]))\n",
+    "\n",
+    "    return alpha"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "7612f052",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[1.0, 0.0]\n",
+      "[0.21, 0.09]\n",
+      "[0.0462, 0.0378]\n",
+      "[0.021293999999999997, 0.010206]\n",
+      "\n",
+      "Probability of whole sequence :  0.0315\n"
+     ]
+    }
+   ],
+   "source": [
+    "alpha = forward_alg()\n",
+    "pos_alpha = 0.0\n",
+    "for i in alpha:\n",
+    "    pos_alpha = sum(i)\n",
+    "    print(i)\n",
+    "    \n",
+    "print(\"\\nProbability of whole sequence : \",pos_alpha)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "70482230",
+   "metadata": {},
+   "source": [
+    "Backward Algorithm"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "445612f0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def backward_alg():\n",
+    "    beta = []\n",
+    "    for _ in range(len(op)+1):\n",
+    "        beta.append([0.0,0.0])\n",
+    "\n",
+    "    beta[len(op)][0] = 1.0\n",
+    "    beta[len(op)][1] = 1.0\n",
+    "    #print(beta)\n",
+    "\n",
+    "    for i in range(len(op)-1,-1,-1):\n",
+    "        \n",
+    "        beta[i][0] = float(float(stp[0][0]*opp[0][i]*beta[i+1][0]) + float(stp[0][1]*opp[0][i]*beta[i+1][1]))\n",
+    "\n",
+    "        beta[i][1] = float(float(stp[1][1]*opp[1][i]*beta[i+1][1]) + float(stp[1][0]*opp[1][i]*beta[i+1][0]))\n",
+    "\n",
+    "    return beta"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "6986b179",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0.0315, 0.029]\n",
+      "[0.045, 0.245]\n",
+      "[0.6, 0.1]\n",
+      "[1.0, 1.0]\n",
+      "\n",
+      "Probability of whole sequence :  0.0315\n"
+     ]
+    }
+   ],
+   "source": [
+    "beta = backward_alg()\n",
+    "for i in beta:\n",
+    "    print(i)\n",
+    "    \n",
+    "print(\"\\nProbability of whole sequence : \",beta[0][0]*ip[0] + beta[0][1]*ip[1])"
+   ]
+  }
+ ],
+ "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.11.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

noshot/data/AIDS CN NLP/NLP/NLP 2/Lab07(HMM,Viterbi)/NLP_Exp_5.ipynb

@@ -0,0 +1,159 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "id": "3be05c09",
+      "metadata": {
+        "id": "3be05c09"
+      },
+      "source": [
+        "# Viterbi Algorithm\n",
+        "\n",
+        "Implement the Viterbi algorithm to find the probability of a word sequence, and infer the best tag sequence using Hidden Markov Model."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def viterbi_algorithm(op):\n",
+        "    delta = []\n",
+        "    psi = []\n",
+        "\n",
+        "    # Initialize the delta and psi matrices\n",
+        "    for _ in range(len(op)):\n",
+        "        delta.append([0.0, 0.0])\n",
+        "        psi.append([0, 0])\n",
+        "\n",
+        "    # Initialization step\n",
+        "    for i in range(len(states)):\n",
+        "        delta[0][i] = ip[i] * opp[i][0]\n",
+        "\n",
+        "    # Recursion step\n",
+        "    for t in range(1, len(op)):\n",
+        "        for j in range(len(states)):\n",
+        "            max_prob = 0.0\n",
+        "            max_state = 0\n",
+        "\n",
+        "            for i in range(len(states)):\n",
+        "                prob = delta[t - 1][i] * stp[i][j] * opp[j][t]\n",
+        "                if prob > max_prob:\n",
+        "                    max_prob = prob\n",
+        "                    max_state = i\n",
+        "\n",
+        "            delta[t][j] = max_prob\n",
+        "            psi[t][j] = max_state\n",
+        "\n",
+        "    # Termination step\n",
+        "    best_path_prob = max(delta[-1])\n",
+        "    best_last_state = delta[-1].index(best_path_prob)\n",
+        "\n",
+        "    # Backtrack to find the best tag sequence\n",
+        "    best_path = [best_last_state]\n",
+        "    for t in range(len(op) - 1, 0, -1):\n",
+        "        best_last_state = psi[t][best_last_state]\n",
+        "        best_path.insert(0, best_last_state)\n",
+        "\n",
+        "    return best_path, best_path_prob\n",
+        "\n",
+        "states = []\n",
+        "ip = []\n",
+        "stp = []\n",
+        "op = []\n",
+        "opp = []\n",
+        "\n",
+        "ls = int(input(\"Enter no of states : \"))\n",
+        "\n",
+        "for i in range(ls):\n",
+        "    states.append(input(f\"Enter state {i+1} : \"))\n",
+        "    ip.append(float(input(f\"Enter initial probability of state {states[i]} : \")))\n",
+        "\n",
+        "for i in range(ls):\n",
+        "    sp_row = []\n",
+        "    for j in range(ls):\n",
+        "        sp = float(input(f\"Enter transition probability from {states[i]} to {states[j]} : \"))\n",
+        "        sp_row.append(sp)\n",
+        "    stp.append(sp_row)\n",
+        "\n",
+        "lop = int(input(\"Enter no of observations : \"))\n",
+        "\n",
+        "for i in range(lop):\n",
+        "    op.append(input(f\"Enter observation {i+1} : \"))\n",
+        "\n",
+        "for i in range(ls):\n",
+        "    opp_row = []\n",
+        "    for j in range(lop):\n",
+        "        opp_row.append(float(input(f\"Enter emission probability of {op[j]} from {states[i]} : \")))\n",
+        "    opp.append(opp_row)\n",
+        "\n",
+        "# Call the Viterbi algorithm\n",
+        "best_tag_sequence, probability = viterbi_algorithm(op)\n",
+        "\n",
+        "# Print the best tag sequence and its probability\n",
+        "print(\"Best Tag Sequence:\", [states[i] for i in best_tag_sequence])\n",
+        "print(\"Probability of the Best Tag Sequence:\", probability)\n"
+      ],
+      "metadata": {
+        "id": "V6IoC75H-5GT",
+        "outputId": "b00142d5-6731-4420-a6e7-8f1b0d2b3f71",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "id": "V6IoC75H-5GT",
+      "execution_count": 2,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Enter no of states : 2\n",
+            "Enter state 1 : cp\n",
+            "Enter initial probability of state cp : 1.0\n",
+            "Enter state 2 : ip\n",
+            "Enter initial probability of state ip : 0.0\n",
+            "Enter transition probability from cp to cp : 0.7\n",
+            "Enter transition probability from cp to ip : 0.3\n",
+            "Enter transition probability from ip to cp : 0.5\n",
+            "Enter transition probability from ip to ip : 0.5\n",
+            "Enter no of observations : 3\n",
+            "Enter observation 1 : lem\n",
+            "Enter observation 2 : ice\n",
+            "Enter observation 3 : cola\n",
+            "Enter emission probability of lem from cp : 0.3\n",
+            "Enter emission probability of ice from cp : 0.1\n",
+            "Enter emission probability of cola from cp : 0.6\n",
+            "Enter emission probability of lem from ip : 0.2\n",
+            "Enter emission probability of ice from ip : 0.7\n",
+            "Enter emission probability of cola from ip : 0.1\n",
+            "Best Tag Sequence: ['cp', 'ip', 'cp']\n",
+            "Probability of the Best Tag Sequence: 0.0189\n"
+          ]
+        }
+      ]
+    }
+  ],
+  "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.11.5"
+    },
+    "colab": {
+      "provenance": []
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 5
+}

noshot/data/AIDS CN NLP/NLP/NLP 2/Lab08(PCFG)/PCFG.ipynb

@@ -0,0 +1,282 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "hwHembMnuehB"
+   },
+   "source": [
+    "## PCFG\n",
+    "\n",
+    "Implement the Probabilistic Context Free Grammar (PCFG) and find the inside probability of a word sequence using the CYK algorithm."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "fkukKpNbr9Fw",
+    "outputId": "852fd759-7ec2-4dd4-c1fa-9db808e40805"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Inside probability of S: 21.400000000000002\n",
+      "Inside probability of NP: 18.479999999999997\n",
+      "Inside probability of VP: 17.120000000000005\n",
+      "Inside probability of Det: 0.0\n",
+      "Inside probability of N: 0.0\n",
+      "Inside probability of V: 0.0\n",
+      "Total inside probability: 21.400000000000002\n"
+     ]
+    }
+   ],
+   "source": [
+    "from collections import defaultdict\n",
+    "from itertools import product\n",
+    "\n",
+    "def cyk_algorithm(words, pcfg_rules):\n",
+    "    n = len(words)\n",
+    "    table = [[defaultdict(float) for _ in range(n)] for _ in range(n)]\n",
+    "\n",
+    "    # Initialization\n",
+    "    for i, word in enumerate(words):\n",
+    "        for nt, (prob, terminals) in pcfg_rules.items():\n",
+    "            if word in terminals:\n",
+    "                table[i][i][nt] = prob\n",
+    "\n",
+    "    # CYK Algorithm\n",
+    "    for length in range(2, n + 1):\n",
+    "        for i in range(n - length + 1):\n",
+    "            j = i + length - 1\n",
+    "            for k in range(i, j):\n",
+    "                for A, (prob_A, _) in pcfg_rules.items():\n",
+    "                    for B, (prob_B, _) in pcfg_rules.items():\n",
+    "                        for C in table[i][k]:\n",
+    "                            for D in table[k + 1][j]:\n",
+    "                                prob = prob_A * prob_B * pcfg_rules[A][1].count(C) * pcfg_rules[B][1].count(D)\n",
+    "                                table[i][j][A] += prob\n",
+    "\n",
+    "    return table\n",
+    "\n",
+    "# Example PCFG rules (non-terminal -> (probability, [productions]))\n",
+    "pcfg_rules = {\n",
+    "    'S': (1.0, ['NP', 'VP']),\n",
+    "    'NP': (0.7, ['Det', 'N']),\n",
+    "    'VP': (0.8, ['V', 'NP']),\n",
+    "    'Det': (1.0, ['the']),\n",
+    "    'N': (0.6, ['cat', 'dog']),\n",
+    "    'V': (0.9, ['chased'])\n",
+    "}\n",
+    "\n",
+    "# Example input sentence\n",
+    "words = ['the', 'cat', 'chased', 'the', 'dog']\n",
+    "\n",
+    "# Call CYK algorithm to get inside probabilities\n",
+    "table = cyk_algorithm(words, pcfg_rules)\n",
+    "\n",
+    "# Inside probabilities for non-terminals in the top cell of the table\n",
+    "inside_probabilities = table[0][-1]\n",
+    "\n",
+    "# Print inside probabilities\n",
+    "for nt, prob in inside_probabilities.items():\n",
+    "    print(f'Inside probability of {nt}: {prob}')\n",
+    "\n",
+    "# Total inside probability (probability of the whole sentence)\n",
+    "total_probability = inside_probabilities['S']\n",
+    "print(f'Total inside probability: {total_probability}')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "BXiMT63eyUU1",
+    "outputId": "9eca3bc3-303f-44ed-e836-e03789e9e1c0"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Inside probability of S: 21.400000000000002\n",
+      "Inside probability of NP: 18.479999999999997\n",
+      "Inside probability of VP: 17.120000000000005\n",
+      "Inside probability of Det: 0.0\n",
+      "Inside probability of N: 0.0\n",
+      "Inside probability of V: 0.0\n",
+      "Total inside probability: 21.400000000000002\n"
+     ]
+    }
+   ],
+   "source": [
+    "from collections import defaultdict\n",
+    "from itertools import product\n",
+    "\n",
+    "def cyk_algorithm(words, pcfg_rules):\n",
+    "    n = len(words)\n",
+    "    table = [[defaultdict(float) for _ in range(n)] for _ in range(n)]\n",
+    "\n",
+    "    # Initialization\n",
+    "    for i, word in enumerate(words):\n",
+    "        for nt, (prob, terminals) in pcfg_rules.items():\n",
+    "            if word in terminals:\n",
+    "                table[i][i][nt] = prob\n",
+    "\n",
+    "    # CYK Algorithm\n",
+    "    for length in range(2, n + 1):\n",
+    "        for i in range(n - length + 1):\n",
+    "            j = i + length - 1\n",
+    "            for k in range(i, j):\n",
+    "                for A, (prob_A, _) in pcfg_rules.items():\n",
+    "                    for B, (prob_B, _) in pcfg_rules.items():\n",
+    "                        for C in table[i][k]:\n",
+    "                            for D in table[k + 1][j]:\n",
+    "                                prob = prob_A * prob_B * pcfg_rules[A][1].count(C) * pcfg_rules[B][1].count(D)\n",
+    "                                table[i][j][A] += prob\n",
+    "\n",
+    "    return table\n",
+    "\n",
+    "# Example PCFG rules (non-terminal -> (probability, [productions]))\n",
+    "pcfg_rules = {\n",
+    "    'S': (1.0, ['NP', 'VP']),\n",
+    "    'NP': (0.7, ['Det', 'N']),\n",
+    "    'VP': (0.8, ['V', 'NP']),\n",
+    "    'Det': (1.0, ['the']),\n",
+    "    'N': (0.6, ['cat', 'dog']),\n",
+    "    'V': (0.9, ['chased'])\n",
+    "}\n",
+    "\n",
+    "# New input sentence\n",
+    "words = ['the', 'dog', 'chased', 'the', 'cat']\n",
+    "\n",
+    "# Call CYK algorithm to get inside probabilities\n",
+    "table = cyk_algorithm(words, pcfg_rules)\n",
+    "\n",
+    "# Inside probabilities for non-terminals in the top cell of the table\n",
+    "inside_probabilities = table[0][-1]\n",
+    "\n",
+    "# Print inside probabilities\n",
+    "for nt, prob in inside_probabilities.items():\n",
+    "    print(f'Inside probability of {nt}: {prob}')\n",
+    "\n",
+    "# Total inside probability (probability of the whole sentence)\n",
+    "total_probability = inside_probabilities['S']\n",
+    "print(f'Total inside probability: {total_probability}')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "ORafeKQsyX08",
+    "outputId": "a1f34a3a-ad0d-480e-c0b6-49e2fb46ae80"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Inside probability of S: 19.599999999999998\n",
+      "Inside probability of NP: 14.519999999999996\n",
+      "Inside probability of VP: 13.72\n",
+      "Inside probability of Det: 0.0\n",
+      "Inside probability of N: 0.0\n",
+      "Inside probability of V: 0.0\n",
+      "Total inside probability: 19.599999999999998\n"
+     ]
+    }
+   ],
+   "source": [
+    "from collections import defaultdict\n",
+    "from itertools import product\n",
+    "\n",
+    "def cyk_algorithm(words, pcfg_rules):\n",
+    "    n = len(words)\n",
+    "    table = [[defaultdict(float) for _ in range(n)] for _ in range(n)]\n",
+    "\n",
+    "    # Initialization\n",
+    "    for i, word in enumerate(words):\n",
+    "        for nt, (prob, terminals) in pcfg_rules.items():\n",
+    "            if word in terminals:\n",
+    "                table[i][i][nt] = prob\n",
+    "\n",
+    "    # CYK Algorithm\n",
+    "    for length in range(2, n + 1):\n",
+    "        for i in range(n - length + 1):\n",
+    "            j = i + length - 1\n",
+    "            for k in range(i, j):\n",
+    "                for A, (prob_A, _) in pcfg_rules.items():\n",
+    "                    for B, (prob_B, _) in pcfg_rules.items():\n",
+    "                        for C in table[i][k]:\n",
+    "                            for D in table[k + 1][j]:\n",
+    "                                prob = prob_A * prob_B * pcfg_rules[A][1].count(C) * pcfg_rules[B][1].count(D)\n",
+    "                                table[i][j][A] += prob\n",
+    "\n",
+    "    return table\n",
+    "\n",
+    "# Different PCFG rules\n",
+    "pcfg_rules = {\n",
+    "    'S': (1.0, ['NP', 'VP']),\n",
+    "    'NP': (0.6, ['Det', 'N']),\n",
+    "    'VP': (0.7, ['V', 'NP']),\n",
+    "    'Det': (1.0, ['the', 'a']),\n",
+    "    'N': (0.5, ['cat', 'dog', 'bat']),\n",
+    "    'V': (0.8, ['chased', 'caught'])\n",
+    "}\n",
+    "\n",
+    "# Different input sentence\n",
+    "words = ['the', 'cat', 'chased', 'a', 'bat']\n",
+    "\n",
+    "# Call CYK algorithm to get inside probabilities\n",
+    "table = cyk_algorithm(words, pcfg_rules)\n",
+    "\n",
+    "# Inside probabilities for non-terminals in the top cell of the table\n",
+    "inside_probabilities = table[0][-1]\n",
+    "\n",
+    "# Print inside probabilities\n",
+    "for nt, prob in inside_probabilities.items():\n",
+    "    print(f'Inside probability of {nt}: {prob}')\n",
+    "\n",
+    "# Total inside probability (probability of the whole sentence)\n",
+    "total_probability = inside_probabilities['S']\n",
+    "print(f'Total inside probability: {total_probability}')\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "provenance": []
+  },
+  "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.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}