noshot 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

noshot/data/ML TS XAI/NLP/NLP 2/Lab07(HMM,Viterbi)/NLP Exp 4.ipynb

@@ -1,255 +0,0 @@
-{
- "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/ML TS XAI/NLP/NLP 2/Lab07(HMM,Viterbi)/NLP_Exp_5.ipynb

@@ -1,159 +0,0 @@
-{
-  "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/ML TS XAI/NLP/NLP 2/Lab08(PCFG)/PCFG.ipynb

@@ -1,282 +0,0 @@
-{
- "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
-}